c# - 如何从继承自 ClassMapper 的类中排除所有虚拟属性默认？

Question

我有很多 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属性，则需要将它们显式标记为忽略，而我总是忘记这样做。

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做类似的事情（链接）。有没有办法为Dapper.Extensions图书馆做到这一点？可能是这样的：

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

Answer 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);
        }
    }
}

}