Shadman Kudchikar

Entity Framework Enum Code First

Entity Framework Enum Code First

Contents

Introduction

Enum or Enumerations is used to declare a list of named integer constants. The enum is used to give a name to each constant so that the constant integer can be referred using its name.

Enumerations appear in your source code. These are things that affect program logic because you’re going to have conditional statements based on the state of some entity comparing it with some enum value. This enums represents numerical values which can get used in place of IDs in database tables.

Creating Enum

C# usually manages the IDs of enumeration for you.

As you version your code from one version to the next you want to make sure that those IDs remain consistent. To keep it consistent we assing values to each enum. Below is the code for StatusEnum we will be working on.

public enum StatusEnum
{
    FullTime = 0,
    PartTime = 1,
    Casual = 2,
    Contract = 3
}

Creating Lookup Table Class Using Code-First Approch

We will create another class named Status to represent our above enum as lookup table. Status class will act as a lookup table for our above StatusEnum. Here we use StatusEnum as datatype for our IDs to constrain the Status ID to just those values in the StatusEnum.

public class Status
{
    public StatusEnum Id { get; set; }
    public string Name { get; set; }
}

Define Foreign Key Constraint Using Code-First Conventions

Below is the Employee class that represent our Employee Table. Below code will create the Foreign Key relationship inside a Employee, and constrain the Status ID to just those values in the StatusEnum.

public class Employee
{
    public long Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    //Below code will create the Foreign Key relationship inside a Employee, and 
    //constrain the Status ID to just those values in the StatusEnum
    //Here StatusEnum will act as ID/Primary key for Status table 
    //and will be seeded manually 
    //Look context class for additional model builder configuration which disables 
    //the identity for Status table and
    //Also look seed method in configuration.cs file
    public StatusEnum StatusId { get; set; }
    public virtual Status Status { get; set; }
    

}

Disable Identity for Lookup Table IDs

When you’re backing enum with the database you want to control those IDs. We can disable the identity on our lookup Status table by confuguring the modelBuilder. By disabling the identity we will have control over the IDs we want to poplulate, which will be the enum values in our case.

public class ApplicationContext:DbContext
{
    public DbSet<Employee> Employees { get; set; }
    public DbSet<Status> Statuses { get; set; }

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

        modelBuilder.Entity<Status>()
            .Property(s => s.Id)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
    }
}

Seeding Enum into Lookup Table

In order to insert the enumeration values into the database we’re going to take advantage of the seed method. This is a method on the configuration class that was created whenever we enabled migrations for the first time. Let’s jump to the code, and see how we can create seed data for an enumeration.

internal sealed class Configuration : DbMigrationsConfiguration<ApplicationContext>
{
    public Configuration()
    {
        AutomaticMigrationsEnabled = false;
    }

    protected override void Seed(MigrationTutorial.Models.ApplicationContext context)
    {
        //  This method will be called after migrating to the latest version.

        //  You can use the DbSet<T>.AddOrUpdate() helper extension method 
        //  to avoid creating duplicate seed data.

        context.Statuses.AddOrUpdate( 
            x=> x.Id,
            Enum.GetValues(typeof(StatusEnum))
                .OfType<StatusEnum>()
                .Select(x => new Status() { Id = x, Name=x.ToString() })
                .ToArray());
    }
}

By using the above method for seeding we can eliminate mistakes and error occur in populating enums in our lookup table.

References


comments powered by Disqus