映射相同类型的两个对象（不包括某些字段）的最佳方法是什么？

Question

我之前在此处发布了我的问题，但没有得到任何回复因为 - 我猜 - 它太笼统了。我会尝试更简洁。

我有两个相同类型的对象，我想映射一些属性并排除其他属性。我想做的是将对象保存在缓存中并稍后获取它，仅使用具有特定属性的属性（字段）。

我看过Automapper，但我没有找到任何适合我的东西，所以我考虑实现自己的系统。
我创建了一个属性：

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class FilterFieldAttribute: Attribute
{
} 

并用它在我需要包含的字段上装饰了一个类：

public class OrdersViewModel : BaseViewModel
{
...

    [FilterField]
    [DisplayName("Order Number:")]
    public string OrderNumber { get; set; }

    [FilterField]
    [DisplayName("From date:")]
    public DateTime FromDate { get; set; }

    [FilterField]
    [DisplayName("To date:")]
    public DateTime ToDate { get; set; }

    [DisplayName("Status:")]
    public int Status { get; set; }

    ...
} 

现在，我已经实现了一个负责映射的函数：

    private T Map<T>(T Source, T Destination) where T : BaseViewModel
    {
        if (Source == null)
        {
            return (Source);
        }

        FilterFieldAttribute filterAttribute;

        foreach (PropertyInfo propInfo in typeof(T).GetProperties())
        {
            foreach (FilterFieldAttribute attr in propInfo.GetCustomAttributes(typeof(FilterFieldAttribute), false))
            {
                filterAttribute = attr as FilterFieldAttribute;
                if (filterAttribute != null)
                {
                    var value = propInfo.GetValue(Source, null);
                    propInfo.SetValue(Destination, value, null);
                }
            }
        }
        return (Destination);
    }

现在，当我需要从缓存中获取视图模型并填充时只有标有属性的属性我的代码看起来像这样：

viewModel = Map<T>(myCache.Get(Key) as T, viewModel);

我不知道这是否是最好的方法，但这似乎是我找到的唯一方法。
任何建议将不胜感激。

Answer 1

使用直接反射（如示例中所示）将会缓慢；给出更完整的答案很棘手，因为这取决于您想要子对象的浅克隆还是深层克隆。无论哪种方式，您都应该期望这涉及一些元编程和缓存 - 使用 ILGenerator 或 Expression。

但是，对于惰性选项，序列化可能有用。许多序列化程序允许您使用属性来包含/排除特定项目；通过序列化到内存流、回滚 (.Position=0) 和反序列化，您应该只获得所选成员的深层副本。

以下是使用表达式的示例：

using System;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class FilterFieldAttribute: Attribute
{
    public static T Clone<T>(T obj) where T : class, new()
    {
        return Cache<T>.clone(obj);
    }

    private static class Cache<T> where T : class, new()
    {
        public static readonly Func<T,T> clone;
        static Cache()
        {
            var param = Expression.Parameter(typeof(T), "source");
            var members = from prop in typeof(T).GetProperties()
                          where Attribute.IsDefined(prop, typeof(FilterFieldAttribute))
                          select Expression.Bind(prop, Expression.Property(param, prop));

            var newObj = Expression.MemberInit(Expression.New(typeof(T)), members);
            clone = Expression.Lambda<Func<T,T>>(newObj, param).Compile();
        }
    }
} 

public class OrdersViewModel 
{
    [FilterField]
    [DisplayName("Order Number:")]
    public string OrderNumber { get; set; }

    [FilterField]
    [DisplayName("From date:")]
    public DateTime FromDate { get; set; }

    [FilterField]
    [DisplayName("To date:")]
    public DateTime ToDate { get; set; }

    [DisplayName("Status:")]
    public int Status { get; set; }

    static void Main()
    {
        var foo = new OrdersViewModel { OrderNumber = "abc", FromDate = DateTime.Now,
            ToDate = DateTime.Now, Status = 1};
        var bar = FilterFieldAttribute.Clone(foo);
    }
}

Answer 2

听起来像是一个好的开始，但您正在失去 AutoMapper 的很多好处。 AutoMapper 还可以处理此处没有的嵌套属性（当您的类包含嵌套映射类时）。

由于 AutoMapper 是一个 oprn 源项目，我建议您获取 AutoMapper 源并在那里实现过滤。事实上，这对其他人也很有用。

Answer 3

我觉得你的做法没问题。反射有一些性能影响——这是值得考虑的。

另一种高效且更简单的方法可能是让 BaseViewModel 定义一个抽象方法：

public abstract BaseViewModel ToCacheVersion();

该方法可用于将子类转换为正确的类型。每个子类都会处理自己的映射：

public class ViewModelX
{
    public ViewModelX(string name, string description)
    {
        Name = name;
        Description = description;
    }

    ...

    public override BaseViewModel ToCacheVersion()
    {
        return new ViewModelX(
            Name, // Include the name.
            null  // Ignore the description.
        );
    }

    ...
}