Ánh xạ tên cột theo cách thủ công với các thuộc tính lớp

Tôi chưa quen với ORM micro Dapper. Cho đến nay tôi có thể sử dụng nó cho các công cụ liên quan đến ORM đơn giản nhưng tôi không thể ánh xạ các tên cột cơ sở dữ liệu với các thuộc tính lớp.

Ví dụ: tôi có bảng cơ sở dữ liệu sau:

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

và tôi có một lớp gọi là Person:

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

Xin lưu ý rằng tên cột của tôi trong bảng khác với tên thuộc tính của lớp mà tôi đang cố gắng ánh xạ dữ liệu mà tôi nhận được từ kết quả truy vấ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;
}

Đoạn mã trên sẽ không hoạt động vì tên cột không khớp với thuộc tính (Person) của đối tượng. Trong kịch bản này, có bất cứ điều gì tôi có thể làm trong Dapper để ánh xạ thủ công (ví dụ person_id => PersonId) tên cột với thuộc tính đối tượng không?

Điều này hoạt động tốt:

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 không có cơ sở nào cho phép bạn chỉ định Thuộc tính Cột , tôi không chống lại việc thêm hỗ trợ cho nó, miễn là chúng tôi không phụ thuộc vào phụ thuộc.

Dapper hiện hỗ trợ cột tùy chỉnh cho người lập bản đồ tài sản. Nó làm như vậy thông qua giao diện ITypeMap . Một lớp CustomPropertyTypeMap được cung cấp bởi Dapper có thể thực hiện hầu hết công việc này. Ví dụ:

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

Và mô hình:

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

Điều quan trọng cần lưu ý là việc triển khai CustomPropertyTypeMap yêu cầu thuộc tính tồn tại và khớp với một trong các tên cột hoặc thuộc tính sẽ không được ánh xạ. Lớp DefaultTypeMap cung cấp chức năng tiêu chuẩn và có thể được tận dụng để thay đổi hành vi này:

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

Và với điều đó, việc tạo một trình ánh xạ loại tùy chỉnh sẽ tự động sử dụng các thuộc tính nếu chúng có mặt nhưng sẽ trở lại hành vi tiêu chuẩn trở nên dễ dàng hơn:

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

Điều đó có nghĩa là bây giờ chúng ta có thể dễ dàng hỗ trợ các loại yêu cầu bản đồ bằng các thuộc tính:

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

Đây là một ý chính cho mã nguồn đầy đủ .

Trong một thời gian, những điều sau đây nên hoạt động:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Đây là một giải pháp đơn giản không yêu cầu các thuộc tính cho phép bạn giữ mã cơ sở hạ tầng khỏi POCO của bạn.

Đây là một lớp để đối phó với các ánh xạ. Một từ điển sẽ hoạt động nếu bạn ánh xạ tất cả các cột, nhưng lớp này cho phép bạn chỉ định sự khác biệt. Ngoài ra, nó bao gồm các bản đồ đảo ngược để bạn có thể lấy trường từ cột và cột từ trường, có thể hữu ích khi thực hiện những việc như tạo câu lệnh 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;
        }
    }
}

Thiết lập đối tượng ColumnMap và báo cho Dapper sử dụng ánh xạ.

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

Tôi làm như sau bằng cách sử dụng động và 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;
    }

Một cách dễ dàng để đạt được điều này là chỉ sử dụng bí danh trên các cột trong truy vấn của bạn. Nếu cột cơ sở dữ liệu của bạn là PERSON_IDvà proprty của đối tượng của IDbạn là bạn có thể thực hiện select PERSON_ID as Id ...trong truy vấn của mình và Dapper sẽ chọn nó như mong đợi.

Lấy từ các thử nghiệm Dapper hiện đang có trên 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);

Lớp trình trợ giúp để lấy tên khỏi thuộc tính Mô tả (Cá nhân tôi đã sử dụng Cột như ví dụ @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;
}

Lớp học

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

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

Lộn xộn với ánh xạ là đường biên giới di chuyển vào vùng đất ORM thực sự. Thay vì chiến đấu với nó và giữ Dapper ở dạng đơn giản (nhanh) thực sự của nó, chỉ cần sửa đổi SQL của bạn một chút như vậy:

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

Trước khi bạn mở kết nối tới cơ sở dữ liệu của mình, hãy thực thi đoạn mã này cho từng lớp poco của bạ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))));

Sau đó thêm các chú thích dữ liệu vào các lớp poco của bạn như thế này:

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

Sau đó, bạn đã hoàn tất. Chỉ cần thực hiện một cuộc gọi truy vấn, đại loại như:

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

Nếu bạn đang sử dụng .NET 4.5.1 hoặc cao hơn, hãy kiểm tra Dapper.FluentColumnMapping để ánh xạ kiểu LINQ. Nó cho phép bạn tách biệt hoàn toàn ánh xạ db khỏi mô hình của bạn (không cần chú thích)

Đây là heo con ủng hộ các câu trả lời khác. Đó chỉ là suy nghĩ của tôi để quản lý các chuỗi truy vấn.

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

Phương pháp API

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

cho tất cả các bạn sử dụng Dapper 1.12, đây là những gì bạn cần làm để hoàn thành công việc này:

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

Giải pháp của Kaleb Pederson đã làm việc cho tôi. Tôi đã cập nhật CộtAttributionTypeMapper để cho phép một thuộc tính tùy chỉnh (có yêu cầu đối với hai ánh xạ khác nhau trên cùng một đối tượng miền) và các thuộc tính được cập nhật để cho phép các setters riêng trong trường hợp một trường cần xuất phát và các loại khác nhau.

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

Tôi biết đây là một chủ đề tương đối cũ, nhưng tôi nghĩ tôi sẽ ném những gì tôi đã làm ra khỏi đó.

Tôi muốn ánh xạ thuộc tính để làm việc trên toàn cầu. Hoặc bạn khớp với tên thuộc tính (còn gọi là mặc định) hoặc bạn khớp với thuộc tính cột trên thuộc tính lớp. Tôi cũng không muốn phải thiết lập điều này cho mỗi lớp tôi đang ánh xạ. Như vậy, tôi đã tạo một lớp DapperStart mà tôi gọi khi bắt đầu ứng dụng:

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

Khá đơn giản. Không chắc vấn đề gì tôi sẽ gặp phải khi tôi vừa viết bài này, nhưng nó hoạt động.

Giải pháp đơn giản cho vấn đề mà Kaleb đang cố gắng giải quyết chỉ là chấp nhận tên thuộc tính nếu thuộc tính cột không tồn tại:

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