Entity Framework supported enums since 4.3 (I think). This works great but requires a few extra steps in case you need to store those enum in lookup table. Here's a walkthrough.

Suppose we want an entity called DatabaseObject which has Id, Name and also database object property type (Database, Table, Stored Procedure, Column). We also want to have a lookup table called DatabaseObjectType with Id and Name.

We start with defining enum:

public enum DatabaseObjectType  
{
    Database = 1, // These values match database values
    Table = 2,
    Column = 3,
    StoredProcedure = 4
}

Then a lookup table which we need to give a different name, but we'll change it in the mapping:

public class DatabaseObjectTypeLookup  
{
    public DatabaseObjectType ObjectType { get; set; }
    public string Name { get; set; }
    public virtual  List<DatabaseObject> DatabaseObjectsType { get; set; }
}

Here's how it is going to be mapped:

public class DatabaseObjectPropertyTypeLookupConfiguration : EntityTypeConfiguration<DatabaseObjectPropertyTypeLookup>  
{
    public DatabaseObjectPropertyTypeLookupConfiguration()
    {            
        HasKey(h => h.PropertyType);
        Property(h => h.PropertyType)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None)
            .HasColumnName("DatabaseObjectPropertyTypeId"); 
        ToTable("DatabaseObjectPropertyType");
    }
}

DatabaseObject entity:

public class DatabaseObject  
{
    public int DatabaseObjectId { get; set; }
    public string FullyQualifiedName { get; set; }
    public DatabaseObjectType ObjectType { get; set; }
}

Here we use enum and adjust its name in the mapping:

public class DatabaseObjectConfiguration : EntityTypeConfiguration<DatabaseObject>  
{
    public DatabaseObjectConfiguration()
    {            
        HasKey(h => h.DatabaseObjectId);
        Property(t => t.ObjectType).HasColumnName("DatabaseObjectTypeId");
        ToTable("DatabaseObject");
    }
}

All of the above will produce this DDL (abbreviated)

create table [dbo].[DatabaseObject] (  
    [DatabaseObjectId] [int] not null identity,
    [FullyQualifiedName] [varchar](500) not null,
    [DatabaseObjectTypeId] [int] not null,
    primary key ([DatabaseObjectId])
);
create table [dbo].[DatabaseObjectType] (  
    [DatabaseObjectTypeId] [int] not null,
    [Name] [varchar](100) not null,
    primary key ([DatabaseObjectTypeId])
);
alter table [dbo].[DatabaseObject] add constraint [DatabaseObjectTypeLookup_DatabaseObjectsType] foreign key ([DatabaseObjectTypeId]) references [dbo].[DatabaseObjectType]([DatabaseObjectTypeId]);  

Final step is to initialize the lookup table in the seeder:

public class DependencyGraphSeeder  
{
    private readonly DependencyGraphContext _context;

    public DependencyGraphSeeder(DependencyGraphContext context)
    {
        _context = context;
    }

    public void Seed()
    {
        _context.DatabaseObjectTypeLookups.AddRange(new DatabaseObjectTypeLookup[]
        {
            new DatabaseObjectTypeLookup { ObjectType = DatabaseObjectType.Database, Name = "Database"},
            new DatabaseObjectTypeLookup { ObjectType = DatabaseObjectType.Table, Name = "Table"},
            new DatabaseObjectTypeLookup { ObjectType = DatabaseObjectType.StoredProcedure, Name = "Stored Procedure"},
            new DatabaseObjectTypeLookup { ObjectType = DatabaseObjectType.Column, Name = "Column"}
        });          
         _context.SaveChanges();
    }
}