EF无外键场景下，如何用Linq自动填充含嵌套类的继承类？

Great question! Manually mapping every property of MainTable to MainTable_Extended is tedious and error-prone, especially when your main entity has dozens of fields. Let’s break down the best approaches to solve this efficiently.

Option 1: Use AutoMapper's ProjectTo (Recommended for IQueryable Performance) #

AutoMapper’s ProjectTo method is perfect here because it works directly with IQueryable, translating your mapping logic into optimized SQL queries (so you don’t pull unnecessary data into memory). Here’s how to set it up:

Step 1: Install Required Packages #

First, install the appropriate AutoMapper package for your EF version:

• For Entity Framework 6: Install-Package AutoMapper.EF6
• For Entity Framework Core: Install-Package AutoMapper.EntityFrameworkCore

Step 2: Configure the Mapping Profile #

Create a mapping profile to tell AutoMapper how to convert MainTable to MainTable_Extended. Since MainTable_Extended inherits from MainTable, AutoMapper will automatically map all base class properties—no need to list them out!

public class MainTableMappingProfile : Profile
{
    public MainTableMappingProfile()
    {
        // Map base properties automatically, ignore the child properties we'll set manually
        CreateMap<MainTable, MainTable_Extended>()
            .ForMember(dest => dest.ChildOne, opt => opt.Ignore())
            .ForMember(dest => dest.ChildTwo, opt => opt.Ignore());
    }
}

Step 3: Initialize AutoMapper #

Initialize the mapper once at your app’s startup (e.g., Global.asax for ASP.NET, Program.cs for .NET Core):

// Configure mapper
var mapperConfig = new MapperConfiguration(cfg => 
{
    cfg.AddProfile<MainTableMappingProfile>();
});
IMapper mapper = mapperConfig.CreateMapper();

Step 4: Update Your LINQ Query #

Use ProjectTo to handle the base property mapping, then explicitly map the child entities:

// First, create a combined query with all needed data
var baseQuery = from main in db.MainTable
                from childone in db.TableChildOne
                    .Where(co => co.TableChildOneID == main.TableChildOneID)
                    .DefaultIfEmpty() // Left join
                from childtwo in db.TableChildTwo
                    .Where(ct => ct.TableChildTwoID == main.TableChildTwoID)
                    .DefaultIfEmpty() // Left join
                select new { main, childone, childtwo };

// Project to MainTable_Extended, mapping child entities explicitly
IQueryable<MainTable_Extended> listMainTable = baseQuery
    .ProjectTo<MainTable_Extended>(mapper.ConfigurationProvider, 
        dest => dest.ChildOne, src => src.childone,
        dest => dest.ChildTwo, src => src.childtwo);

This will generate clean SQL that only selects the necessary fields, and AutoMapper handles all the base property mapping for you.

Option 2: In-Memory Cloning (Simpler, but Less Efficient for Large Datasets) #

If you don’t want to add AutoMapper to your project, you can use MemberwiseClone() to copy base properties in memory. Note this pulls all MainTable data into memory first, so it’s not ideal for large datasets.

Step 1: Update MainTable_Extended (Optional but Clean) #

Add a constructor or method to handle cloning:

public class MainTable_Extended : MainTable
{
    public TableChildOne ChildOne { get; set; }
    public TableChildTwo ChildTwo { get; set; }

    public static MainTable_Extended FromMainTable(MainTable main, TableChildOne childOne, TableChildTwo childTwo)
    {
        // Shallow clone the main entity (works for value-type properties, which is standard for DB entities)
        var extended = main.MemberwiseClone() as MainTable_Extended;
        extended.ChildOne = childOne;
        extended.ChildTwo = childTwo;
        return extended;
    }
}

Step 2: Modify Your Query #

First fetch the combined data into memory, then map using the cloning method:

// Fetch data into memory first (use ToList() or AsEnumerable())
var tempData = db.MainTable
    .Select(main => new 
    { 
        main, 
        childone = db.TableChildOne.FirstOrDefault(co => co.TableChildOneID == main.TableChildOneID),
        childtwo = db.TableChildTwo.FirstOrDefault(ct => ct.TableChildTwoID == main.TableChildTwoID)
    })
    .ToList();

// Map to MainTable_Extended using the cloning method
IQueryable<MainTable_Extended> listMainTable = tempData
    .Select(item => MainTable_Extended.FromMainTable(item.main, item.childone, item.childtwo))
    .AsQueryable();

Why Avoid Manual Mapping? #

Manual mapping is error-prone—if you add a new property to MainTable, you’ll have to remember to update the mapping code everywhere. Both options above eliminate this overhead, with AutoMapper being the best choice for performance and scalability.

内容的提问来源于stack exchange，提问作者Hassan N