Question

我讨厌拥有一堆“左/右”方法。每次添加或删除属性时，我都必须修复每个方法。代码本身看起来......错了。

public Foo(Foo other)
{
    this.Bar = other.Bar;
    this.Baz = other.Baz;
    this.Lur = other.Lur;
    this.Qux = other.Qux;
    this.Xyzzy= other.Xyzzy;
}

实际上这只是一个展开的循环，它遍历属性，在对象之间复制它们。那么为什么不对这个事实说实话呢？反思救援！

public Foo(IFoo other)
{
    foreach (var property in typeof(IFoo).GetProperties())
    {
        property.SetValue(this, property.GetValue(other, null), null);
    }
}

我可能只是试图强迫我从Lua学习到C＃的范例，但这个特殊的例子对我来说似乎并不太臭。从这里开始，我开始做一些对字段顺序敏感的更复杂的事情。例如，我不是用一堆几乎相同的if语句来组成字段中的字符串，而是按照所需的顺序迭代它们：

public override string ToString()
{
    var toJoin = new List<string>();
    foreach (var property in tostringFields)
    {
        object value = property.GetValue(this, null);
        if (value != null)
            toJoin.Add(value.ToString());
    }
    return string.Join(" ", toJoin.ToArray());
}
private static readonly PropertyInfo[] tostringFields =
{
    typeof(IFoo).GetProperty("Bar"),
    typeof(IFoo).GetProperty("Baz"),
    typeof(IFoo).GetProperty("Lur"),
    typeof(IFoo).GetProperty("Qux"),
    typeof(IFoo).GetProperty("Xyzzy"),
};

所以现在我有了我想要的可迭代性，但我仍然有一堆代码镜像我感兴趣的每个属性（我也是为CompareTo做的，使用不同的属性以不同的顺序）。更糟糕的是失去了强烈的打字。这真的开始闻起来了。

那么在每个属性上使用属性来定义顺序呢？我开始走这条路，确实运作良好，但它让整个事情变得臃肿。它在语义上很有效，但我总是担心使用高级功能只是因为它们“整洁”。以这种方式使用反射是否过度杀伤？是否有其他解决左/右代码问题的解决方案？

Answer 1

使用反射本身并不坏，但是如果你以递归方式执行它，你会受到性能影响。

我不是硬编码拷贝构造函数的粉丝，因为开发人员在向类添加新属性时忘记更新它们。

还有其他方法可以实现您的目标，包括Marc Gravells Hyper Property Descriptor，或者如果您想学习一些IL和OPCode，您可以使用System.Reflection.Emit甚至Cecil from Mono。

以下是使用超级属性描述符的示例，您可以根据自己的需要进行定制：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using Hyper.ComponentModel;
namespace Test {
    class Person {
        public int Id { get; set; }
        public string Name { get; set; }
    }
    class Program {
        static void Main() {
            HyperTypeDescriptionProvider.Add(typeof(Person));
            var properties = new Dictionary<string, object> { { "Id", 10 }, { "Name", "Fred Flintstone" } };
            Person person = new Person();
            DynamicUpdate(person, properties);
            Console.WriteLine("Id: {0}; Name: {1}", person.Id, person.Name);
            Console.ReadKey();
        }
        public static void DynamicUpdate<T>(T entity, Dictionary<string, object>  {
            foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(typeof(T)))
                if (properties.ContainsKey(propertyDescriptor.Name))
                    propertyDescriptor.SetValue(entity, properties[propertyDescriptor.Name]);
        }
    }
}

如果您决定继续使用反射，可以通过缓存对GetProperties（）的调用来降低性能：

public Foo(IFoo other) {
    foreach (var property in MyCacheProvider.GetProperties<IFoo>())
        property.SetValue(this, property.GetValue(other, null), null);
}

Answer 2

我知道已经有了答案，但我想指出，有一个库结合了一些缓解策略来解决一些人讨论过的性能影响。

该库名为AutoMapper，它从一个对象映射到另一个对象，并通过动态创建IL程序集来实现。这确保了除了第一次点击之外，您将获得卓越的性能，并且您的代码将更加简单：

public Foo(Foo other)
{
    Mapper.Map(other, this);
}

这往往效果很好，还有一个额外的好处，就是不会在这里发明，我很喜欢。

我做了一些性能测试，在第一次达到20毫秒后（仍然相当快），它几乎接近0，你可以得到。非常令人印象深刻。

希望这有助于某人。

Answer 3

恕我直言，反射是C＃的一个非常强大的功能，但很可能会导致代码膨胀，并且会增加代码的学习曲线并降低可维护性。你更有可能犯错（一旦基本重构可能导致错误），更害怕改变任何属性的名称（如果你碰巧找到一个更好的名字）或类似的东西。

我个人有一个类似问题的代码，我有同样的想法添加属性来维护秩序等等。但我的团队（包括我）认为最好不要浪费时间更改设计而不需要这个。也许这个问题是由糟糕的设计引起的（嗯，这是我的情况，但我不能对你的情况说同样的事情）。

Answer 4

基本问题是您尝试使用静态类型语言，如动态类型语言。

实际上并不需要任何花哨的东西。如果您希望能够迭代属性，可以使用Map＆lt;＆gt;作为您班级中所有房产的后备商店。

巧合的是，这正是VS项目向导为您设计应用程序设置的方式。（参见System.Configuration.ApplicationSettingsBase）它也非常像'lua-like'

   public bool ConfirmSync {
        get {
            return ((bool)(this["ConfirmSync"]));
        }
        set {
            this["ConfirmSync"] = value;
        }
    }

如何使用反射来简化构造函数和比较？

4 个答案: