Sütun adlarını sınıf özellikleriyle manuel olarak eşleme

Dapper micro ORM'de yeniyim. Şimdiye kadar basit ORM ile ilgili şeyler için kullanabilirsiniz ama sınıf özellikleri ile veritabanı sütun adları eşlemek mümkün değil.

Örneğin, aşağıdaki veritabanı tablosu var:

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

ve Kişi adında bir dersim var:

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

Tablodaki sütun adlarımın, sorgu sonucundan aldığım verileri eşlemeye çalıştığım sınıfın özellik adından farklı olduğunu lütfen unutmayın.

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

Sütun adları nesnenin (Kişi) özellikleriyle eşleşmediğinden yukarıdaki kod çalışmaz. Bu senaryoda, Dapper'da person_id => PersonIdnesne adlarına sahip sütun adlarını el ile eşleştirmek (örn. ) İçin yapabileceğim bir şey var mı?

Bu iyi çalışıyor:

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, bir Sütun Özelliği belirtmenize izin veren bir tesise sahip değildir, bağımlılığı çekmemek kaydıyla, destek eklemeye karşı değilim.

Dapper artık özellik eşleyicilere özel sütun destekliyor. Bunu ITypeMap arayüzü üzerinden yapar . Bu çalışmanın çoğunu yapabilecek bir CustomPropertyTypeMap sınıfı Dapper tarafından sağlanır. Örneğin:

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

Ve model:

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

CustomPropertyTypeMap uygulamasının, özelliğin var olmasını ve sütun adlarından biriyle eşleşmesini veya özelliğin eşlenmeyeceğini gerektirdiğini unutmayın . DefaultTypeMap sınıfı standart işlevleri sağlar ve bu davranışı değiştirmek için de yararlanılabilir:

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

Ve bununla birlikte, mevcutsa öznitelikleri otomatik olarak kullanacak, ancak standart davranışa geri dönecek özel bir tür eşleyici oluşturmak kolaylaşır:

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

Bu, artık özellikleri kullanarak harita gerektiren türleri kolayca destekleyebileceğimiz anlamına gelir:

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

İşte tam kaynak kodunun bir özeti .

Bir süre için aşağıdakilerin çalışması gerekir:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Altyapı kodunu POCO'larınızdan uzak tutmanıza izin veren özellikler gerektirmeyen basit bir çözüm.

Bu, eşlemelerle ilgilenmek için bir sınıftır. Tüm sütunları eşlediyseniz sözlük işe yarar, ancak bu sınıf yalnızca farkları belirtmenize olanak tanır. Buna ek olarak, ters haritalar içerir, böylece alanı sütundan ve sütunu alandan alabilirsiniz; bu, sql ifadeleri oluşturma gibi şeyler yaparken faydalı olabilir.

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

ColumnMap nesnesini ayarlayın ve Dapper'a eşlemeyi kullanmasını söyleyin.

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

Dinamik ve LINQ kullanarak aşağıdakileri yaparım:

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

Bunu başarmanın kolay bir yolu, yalnızca sorgunuzdaki sütunlarda takma adları kullanmaktır. Veritabanı sütunu ise PERSON_IDve nesnenin proprty olan IDsadece yapabileceği select PERSON_ID as Id ...Sorgunuzda ve beklendiği gibi Zarif onu almak olacak.

Şu anda Dapper 1.42'de bulunan Dapper Testlerinden alınmıştır .

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

Açıklama özelliğinden isim almak için yardımcı sınıf (Şahsen @kalebs örneği gibi Sütunu kullandım)

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

Sınıf

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

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

Haritalama ile uğraşmak, gerçek ORM arazisine hareket eden sınır çizgisidir. Bununla savaşmak ve Dapper'ı gerçek basit (hızlı) formunda tutmak yerine, SQL'inizi biraz değiştirin:

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

Veritabanınızla bağlantıyı açmadan önce, poco sınıflarınızın her biri için bu kod parçasını yürütün:

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

Sonra veri ek açıklamalarını aşağıdaki gibi poco sınıflarınıza ekleyin:

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

Bundan sonra, hepiniz hazırsınız. Sadece bir sorgu çağrısı yapın, şunun gibi:

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

.NET 4.5.1 veya daha üstünü kullanıyorsanız , LINQ stilini eşleştirmek için Dapper.FluentColumnMapping kasasını kullanın . Db eşlemesini modelinizden tamamen ayırmanızı sağlar (ek açıklamalara gerek yoktur)

Bu, diğer cevaplardan geri dönen domuzcuk. Bu sadece sorgu dizelerini yönetmek için sahip olduğum bir düşünce.

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 Yöntemi

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

Dapper 1.12 kullanan herkes için, İşte bunu yapmak için yapmanız gerekenler:

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

Kaleb Pederson'un çözümü benim için çalıştı. Özel bir özniteliğe izin vermek için ColumnAttributeTypeMapper'ı güncelledim (aynı etki alanı nesnesinde iki farklı eşleme gereksinimi vardı) ve bir alanın türetilmesi gereken durumlarda ve türlerin farklı olduğu durumlarda özel ayarlayıcılara izin vermek için özellikleri güncelleştirdim.

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

Bu nispeten eski bir iplik olduğunu biliyorum, ama orada ne yaptım atmak düşündüm.

Nitelik haritalamanın global olarak çalışmasını istedim. Özellik adıyla (varsayılan olarak da bilinir) veya class özelliğindeki bir sütun özelliğiyle eşleşirsiniz. Ayrıca, eşleştirdiğim her sınıf için bunu ayarlamak istemedim. Bu nedenle, uygulama başlangıcında çağırdığım bir DapperStart sınıfı oluşturdum:

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

Gayet basit. Henüz yazdığım gibi hangi sorunlarla karşılaşacağımdan emin değilim, ama işe yarıyor.

Kaleb'in çözmeye çalıştığı sorunun basit çözümü, yalnızca sütun özelliği yoksa özellik adını kabul etmektir:

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