微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

c# – 展平嵌套对象以将其属性映射到目标对象

分类：C#作者：编程之家AI导航网
我正在尝试使用AutoMapper来映射这样的类： 

class FooDTO
{
    public int X { get; set; }
    public EmbeddedDTO Embedded { get; set; }
    public class EmbeddedDTO
    {
        public BarDTO Y { get; set; }
        public BazDTO Z { get; set; }
    }
}

对于这样的类：

class Foo
{
    public int X { get; set; }
    public Bar Y { get; set; }
    public Baz Z { get; set; }
}

(FooDTO是一个HAL资源)

我知道我可以通过这样明确地创建地图来实现：

Mapper.CreateMap<FooDTO,Foo>()
      .ForMember(f => f.Y,c => c.MapFrom(f => f.Embedded.Y))
      .ForMember(f => f.Z,c => c.MapFrom(f => f.Embedded.Z));

或者甚至用这样的技巧：

Mapper.CreateMap<FooDTO,Foo>()
      .AfterMap((source,dest) => Mapper.Map(source.Embedded,dest));

但问题是我将有许多类似的HAL资源来映射,而我宁愿不必单独配置每个资源.我实际上有一个通用对象模型,如下所示：

class HalResource
{
    [JsonProperty("_links")]
    public IDictionary<string,HalLink> Links { get; set; }
}

class HalResource<TEmbedded> : HalResource
{
    [JsonProperty("_embedded")]
    public TEmbedded Embedded { get; set; }
}

class HalLink
{
    [JsonProperty("href")]
    public string Href { get; set; }
}

使用此模型,FooDTO类实际上是这样声明的

class FooDTO : HalResource<FooDTO.EmbeddedDTO>
{
    public int X { get; set; }
    public class EmbeddedDTO
    {
        public int Y { get; set; }
        public int Z { get; set; }
    }
}

有没有办法为继承HalResource< TEmbedded>的所有类全局配置映射,以便DTO的Embedded属性的属性直接映射到目标对象？我尝试用自定义的IObjectMapper来做,但事实证明它比我预期的更具挑战性……

解决方法

如果您的用例与问题中的限制一样,那就是：

>从HalResource派生实例到直接POCOS的单向映射(与双向映射相比)
>映射相同名称和类型的属性
>您在此处介绍的确切嵌入式结构

考虑到这种结构,自己设置一个特定的映射可能是有意义的.如果我对一些明确的映射约定(而不是依赖于诸如AutoMapper的通用映射器)的映射需求非常狭窄,那么我倾向于这样做.为此,我有一些构建块,我倾向于在不同的上下文中重用.我将一个映射器组合在一起,适用于您从这些构建块中描述的问题,如下所示：

public class Mapper
{
    private const BindingFlags DestConstructorFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
    private const BindingFlags DestFlags = BindingFlags.Instance | BindingFlags.Public;
    private const BindingFlags SrcFlags = BindingFlags.Instance | BindingFlags.Public;
    private static readonly object[] NoArgs = new object[0];
    private static readonly Type GenericEmbeddedSourceType = typeof(HalResource<>);
    private readonly Dictionary<Type,Func<object,object>> _oneWayMap = new Dictionary<Type,object>>();

    public void CreateMap<TDestination,TSource>() 
        where TDestination : class 
        where TSource : HalResource
    {
        CreateMap(typeof(TDestination),typeof(TSource));
    }

    public void CreateMap(Type destType,Type srcType)
    {
        _oneWayMap[srcType] = InternalCreateMapper(destType,srcType);
    }

    public object Map<TSource>(TSource toMap) where TSource : HalResource
    {
        var mapper = default(Func<object,object>);
        if (!_oneWayMap.TryGetValue(typeof(TSource),out mapper))
            throw new KeyNotFoundException(string.Format("No mapping for {0} is defined.",typeof(TSource)));
        return mapper(toMap);
    }

    public TDestination Map<TDestination,TSource>(TSource toMap)
        where TDestination : class
        where TSource : HalResource
    {
        var converted = Map(toMap);
        if (converted != null && !typeof(TDestination).IsAssignableFrom(converted.GetType()))
            throw new InvalidOperationException(string.Format("No mapping from type {0} to type {1} has been configured.",typeof(TSource),typeof(TDestination)));
        return (TDestination)converted;
    }

    public void Clear()
    {
        _oneWayMap.Clear();
    }

    private static Func<object,object> InternalCreateMapper(Type destType,Type srcType)
    {
        // Destination specific constructor + setter map.
        var destConstructor = BuildConstructor(destType.GetConstructor(DestConstructorFlags,null,Type.EmptyTypes,null));
        var destSetters = destType
            .GetProperties(DestFlags)
            .Where(p => p.CanWrite)
            .ToDictionary(k => k.Name,v => Tuple.Create(v.PropertyType,BuildSetter(v)));

        // Source specific getter maps
        var srcPrimPropGetters = CreateGetters(srcType);
        var srcEmbeddedGetter = default(Func<object,object>);
        var srcEmbeddedPropGetters = default(IDictionary<string,Tuple<Type,object>>>);
        var baseType = srcType.BaseType;
        while (baseType != null && baseType != typeof(object))
        {
            if (baseType.IsGenericType && GenericEmbeddedSourceType.IsAssignableFrom(baseType.GetGenericTypeDeFinition()))
            {
                var genericParamType = baseType.GetGenericArguments()[0];
                if (srcPrimPropGetters.Any(g => g.Value.Item1.Equals(genericParamType)))
                {
                    var entry = srcPrimPropGetters.First(g => g.Value.Item1.Equals(genericParamType));
                    srcPrimPropGetters.Remove(entry.Key);
                    srcEmbeddedGetter = entry.Value.Item2;
                    srcEmbeddedPropGetters = CreateGetters(entry.Value.Item1);
                    break;
                }
            }
            baseType = baseType.BaseType;
        }

        // Build mapper delegate function.
        return (src) =>
        {
            var result = destConstructor(NoArgs);
            var srcEmbedded = srcEmbeddedGetter != null ? srcEmbeddedGetter(src) : null;
            foreach (var setter in destSetters)
            {
                var getter = default(Tuple<Type,object>>);
                if (srcPrimPropGetters.TryGetValue(setter.Key,out getter) && setter.Value.Item1.IsAssignableFrom(getter.Item1))
                    setter.Value.Item2(result,getter.Item2(src));
                else if (srcEmbeddedPropGetters.TryGetValue(setter.Key,getter.Item2(srcEmbedded));
            }
            return result;
        };
    }

    private static IDictionary<string,object>>> CreateGetters(Type srcType)
    {
        return srcType
            .GetProperties(SrcFlags)
            .Where(p => p.CanRead)
            .ToDictionary(k => k.Name,BuildGetter(v)));
    }

    private static Func<object[],object> BuildConstructor(ConstructorInfo constructorInfo)
    {
        var param = Expression.Parameter(typeof(object[]),"args");
        var argsExp = constructorInfo.GetParameters()
            .Select((p,i) => Expression.Convert(Expression.ArrayIndex(param,Expression.Constant(i)),p.ParameterType))
            .ToArray();
        return Expression.Lambda<Func<object[],object>>(Expression.New(constructorInfo,argsExp),param).Compile();
    }

    private static Func<object,object> BuildGetter(PropertyInfo propertyInfo)
    {
        var instance = Expression.Parameter(typeof(object),"instance");
        var instanceCast = propertyInfo.DeclaringType.IsValueType
            ? Expression.Convert(instance,propertyInfo.DeclaringType)
            : Expression.TypeAs(instance,propertyInfo.DeclaringType);
        var propertyCast = Expression.TypeAs(Expression.Property(instanceCast,propertyInfo),typeof(object));
        return Expression.Lambda<Func<object,object>>(propertyCast,instance).Compile();
    }

    private static Action<object,object> BuildSetter(PropertyInfo propertyInfo)
    {
        var setMethodInfo = propertyInfo.GetSetMethod(true);
        var instance = Expression.Parameter(typeof(object),"instance");
        var value = Expression.Parameter(typeof(object),"value");
        var instanceCast = propertyInfo.DeclaringType.IsValueType
            ? Expression.Convert(instance,propertyInfo.DeclaringType);
        var call = Expression.Call(instanceCast,setMethodInfo,Expression.Convert(value,propertyInfo.PropertyType));
        return Expression.Lambda<Action<object,object>>(call,instance,value).Compile();
    }
}

可以执行一些优化,但性能可能足以解决大多数问题.然后可以使用它：

public abstract class HalResource
{
    public IDictionary<string,HalLink> Links { get; set; }
}

public abstract class HalResource<TEmbedded> : HalResource
{
    public TEmbedded Embedded { get; set; }
}

public class HalLink
{
    public string Href { get; set; }
}

public class FooDTO : HalResource<FooDTO.EmbeddedDTO>
{
    public int X { get; set; }
    public class EmbeddedDTO
    {
        public int Y { get; set; }
        public int Z { get; set; }
    }
}

public class MyMappedFoo
{
    public int X { get; set; }
    public int Y { get; set; }
    public int Z { get; set; }
}

class Program
{
    public static void Main(params string[] args)
    {
        // Configure mapper manually
        var mapper = new Mapper();
        mapper.CreateMap<MyMappedFoo,FooDTO>();

        var myDTO = new FooDTO 
        { 
            X = 10,Embedded = new FooDTO.EmbeddedDTO { Y = 5,Z = 9 } 
        };
        var mappedFoo = mapper.Map<MyMappedFoo,FooDTO>(myDTO);
        Console.WriteLine("X = {0},Y = {1},Z = {2}",mappedFoo.X,mappedFoo.Y,mappedFoo.Z);

        Console.WriteLine("Done");
        Console.ReadLine();
    }
}

如果可以通过约定发现源和目标类型,则可以更进一步,并使用编码这些约定的构建器填充映射,如下面的示例所示(同样不是最佳实现,但有说明点)：

public static class ByConventionMapBuilder
{
    public static Func<IEnumerable<Type>> DestinationTypesProvider = DefaultDestTypesProvider;
    public static Func<IEnumerable<Type>> SourceTypesProvider = DefaultSourceTypesProvider;
    public static Func<Type,Type,bool> TypeMatcher = DefaultTypeMatcher;

    public static Mapper Build()
    {
        var mapper = new Mapper();
        var sourceTypes = SourceTypesProvider().ToList();
        var destTypes = DestinationTypesProvider();
        foreach (var destCandidateType in destTypes)
        {
            var match = sourceTypes.FirstOrDefault(t => TypeMatcher(t,destCandidateType));
            if (match != null)
            {
                mapper.CreateMap(destCandidateType,match);
                sourceTypes.Remove(match);
            }
        }
        return mapper;
    }

    public static IEnumerable<Type> TypesFromAssembliesWhere(Func<IEnumerable<Assembly>> assembliesProvider,Predicate<Type> matches)
    {
        foreach (var a in assembliesProvider())
        {
            foreach (var t in a.GetTypes())
            {
                if (matches(t))
                    yield return t;
            }
        }
    }

    private static IEnumerable<Type> DefaultDestTypesProvider()
    {
        return TypesFromAssembliesWhere(
            () => new[] { Assembly.GetExecutingAssembly() },t => t.IsClass && !t.IsAbstract && !t.Name.EndsWith("DTO"));
    }

    private static IEnumerable<Type> DefaultSourceTypesProvider()
    {
        return TypesFromAssembliesWhere(
            () => new[] { Assembly.GetExecutingAssembly() },t => typeof(HalResource).IsAssignableFrom(t) && !t.IsAbstract && t.Name.EndsWith("DTO"));
    }

    private static bool DefaultTypeMatcher(Type srcType,Type destType)
    {
        var stn = srcType.Name;
        return (stn.Length > 3 && stn.EndsWith("DTO") && destType.Name.EndsWith(stn.Substring(0,stn.Length - 3)));
    }
}

class Program
{
    public static void Main(params string[] args)
    {
        // Configure mapper by type scanning & convention matching
        var mapper = ByConventionMapBuilder.Build();

        var myDTO = new FooDTO 
        { 
            X = 10,mappedFoo.Z);

        Console.WriteLine("Done");
        Console.ReadLine();
    }
}

如果您有其他理由想要继续使用AutoMapper,我建议创建一个类似的地图构建器,它对类型匹配和嵌入属性映射进行编码.

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

Blazor 调用 Clipboard API 读写剪贴板数据
目录简介使用JS互操作使用ClipLazor库创建项目使用方法简单测试参考链接 简介 Clipboard API 是一种允许网页读取剪贴板数据或向其中写入数据的API，主要有两个方法： navigator.clipboard.writeText() ：用于将文本写入剪贴板。 navigator.cl
C# 轻量级 ORM 框架 NPoco 的简单应用
目录简介快速入门安装 NuGet 包实体类User数据库类DbFactory增删改查InsertSelectUpdateDelete总结 简介 NPoco 是 PetaPoco 的一个分支，具有一些额外的功能，截至现在 github 星数 839。NPoco 中文资料没多少，我是被博客园群友推荐的，
C#简单配置类及数据绑定
本文实现一个简单的配置类，原理比较简单，适用于一些小型项目。主要实现以下功能：保存配置到json文件、从文件或实例加载配置类的属性值、数据绑定到界面控件。&#xA;一般情况下，项目都会提供配置的设置界面，很少手动更改配置文件，所以选择以json文件保存配置数据。
C#获取Description特性的扩展类
C#中Description特性主要用于枚举和属性，方法比较简单，记录一下以便后期使用。 扩展类DescriptionExtension代码如下： using System; using System.ComponentModel; using System.Reflection; /// &lt;
C#实现软件开机自启动（不需要管理员权限）
[TOC] # 原理简介 本文参考[C#/WPF/WinForm/程序实现软件开机自动启动的两种常用方法](https://blog.csdn.net/weixin_42288432/article/details/120059296)，将里面中的第一种方法做了封装成**AutoStart**类，使
C#爬取动态网页上的信息：B站主页
目录简介获取 HTML 文档解析 HTML 文档测试补充：使用 CSS 选择器参考文章 简介 动态内容网站使用 JavaScript 脚本动态检索和渲染数据，爬取信息时需要模拟浏览器行为，否则获取到的源码基本是空的。 本文使用的爬取步骤如下： 使用 Selenium 获取渲染后的 HTML 文档 使
C#项目管理引用的dll文件
这篇文章主要简单记录一下C#项目的dll文件管理方法，以便后期使用。 设置dll路径 参考C#开发奇技淫巧三：把dll放在不同的目录让你的程序更整洁中间的 方法一：配置App.config文件的privatePath ： &lt;runtime&gt; &lt;assemblyBinding xml
C# 常用特性(Attribute)
使用特性，可以有效地将元数据或声明性信息与代码（程序集、类型、方法、属性等）相关联。 将特性与程序实体相关联后，可以在运行时使用反射这项技术查询特性。&#xA;在 C# 中，通过用方括号 ([]) 将特性名称括起来，并置于应用该特性的实体的声明上方以指定特性。
C#事件总线
事件总线是对发布-订阅模式的一种实现，是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。&#xA;EventBus维护一个事件的字典，发布者、订阅者在事件总线中获取事件实例并执行发布、订阅操作，事件实例负责维护、执行事件处理程序。
C#中使用jieba.NET、WordCloudSharp制作词云图
词云”由美国西北大学新闻学副教授、新媒体专业主任里奇·戈登（Rich Gordon）于2006年最先使用，是通过形成“关键词云层”或“关键词渲染”，对文本中出现频率较高的“关键词”的视觉上的突出。词云图过滤掉大量的文本信息，使浏览者只要一眼扫过文本就可以领略文本的主旨。&#xA;网上大部分文章介绍的是使用P
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native