如果它们具有相同的接口，可以将一个对象的内容动态复制到另一个对象吗？

Question

例如，如果我有两个对象，一个是 Monkey 类型，另一个是 Dog 类型，它们都实现了 IAnimal，如下所示：

interface IAnimal
{
  int numberOfEyes {get; set;}
  string name {get; set;}
}

我想做这样的事情：

Monkey monkey = new Monkey() { numberOfEyes = 7, name = "Henry" };
Dog dog = new Dog();
MyFancyClass.DynamicCopy(monkey, dog, typeof(IAnimal));
Debug.Assert(dog.numberOfEyes == monkey.numberOfEyes);

我想可以使用反射创建一个像 MyFancyClass 这样的类...任何聪明的人都有想法？

谢谢， 斯蒂芬

Answer 1

只是把它混在一起......你也可以使用AutoMapper将一个对象映射/复制到另一个......他们甚至不必实现相同的接口。要使其自动工作，只需属性的名称必须匹配，然后您只需执行以下操作：

Mapper.Map<IAnimal, MyClass>(myInstance);

Answer 2

以下是基于反射的解决方案。请注意，每个 Type 只进行一次反射工作，然后进行缓存，因此开销应该是最小的。将与 .NET 3.5 一起使用，并且不限于接口。

请注意，我使用反射来获取类型 T 的所有属性，并过滤到同时具有 getter 和 setter 的属性。然后，我为从源中检索值并将该值分配给目标的每个属性构建一个表达式树。表达式树被编译并缓存在一个静态字段中。当调用 CopyProperties 方法时，它会为每个属性调用复制器，复制类型 T 中定义的所有属性。

// Usage
Monkey monkey = new Monkey() { numberOfEyes = 7, name = "Henry" };
Dog dog = new Dog();
DynamicCopy.CopyProperties<IAnimal>(monkey, dog);
Debug.Assert(dog.numberOfEyes == monkey.numberOfEyes);

...    

// The copier
public static class DynamicCopy
{
    public static void CopyProperties<T>(T source, T target)
    {
        Helper<T>.CopyProperties(source, target);
    }

    private static class Helper<T>
    {
        private static readonly Action<T, T>[] _copyProps = Prepare();

        private static Action<T, T>[] Prepare()
        {
            Type type = typeof(T);
            ParameterExpression source = Expression.Parameter(type, "source");
            ParameterExpression target = Expression.Parameter(type, "target");

            var copyProps = from prop in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                            where prop.CanRead && prop.CanWrite
                            let getExpr = Expression.Property(source, prop)
                            let setExpr = Expression.Call(target, prop.GetSetMethod(true), getExpr)
                            select Expression.Lambda<Action<T, T>>(setExpr, source, target).Compile();

            return copyProps.ToArray();
        }

        public static void CopyProperties(T source, T target)
        {
            foreach (Action<T, T> copyProp in _copyProps)
                copyProp(source, target);
        }
    }
}

Answer 3

复制构造函数是我通常做的：

class Monkey : IAnimal
{
  public Monkey(IAnimal other)
  {
    //Copy properties here...
  }
}

Answer 4

你有几个选择：

您可以选择使用反射，但这会比其他选项慢得多，而且您必须编写自己的反射代码。使用反射制作漂亮的通用“克隆”代码非常重要，尤其是当您必须开始处理包含其他对象实例的列表/数组/字典的对象时。

正如 Herbie 博士所说，复制构造函数是一种选择。

另一种方法是在所有类型上实现ICloneable（您可以让接口实现ICloneable 以强制所有IAnimals 实现它）。这可能不像反射那样是动态的（你必须为每个类手工制作它），但假设你只是复制属性值，它会比反射快得多。

同样值得考虑的是不变性。如果您可以使您的具体类型不可变（在所有字段上使用readonly 以便它们无法更改），那么您可能根本不需要担心克隆。一切都可以安全地共享同一个实例，因为其他共享者无法以任何方式对其进行修改。这种不变性可能非常强大，但如果您的界面包含可以修改的集合/数组，您需要小心。

最后，如果您有很多类，您可以查看代码生成以生成 C#“克隆”类（其工作是生成给定类型的克隆）并将它们编译成程序集。您可以在此处使用反射来创建“克隆类模板”，但由于它会生成代码（与项目的其余部分一起编译），因此您不会受到慢反射的运行时影响。

因此，克隆有很多选择 - 但使用反射，即使它可以是天真的和动态的，通常也不是最好的方法。

Answer 5

您可以使 IAnimal 实现 ICloneable。然后对猴子或其他实现 ICloneable 的类进行 memeberwise 克隆。顺便说一下，这是一个浅拷贝。

public interface IAnmial : ICloneable
{
    string Name{get; set;}
    object Clone();
}

public class Monkey : IAnmial
{
    public string Name{get; set;}

    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

public class Dog : IAnmial
{
    public string Name{get; set;}

    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

public class Test()
{
    public void CloneAnimal()
    {
        Dog dog = new Dog()
        {
            Name = "MyAnimal",
        };
        IAnimal monkey = dog.Clone() as IAnimal;
    }
}

Answer 6

只要DynamicCopy 接受IAnimal 作为方法参数，您就可以做到这一点。 但这确实有助于了解您要做什么。

Answer 7

为什么不在IAnimal 中实现一个方法？

（编辑：正如评论者有帮助指出的那样，IAnimal 应该被转换为这个解决方案的抽象基类Animal。无论如何这都是有道理的，因为这个问题背后的整个推论是子类包含父类中定义的属性。）

// In Aminal class.
public void CopyAttributes(Animal source)
{
    this.numberOfEyes = source.numberOfEyes;
    this.name = source.name;
}

通过反射做这样的事情很快就会变得一团糟。你应该只复制属性吗？获取/设置方法呢？只读属性呢？这就是为什么最好在每个级别定义您实际想要的行为。然后，您可以根据需要在较低级别覆盖。

// In Monkey class.
public void CopyAttributes(Monkey source)
{
    super.CopyAttributes(source);
    this.numberOfTails = source.numberOfTails;
}

Answer 8

尝试查看struct 方法