我喜欢这样的Copyconstructors：

    public AnyObject(AnyObject anyObject)
    {
        foreach (var property in typeof(AnyObject).GetProperties())
        {
            property.SetValue(this, property.GetValue(anyObject));
        }
        foreach (var field in typeof(AnyObject).GetFields())
        {
            field.SetValue(this, field.GetValue(anyObject));
        }
    }

如果您有更多内容要复制，请添加它们

我在Silverlight中使用ICloneable时遇到了问题，但我喜欢序列化的想法，我可以序列化XML，所以我这样做了：

static public class SerializeHelper
{
    //Michael White, Holly Springs Consulting, 2009
    //michael@hollyspringsconsulting.com
    public static T DeserializeXML<T>(string xmlData) 
        where T:new()
    {
        if (string.IsNullOrEmpty(xmlData))
            return default(T);

        TextReader tr = new StringReader(xmlData);
        T DocItms = new T();
        XmlSerializer xms = new XmlSerializer(DocItms.GetType());
        DocItms = (T)xms.Deserialize(tr);

        return DocItms == null ? default(T) : DocItms;
    }

    public static string SeralizeObjectToXML<T>(T xmlObject)
    {
        StringBuilder sbTR = new StringBuilder();
        XmlSerializer xmsTR = new XmlSerializer(xmlObject.GetType());
        XmlWriterSettings xwsTR = new XmlWriterSettings();
        
        XmlWriter xmwTR = XmlWriter.Create(sbTR, xwsTR);
        xmsTR.Serialize(xmwTR,xmlObject);
        
        return sbTR.ToString();
    }

    public static T CloneObject<T>(T objClone) 
        where T:new()
    {
        string GetString = SerializeHelper.SeralizeObjectToXML<T>(objClone);
        return SerializeHelper.DeserializeXML<T>(GetString);
    }
}

虽然一种方法是实现ICloneable接口（在这里描述，所以我不会反悔），但这里有一个很好的深度克隆对象复制器，我不久前在代码项目中找到了它，并将其合并到我们的代码中。如其他地方所述，它要求您的对象是可序列化的。

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// Reference Article http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
/// Provides a method for performing a deep copy of an object.
/// Binary Serialization is used to perform the copy.
/// </summary>
public static class ObjectCopier
{
    /// <summary>
    /// Perform a deep copy of the object via serialization.
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>A deep copy of the object.</returns>
    public static T Clone<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", nameof(source));
        }

        // Don't serialize a null object, simply return the default for that object
        if (ReferenceEquals(source, null)) return default;

        using var Stream stream = new MemoryStream();
        IFormatter formatter = new BinaryFormatter();
        formatter.Serialize(stream, source);
        stream.Seek(0, SeekOrigin.Begin);
        return (T)formatter.Deserialize(stream);
    }
}

其思想是它序列化对象，然后将其反序列化为新对象。好处是，当对象变得太复杂时，您不必担心克隆任何东西。

如果您希望使用C#3.0的新扩展方法，请将该方法更改为具有以下签名：

public static T Clone<T>(this T source)
{
   // ...
}

现在，方法调用简单地变成objectBeingCloned.Clone（）；。

EDIT（2015年1月10日）我想我会重新考虑这个问题，要说我最近开始使用（Newtonsoft）Json来做这个，它应该更轻，并避免[Serializable]标签的开销。（NB@atconway在评论中指出，私有成员不是使用JSON方法克隆的）

/// <summary>
/// Perform a deep Copy of the object, using Json as a serialization method. NOTE: Private members are not cloned using this method.
/// </summary>
/// <typeparam name="T">The type of object being copied.</typeparam>
/// <param name="source">The object instance to copy.</param>
/// <returns>The copied object.</returns>
public static T CloneJson<T>(this T source)
{            
    // Don't serialize a null object, simply return the default for that object
    if (ReferenceEquals(source, null)) return default;

    // initialize inner objects individually
    // for example in default constructor some list property initialized with some values,
    // but in 'source' these items are cleaned -
    // without ObjectCreationHandling.Replace default constructor values will be added to result
    var deserializeSettings = new JsonSerializerSettings {ObjectCreationHandling = ObjectCreationHandling.Replace};

    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source), deserializeSettings);
}

编辑：项目已停止

如果您想真正克隆到未知类型，可以查看fastclone。

这是基于表达式的克隆，其工作速度比二进制序列化快10倍，并保持完整的对象图完整性。

这意味着：如果多次引用层次结构中的同一对象，克隆也将引用一个实例。

不需要对正在克隆的对象进行接口、属性或任何其他修改。

当使用Marc Gravells protobuf net作为序列化程序时，接受的答案需要一些轻微的修改，因为要复制的对象不会被归因于[Serializable]，因此不可序列化，Clone方法将抛出异常。我修改了它以与protobuf net一起使用：

public static T Clone<T>(this T source)
{
    if(Attribute.GetCustomAttribute(typeof(T), typeof(ProtoBuf.ProtoContractAttribute))
           == null)
    {
        throw new ArgumentException("Type has no ProtoContract!", "source");
    }

    if(Object.ReferenceEquals(source, null))
    {
        return default(T);
    }

    IFormatter formatter = ProtoBuf.Serializer.CreateFormatter<T>();
    using (Stream stream = new MemoryStream())
    {
        formatter.Serialize(stream, source);
        stream.Seek(0, SeekOrigin.Begin);
        return (T)formatter.Deserialize(stream);
    }
}

这将检查[ProtoControl]属性的存在，并使用protobufs自己的格式化程序来序列化对象。

如果您已经在使用第三方应用程序（如ValueInjector或Automapper），可以执行以下操作：

MyObject oldObj; // The existing object to clone

MyObject newObj = new MyObject();
newObj.InjectFrom(oldObj); // Using ValueInjecter syntax

使用此方法，您不必在对象上实现ISerializable或ICloneable。这在MVC/MVVM模式中很常见，因此已经创建了这样的简单工具。

请参阅GitHub上的ValueInjecter深度克隆示例。