Mapper manuellement les noms de colonnes avec les propriétés de classe

Je suis nouveau sur le micro ORM Dapper. Jusqu'à présent, je suis capable de l'utiliser pour des trucs simples liés à l'ORM, mais je ne suis pas en mesure de mapper les noms de colonne de la base de données avec les propriétés de classe.

Par exemple, j'ai la table de base de données suivante:

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

et j'ai une classe appelée Person:

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

Veuillez noter que les noms de mes colonnes dans la table sont différents du nom de propriété de la classe à laquelle j'essaie de mapper les données que j'ai obtenues à partir du résultat de la requête.

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

Le code ci-dessus ne fonctionnera pas car les noms de colonne ne correspondent pas aux propriétés (Person) de l'objet. Dans ce scénario, y a-t-il quelque chose que je puisse faire dans Dapper pour mapper manuellement (par exemple person_id => PersonId) les noms de colonnes avec les propriétés d'objet?

Cela fonctionne bien:

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

Dapper n'a aucune fonctionnalité qui vous permet de spécifier un attribut de colonne , je ne suis pas contre l'ajout de la prise en charge de celui-ci, à condition que nous ne tirions pas dans la dépendance.

Dapper prend désormais en charge la colonne personnalisée vers les mappeurs de propriétés. Il le fait via l' interface ITypeMap . Une classe CustomPropertyTypeMap est fournie par Dapper qui peut effectuer la plupart de ce travail. Par exemple:

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

Et le modèle:

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

Il est important de noter que l'implémentation de CustomPropertyTypeMap nécessite que l'attribut existe et corresponde à l'un des noms de colonne ou la propriété ne sera pas mappée. La classe DefaultTypeMap fournit la fonctionnalité standard et peut être exploitée pour modifier ce comportement:

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

Et avec cela en place, il devient facile de créer un mappeur de type personnalisé qui utilisera automatiquement les attributs s'ils sont présents, mais qui reviendra autrement au comportement standard:

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

Cela signifie que nous pouvons désormais facilement prendre en charge les types qui nécessitent une carte à l'aide d'attributs:

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

Voici un résumé du code source complet .

Pendant un certain temps, les éléments suivants devraient fonctionner:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Voici une solution simple qui ne nécessite pas d'attributs vous permettant de garder le code d'infrastructure hors de vos POCO.

C'est une classe pour gérer les mappages. Un dictionnaire fonctionnerait si vous mappiez toutes les colonnes, mais cette classe vous permet de spécifier uniquement les différences. En outre, il inclut des cartes inversées afin que vous puissiez obtenir le champ de la colonne et la colonne du champ, ce qui peut être utile lors de tâches telles que la génération d'instructions 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;
        }
    }
}

Configurez l'objet ColumnMap et indiquez à Dapper d'utiliser le mappage.

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

Je fais ce qui suit en utilisant dynamic et 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;
    }

Un moyen simple d'y parvenir est d'utiliser simplement des alias sur les colonnes de votre requête. Si votre colonne de base de données est PERSON_IDet que la propriété de votre objet est, IDvous pouvez simplement le faire select PERSON_ID as Id ...dans votre requête et Dapper la récupérera comme prévu.

Tiré des tests Dapper qui sont actuellement sur 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 d'assistance pour obtenir le nom de l'attribut Description (j'ai personnellement utilisé Column comme l'exemple @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; }
}

Jouer avec la cartographie est à la limite du déplacement vers de véritables terres ORM. Au lieu de se battre avec lui et de garder Dapper dans sa vraie forme simple (rapide), modifiez simplement votre SQL légèrement comme ceci:

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

Avant d'ouvrir la connexion à votre base de données, exécutez ce morceau de code pour chacune de vos 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))));

Ajoutez ensuite les annotations de données à vos classes poco comme ceci:

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

Après cela, vous êtes prêt. Faites simplement un appel de requête, quelque chose comme:

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

Si vous utilisez .NET 4.5.1 ou une version ultérieure, vérifiez Dapper.FluentColumnMapping pour mapper le style LINQ. Il vous permet de séparer complètement le mappage db de votre modèle (pas besoin d'annotations)

C'est le soutien d'autres réponses. C'est juste une pensée que j'avais pour gérer les chaînes de requête.

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éthode API

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

pour tous ceux qui utilisent Dapper 1.12, voici ce que vous devez faire pour y parvenir:

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

La solution de Kaleb Pederson a fonctionné pour moi. J'ai mis à jour le ColumnAttributeTypeMapper pour autoriser un attribut personnalisé (exigeant deux mappages différents sur le même objet de domaine) et mis à jour les propriétés pour autoriser les setters privés dans les cas où un champ devait être dérivé et les types différaient.

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))
            })
    {
        //
    }
}

Je sais que c'est un fil de discussion relativement ancien, mais j'ai pensé jeter ce que j'ai fait là-bas.

Je voulais que le mappage d'attributs fonctionne globalement. Soit vous faites correspondre le nom de la propriété (aka default), soit vous faites correspondre un attribut de colonne sur la propriété de classe. Je ne voulais pas non plus avoir à configurer cela pour chaque classe à laquelle je mappais. En tant que tel, j'ai créé une classe DapperStart que j'appelle au démarrage de l'application:

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

Assez simple. Je ne sais pas quels problèmes je vais encore rencontrer car je viens d'écrire ceci, mais cela fonctionne.

La solution simple au problème que Kaleb essaie de résoudre est simplement d'accepter le nom de la propriété si l'attribut de colonne n'existe pas:

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