继承映射关系 TPH、TPT、TPC<EntityFramework6.0>

   public class Business
    {
        [Key]
        public int BusinessId { get; protected set; }
        public string Name { get; set; }
        public string LicenseNumber { get; set; }
    }
    public class Retail : Business
    {
        public string Address { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string ZIPCode { get; set; }
    }    
    public class eCommerce : Business
    {
        public string URL { get; set; }
    }public class BusinessesContext : DbContext
    {
        public DbSet<Business> Businesses { get; set; }
       
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<Business>()
                .Property(b=>b.BusinessId)
                .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
            modelBuilder.Entity<Business>().ToTable("Business", "halower");
            modelBuilder.Entity<Retail>().ToTable("Retail", "halower");
            modelBuilder.Entity<eCommerce>().ToTable("eCommerce", "halower");
        }
    }

 private static void Main(string[] args)
        {
            using (var context = new BusinessesContext())
            {
                 
                var retail = new Retail
                {
                    Name = "Shop and Save",
                    LicenseNumber = "200C",
                    Address = "101 Main",
                    City = "Anytown",
                    State = "TX",
                    ZIPCode = "76106"
                };
                context.Businesses.Add(retail);
                var web = new eCommerce
                {
                    Name = "BuyNow.com",
                    LicenseNumber = "300AB",
                    URL = "www.buynow.com"
                };
                context.Businesses.Add(web);
                context.SaveChanges();
            }
            using (var context = new BusinessesContext())
            {
                Console.WriteLine("\n--- All Businesses ---");
                foreach (var b in context.Businesses)
                {
                    Console.WriteLine("{0} (#{1})", b.Name, b.LicenseNumber);
                }
                Console.WriteLine("\n--- Retail Businesses ---");
                //OfType<T>:根据指定类型筛选
                foreach (var r in context.Businesses.OfType<Retail>())
                {
                    Console.WriteLine("{0} (#{1})", r.Name, r.LicenseNumber);
                    Console.WriteLine("{0}", r.Address);
                    Console.WriteLine("{0}, {1} {2}", r.City, r.State, r.ZIPCode);
                }
                Console.WriteLine("\n--- eCommerce Businesses ---");
                foreach (var e in context.Businesses.OfType<eCommerce>())
                {
                    Console.WriteLine("{0} (#{1})", e.Name, e.LicenseNumber);
                    Console.WriteLine("Online address is: {0}", e.URL);
                }
                Console.ReadKey();
            }
        }

  public abstract class Employee
        {
            public int EmployeeId { get; protected set; }
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }

        public class FullTimeEmployee : Employee
        {
            public decimal? Salary { get; set; }
        }

        public class HourlyEmployee : Employee
        {
            public decimal? Wage { get; set; }
        }

        public class EmployeeContext: DbContext
        {
            public DbSet<Employee> Employees { get; set; }

            protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                base.OnModelCreating(modelBuilder);
                modelBuilder.Entity<Employee>()
                    .HasKey(e => e.EmployeeId)
                    .Property(e => e.EmployeeId)
                    .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
                modelBuilder.Entity<Employee>()
                    .Map<FullTimeEmployee>(m => m.Requires("EmployeeType").HasValue(1))
                    .Map<HourlyEmployee>(m => m.Requires("EmployeeType").HasValue(2));
            }

      private static void Main(string[] args)
        {
            using (var context = new EmployeeContext())
            {
                var fte = new FullTimeEmployee
                {
                    FirstName = "Jane",
                    LastName = "Doe",
                    Salary = 71500M
                };
                context.Employees.Add(fte);
                fte = new FullTimeEmployee
                {
                    FirstName = "John",
                    LastName = "Smith",
                    Salary = 62500M
                };
                context.Employees.Add(fte);
                var hourly = new HourlyEmployee
                {
                    FirstName = "Tom",
                    LastName = "Jones",
                    Wage = 8.75M
                };
                context.Employees.Add(hourly);
                context.SaveChanges();
            }
            using (var context = new EmployeeContext())
            {
                Console.WriteLine("--- All Employees ---");
                foreach (var emp in context.Employees)
                {
                    bool fullTime = !(emp is HourlyEmployee);
                    Console.WriteLine("{0} {1} ({2})", emp.FirstName, emp.LastName,
                        fullTime ? "Full Time" : "Hourly");
                }
                Console.WriteLine("--- Full Time ---");
                foreach (var fte in context.Employees.OfType<FullTimeEmployee>())
                {
                    Console.WriteLine("{0} {1}", fte.FirstName, fte.LastName);
                }
                Console.WriteLine("--- Hourly ---");
                foreach (var hourly in context.Employees.OfType<HourlyEmployee>())
                {
                    Console.WriteLine("{0} {1}", hourly.FirstName, hourly.LastName);

                }
            }
            Console.ReadKey();
        }

 protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                base.OnModelCreating(modelBuilder);
                modelBuilder.Entity<Employee>()
                    .HasKey(e => e.EmployeeId)
                    .Property(e => e.EmployeeId)
                    .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
                modelBuilder.Entity<FullTimeEmployee>()
                    .Map(m =>
                    {
                        m.MapInheritedProperties();
                        m.ToTable("FullTimeEmployee");
                    });
                modelBuilder.Entity<HourlyEmployee>()
                    .Map(m =>
                    {
                        m.MapInheritedProperties();
                        m.ToTable("HourlyEmployee");
                    });
            }