Now, we want to add a new table to work with foreign key. Let’s add a new Project class like this :

public class Project
{
    public int ProjectId { get; set; }
    public string Name { get; set; }
    public int ManagerId { get; set; }
    public Person Manager { get; set; }
}

You can see the Manager property is of type Person and I add ManagerId property to be the key between the two tables.

Now add the DbSet of Project as you’ve done for Person :

public DbSet Projects { get; set; }

And run the application.

You should get an InvalidOperationException :
The model backing the ‘MyContext’ context has changed since the database was created. Either manually delete/update the database, or call Database.SetInitializer with an IDatabaseInitializer instance. For example, the DropCreateDatabaseIfModelChanges strategy will automatically delete and recreate the database, and optionally seed it with new data.

This is because the changes we made have too more effect on the database and it should be deleted. But the EF Context can’t decide itself if it can drop the database to recreate it.
What’s the solution ?
There is two solutions :

• You can delete the database yourself and rerun the application
• You can use the SetInitializer using DropCreateDatabaseIfModelChanges.

I won’t explain the first solution. About the second one, it’s a feature allowed by Code First. You can ask the context to automatically drop and recreate the database if the model change.
You should be very careful with this option, because in a production environment, you can loose all your datas.

Because we don’t want to drop ourself the database, we will see how to tell the context to do it for us.

In the file MyContext.cs, add a new class : MyInitializer

public class MyInitializer : DropCreateDatabaseIfModelChanges
{
}

As you can see, the database would be dropped and recreated each time the model change.
You can do more things in the initializer but we will see that later in this post.

Now we will set the initializer. Go back to Program.cs and add the following line at the beginning of the Main method :

Database.SetInitializer(new MyInitializer());

Now, you can run our application.

What has hapenned ? The context has detected changes in the model and so, the database has been deleted and recreated. If you check the tables in the database, you should see 2 tables : People and Project.
The person in the Main method has been created in the People table. The item appears only once because the table was recreated and so, the previous record was deleted and not backed up.

If we look closer, we can see a column named ManagerId and another one named Manager_PersonId.

Project table with FK auto generated

EF Code First has created a foreign key for us and it’s great, but what we’d want is to use the ManagerId property.
So let’s modify our Project class to use this property whereas let Code First create it for us.

To configure Code First and the way it will generate our database, there is two methods : DataAnnotation and Fluent API

Let’s use DataAnnotation.
Modify your class like this :

public class Project
{
    public int ProjectId { get; set; }
    public string Name { get; set; }
    public int ManagerId { get; set; }
    [ForeignKey("ManagerId")]
    public Person Manager { get; set; }
}

You should add the System.ComponentModel.DataAnnotations namespace.
Adding the ForeignKey attribute, we say to Code First that we want the ManagerId properties to be used as Foreign Key to the Person table.

Run the application and check your database schema. The Manager_PersonId column does not exist anymore, there is only the ManagerId column and it is declare as a foreign key to the People table.

We just create our first one to many relationship using EF Code First. As we have seen, we can declare the FK in the class or let Code First managed it for us.
In the next article, we will talk about Data Annotation and Code Fluent.

1 – First sample : A very simple example on how to create a database with a table
2 – Add foreign key relationship : We will enhanced the application created on the first tutorial to add relationships.
3 – Data Annotation and Code Fluent configuration
4 – Initialize database with data
5 – Table per Type and Table per Hierarchy

I hope I’ll find enough time to write all of this.
Hopefully, I already write the first one !

Add package

Once added, check references in your project. EntityFramework should have appeared. You should also see a new file package.config. This file contains all information about NuGet packages installed.

Ok, so now, we can start our project. We will first add a new class file : Person.cs and declare four properties : an ID, a lastname, a firstname and a date of birth, like this :

public class Person
{
    public int PersonId { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public DateTime BirthDate { get; set; }
}

Now, we will create a class to manage the link with the database : our DBContext. Add a new class MyContext.cs and let it inherite from DbContext class (add System.Data.Entity as using)

using System.Data.Entity;

namespace EFFirstSample
{
    public class MyContext : DbContext
    {
        public MyContext()
        {}
    }
}

So now, we will tell to the context what should be created in the database. Add the following line :

public DbSet<Person> Persons { get; set; }

It allow the context to know that it will contains a collection of Persons (and that a table Person should be created).
If we run the application, nothing will happen. You can check, connecting to your SqlExpress instance.
Let’s add some code in our Console, to call our context. Go to Program class and modify it like that :

static void Main(string[] args)
{
    var person = new Person {FirstName = "Nadege", LastName = "Deroussen", BirthDate = DateTime.Now};
    using (var context = new MyContext())
    {
        context.Persons.Add(person);
        context.SaveChanges();
    }
    Console.Write("Person saved !");
    Console.ReadLine();
}

We just create a new Person and add it to the database. Now, run the application and check the message before closing.

Save a person

It’s time to check in the person was well created. Connect to SqlExpress and check that a new database was created.

On the Toolbar Server Explorer, you should be a Data Connections node. If the toolbar is not visible, go to View -> Server Explorer

Right click on the node and select Add connection. A new window appears. Add your server (.\SqlExpress if you use SQL Express) and select your database in the dropdownlist. Here is what I have :

Test your connection and validate with the OK button. You should now see your database.

You can see a People table and an EdmMetadata table. The first one represent the table corresponding to your Person class. Why is it name People ? Because of naming convention. EF Code First uses pluralization rules and so our DbSet Persons is rename “People”, singularized.
Right click on the table name and select Open table definition. You should see something like that :

You can see the PersonId has been created as a primary key. How is it possible ? We don’t specify anything !
It’s simple. Code First uses naming convention to determine which property should be used as primary key. If you name a property TableNameId, Code First will see that this property will be used to define the primary key. Very simple.
There is other way to define the property that would match the primary key. We will see that in a future post.

The other table, EdmMetadata, stores a hash that will allow EF to check if there is modification to the model or not.

You just create your first, simple, application with Entity Framework Code First.
In a future post, we will see how to add multiple table with foreign key.

Edit (Jan, 27th 2012) : Add information on how to connect to the database

public class Person
{
    public int PersonId { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public DateTime BirthDate { get; set; }
}

I create my context with a DbSet of Person :

public class MyContext : DbContext
{
   public DbSet<Person> Persons { get; set; }

    public MyContext()
    {}
}

Nothing special. I create a new Person in a console application and add it to the context, so the table Person is created and the new row added :

static void Main(string[] args)
{
    var person = new Person {FirstName = "Nadege", LastName = "Deroussen", BirthDate = DateTime.Now};
    using (var context = new MyContext())
    {
        context.Persons.Add(person);
    }
    Console.Write("Person saved !");
    Console.ReadLine();
}

I run the application and connect to my SqlExpress to check the database was created and this is what I obtain :

Where is the Person table ?

I get a People table. I return to Visual Studio to check I don’t make a mistake and I run a search on the entire solution. No occurence of “People”.
Where is my Person table ? Why do I get a People table ?
For information, I use Entity Framework 4.2.

Does somebody know how to explain that ?

Edit 19/01/2012 :
Ok, I get the answer from Diego Vega. It’s just because of pluralization rules. As my DbSet is named Persons, Code First, creating the table, singularize the name and Person become People and no Person as I was expecting.

Entity Framework : Code First

You can find the book as paperback or Kindle edition.

Imagine a field declare like that :

<Field ID="{B126F0CB-C1C3-476E-A499-80528707A784}" Name="Comments" DisplayName="Comments" Type="HTML" RichText="TRUE" RichTextMode="FullHtml" Required="TRUE" />

Here is a solution to this problem. Create a partial class for accessing your list and add manually a property like this :

public partial class MyClassCT
    {
        private string _comments;

        [Microsoft.SharePoint.Linq.ColumnAttribute(Name = "Comments", Storage = "_comments", FieldType = "Text")]
        public string Comments
        {
            get { return _comments; }
            set
            {
                if ((value != this._comments))
                {
                    this.OnPropertyChanging("Comments", this._comments);
                    this._comments= value;
                    this.OnPropertyChanged("Comments");
                }
            }
        }
    }

As you can see, I declare the fieldtype as Text and so, the property can be a simple string.
That’s it, you can now access the property like any others.

This works very well for reading, but when you try to create or update the list, you would get this error :
Incompatible column types. Previous type: Text . Current type: Invalid.

After some research, I can’t find which type should be use. I try FieldType = “Invalid” and …, it works.
Here is the column attribute definition :

[ColumnAttribute(Name = "Comments", Storage = "_comments", FieldType = "Invalid")]

There is some things I don’t understand. If someone can explain me why Invalid is considered as a good value, I would be very grateful !

NB : your field must be declare as HTML is the schema.xml.

Edit (20/09/2011) :
If you are interested by the PascalCaseWordSplittingEnumConverter, you can find the code in the comments.

[Authorize(Roles = "Contributor, Administrator")]
public ActionResult Create()
{
    return View("Create");
}

Only Contributors could add articles to your blog. Fine !
Now, run your app and click on the “Add new article” link. Wow, you’re redirected to the login page. It’s perfect. You don’t have to manage it yourself. So, let’s try if it works. Connect with an account with Contributor rights. You are redirected to the Home page. Not so bad, but now, you have to click again on the link. It could be better if you can be redirected to the page you want to go.

It’s possible. You can modify your ActionLink to specify a returnUrl. It’s a simple attribute to add, like you can specify an area or a CSS style. Here is how to do :

@Html.ActionLink("Add new article", "Create", "Article", new { returnUrl = HttpContext.Current.Request.RawUrl }, null)

Now, when you click on the “Create” link and log in after being redirected, you are no longer redirected to the Home but to the Create page for articles.

Enjoy.

Here is my object definition :

public enum PostStatut
    {
        Draft,
        Pending,
        Published,
        Deleted
    }

public class Article
    {
        public int ArticleID { get; set; }

        [Required(ErrorMessage = "Title is required")]
        public string Title { get; set; }

        [Required(ErrorMessage = "Content is required")]
        [AllowHtml]
        public string Content { get; set; }

        [Required(ErrorMessage = "DateCreation is mandatory")]
        [DisplayFormat(ApplyFormatInEditMode = false, DataFormatString = "{0:dd/MM/yyyy hh:mm}")]
        public DateTime DateCreation { get; set; }

        public virtual IList<Commentaire> Commentaires { get; set; }

        public int? AuthorID { get; set; }
        [ForeignKey("AuthorID")]
        public Person Author { get; set; }

        [Column("Statut", TypeName = "int")]
        public int InternalStatut { get; set; }

        [NotMapped]
        public PostStatut Statut
        {
            get { return (PostStatut)InternalStatut; }
            set { InternalStatut = (int)value; }
        }

You can see that I have an enum property : PostStatus and a property to manage enum with Entity Framework : InternalStatut, a simple integer.

In my home page, I try to display all my posts that have a Published status. here is my query :

return _context.Articles.Include("Commentaires").Include("Author").Where(a => a.Statut == PostStatut.Published).OrderBy(a => a.DateCreation);

You can see that I use the enumeration in the query and it seems to be THE problem. I modify my query to use the InternalStatut like this :

return _context.Articles.Include("Commentaires").Include("Author").Where(a => a.InternalStatut == (int)PostStatut.Published).OrderBy(a => a.DateCreation);

And now it works ! EF doesn’t support query with enumerations yet.

I use a simple list like that :

<body>
	<ul class="navigation">
		<li>
			<a href="#">Menu 1</a>
		</li>
		<li>
			<a href="#">Menu 2</a>
		</li>
		<li>
			<a href="#">Menu 3</a>
		</li>
		<li>
			<a href="#">Settings</a>
			<div id="sub">
				<ul>
					<li>
						<a href="#">Display</a>
					</li>
					<li>
						<a href="#">Themes</a>
					</li>
					<li>
						<a href="#">Account</a>
					</li>
				</ul>
			</div>
		</li>
	</ul>
</body>

and add this simple css to hide or show my sub menu :

<style>
#sub ul {
    display: none;
}
li:hover > #sub ul {
    display: block;
}
</style>

I try to display this in Chrome and it works pretty fine. I open it with Firefox and my menu shows well too. I try to open it with IE 9 and here, nothing happen.
When my mouse is over the Settings item, nothing happens. My menu doesn’t show ? Is it a problem with display:block and IE 9 or is it my css that should be done another way ?
If somebody know how to do it works, just tell me ! I would be very happy.

I also try “inline” and “list-item” as value for the display attribute but I have the same result : works with Firefox and Chrome but not with IE 9 (I don’t try to use it with older version of IE 9).

Update :
Thanks to BatisteRouelle, I have my menu works with css only on IE 9.
I have to add a meta asking to render for IE 9 compatibility :

<meta http-equiv="X-UA-Compatible" content="IE=9" >

Update 12/08/2011: Trying to understand why this happen, we try to add the html page in an IIS Web Site and, using the default DOCTYPE, it works ! The problem is about autorization. IE, and only IE, don’t allow you to execute some code in local. It’s a security question. A little disturbing first but a good idea in fact.