Cómo excluir todas las propiedades virtuales de las clases heredadas de ClassMapper ¿por defecto?

c# dapper dapper-extensions mapping

Pregunta

Tengo muchas clases de POCO que contienen varias propiedades virtuales cada una. Algo como esto:

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

Para hacer que Dapper.Extensions funcione, necesito escribir un mapeo para cada una de estas clases, lo cual está bien. Mi problema es que si hay propiedades virtual dentro de una clase, deben marcarse explícitamente como ignoradas , lo que siempre olvido hacer.

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

Lo que sería genial para mí, si la biblioteca Dapper.Extensions excluirá automáticamente las propiedades virtuales, si las hubiere, cuando se asignan a la clase POCO. Existe una extensión para Automapper que hace algo similar ( enlace ). ¿Hay alguna manera de hacer eso para la biblioteca Dapper.Extensions ? Posiblemente algo como esto:

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

Respuesta aceptada

Encontré mi propia solución. Dado que todas mis clases de mapeo se derivan de la clase BaseMapper, decidí anular el método AutoMap () que excluirá las propiedades virtuales:

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

}



Licencia bajo: CC-BY-SA with attribution
No afiliado con Stack Overflow
¿Es esto KB legal? Sí, aprende por qué
Licencia bajo: CC-BY-SA with attribution
No afiliado con Stack Overflow
¿Es esto KB legal? Sí, aprende por qué