Asp.net mvc 4 net如何创建地图

我想为dapper.query函数创建这种映射。
有人能帮忙吗？
我想将自定义列名映射到实体属性名

---

---

现在，如果我使用Person实体，它不会在Person实体内部映射EntityBase属性。

基本上，您需要编写一个

ITypeMap

和

IMemberMap

实现，它在内部可以基于您选择的任何规则（命名约定，如删除

S

etc标识符、下划线等；属性；或自定义映射，如您的情况）

下面是一个完整的可运行示例，可能会有所帮助：

EntityBaseMap entityBaseMap = new EntityBaseMap();
PersonMap personMap = new PersonMap();

使用简洁；
使用制度；
使用System.Collections.Generic；
使用System.Data.SqlClient；
使用System.Linq；
运用系统反思；
类SomeType
{
公共字符串条{get；set；}
公共int Foo{get；set；}
}
静态类程序
{
静态程序（）
{
//只需要做一次
var oldMap=SqlMapper.GetTypeMap（typeof（SomeType））；
var映射=新的CustomTypeMap（typeof（SomeType），oldMap）；
map.map（“IFoo”、“Foo”）；
地图（“SBar”、“酒吧”）；
SetTypeMap（map.Type，map）；
}
静态void Main（）
{
使用（var conn=new SqlConnection（“服务器=；数据库=主机；受信任的连接=真”））
{
conn.Open（）；
var row=conn.Query（“选择123作为[IFoo]，'abc'作为[SBar]”）.Single（）；
Console.WriteLine（row.Foo）；
控制台写入线（行栏）；
}
}
类CustomTypeMap:SqlMapper.ITypeMap
{
专用只读词典成员
=新字典（StringComparer.OrdinalIgnoreCase）；
公共类型类型{get{return Type；}}
私有只读类型；
私有只读SqlMapper.ITypeMap tail；
公共无效映射（字符串columnName、字符串memberName）
{
members[columnName]=新成员映射（type.GetMember（memberName）.Single（），columnName）；
}
公共CustomTypeMap（类型，SqlMapper.ITypeMap tail）
{
this.type=type；
this.tail=tail；
}
public System.Reflection.ConstructorInfo FindConstructor（字符串[]名称，类型[]类型）
{
返回tail.FindConstructor（名称、类型）；
}
公共SqlMapper.IMemberMap GetConstructorParameter(
System.Reflection.ConstructorInfo构造函数，字符串列名称）
{
返回tail.GetConstructorParameter（构造函数，列名）；
}
public SqlMapper.IMemberMap GetMember（字符串columnName）
{
SqlMapper.IMemberMap；
if（！members.TryGetValue（columnName，out map））
{//如果您不想回退到
//默认实现
map=tail.GetMember（columnName）；
}
返回图；
}
}
类成员映射：SqlMapper.IMemberMap
{
私人只读成员信息成员；
私有只读字符串列名称；
公共成员映射（成员信息成员，字符串列名称）
{
this.member=成员；
this.columnName=columnName；
}
公共字符串ColumnName{get{return ColumnName；}}
public System.Reflection.FieldInfo字段{get{return member as FieldInfo；}}
公共类型MemberType{get{
开关（成员.成员类型）
{
案例成员类型。字段：返回（（FieldInfo）成员）。字段类型；
case MemberTypes.Property:return（（PropertyInfo）member.PropertyType；
默认值：抛出新的NotSupportedException（）；
}
} }
public System.Reflection.ParameterInfo参数{get{return null；}}
public System.Reflection.PropertyInfo属性{get{return member as PropertyInfo；}}
}
}

感谢Marc的快速回复。如果我使用的是MVC应用程序，其中包含数据层（我将在其中使用dapper），还有一个问题。我的问题是，我可以在哪里编写u提供的代码，以便在启动时只需进行一次映射。？@CodeCrusher最简单的地方是从global.asax调用DAL中的Init方法，在您配置MVC routesHi Marc的位置附近。如果我有一个基本实体，则代码不起作用。它不映射基本实体的属性tity.即使我正在以一定的速度映射基本实体。@CodeCrusher您能提供一个例子吗？公共类客户端：EntityBase。EntityBase我正在映射u给出的。也可以单独映射客户端。

public class EntityBase
{
    public string CreatedBy { get; set; }
    public DateTime CreatedOn { get; set; }
}

public class Person :EntityBase
{
    public string SecurityAlias{ get; set; }
    public DateTime Identifier{ get; set; }
}

public class EntityBaseMap
{
    public EntityBaseMap()
    {
        var map = new CustomTypeMap<EntityBase>();
        map.Map("CreatingPerson", "CreatedBy");
        map.Map("CreatedDate", "CreatedOn");
        SqlMapper.SetTypeMap(map.Type, map);
    }
}

public class PersonMap
{
    public PersonMap()
    {
        var map = new CustomTypeMap<Person>();
        map.Map("security_alias", "SecurityAlias");
        map.Map("Id", "Identifier");
        SqlMapper.SetTypeMap(map.Type, map);
    }
}

EntityBaseMap entityBaseMap = new EntityBaseMap();
PersonMap personMap = new PersonMap();

using Dapper;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Reflection;

class SomeType
{
    public string Bar { get; set; }
    public int Foo { get; set; }
}

static class Program
{
    static Program()
    {
        // only need to do this ONCE
        var oldMap = SqlMapper.GetTypeMap(typeof(SomeType));
        var map = new CustomTypeMap(typeof(SomeType), oldMap);
        map.Map("IFoo", "Foo");
        map.Map("SBar", "Bar");
        SqlMapper.SetTypeMap(map.Type, map);
    }

    static void Main()
    {
        using (var conn = new SqlConnection("Server=.;Database=master;Trusted_Connection=true"))
        {
            conn.Open();

            var row = conn.Query<SomeType>("select 123 as [IFoo], 'abc' as [SBar]").Single();
            Console.WriteLine(row.Foo);
            Console.WriteLine(row.Bar);
        }
    }

    class CustomTypeMap : SqlMapper.ITypeMap
    {
        private readonly Dictionary<string, SqlMapper.IMemberMap> members
            = new Dictionary<string, SqlMapper.IMemberMap>(StringComparer.OrdinalIgnoreCase);
        public Type Type { get { return type; } }
        private readonly Type type;
        private readonly SqlMapper.ITypeMap tail;
        public void Map(string columnName, string memberName)
        {
            members[columnName] = new MemberMap(type.GetMember(memberName).Single(), columnName);
        }
        public CustomTypeMap(Type type, SqlMapper.ITypeMap tail)
        {
            this.type = type;
            this.tail = tail;
        }
        public System.Reflection.ConstructorInfo FindConstructor(string[] names, Type[] types)
        {
            return tail.FindConstructor(names, types);
        }

        public SqlMapper.IMemberMap GetConstructorParameter(
            System.Reflection.ConstructorInfo constructor, string columnName)
        {
            return tail.GetConstructorParameter(constructor, columnName);
        }

        public SqlMapper.IMemberMap GetMember(string columnName)
        {
            SqlMapper.IMemberMap map;
            if (!members.TryGetValue(columnName, out map))
            { // you might want to return null if you prefer not to fallback to the
              // default implementation
                map = tail.GetMember(columnName);
            }
            return map;
        }
    }
    class MemberMap : SqlMapper.IMemberMap
    {
        private readonly MemberInfo member;
        private readonly string columnName;
        public MemberMap(MemberInfo member, string columnName)
        {
            this.member = member;
            this.columnName = columnName;
        }
        public string ColumnName { get { return columnName; } }
        public System.Reflection.FieldInfo Field { get { return member as FieldInfo; } }
        public Type MemberType { get {
            switch (member.MemberType)
            {
                case MemberTypes.Field: return ((FieldInfo)member).FieldType;
                case MemberTypes.Property: return ((PropertyInfo)member).PropertyType;
                default: throw new NotSupportedException();
            }
        } }
        public System.Reflection.ParameterInfo Parameter { get { return null; } }
        public System.Reflection.PropertyInfo Property { get { return member as PropertyInfo; } }
    }
}