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

Question

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

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

Nom de la table : Personne
person_id  int
first_name varchar(50)
last_name  varchar(50)

et j'ai une classe appelée Personne :

public class Personne 
{
    public int PersonneId { get; set; }
    public string Prenom { get; set; }
    public string Nom { 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 du résultat de la requête.

var sql = @"select top 1 PersonneId,Prenom,Nom from Personne";
using (var conn = ConnectionFactory.GetConnection())
{
    var personne = conn.Query(sql).ToList();
    return personne;
}

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

Answer 1

Cela fait suite à d'autres réponses. C'est juste une idé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.Select()).ToList();
    return person;
}

Answer 2

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()
                    .Any(attr => attr.Name == columnName) || prop.Name == columnName)));

Answer 3

La manière la plus facile (identique à la réponse de @Matt M mais corrigée et ajout de retour au map par défaut)

// substituer TypeMapProvider pour retourner une map personnalisée pour chaque type demandé
Dapper.SqlMapper.TypeMapProvider = type =>
   {
       // créer une map de type par défaut de secours
       var fallback = new DefaultTypeMap(type);
       return new CustomPropertyTypeMap(type, (t, column) =>
       {
           var property = t.GetProperties().FirstOrDefault(prop =>
               prop.GetCustomAttributes(typeof(ColumnAttribute))
                   .Cast()
                   .Any(attr => attr.Name == column));

           // si aucune propriété ne correspond - retour à la map de type par défaut
           if (property == null)
           {
               property = fallback.GetMember(column)?.Property;
           }

           return property;
       });
   };

Answer 4

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

• Ajoutez un nouvel attribut de colonne de classe :

    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property]
  
    public class ColumnAttribute : Attribute
    {
  
      public string Name { get; set; }
  
      public ColumnAttribute(string name)
      {
        this.Name = name;
      }
    }

• Recherchez cette ligne :

  map = new DefaultTypeMap(type);

  et commentez-la.

• Écrivez ceci à la place :

          map = new CustomPropertyTypeMap(type, (t, columnName) =>
          {
            PropertyInfo pi = t.GetProperties().FirstOrDefault(prop =>
                              prop.GetCustomAttributes(false)
                                  .OfType()
                                  .Any(attr => attr.Name == columnName));
  
            return pi != null ? pi : t.GetProperties().FirstOrDefault(prop => prop.Name == columnName);
          });

Answer 5

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

public class ColumnAttributeTypeMapper : 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()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(typeof(T))
            })
    {
        //
    }
}