Entity Framework let us use the Code First Fluent API in the DbContext to configure how your entities are created. This is done by using the modelbuilder in an override of the OnModelCreate method as explained here. A cleaner way of organizing your configurations is by deriving a custom class from EntityTypeConfiguration for each entity you need to configure.

In this example we configure the AssemblyItem entity from our previous example.

namespace CodeFirstPocos
{
    public class AssemblyItem
    {
        public int AssemblyId { get; set; }
        public int BillOfMaterialsId { get; set; }
        public string PartNumber { get; set; }
        public string Description { get; set; }
        public double Quantity { get; set; }
        public decimal Price { get; set; }
        public bool IsInStock { get; set; }
    }
}

By convention Entity Framework looks for an Id or classname + Id property to define the key for a specific entity. In our entity we want to use a different naming convention for our key property. We also want to change the name of the corresponding table column for the rather lengthy BillOfMaterialsId to BomId. Besides that we need to tell Entity Framework we don’t need to store the value of the IsInStock property, since it’s only used as a temporary value.

To do this we create a derived class named AssemblyItemConfiguration from EntityTypeConfiguration and set up the configuration in the constructor by using the Code First Fluent API.

using System.Data.Entity.ModelConfiguration;
using CodeFirstPocos;

namespace CodeFirstData
{
    public class AssemblyItemConfiguration
        : EntityTypeConfiguration<AssemblyItem>
    {
        public AssemblyItemConfiguration()
        {
            HasKey(ai => ai.AssemblyId);
            Property(ai => ai.BillOfMaterialsId)
                .HasColumnName("BomId");
            Ignore(ai => ai.IsInStock);
        }
    }
}

The only thing we need to do for this new Entity Type Configuration to work is to add it to the configurations collection of the modelbuilder in the OnModelCreating method of our DbContext derived class.

using System.Data.Entity;
using CodeFirstPocos;

namespace CodeFirstData
{
    public class BomContext : DbContext
    {
        public DbSet<BillOfMaterials> BillOfMaterialsSet { get; set; }
        public DbSet<AssemblyItem> AssemblyItems { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.Add(new AssemblyItemConfiguration());

            base.OnModelCreating(modelBuilder);
        }
    }
}

Lets write a simple test to see if this works…

using System;
using System.Collections.Generic;
using System.Data.Entity;
using CodeFirstData;
using CodeFirstPocos;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CodeFirstTests
{
    [TestClass]
    public class BomTests
    {
        [TestMethod]
        public void AssemblyItemEntityShouldGetCustomConfiguration()
        {
            Database.SetInitializer(new DropBomContextIfModelChanges());
            var bomContext = new BomContext();

            var assemblyItem =
                new AssemblyItem
                    {
                        Description = "Screw",
                        IsInStock = true,
                        PartNumber = "S05-331",
                        Price = 12.50m,
                        Quantity = 4,
                    };

            var bom =
                new BillOfMaterials
                    {
                        CreationDate = DateTime.Today,
                        ProjectName = "AssemblyItem monster",
                        IsHandleWithCare = true,
                        AssemblyItems =
                            new List<AssemblyItem>
                                {
                                    assemblyItem,
                                },
                    };

            bomContext.BillOfMaterialsSet.Add(bom);
            bomContext.SaveChanges();
        }
    }
}

If we take a look in de database at the AssemblyItem table we see the expected key name is AssemblyId, the shortened version of the BillOfMaterialsId is now BomId and there is no IsInStock column.

Since Entity Framework 4.1 we can use the Code First Fluent API to specify how our database gets created, effectively overriding the default settings. This is also possible with data annotations, but the Fluent API gives us a way to keep this out of our POCO classes and into the data layer.

In this example we have two POCO’s; first a Bill of Materials (BOM)…

using System;
using System.Collections.Generic;

namespace CodeFirstPocos
{
    public class BillOfMaterials
    {
        public int Id { get; set; }
        public string ProjectName { get; set; }
        public DateTime CreationDate { get; set; }
        public List<AssemblyItem> AssemblyItems { get; set; }
    }
}

… which can contain a list of assembly items.

namespace CodeFirstPocos
{
    public class AssemblyItem
    {
        public int Id { get; set; }
        public int BillOfMaterialsId { get; set; }
        public string PartNumber { get; set; }
        public string Description { get; set; }
        public double Quantity { get; set; }
        public decimal Price { get; set; }
    }
}

If we let Entity Framework create our database, we get default creation behavior which is not always what we want. For instance the string type gets translated to the database as a nullable varchar(max) column by default. Maybe we want to restrict the length of that property. Or maybe we use lengthy names for properties in our POCO classes, but we want shorter equivalents in the table. That’s where the Code First Fluent API comes into play.

With Code First we create a descendant of the DbContext class with a DbSet property for each POCO entity. The first time this DbContext gets instantiated it will create the database for us (if it’s not already there). During that process the OnModelCreating method gets called and that is the spot where we may provide different configuration using the Code First Fluent API.

In the BomContext class below we override the OnModelCreating method and specify the maximum length of the ProjectName property of the BillOfMaterials entity. We also tell Entity Framework to make it required and rename this property to ‘Project’ in the database.

using System.Data.Entity;
using CodeFirstPocos;

namespace CodeFirstData
{
    public class BomContext : DbContext
    {
        public DbSet<BillOfMaterials> BillOfMaterialsSet { get; set; }
        public DbSet<AssemblyItem> AssemblyItems { get; set; }

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

            modelBuilder.Entity<BillOfMaterials>()
                .Property(p => p.ProjectName)
                .HasMaxLength(24)
                .IsRequired()
                .HasColumnName("Project");
        }
    }
}

We create a simple test against SQL Express to see how Entity Framework creates our tables. We create one fictive Bill of Materials with three assembly items.

using System;
using System.Collections.Generic;
using CodeFirstData;
using CodeFirstPocos;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CodeFirstTests
{
    [TestClass]
    public class BomTests
    {
        [TestMethod]
        public void FirstCallToBomContextShouldCreateDatabase()
        {
            var bom =
                new BillOfMaterials
                    {
                        CreationDate = new DateTime(2012, 5, 18),
                        ProjectName = "The Code Project",
                        AssemblyItems =
                            new List<AssemblyItem>
                                {
                                    new AssemblyItem
                                        {
                                            PartNumber = "A1284-e",
                                            Description = "Case",
                                            Price = 199m,
                                            Quantity = 1,
                                        },
                                    new AssemblyItem
                                        {
                                            PartNumber = "124-448",
                                            Description = "Motherboard",
                                            Price = 398m,
                                            Quantity = 1,
                                        },
                                    new AssemblyItem
                                        {
                                            PartNumber = "i7-2600K",
                                            Description = "Intel i7 CPU",
                                            Price = 720m,
                                            Quantity = 1,
                                        },
                                }
                    };

            var context = new BomContext();
            context.BillOfMaterialsSet.Add(bom);
            context.SaveChanges();
        }
    }
}

We take a look at the database after we run the test method. Entity Framework created the database for us called CodeFirstData.BomContext. In the BillOfMaterials table we now have the required column ‘Project’ allowing a maximum length of 24 characters.