Вручну зіставити назви стовпців із властивостями класу

Я новачок у Dapper micro ORM. Поки я можу використовувати його для простих матеріалів, пов'язаних з ORM, але я не в змозі зіставити назви стовпців бази даних із властивостями класу.

Наприклад, у мене є така таблиця баз даних:

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

і у мене клас під назвою Person:

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

Зауважте, що назви моїх стовпців у таблиці відрізняються від назви властивості класу, до якого я намагаюся відобразити дані, отримані в результаті запиту.

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

Вищевказаний код не працюватиме, оскільки назви стовпців не відповідають властивостям об'єкта (Person). У цьому сценарії чи є щось, що я можу зробити в Dapper, щоб вручну відобразити (наприклад person_id => PersonId) імена стовпців із властивостями об’єкта?

Це добре працює:

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 не має можливості, яка дозволяє вказати атрибут стовпця , я не проти додавати підтримку, якщо ми не тягнемося в залежність.

Тепер Dapper підтримує власні стовпці для картографів властивостей. Це робиться через інтерфейс ITypeMap . CustomPropertyTypeMap клас забезпечується Dapper , що може зробити більшу частину цієї роботи. Наприклад:

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

І модель:

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

Важливо зауважити, що для реалізації CustomPropertyTypeMap необхідний атрибут існування та відповідність одному з імен стовпців, або властивість не буде відображатися. Клас DefaultTypeMap забезпечує стандартну функціональність і може бути використаний для зміни такої поведінки:

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

І з цим на місці стає легко створити спеціальний картографічний тип, який автоматично використовуватиме атрибути, якщо вони є, але в іншому випадку повернеться до стандартної поведінки:

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

Це означає, що тепер ми можемо легко підтримувати типи, для яких потрібна карта за допомогою атрибутів:

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

Ось історія повного вихідного коду .

Деякий час має працювати наступне:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Ось просте рішення, яке не потребує атрибутів, що дозволяють утримувати інфраструктурний код поза вашими POCO.

Це клас для розгляду карт. Словник спрацював би, якщо ви зіставили всі стовпці, але цей клас дозволяє вказати лише відмінності. Крім того, вона включає зворотні карти, щоб ви могли отримати поле зі стовпця та стовпця з поля, що може бути корисно при виконанні таких речей, як генерація заяв 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;
        }
    }
}

Встановіть об'єкт ColumnMap і скажіть Dapper використовувати відображення.

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

Я роблю такі дії, використовуючи динамічні та 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;
    }

Простий спосіб досягти цього - просто використовувати псевдоніми на стовпцях у вашому запиті. Якщо стовпець вашої бази даних є PERSON_IDвластивістю вашого об'єкта, IDви можете просто зробити select PERSON_ID as Id ...свій запит, і Dapper підбере його як очікувалося.

Взяте з тестів Dapper, які зараз на 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);

Клас помічників, щоб отримати ім'я від атрибуту Опис (я особисто використовував стовпець, як приклад @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;
}

Клас

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

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

Возитися з картографуванням - це переміщення кордону в реальну землю ORM. Замість того, щоб боротися з ним і зберігати Dapper у його справжньому простому (швидкому) вигляді, просто змініть свій SQL трохи так:

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

Перш ніж відкрити з'єднання зі своєю базою даних, виконайте цей фрагмент коду для кожного з ваших класів 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))));

Потім додайте примітки до даних у ваші класи такої категорії:

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

Після цього у вас все налаштовано. Просто зателефонуйте, наприклад:

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 або вище, замовлення Dapper.FluentColumnMapping для відображення стилю LINQ. Це дозволяє повністю відокремити відображення db від вашої моделі (немає необхідності в анотаціях)

Це скарбничка інших відповідей. Це просто думка, яку я мав для управління рядками запитів.

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

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

для всіх, хто використовує Dapper 1.12. Ось що потрібно зробити, щоб це зробити:

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

Рішення Калеба Педерсона працювало на мене. Я оновив ColumnAttributeTypeMapper, щоб дозволити спеціальний атрибут (мав вимогу до двох різних відображень на одному об’єкті домену) та оновив властивості, щоб дозволити приватним сеттерам у випадках, коли потрібно було отримати поле та різні типи.

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

Я знаю, що це відносно стара нитка, але я думав, що кину те, що я зробив там.

Я хотів, щоб відображення атрибутів працювало глобально. Або ви збігаєтеся з назвою властивості (він же за замовчуванням), або з атрибутом стовпця у властивості класу. Я також не хотів встановлювати це для кожного класу, до якого я збирався. Таким чином, я створив клас DapperStart, до якого запускаю додаток:

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

Досить просто. Не впевнений, з якими проблемами я зіткнувся ще, коли я це лише написав, але це працює.

Просте рішення проблеми, яку намагається вирішити Kaleb, - це просто прийняти ім'я властивості, якщо атрибут стовпця не існує:

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