Ordnen Sie Spaltennamen manuell mit Klasseneigenschaften zu

Ich bin neu im Dapper Micro ORM. Bisher kann ich es für einfache ORM-bezogene Dinge verwenden, aber ich kann die Namen der Datenbankspalten nicht den Klasseneigenschaften zuordnen.

Zum Beispiel habe ich die folgende Datenbanktabelle:

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

und ich habe eine Klasse namens Person:

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

Bitte beachten Sie, dass sich meine Spaltennamen in der Tabelle vom Eigenschaftsnamen der Klasse unterscheiden, der ich die Daten zuordnen möchte, die ich aus dem Abfrageergebnis erhalten habe.

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

Der obige Code funktioniert nicht, da die Spaltennamen nicht mit den Eigenschaften des Objekts (Person) übereinstimmen. Kann ich in diesem Szenario in Dapper etwas tun, um person_id => PersonIddie Spaltennamen mit Objekteigenschaften manuell zuzuordnen (z. B. )?

Das funktioniert gut:

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 hat keine Funktion, mit der Sie ein Spaltenattribut angeben können. Ich bin nicht dagegen, Unterstützung dafür hinzuzufügen, vorausgesetzt, wir ziehen die Abhängigkeit nicht ein.

Dapper unterstützt jetzt benutzerdefinierte Zuordnungen von Spalten zu Eigenschaften. Dies geschieht über die ITypeMap- Schnittstelle. Dapper stellt eine CustomPropertyTypeMap- Klasse bereit, die den größten Teil dieser Arbeit erledigen kann. Beispielsweise:

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

Und das Modell:

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

Es ist wichtig zu beachten, dass die Implementierung von CustomPropertyTypeMap erfordert, dass das Attribut vorhanden ist und mit einem der Spaltennamen übereinstimmt, da sonst die Eigenschaft nicht zugeordnet wird. Die DefaultTypeMap- Klasse bietet die Standardfunktionalität und kann genutzt werden, um dieses Verhalten zu ändern:

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

Auf diese Weise wird es einfach, einen benutzerdefinierten Typ-Mapper zu erstellen, der die Attribute automatisch verwendet, wenn sie vorhanden sind, ansonsten aber auf das Standardverhalten zurückgreift:

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

Das heißt, wir können jetzt problemlos Typen unterstützen, für die eine Zuordnung erforderlich ist, indem wir Attribute verwenden:

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

Hier ist eine Zusammenfassung des vollständigen Quellcodes .

Für einige Zeit sollte Folgendes funktionieren:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Hier ist eine einfache Lösung, für die keine Attribute erforderlich sind, sodass Sie den Infrastrukturcode aus Ihren POCOs heraushalten können.

Dies ist eine Klasse, die sich mit den Zuordnungen befasst. Ein Wörterbuch würde funktionieren, wenn Sie alle Spalten zugeordnet hätten. Mit dieser Klasse können Sie jedoch nur die Unterschiede angeben. Darüber hinaus enthält es umgekehrte Zuordnungen, sodass Sie das Feld aus der Spalte und die Spalte aus dem Feld abrufen können. Dies kann hilfreich sein, wenn Sie beispielsweise SQL-Anweisungen generieren.

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

Richten Sie das ColumnMap-Objekt ein und weisen Sie Dapper an, das Mapping zu verwenden.

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

Ich mache folgendes mit Dynamic und 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;
    }

Eine einfache Möglichkeit, dies zu erreichen, besteht darin, nur Aliase für die Spalten in Ihrer Abfrage zu verwenden. Wenn Ihre Datenbankspalte PERSON_IDund die Eigenschaft Ihres Objekts ist ID, können Sie dies einfach select PERSON_ID as Id ...in Ihrer Abfrage tun, und Dapper wird es wie erwartet abholen.

Entnommen aus den Dapper-Tests, die derzeit auf Dapper 1.42 laufen.

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

Hilfsklasse, um den Namen aus dem Description-Attribut zu entfernen (ich persönlich habe Column wie das @ kalebs-Beispiel verwendet)

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

Klasse

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

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

Das Spielen mit dem Mapping ist eine Grenzlinie, die sich in echtes ORM-Land bewegt. Anstatt damit zu kämpfen und Dapper in seiner wirklich einfachen (schnellen) Form zu halten, ändern Sie Ihr SQL einfach leicht wie folgt:

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

Führen Sie diesen Code für jede Ihrer Poco-Klassen aus, bevor Sie die Verbindung zu Ihrer Datenbank öffnen:

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

Fügen Sie dann die Datenanmerkungen wie folgt zu Ihren Poco-Klassen hinzu:

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

Danach sind Sie fertig. Machen Sie einfach einen Abfrageanruf, so etwas wie:

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

Wenn Sie .NET 4.5.1 oder höher verwenden, überprüfen Sie Dapper.FluentColumnMapping für die Zuordnung des LINQ-Stils. Damit können Sie die Datenbankzuordnung vollständig von Ihrem Modell trennen (keine Anmerkungen erforderlich).

Dies ist ein Huckepack von anderen Antworten. Es ist nur ein Gedanke, den ich hatte, um die Abfragezeichenfolgen zu verwalten.

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

API-Methode

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

Für alle, die Dapper 1.12 verwenden, müssen Sie Folgendes tun, um dies zu erreichen:

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

Die Lösung von Kaleb Pederson hat bei mir funktioniert. Ich habe den ColumnAttributeTypeMapper aktualisiert, um ein benutzerdefiniertes Attribut zuzulassen (für das zwei verschiedene Zuordnungen für dasselbe Domänenobjekt erforderlich waren), und die Eigenschaften aktualisiert, um private Setter in Fällen zuzulassen, in denen ein Feld abgeleitet werden musste und die Typen unterschiedlich waren.

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

Ich weiß, dass dies ein relativ alter Thread ist, aber ich dachte, ich würde das, was ich getan habe, da draußen werfen.

Ich wollte, dass die Attributzuordnung global funktioniert. Entweder stimmen Sie mit dem Eigenschaftsnamen überein (auch bekannt als Standard), oder Sie stimmen mit einem Spaltenattribut für die Klasseneigenschaft überein. Ich wollte dies auch nicht für jede einzelne Klasse einrichten müssen, der ich zugeordnet war. Aus diesem Grund habe ich eine DapperStart-Klasse erstellt, die ich beim Start der App aufrufe:

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

Ziemlich einfach. Ich bin mir nicht sicher, auf welche Probleme ich noch stoßen werde, als ich das gerade geschrieben habe, aber es funktioniert.

Die einfache Lösung für das Problem, das Kaleb zu lösen versucht, besteht darin, nur den Eigenschaftsnamen zu akzeptieren, wenn das Spaltenattribut nicht vorhanden ist:

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