属性付きDapperマッピング

c# dapper system.reflection

質問

IdのフィールドをColumn Attributesにマップしようとしましたが、なんらかの理由でこれが機能していないように見えて、なぜその理由が分かりません。私が試していることを実証するためのテストプロジェクトを立ち上げました。

まず、2つのエンティティを取得しました。

エンティティテーブル1

using System.Data.Linq.Mapping;

namespace DapperTestProj
{
    public class Table1
    {
        [Column(Name = "Table1Id")]
        public int Id { get; set; }

        public string Column1 { get; set; }

        public string Column2 { get; set; }

        public Table2 Table2 { get; set; }

        public Table1()
        {
            Table2 = new Table2();
        }
    }
}

エンティティテーブル2

using System.Data.Linq.Mapping;

namespace DapperTestProj
{
    public class Table2
    {
        [Column(Name = "Table2Id")]
        public int Id { get; set; }

        public string Column3 { get; set; }

        public string Column4 { get; set; }
    }
}

私のデータベースには、Table1とTable2という2つのテーブルがあります。どちらのテーブルも、Table1にTable2Idという名前の列があり、Table1.Table2IdとTable2.Idの間に外部キーがあるという例外を除き、エンティティと同じ名前の列があります。

また、両方のテーブルにそれぞれ1つのレコードがあり、Id 2の両方を持っています。

次は、dapperでクエリを実行し、Table1型のオブジェクトを返さなければなりません。これは機能しますが、プロパティTable1.IdとTable1.Table2.Idの両方が0(デフォルトの整数)のままです。私は列の属性がIdフィールドをマップすることを期待していますが、これははっきりしていません。

これはコードで実行しているクエリとマッピングです:

private Table1 TestMethod(IDbConnection connection)
{
    var result = connection.Query<Table1, Table2, Table1>(
        @"SELECT 
             T1.Id as Table1Id, 
             T1.Column1 as Column1,
             T1.Column2 as Column2,
             T2.Id as Table2Id,
             T2.Column3 as Column3,
             T2.Column4 as Column4
          FROM Table1 T1 
          INNER JOIN Table2 T2 ON T1.Table2Id = T2.Id",
        (table1, table2) =>
            {
                table1.Table2 = table2;
                return table1;
            },
        splitOn: "Table2Id"
        ).SingleOrDefault();

    return result;
}

Entityの両方のIdプロパティフィールドの名前をTable1IdとTable2Idに変更することができましたが、代わりにTable1.Table1Idの代わりにTable1.Idのようなロジックコードが必要になりました。だから私は疑問に思っていました。私がここで欲しいものは可能なのでしょうか?

編集:

私はこのトピックを発見しました: クラスプロパティで列名を手動でマップする

Kaleb Pedersonの最初の投稿にあるコードでは、FallBackTypeMapperクラスとColumnAttributeTypeMapperクラスを使用して、必要に応じて属性を使用することができます。必要なのは、必要なクラスをタイプ・マッピングに追加することだけです。

SqlMapper.SetTypeMap(typeof(Table1), new ColumnAttributeTypeMapper<Table1>());
SqlMapper.SetTypeMap(typeof(Table2), new ColumnAttributeTypeMapper<Table2>());

しかし、多くのエンティティでは、このリストは長く成長します。また、すべてのクラスをリストに手動で追加する必要があります。これがReflectionを使ってより一般的に自動実行できるのかどうか疑問に思っていました。すべてのタイプを取得できるコードフラグメントが見つかりました。

        const string @namespace = "DapperTestProj.Entities";

        var types = from type in Assembly.GetExecutingAssembly().GetTypes()
                    where type.IsClass && type.Namespace == @namespace
                    select type;

そして、すべての型をループすることで、私はこれを行うことができます。今問題となっているのは、どのようなコードフラグメントが質問マークがある場所に置く必要がありますか?

        typeList.ToList().ForEach(type => SqlMapper.SetTypeMap(type, 
                               new ColumnAttributeTypeMapper</*???*/>()));

編集:

より多くの検索の後、私は私の最後の問題の解決策を見つけました:

        typeList.ToList().ForEach(type =>
            {
                var mapper = (SqlMapper.ITypeMap)Activator.CreateInstance(
                    typeof(ColumnAttributeTypeMapper<>)
                        .MakeGenericType(type));
                SqlMapper.SetTypeMap(type, mapper);
            });

受け入れられた回答

解決策を完成させるために、私が見つけたコードを、関心のある人と共有したいと思います。

System.Data.Linq.Mapping.ColumnAttributeを使用する代わりに、独自のColumnAttributeを作成するために、Microsoftがlinqをsql ColumnAttributeクラスに変更する可能性は非常に小さいですが、より多くのロジックが必要です(おそらく保存されます)クラス:

ColumnAttribute.cs

using System;

namespace DapperTestProj.DapperAttributeMapper //Maybe a better namespace here
{
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    public class ColumnAttribute : Attribute
    {
        public string Name { get; set; }

        public ColumnAttribute(string name)
        {
            Name = name;
        }
    }
}

前述のトピックで見つかったFallBackTypeMapperクラスとColumnAttributeTypeMapperクラスは次のとおりです。

FallBackTypeMapper.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using Dapper;

namespace DapperTestProj.DapperAttributeMapper
{
    public class FallBackTypeMapper : SqlMapper.ITypeMap
    {
        private readonly IEnumerable<SqlMapper.ITypeMap> _mappers;

        public FallBackTypeMapper(IEnumerable<SqlMapper.ITypeMap> mappers)
        {
            _mappers = mappers;
        }

        public ConstructorInfo FindConstructor(string[] names, Type[] types)
        {
            foreach (var mapper in _mappers)
            {
                try
                {
                    var result = mapper.FindConstructor(names, types);

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

        public SqlMapper.IMemberMap GetConstructorParameter(ConstructorInfo constructor, string columnName)
        {
            foreach (var mapper in _mappers)
            {
                try
                {
                    var result = mapper.GetConstructorParameter(constructor, 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;
        }

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

ColumnAttributeTypeMapper.cs

using System.Linq;
using Dapper;

namespace DapperTestProj.DapperAttributeMapper
{
    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(attribute => attribute.Name == columnName)
                            )
                        ),
                        new DefaultTypeMap(typeof(T)) 
                    })
        {
        }
    }
}

最後にTypeMapper.csを使用してマッピングを初期化します。

using System;
using System.Linq;
using System.Reflection;
using Dapper;

namespace DapperTestProj.DapperAttributeMapper
{
    public static class TypeMapper
    {
        public static void Initialize(string @namespace)
        {
            var types = from type in Assembly.GetExecutingAssembly().GetTypes()
                        where type.IsClass && type.Namespace == @namespace
                        select type;

            types.ToList().ForEach(type =>
            {
                var mapper = (SqlMapper.ITypeMap)Activator
                    .CreateInstance(typeof(ColumnAttributeTypeMapper<>)
                                    .MakeGenericType(type));
                SqlMapper.SetTypeMap(type, mapper);
            });
        }
    }
}

起動時に、TypeMapper.Initializeを呼び出す必要があります:

TypeMapper.Initialize("DapperTestProj.Entities");

また、エンティティプロパティの属性を使用することもできます

using DapperTestProj.DapperAttributeMapper;

namespace DapperTestProj.Entities
{
    public class Table1
    {
        [Column("Table1Id")]
        public int Id { get; set; }

        public string Column1 { get; set; }

        public string Column2 { get; set; }

        public Table2 Table2 { get; set; }

        public Table1()
        {
            Table2 = new Table2();
        }
    }
}

人気のある回答

Cornelisの答えは正しいですが、私はこれに更新を加えたいと思っていました。 Dapperの現在のバージョンでは、 SqlMapper.ItypeMap.FindExplicitConstructor()を実装する必要もあります。この変更がいつ行われたのかは分かりませんが、この問題を抱えて解決策のその部分が欠落している他の人にとってはこれはわかりません。

FallbackTypeMapper.cs

public ConstructorInfo FindExplicitConstructor()
{
    return _mappers.Select(m => m.FindExplicitConstructor())
        .FirstOrDefault(result => result != null);
}

また、 System.ComponentModel.DataAnnotations.Schema名前空間内にあるColumnAttributeクラスを使用することもできます。



ライセンスを受けた: CC-BY-SA with attribution
所属していない Stack Overflow
このKBは合法ですか? はい、理由を学ぶ
ライセンスを受けた: CC-BY-SA with attribution
所属していない Stack Overflow
このKBは合法ですか? はい、理由を学ぶ