默认情况下，如何从继承自 ClassMapper<T> 的类中排除所有虚拟属性？答案

【问题标题】：How to exclude all virtual properties from classes inheritted from ClassMapper<T> by default?默认情况下，如何从继承自 ClassMapper<T> 的类中排除所有虚拟属性？
【发布时间】：2016-08-31 15:17:43
【问题描述】：

我有很多 POCO 类，每个类都包含多个虚拟属性。像这样的：

public class Policy
{
    public int Id { get; set; }
    public int EntityId { get; set; }
    public int ProgramId { get; set; }

    public string PolicyNumber { get; set; }
    public DateTime EffectiveDate { get; set; }
    public DateTime ExpirationDate { get; set; }

    public virtual Entity Entity{ get; set; }
    public virtual Program Program { get; set; }
    public virtual ICollection<Transaction> Transactions { get; set; }
}

为了使Dapper.Extensions 工作，我需要为这些类中的每一个编写一个映射，这很好。我的问题是，如果一个类中有任何virtual 属性，它们需要显式标记为ignored，而我总是忘记这样做。

public sealed class PolicyMapper : BaseMapper<Policy>
{
    public PolicyMapper()
    {
        Map(p => p.Entity).Ignore();
        Map(p => p.Program).Ignore();
        Map(p => p.Transactions).Ignore();
        AutoMap();
    }
}

如果Dapper.Extensions 库在映射到 POCO 类时会自动排除虚拟属性（如果有的话），那对我有什么好处。 Automapper 有一个扩展，它做类似的事情 (link)。有没有办法为Dapper.Extensions 库做到这一点？可能是这样的：

public sealed class PolicyMapper : BaseMapper<Policy>
{
    public PolicyMapper()
    {
        IgnoreAllVirtual();
        AutoMap();
    }
}

【问题讨论】：

标签： c# mapping dapper dapper-extensions

【解决方案1】：

我找到了自己的解决方案。由于我所有的映射类都派生自 BaseMapper 类，因此我决定重写 AutoMap() 方法，该方法将排除虚拟属性：

public class BaseMapper<T> : ClassMapper<T> where T : BaseClass
{
    public BaseMapper()
    {

    }

    protected override void AutoMap()
    {
        CustomAutoMap(null);
    }

    private void CustomAutoMap(Func<Type, PropertyInfo, bool> canMap)
    {
        Type type = typeof(T);
        bool hasDefinedKey = Properties.Any(p => p.KeyType != KeyType.NotAKey);
        PropertyMap keyMap = null;

        foreach (var propertyInfo in type.GetProperties())
        {
            // Exclude virtual properties
            if (propertyInfo.GetGetMethod().IsVirtual)
            {
                continue;
            }

            if (Properties.Any(p => p.Name.Equals(propertyInfo.Name, StringComparison.InvariantCultureIgnoreCase)))
            {
                continue;
            }

            if ((canMap != null && !canMap(type, propertyInfo)))
            {
                continue;
            }

            PropertyMap map = Map(propertyInfo);
            if (!hasDefinedKey)
            {
                if (string.Equals(map.PropertyInfo.Name, "id", StringComparison.InvariantCultureIgnoreCase))
                {
                    keyMap = map;
                }

                if (keyMap == null && map.PropertyInfo.Name.EndsWith("id", true, CultureInfo.InvariantCulture))
                {
                    keyMap = map;
                }
            }
        }

        if (keyMap != null)
        {
            keyMap.Key(PropertyTypeKeyTypeMapping.ContainsKey(keyMap.PropertyInfo.PropertyType)
                ? PropertyTypeKeyTypeMapping[keyMap.PropertyInfo.PropertyType]
                : KeyType.Assigned);
        }
    }
}

}

【讨论】：