Automapper多映射存在相同配置冗余，寻求优化解决方案

Got it, let's tackle that annoying repetitive code in your AutoMapper profiles. Copy-pasting the same ForMember(x => x.Field, opt => opt.Ignore()) lines for every mapping isn't just tedious—it's a maintenance nightmare. Here are three clean, scalable solutions to eliminate that redundancy:

1. Global Ignore (Simplest for Universal Rules) #

If those audit fields (CreationDate, ModifiedDate, etc.) should be ignored in all your mappings, use AutoMapper's AddGlobalIgnore method directly in your profile's constructor. This applies the ignore rule once, and it works for every mapping in the profile.

Example: #

public MappingProfile()
{
    // Add global ignores for all audit fields (use nameof() to avoid typos)
    AddGlobalIgnore(nameof(CreationDate));
    AddGlobalIgnore(nameof(ModifiedDate));
    AddGlobalIgnore(nameof(ModifiedUser));
    AddGlobalIgnore(nameof(CreationUser));
    AddGlobalIgnore(nameof(Language));

    // Now your mappings are clean and concise
    CreateMap<DesireDto, Desire>();
    CreateMap<ProductDto, Product>();
    // Other mappings...
}

Pro Tip: If you ever need to override this rule for a specific mapping, just add a .ForMember(x => x.CreationDate, opt => opt.MapFrom(...)) to that individual map—it will take precedence over the global ignore.

2. Extension Method (Flexible for Partial Mappings) #

If you only need to ignore these fields for some mappings (not all), create a reusable extension method. This keeps your profile code tidy and lets you apply the rule only where needed. For extra safety, add an interface constraint to ensure the target entity actually has these audit fields.

Step 1: Define an Audit Interface #

public interface IAuditableEntity
{
    DateTime CreationDate { get; set; }
    DateTime ModifiedDate { get; set; }
    string ModifiedUser { get; set; }
    string CreationUser { get; set; }
    string Language { get; set; }
}

Make sure your target entities (Desire, Product) implement this interface.

Step 2: Create the Extension Method #

public static class AutoMapperExtensions
{
    public static IMappingExpression<TSource, TDestination> IgnoreAuditFields<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> mappingExpression)
        where TDestination : IAuditableEntity
    {
        return mappingExpression
            .ForMember(dest => dest.CreationDate, opt => opt.Ignore())
            .ForMember(dest => dest.ModifiedDate, opt => opt.Ignore())
            .ForMember(dest => dest.ModifiedUser, opt => opt.Ignore())
            .ForMember(dest => dest.CreationUser, opt => opt.Ignore())
            .ForMember(dest => dest.Language, opt => opt.Ignore());
    }
}

Step 3: Use It in Your Profile #

public MappingProfile()
{
    CreateMap<DesireDto, Desire>().IgnoreAuditFields();
    CreateMap<ProductDto, Product>().IgnoreAuditFields();
    // Mappings that don't need the ignore rule can skip this method entirely
}

This approach is self-documenting (IgnoreAuditFields() clearly communicates what's happening) and keeps your entity classes decoupled from AutoMapper-specific logic.

3. Ignore Attributes (Cleanest for Entity-Level Rules) #

If you control the target entity classes, you can use AutoMapper's [IgnoreMap] attribute directly on the audit fields. This eliminates the need to configure ignores in your profile entirely.

Example: #

public class Desire : IAuditableEntity
{
    [IgnoreMap]
    public DateTime CreationDate { get; set; }
    
    [IgnoreMap]
    public DateTime ModifiedDate { get; set; }
    
    [IgnoreMap]
    public string ModifiedUser { get; set; }
    
    [IgnoreMap]
    public string CreationUser { get; set; }
    
    [IgnoreMap]
    public string Language { get; set; }

    // Other properties...
}

Then your profile becomes super simple:

public MappingProfile()
{
    CreateMap<DesireDto, Desire>();
    CreateMap<ProductDto, Product>();
}

Note: Only use this if you never need to map these fields in any scenario. Also, if your entities are EF Core models, adding AutoMapper attributes won't interfere with EF's mappings—just be okay with coupling your entity to AutoMapper's conventions.

Which Should You Choose? #

• Global Ignore: Best if every mapping needs to ignore these fields.
• Extension Method: Best if only some mappings need the rule, or if you want to keep entity classes decoupled from AutoMapper.
• Ignore Attributes: Best if you control the entities and want zero profile configuration for these fields.

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