Here is what we’ve done in the previous post :

public class MyContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }
        public DbSet<Project> Projects { get; set; }
        public DbSet<Task> Tasks { get; set; } 

        public MyContext():base("EFSample")
        {}

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<Task>().HasRequired(t => t.Project).WithMany(p => p.Tasks).HasForeignKey(t => t.ProjectId).WillCascadeOnDelete(false);
            modelBuilder.Entity<Task>().HasRequired(p => p.AssignedTo);
            modelBuilder.Entity<Person>().Property(d => d.BirthDate).HasColumnName("Birth");
            modelBuilder.Entity<Project>().Property(p => p.Name).HasMaxLength(255).IsRequired();
            modelBuilder.Entity<Project>().HasRequired(p => p.Manager);
        }
    }

As you can see, in real project, you can fastly get hundred of configuration lines here and it can become difficult to browse and to maintain. That’s why, Code First allows you to use configuration files to manage your configuration by entity type.

First, we will create a new class to contain our configuration for the Task entity. reate a new class named TaskConfiguration and let it inherit from EntityTypeConfiguration (You should add the following namespace : System.Data.Entity.ModelConfiguration). Add a default constructor to this class. When this is done, move our configuration from MyContext class to TaskConfiguration. Here is how to modify your class :

public class TaskConfiguration : EntityTypeConfiguration<Task>
    {
        public TaskConfiguration()
        {
            Property(t => t.Title).IsRequired().HasMaxLength(255);
            HasRequired(t => t.AssignedTo);
            HasRequired(t => t.Project).WithMany(p => p.Tasks).HasForeignKey(t => t.ProjectId).WillCascadeOnDelete(false);
        }
    }

You can see I’ve added a new constraint about the Name length and I have just remove the modelBuilder.Entity(). Easy, no ?!

On the MyContext class, be sure you’ve deleted the line about the Task class and add the following line to register the configuration class for Task :

modelBuilder.Configurations.Add(new TaskConfiguration());

Here is what the MyContext class should look like :

public class MyContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }
        public DbSet<Project> Projects { get; set; }
        public DbSet<Task> Tasks { get; set; } 

        public MyContext():base("EFSample")
        {}

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Configurations.Add(new TaskConfiguration());
            modelBuilder.Entity<Person>().Property(d => d.BirthDate).HasColumnName("Birth");
            modelBuilder.Entity<Project>().Property(p => p.Name).HasMaxLength(255).IsRequired();
            modelBuilder.Entity<Project>().HasRequired(p => p.Manager);
        }
    }

Now, you can run the application and check your database. This is the expected result :

So, now, let’s do the same for Project and Person configuration.

public class ProjectConfiguration : EntityTypeConfiguration<Project>
    {
        public ProjectConfiguration()
        {
            Property(p => p.Name).HasMaxLength(255).IsRequired();
            HasRequired(p => p.Manager);
        }
    }

public class PersonConfiguration : EntityTypeConfiguration<Person>
    {
        public PersonConfiguration()
        {
            Property(d => d.BirthDate).HasColumnName("Birth");
        }
    }

And here is our new MyContext class. It now contains only “links” to our configuration classes :

public class MyContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }
        public DbSet<Project> Projects { get; set; }
        public DbSet<Task> Tasks { get; set; } 

        public MyContext():base("EFSample")
        {}

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Configurations.Add(new TaskConfiguration());
            modelBuilder.Configurations.Add(new ProjectConfiguration());
            modelBuilder.Configurations.Add(new PersonConfiguration());
        }
    }

If you run the application, now, the database would be created exactly as it was before and now, it would be easier to locate the code to modify in order to configure our database tables.

Enjoy !

Here is a simple MyContext class :

public class MyContext : DbContext
{
	public DbSet<Person> Persons { get; set; }
	public DbSet<Project> Projects { get; set; }
	public DbSet<Task> Tasks { get; set; } 

	public MyContext()
	{}

	protected override void OnModelCreating(DbModelBuilder modelBuilder)
	{
		base.OnModelCreating(modelBuilder);
		modelBuilder.Entity<Task>().HasRequired(t => t.Project).WithMany(p => p.Tasks).HasForeignKey(t => t.ProjectId).WillCascadeOnDelete(false);
		modelBuilder.Entity<Task>().HasRequired(p => p.AssignedTo);
		modelBuilder.Entity<Person>().Property(d => d.BirthDate).HasColumnName("Birth");
		modelBuilder.Entity<Project>().Property(p => p.Name).HasMaxLength(255).IsRequired();
		modelBuilder.Entity<Project>().HasRequired(p => p.Manager);
	}
}

This code will generate a database named EFFirstSample.MyContext.

To change the database name I just do this little tweak :

public class MyContext : DbContext
{
	public DbSet<Person> Persons { get; set; }
	public DbSet<Project> Projects { get; set; }
	public DbSet<Task> Tasks { get; set; } 

	public MyContext():base("EFSample")
	{}

	protected override void OnModelCreating(DbModelBuilder modelBuilder)
	{
		base.OnModelCreating(modelBuilder);
		modelBuilder.Entity<Task>().HasRequired(t => t.Project).WithMany(p => p.Tasks).HasForeignKey(t => t.ProjectId).WillCascadeOnDelete(false);
		modelBuilder.Entity<Task>().HasRequired(p => p.AssignedTo);
		modelBuilder.Entity<Person>().Property(d => d.BirthDate).HasColumnName("Birth");
		modelBuilder.Entity<Project>().Property(p => p.Name).HasMaxLength(255).IsRequired();
		modelBuilder.Entity<Project>().HasRequired(p => p.Manager);
	}
}

if i run my application, a new database will be created, named EFSample.
It’s very simple, there is nothing more to add or to do.

Hope it helps.

In Code First, there is two ways for configuring database creation. The first one is using Data Annotation as we have seen on my second post about foreign key relationship, the second one is using the Fluent API.

Let’s see how it works.

Define MaxLength of a column using DataAnnotation

First, we will define our columns. If we take a look at the table Project, we can see that all our columns created from string type in our class are nvarchar(max).

It’s not really useful and we don’t want the Name of the project to be so long. So we will define a max lenght for our project name and we will also indicate that a project should have a Name.

Here is how to do it using DataAnnotations.

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

Run the application and check your database columns :

This time, the Name column has a max length defined and the column Name is set as Not null.

Define column’s name using DataAnnotation

This time, we are going to see how to define a name for a column. Take a look at your Person class :

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

Let’s say we don’t want the property BirthDate to be stored in a column named BirthDate but in a column named Birth.

Here is how we can modify your class :

using System.ComponentModel.DataAnnotations;

public class Person
{
	public int PersonId { get; set; }
	public string LastName { get; set; }
	public string FirstName { get; set; }
	[Column("Birth")]
	public DateTime BirthDate { get; set; }
}

Run the application and check your database :

You can see the column name has changed.

Declare a property as foreign key with DataAnnotation

First we are going to add a new class Task with a foreign key to Project and to Person classes, add a list of tasks in the Project class and remove the Manager property.

public class Task
{
    public int TaskId { get; set; }
	public string Title { get; set; }
	public string Description { get; set; }
	public int PersonId { get; set; }
	[ForeignKey("PersonId")]
	public Person AssignedTo { get; set; }
	public int ProjectId { get; set; }
	[ForeignKey("ProjectId")]
	public Project Project { get; set; }
}

public class Project
	{
		public int ProjectId { get; set; }
		MaxLength(255)]
		[Required]
		public string Name { get; set; }
		public List<Task> Tasks { get; set; }
	}

We use DataAnnotation to specify foreign keys to Project and Person tables. Then we modify your Context class :

public class MyContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }
        public DbSet<Project> Projects { get; set; }
        public DbSet<Task> Tasks { get; set; } 

        public MyContext()
        {}

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }
    }

And we run the console application. Here is the result :

Ok, all works fine until now. Let’s re add the Manager property in the Project class :

public class Project
    {
        public int ProjectId { get; set; }
        [MaxLength(255)]
        [Required]
        public string Name { get; set; }

        public int ManagerId { get; set; }
        [ForeignKey("ManagerId")]
        public Person Manager { get; set; }

        public List<Task> Tasks { get; set; }
    }

Here we get an SqlException:

Introducing FOREIGN KEY constraint ‘FK_Tasks_Projects_ProjectId’ on table ‘Tasks’ may cause cycles or multiple cascade paths. Specify ON DELETE NO ACTION or ON UPDATE NO ACTION, or modify other FOREIGN KEY constraints.

Could not create constraint. See previous errors.

This error doesn’t come from Entity Framework nor Code First, it comes from Sql Server. It doesn’t want to create tables and constraints because it estimate there will be some issues if we let it as is. It asks us to specify action in case of delete (to avoid multiple cascade delete) or to modify our contraints.

As we don’t want to modify our contraints, we will specify action in case of delete. Here is the first operation we can’t do using DataAnnotation. We will have to do it using Code Fluent.

Declare a property as foreign key with Code Fluent

Now, we have seen how to configure the generation of the database with DataAnnotation, we’ll see how to do the same, and more, with Fluent API.

This configuration should be done in the Context class. Here is how I modify it to declare the foreign key between Task and Project :

public class MyContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }
        public DbSet<Project> Projects { get; set; }
        public DbSet<Task> Tasks { get; set; } 

        public MyContext()
        {}

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<Task>().HasRequired(t => t.Project).WithMany(p => p.Tasks).HasForeignKey(t => t.ProjectId).WillCascadeOnDelete(false);
            modelBuilder.Entity<Task>().HasRequired(p => p.AssignedTo);
        }
    }

It’s easy to understand. A task should be linked to a project which could have multiple tasks, this relation would be done using the property ProjectId and there will be no action in case of Delete.

We’ve done the same for the relationship between task and Person.

Now, we need to modify our Task class like this, to remove DataAnnotations :

public class Task
    {
        public int TaskId { get; set; }
        public string Title { get; set; }
        public string Description { get; set; }

        public int PersonId { get; set; }
        public Person AssignedTo { get; set; }

        public int ProjectId { get; set; }
        public Project Project { get; set; }
    }

And we can remove the directive :

using System.ComponentModel.DataAnnotations;

This time, when we run the application, there is no error and our tables are correctly created :

Define column’s name using Code Fluent

Now, we will modify our Person class to use Code Fluent.

First, we delete the Attribute Column.

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

Then we go to the Context class and add the line below :

modelBuilder.Entity<Person>().Property(d => d.BirthDate).HasColumnName("Birth");

Define a column as non nullable

We will also indicate that a project should have a manager:

modelBuilder.Entity<Project>().HasRequired(p => p.Manager);

Define the MaxLength of a property and that it is a required information

modelBuilder.Entity<Project>().Property(p => p.Name).HasMaxLength(255).IsRequired();             modelBuilder.Entity<Project>().HasRequired(p => p.Manager);

This article is now finished. I hope it’ll help you understand how DataAnnotation and Code Fluent work.

You can download source here :
Data Annotation and Code Fluent

In a future article we’ll see how to organize our configuration.

Tips for Entity Framework Migrations

Maybe some of you can find it useful too.

If you find the following line with Taxonomy category an error code ca3r

Error encountered in background cache check System.UnauthorizedAccessException: The current user has insufficient permissions to perform this operation.

The issue should come from permissions. The account use to run the Managed Metadata service should miss some rights.

Here are some explanations on how to configure it with the right permissions :
Failed Background Check

Hope this helps.

I also find this article very interesting because it lists some tips really important on my opinion.

The tip really important to me is the use of the force attribute :

Never use the Force switch. Not only it makes SharePoint stop affected Application Pools but also it prevents you from seeing errors should there be any. The Force switch might be useful in some scenarios, like fixing broken deployments of SharePoint Packages, but in general you should try to avoid using it.

I think this is really important. If you use the force attribute you will think that everything went right, but it could be wrong. You just don’t see any errors. It doesn’t mean everything went ok. And sometimes, you will encountered some issues, you will spend lot’s of time to understand why, and will see that some features are not well deployed on all your Web Front End whereas there were no errors during deployments.

I select a color for my background.

I clicked Next and went on a screen to connect to a wireless network.

It’s a good thing to allow user to connect an hidden network from there.
I continued and a new screen purpose me to configure other settings. I choose to use Express Settings. I could change them later if I need it.
The next screen helped me to sign in.

I was a little confused there because I had to sign in with a windows account. I was not able to create an account for my computer. I imagine it’s because of Azure and cloud computing. We will no more be able to choose what we want to use or not. We will be oblige to be connected. Bad thing !!!
But I continued. My account was created.

My Widows finished to configure all settings.

And I launch Windows 8 on my laptop.

Now, I have to play with it and see what’s new ( lots of things) !

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. I recommend not to use this in a production environment. It could be very useful for a developer but not to run in a real world.

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
4 – Code Fluent configuration file
4 – Initialize database with data
5 – Table per Type and Table per Hierarchy

Tips : How to define your own Database name

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