Complex type in EFCodeFirst

I have already written a few blog post about EF Code first and it’s features following is a complete list of blog posts.

Entity framework code first and inheritance- Table Per Type
Entity Framework code first and Inheritance–Table per hierarchy
Entity Framework Code First migrations
Different way of mapping with EFCodeFirst
Different way of creating keys in EFCodeFirst

This post will also be part of this EF code first series. In this blog post we are going to learn how we can handle complex type in EF Code First. In our day to day operation we are having different kind of database tables where there are multiple type of relationships are defined like one-to-one, one-to-many and many-to-many. This all kind of relationship is handle by complex types.

Let’s create a simple console application for student and through this We are going to understand how EF Code First handles complex types. Following is our model implementation.

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string PostalCode { get; set; }
}

And following is student class implementation.

public class Student
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Address StudentAddress { get; set; }
}

Now let’s create a Entity Framework Code First Data context. For that we need to add entity framework reference via NuGet Package.

entity-framework-code-first-nuget-package-complex-type

Now It’s time to add a database.

Let’s create data context for EF Code First like following.

using System.Data.Entity;

namespace EFCodeFirstComplexType
{
    
    public class StudentContext : DbContext
    {
        public StudentContext()
            : base("DefaultConnectionString")
        {
            
        }
        public DbSet<Student> Students { get; set; }
    }
}

And here is code for my console application.

using System;

namespace EFCodeFirstComplexType
{
    class Program
    {
        static void Main(string[] args)
        {
            var studentContext = new StudentContext();
            foreach(Student student in studentContext.Students)
            {
               Console.WriteLine(student.FirstName); 
               Console.WriteLine(student.LastName);
            }
        }
    }
}

Now when you run this console application it will create a database like following.

using System;

namespace EFCodeFirstComplexType
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student student = new Student
                {
                    Id = 1,
                    FirstName = "Jalpesh",
                    LastName = "Vadgama",
                    StudentAddress = new Address()
                };
                using (var studentContext = new StudentContext())
                {
                    studentContext.Students.Add(student);
                    studentContext.SaveChanges();
                }
            }
            catch (Exception exception)
            {
              Console.WriteLine(exception.Message);
            }
        }
    }
}

Here you can notice that I have initialized the Address object in student with keyword otherwise it will give a error the limitation of EFCodeFirst is complex type if already required.. Now once you run that application it will create following table in database.

So Here I have given property name Student Address that’s why it it created like above.

How EF Code First discovered complex type:

Here in EFCode First complex type is discovered via convention. Here EFCodeFirst determines that Student class has a property of Address type and that’s why it also included properties of Address class in to table. You can find more information about default convection in EFCode First from the following link.

http://blogs.msdn.com/b/efdesign/archive/2010/06/01/conventions-for-code-first.aspx

Explicitly Register a Complex Type:

You can also explicitly register Address class as Complex Type in EFCodeFirst with ComplexType attribute.

[ComplexType]
public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string PostalCode { get; set; }
}

You can also defined complex type with OnModelCreating event of datacontext like following.

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.ComplexType<Address>();
}

That's it. Hope you like it. Stay tuned for more about EFCodeFirst in forthcoming post.

You can find complete source code for this blog post at gihub at -https://github.com/dotnetjalps/EFCodeFirstComplexType

DotNetJalps