Mapear manualmente nomes de colunas com propriedades de classe

Eu sou novo no Dapper micro ORM. Até agora, posso usá-lo para coisas simples relacionadas ao ORM, mas não consigo mapear os nomes das colunas do banco de dados com as propriedades da classe.

Por exemplo, eu tenho a seguinte tabela de banco de dados:

Table Name: Person
person_id  int
first_name varchar(50)
last_name  varchar(50)

e eu tenho uma classe chamada Person:

public class Person 
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Observe que os nomes das minhas colunas na tabela são diferentes do nome da propriedade da classe para a qual estou tentando mapear os dados que obtive do resultado da consulta.

var sql = @"select top 1 PersonId,FirstName,LastName from Person";
using (var conn = ConnectionFactory.GetConnection())
{
    var person = conn.Query<Person>(sql).ToList();
    return person;
}

O código acima não funcionará, pois os nomes das colunas não correspondem às propriedades (Pessoa) do objeto. Nesse cenário, há algo que eu possa fazer no Dapper para mapear manualmente (por exemplo person_id => PersonId) os nomes das colunas com propriedades do objeto?

Isso funciona bem:

var sql = @"select top 1 person_id PersonId, first_name FirstName, last_name LastName from Person";
using (var conn = ConnectionFactory.GetConnection())
{
    var person = conn.Query<Person>(sql).ToList();
    return person;
}

O Dapper não possui nenhum recurso que permita especificar um Atributo de Coluna ; não sou contra a adição de suporte a ele, desde que não extraamos a dependência.

O Dapper agora suporta colunas personalizadas para mapeadores de propriedades. Isso é feito através da interface ITypeMap . Uma classe CustomPropertyTypeMap é fornecida pelo Dapper que pode executar a maior parte deste trabalho. Por exemplo:

Dapper.SqlMapper.SetTypeMap(
    typeof(TModel),
    new CustomPropertyTypeMap(
        typeof(TModel),
        (type, columnName) =>
            type.GetProperties().FirstOrDefault(prop =>
                prop.GetCustomAttributes(false)
                    .OfType<ColumnAttribute>()
                    .Any(attr => attr.Name == columnName))));

E o modelo:

public class TModel {
    [Column(Name="my_property")]
    public int MyProperty { get; set; }
}

É importante observar que a implementação do CustomPropertyTypeMap exige que o atributo exista e corresponda a um dos nomes de coluna ou a propriedade não será mapeada. A classe DefaultTypeMap fornece a funcionalidade padrão e pode ser aproveitada para alterar esse comportamento:

public class FallbackTypeMapper : SqlMapper.ITypeMap
{
    private readonly IEnumerable<SqlMapper.ITypeMap> _mappers;

    public FallbackTypeMapper(IEnumerable<SqlMapper.ITypeMap> mappers)
    {
        _mappers = mappers;
    }

    public SqlMapper.IMemberMap GetMember(string columnName)
    {
        foreach (var mapper in _mappers)
        {
            try
            {
                var result = mapper.GetMember(columnName);
                if (result != null)
                {
                    return result;
                }
            }
            catch (NotImplementedException nix)
            {
            // the CustomPropertyTypeMap only supports a no-args
            // constructor and throws a not implemented exception.
            // to work around that, catch and ignore.
            }
        }
        return null;
    }
    // implement other interface methods similarly

    // required sometime after version 1.13 of dapper
    public ConstructorInfo FindExplicitConstructor()
    {
        return _mappers
            .Select(mapper => mapper.FindExplicitConstructor())
            .FirstOrDefault(result => result != null);
    }
}

E, com isso em prática, fica fácil criar um mapeador de tipo personalizado que usará automaticamente os atributos se estiverem presentes, mas que retornará ao comportamento padrão:

public class ColumnAttributeTypeMapper<T> : FallbackTypeMapper
{
    public ColumnAttributeTypeMapper()
        : base(new SqlMapper.ITypeMap[]
            {
                new CustomPropertyTypeMap(
                   typeof(T),
                   (type, columnName) =>
                       type.GetProperties().FirstOrDefault(prop =>
                           prop.GetCustomAttributes(false)
                               .OfType<ColumnAttribute>()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(typeof(T))
            })
    {
    }
}

Isso significa que agora podemos suportar facilmente tipos que exigem mapa usando atributos:

Dapper.SqlMapper.SetTypeMap(
    typeof(MyModel),
    new ColumnAttributeTypeMapper<MyModel>());

Aqui está uma lista do código fonte completo .

Por algum tempo, o seguinte deve funcionar:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Aqui está uma solução simples que não requer atributos, permitindo que você mantenha o código de infraestrutura fora dos seus POCOs.

Esta é uma classe para lidar com os mapeamentos. Um dicionário funcionaria se você mapeasse todas as colunas, mas essa classe permite especificar apenas as diferenças. Além disso, inclui mapas reversos para que você possa obter o campo da coluna e a coluna do campo, o que pode ser útil ao fazer coisas como gerar instruções sql.

public class ColumnMap
{
    private readonly Dictionary<string, string> forward = new Dictionary<string, string>();
    private readonly Dictionary<string, string> reverse = new Dictionary<string, string>();

    public void Add(string t1, string t2)
    {
        forward.Add(t1, t2);
        reverse.Add(t2, t1);
    }

    public string this[string index]
    {
        get
        {
            // Check for a custom column map.
            if (forward.ContainsKey(index))
                return forward[index];
            if (reverse.ContainsKey(index))
                return reverse[index];

            // If no custom mapping exists, return the value passed in.
            return index;
        }
    }
}

Configure o objeto ColumnMap e diga ao Dapper para usar o mapeamento.

var columnMap = new ColumnMap();
columnMap.Add("Field1", "Column1");
columnMap.Add("Field2", "Column2");
columnMap.Add("Field3", "Column3");

SqlMapper.SetTypeMap(typeof (MyClass), new CustomPropertyTypeMap(typeof (MyClass), (type, columnName) => type.GetProperty(columnMap[columnName])));

Eu faço o seguinte usando dinâmico e LINQ:

    var sql = @"select top 1 person_id, first_name, last_name from Person";
    using (var conn = ConnectionFactory.GetConnection())
    {
        List<Person> person = conn.Query<dynamic>(sql)
                                  .Select(item => new Person()
                                  {
                                      PersonId = item.person_id,
                                      FirstName = item.first_name,
                                      LastName = item.last_name
                                  }
                                  .ToList();

        return person;
    }

Uma maneira fácil de conseguir isso é usar aliases nas colunas da sua consulta. Se a coluna do banco de dados estiver PERSON_IDe a propriedade do seu objeto for, IDvocê pode fazer isso select PERSON_ID as Id ...na sua consulta e o Dapper irá buscá-la conforme o esperado.

Retirado dos testes do Dapper, atualmente no Dapper 1.42.

// custom mapping
var map = new CustomPropertyTypeMap(typeof(TypeWithMapping), 
                                    (type, columnName) => type.GetProperties().FirstOrDefault(prop => GetDescriptionFromAttribute(prop) == columnName));
Dapper.SqlMapper.SetTypeMap(typeof(TypeWithMapping), map);

Classe auxiliar para obter o nome do atributo Descrição (eu pessoalmente usei a coluna como exemplo @kalebs)

static string GetDescriptionFromAttribute(MemberInfo member)
{
   if (member == null) return null;

   var attrib = (DescriptionAttribute)Attribute.GetCustomAttribute(member, typeof(DescriptionAttribute), false);
   return attrib == null ? null : attrib.Description;
}

Classe

public class TypeWithMapping
{
   [Description("B")]
   public string A { get; set; }

   [Description("A")]
   public string B { get; set; }
}

Mexer com o mapeamento é limítrofe, movendo-se para o terreno ORM real. Em vez de lutar com ele e manter o Dapper em sua verdadeira forma simples (rápida), apenas modifique seu SQL da seguinte maneira:

var sql = @"select top 1 person_id as PersonId,FirstName,LastName from Person";

Antes de abrir a conexão com o banco de dados, execute este código para cada uma de suas classes poco:

// Section
SqlMapper.SetTypeMap(typeof(Section), new CustomPropertyTypeMap(
    typeof(Section), (type, columnName) => type.GetProperties().FirstOrDefault(prop =>
    prop.GetCustomAttributes(false).OfType<ColumnAttribute>().Any(attr => attr.Name == columnName))));

Em seguida, adicione as anotações de dados às suas classes poco da seguinte maneira:

public class Section
{
    [Column("db_column_name1")] // Side note: if you create aliases, then they would match this.
    public int Id { get; set; }
    [Column("db_column_name2")]
    public string Title { get; set; }
}

Depois disso, está tudo pronto. Basta fazer uma chamada de consulta, algo como:

using (var sqlConnection = new SqlConnection("your_connection_string"))
{
    var sqlStatement = "SELECT " +
                "db_column_name1, " +
                "db_column_name2 " +
                "FROM your_table";

    return sqlConnection.Query<Section>(sqlStatement).AsList();
}

Se você estiver usando o .NET 4.5.1 ou o checkout Dapper.FluentColumnMapping para mapear o estilo LINQ. Permite separar completamente o mapeamento db do seu modelo (sem necessidade de anotações)

Isso é um retrocesso de outras respostas. É apenas um pensamento que eu tinha para gerenciar as cadeias de consulta.

Person.cs

public class Person 
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public static string Select() 
    {
        return $"select top 1 person_id {nameof(PersonId)}, first_name {nameof(FirstName)}, last_name {nameof(LastName)}from Person";
    }
}

Método API

using (var conn = ConnectionFactory.GetConnection())
{
    var person = conn.Query<Person>(Person.Select()).ToList();
    return person;
}

para todos que usam o Dapper 1.12, veja o que você precisa fazer para fazer isso:

  [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property]

  public class ColumnAttribute : Attribute
  {

    public string Name { get; set; }

    public ColumnAttribute(string name)
    {
      this.Name = name;
    }
  }

map = new DefaultTypeMap(type);

        map = new CustomPropertyTypeMap(type, (t, columnName) =>
        {
          PropertyInfo pi = t.GetProperties().FirstOrDefault(prop =>
                            prop.GetCustomAttributes(false)
                                .OfType<ColumnAttribute>()
                                .Any(attr => attr.Name == columnName));

          return pi != null ? pi : t.GetProperties().FirstOrDefault(prop => prop.Name == columnName);
        });

A solução de Kaleb Pederson funcionou para mim. Atualizei o ColumnAttributeTypeMapper para permitir um atributo personalizado (tinha requisito para dois mapeamentos diferentes no mesmo objeto de domínio) e atualizei as propriedades para permitir setters privados nos casos em que um campo precisava ser derivado e os tipos diferentes.

public class ColumnAttributeTypeMapper<T,A> : FallbackTypeMapper where A : ColumnAttribute
{
    public ColumnAttributeTypeMapper()
        : base(new SqlMapper.ITypeMap[]
            {
                new CustomPropertyTypeMap(
                   typeof(T),
                   (type, columnName) =>
                       type.GetProperties( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).FirstOrDefault(prop =>
                           prop.GetCustomAttributes(true)
                               .OfType<A>()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(typeof(T))
            })
    {
        //
    }
}

Sei que esse é um tópico relativamente antigo, mas pensei em lançar o que fiz por aí.

Eu queria que o mapeamento de atributos funcionasse globalmente. Você corresponde ao nome da propriedade (também conhecido como padrão) ou corresponde a um atributo de coluna na propriedade da classe. Eu também não queria configurar isso para todas as classes para as quais estava mapeando. Como tal, criei uma classe DapperStart que invoco no início do aplicativo:

public static class DapperStart
{
    public static void Bootstrap()
    {
        Dapper.SqlMapper.TypeMapProvider = type =>
        {
            return new CustomPropertyTypeMap(typeof(CreateChatRequestResponse),
                (t, columnName) => t.GetProperties().FirstOrDefault(prop =>
                    {
                        return prop.Name == columnName || prop.GetCustomAttributes(false).OfType<ColumnAttribute>()
                                   .Any(attr => attr.Name == columnName);
                    }
                ));
        };
    }
}

Bem simples. Não tenho certeza de quais problemas encontrarei ainda quando acabei de escrever isso, mas funciona.

A solução simples para o problema que Kaleb está tentando resolver é aceitar o nome da propriedade se o atributo da coluna não existir:

Dapper.SqlMapper.SetTypeMap(
    typeof(T),
    new Dapper.CustomPropertyTypeMap(
        typeof(T),
        (type, columnName) =>
            type.GetProperties().FirstOrDefault(prop =>
                prop.GetCustomAttributes(false)
                    .OfType<ColumnAttribute>()
                    .Any(attr => attr.Name == columnName) || prop.Name == columnName)));