Ręcznie mapuj nazwy kolumn z właściwościami klas

Jestem nowy w Dapper micro ORM. Do tej pory mogę go używać do prostych rzeczy związanych z ORM, ale nie jestem w stanie zmapować nazw kolumn bazy danych z właściwościami klasy.

Na przykład mam następującą tabelę bazy danych:

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

i mam klasę o nazwie Osoba:

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

Zwróć uwagę, że nazwy moich kolumn w tabeli różnią się od nazwy właściwości klasy, do której próbuję zmapować dane, które otrzymałem z wyniku zapytania.

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

Powyższy kod nie zadziała, ponieważ nazwy kolumn nie są zgodne z właściwościami obiektu (Person). Czy w tym scenariuszu jest coś, co mogę zrobić w Dapper, aby ręcznie mapować (np. person_id => PersonId) Nazwy kolumn z właściwościami obiektu?

To działa dobrze:

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 nie ma funkcji, która pozwala określić atrybut kolumny , nie jestem przeciwny dodawaniu jej obsługi, pod warunkiem, że nie pobieramy zależności.

Dapper obsługuje teraz niestandardowe kolumny do mapowania właściwości. Robi to za pośrednictwem interfejsu ITypeMap . CustomPropertyTypeMap klasa jest przez Dapper że można zrobić większość tej pracy. Na przykład:

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

A model:

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

Należy zauważyć, że implementacja CustomPropertyTypeMap wymaga, aby atrybut istniał i pasował do jednej z nazw kolumn, w przeciwnym razie właściwość nie zostanie zmapowana. DefaultTypeMap klasa zapewnia standardową funkcjonalność i może być użyta do zmiany tego zachowania:

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

Dzięki temu łatwo jest utworzyć niestandardowy program odwzorowujący typy, który automatycznie użyje atrybutów, jeśli są obecne, ale w przeciwnym razie powróci do standardowego zachowania:

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

Oznacza to, że możemy teraz łatwo obsługiwać typy, które wymagają mapowania przy użyciu atrybutów:

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

Oto streszczenie pełnego kodu źródłowego .

Przez jakiś czas powinny działać:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Oto proste rozwiązanie, które nie wymaga atrybutów, które pozwalają utrzymać kod infrastruktury z dala od POCO.

To jest klasa do obsługi mapowań. Słownik działałby, gdybyś zmapował wszystkie kolumny, ale ta klasa umożliwia określenie tylko różnic. Ponadto zawiera odwrócone mapy, dzięki czemu można pobrać pole z kolumny i kolumnę z pola, co może być przydatne podczas wykonywania takich czynności, jak generowanie instrukcji 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;
        }
    }
}

Skonfiguruj obiekt ColumnMap i powiedz Dapperowi, aby użył mapowania.

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

Wykonuję następujące czynności przy użyciu dynamicznego i 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;
    }

Prostym sposobem osiągnięcia tego jest użycie aliasów w kolumnach w zapytaniu. Jeśli twoja kolumna bazy danych jest PERSON_IDi obiekt ma właściwość ID, możesz po prostu wykonać select PERSON_ID as Id ...zapytanie, a Dapper odbierze go zgodnie z oczekiwaniami.

Zaczerpnięte z Dapper Tests, które są obecnie na 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);

Klasa pomocnicza, aby uzyskać nazwę z atrybutu Description (osobiście użyłem kolumny jak przykład @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;
}

Klasa

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

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

Zamieszanie z mapowaniem to graniczne przejście do prawdziwej krainy ORM. Zamiast walczyć z nim i utrzymywać Dapper w jego prawdziwej prostej (szybkiej) formie, po prostu zmodyfikuj swój SQL w taki sposób:

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

Zanim otworzysz połączenie z bazą danych, wykonaj ten fragment kodu dla każdej z klas 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))));

Następnie dodaj adnotacje danych do swoich klas poco w następujący sposób:

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

Potem wszystko jest gotowe. Po prostu wykonaj zapytanie, na przykład:

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

Jeśli używasz .NET 4.5.1 lub nowszego, wyewidencjonuj Dapper.FluentColumnMapping do mapowania stylu LINQ. Pozwala w pełni oddzielić mapowanie db od modelu (bez adnotacji)

To jest świnka wycofująca się z innych odpowiedzi. To tylko myśl, którą miałem do zarządzania ciągami zapytań.

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

Metoda API

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

dla wszystkich, którzy używają Dapper 1.12, oto, co musisz zrobić, aby to zrobić:

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

Rozwiązanie Kaleba Pedersona zadziałało dla mnie. Zaktualizowałem ColumnAttributeTypeMapper, aby zezwolić na niestandardowy atrybut (wymagał dwóch różnych mapowań w tym samym obiekcie domeny) i zaktualizowałem właściwości, aby umożliwić ustawianie prywatne w przypadkach, gdy trzeba było wyprowadzić pole, a typy różniły się.

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

Wiem, że to stosunkowo stary wątek, ale pomyślałem, że wyrzucę tam to, co zrobiłem.

Chciałem, aby mapowanie atrybutów działało globalnie. Albo dopasujesz nazwę właściwości (aka domyślną), albo dopasujesz atrybut kolumny do właściwości klasy. Nie chciałem też konfigurować tego dla każdej klasy, do której mapowałem. W związku z tym utworzyłem klasę DapperStart, którą wywołuję przy starcie aplikacji:

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

Dość proste. Nie jestem pewien, jakie problemy napotkam, gdy właśnie to napisałem, ale działa.

Prostym rozwiązaniem problemu, który Kaleb próbuje rozwiązać, jest po prostu zaakceptowanie nazwy właściwości, jeśli atrybut kolumny nie istnieje:

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