Entity Framework Code-First Migration

Purpose: Learn how to use migration history to control your database changes

1.Preparation for Setting Entity Framework, connection string, and relating database

        a. Created a ASP.NET MVC project and install Entity Framework

            Tools -> NuGet Package Manager -> Manage NuGet Packages for Solutions…

              

              

        b. Setup connection string

              

                 project -> right click -> Properties

        c. On "Settings" section, select Connection String on Type field, and edit Value…

           Then you can select the relating database to this project.

2. Create Model and setup DbContext

        a. Create a class which represents your table (Under Models folder).

                 For example, if we want to create a Person table, you can setup it as the following picture.

                 Note: Property name ends with Id will be considered as primary key in table. 

               

        b. Create our DbContext class which inherits DbContext of Entity Framework.

                Note: We use DbContext to coordinate Entity Framework Functionality.

                In addition, add the previous class to DbSet.

                Also, we can specific the database from customized connection string name.

                On this example, we named it “DefaultContext”

       

        

            

     

        c. Then, change the connection string to the name we specified on previous step

            

3. Migration

         

        a. Enable Migration for our project

                 Tools -> NuGet Package Manager -> Package Manager Console

         Run: enable-migrations

        b. Then, we can notice that in our project folder, the Migrations folder was created.

        c. Run: “add-migration init” for creating migration
            Note: "init" is the migration name in this example, you can use anything you want.

            After that, we can see that under the folder, the migration file called “xxxx_init.cs” was created

         

             Then, we can run "update-database" commands to change database.


        d. On SQL Server management, we can find that the Person table was created!
            In addition, this database includes the migration history table (Only One record.)

4. How to revert migrations

        a. Assume that we keep developing our system, and we want to modify person table for more information to meet clients’ requirement.
             For testing purpose in this example, in this step, we want to deliberately make a mistake for the typo issue. And do the Migration to update database!

                       

        b. On SQL Server Management, we can find that the Person table has been changed, and the new migration history has been inserted.

        c. On this moment, we might find that we make a typo mistake.

            

            We can run the following commands on Console to revert to the specific migration history record.

            

            Commands: update-databse -targetMigration init
 

             

        d. Then we can find that the database has been reverted to the first migration we created before. And the second migration history has been removed!

        e. Now, we can delete the wrong migration on our project folder.

            Then, we correct the properties of models (correct the typo). 

            In the end, add the new migration again.

         

        f. Then, we can check the database and migration history.

            Everything is in control now!

Web.config Transform (Visual Studio)

Introduction:

Sometimes, you may encounter a situation that you want your web.config of staging server to be different with the web.config of production server. For example, the connection string of staging server should be different from that of production server (one is for test database, and one is for client database).  

How to create our own transform web.config?

Note: Originally, VS create “Debug” and “Release” configuration for us.

If we want to create our own configuration, select “VS -> Build -> Configuration Manage”.

Then you can see the following picture to create a new configuration.

After creating our customized configuration, on Solution Explorer right click on the web.config, then click “Add Config Transform”.

Then, you can see the one we created has been shown.

How to know the difference through using different transform config?

As default, VS will create “Debug” and “Release” configuration for us. We can use those to be example to declare this question. We found there is only one-line difference between Debug and Release.

<compilation xdt:Transform="RemoveAttributes(debug)" />

From above instruction, we assume that on “Release” build we want to delete the debug attributes.

On Solution Employer, we can right click our project and select Publish…

Then select Folder option.

Then go the file path “source/repos/ConfigTransform/ConfigTransform/bin/Release/PublishOutput” to check the transform web.config.

"Release" version of web.config as shown as following picture.

On the other hand, we want to change the build configuration to “Debug”.

Go to Publish page, click Settings…

And change Configuration to Debug.

Then you can notice that the web.config has been changed! The Debug version contains debug information.

Conclusion:

According above, we can use web.config transform to define the different setting between staging server and production server.

tmux (session tool)

Introduction

The tool can help to reattach the losing sessions. It is really useful if your network connection is unstable. You can attach the losing session and keep working. In addition, it enables users to control window panes through keyboard.

Installation (Linux):

sudo apt-get update

sudo apt-get install tmux

tmux -V

To start:

In:

tmux new (it will use number to name the session)

tmux new -s name-of-session

Out:

exit

Prefix + d

Commands:

Note: all commands need a prefix  

Default prefix: 

                       ctrl + b

Session

Attach

 tmux a -t number-of-session

 tmux a -t name-of-session

Kill

 tmux kill-session -t number-of-session

List   

 tmux ls

Windows

New: 

  Prefix + c

Kill:  

  Prefix + ,

Moving:

                        Prefix + p

                        Prefix + n

                        Prefix + Number

Panes

New:

  Horizontally:

prefix + “

  Vertically:

prefix + %

Kill:

                        Prefix + x

Moving:

                        Prefix + up|down|left|right

                        Prefix + o

How to customize it?

The keyboard combination of prefix seems to be not that user friendly. If we can change it to something else, that will be really appreciated.

First, we need to create a tmux configuration file.

    vim ~/.tmux.conf

Copy the following instructions into that file.

    unbind c-b

    set -g prefix C-a

    bind C-a send-prefix

The above instructions mean that we change prefix from ctrl + b to ctrl + a.

Reload Config

tmux source-file ~/.tmux.conf

Extension Methods (C#)

Purpose:

Enable us to add methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type.

Why:

Sometimes, when using system library, the built-in funciton might not be suitable enough for our needs. Therefore, we need to write some customized function to deal with it. We might creat Util class and put our new function inside it.

For example:

public static class Util {         public static string ConvertStringForSomePurpose(string s) {             // todo             return result;     } }

class Program {     static void Main(string[] args) {             string s = “test”;             var newString = Util. ConvertStringForSomePurpose (s);     } }

We have another way to satisfy this purpose with Extension Methods.

Extension Methods are a special static method. It need the special key word called ‘this’. In addition, it should be the first parameter.

public static class Util {         public static string ConvertStringForSomePurpose(this  string s) {             // todo             return result;     } }

class Program {         static void Main(string[] args) {             string s = “test”;             var newString = s. ConvertStringForSomePurpose();     } }

Furthermore, it is widely used when doing lots of LINQ query.

For example, assume we already have some query to get all the students who are male.

// First Query Var students = from s in students                            select s.Gender = ‘Male’;

Unfortunately, clients want to get not only the Male students, but also, they want all selected male students are over 18 ages.  But we do not want to modify this query, because this query has been used by another function already. In order not to modify the first Query, we can use extension methods to handle it.

Public static IQueryable <Student> Valid(this IQueryable <Student> query) {         Var adultMaleStudents = from q in query                                            Where q.Age > 18                                            Select q;         return adultMaleStudents; }

// After first Query var validStudents = students.Valid();

Therefore, we do not need to modify the original query at all.

GIT Ignore

Purpose:

Sometimes, we do not want to commit the sensitive file such as config file to git. In order to handle it, we can use .gitignore file to claim that which files will be excluded for the committing.

Step 1:

Create a file called “.gitignore”

touch .gitignore

Step 2:

Write the untracked file’s name to “.gitignore” file

echo xxx.xxx >> .gitignore

Step 3:

Sometimes, if you want to remove some committed files from git, you need to do the following commands

git rm --cached xxx.xxx

Step 4:

The normal way to commit

git commit -m "Remove the committed untracked file" git push