好的，这篇文章中有一些明显的反射示例，但反射通常很慢，直到你开始正确缓存它。

如果你能正确缓存它，那么它将以4.6s的速度深度克隆1000000个对象（由Watcher测量）。

static readonly Dictionary<Type, PropertyInfo[]> ProperyList = new Dictionary<Type, PropertyInfo[]>();

而不是获取缓存的财产或将新属性添加到字典并简单使用它们

foreach (var prop in propList)
{
        var value = prop.GetValue(source, null);   
        prop.SetValue(copyInstance, value, null);
}

在另一个答案中查看我的帖子中的完整代码

https://stackoverflow.com/a/34365709/4711853

另一个JSON.NET答案。此版本适用于不实现ISerializable的类。

public static class Cloner
{
    public static T Clone<T>(T source)
    {
        if (ReferenceEquals(source, null))
            return default(T);

        var settings = new JsonSerializerSettings { ContractResolver = new ContractResolver() };

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

    class ContractResolver : DefaultContractResolver
    {
        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            var props = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                .Select(p => base.CreateProperty(p, memberSerialization))
                .Union(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                    .Select(f => base.CreateProperty(f, memberSerialization)))
                .ToList();
            props.ForEach(p => { p.Writable = true; p.Readable = true; });
            return props;
        }
    }
}

要克隆类对象，可以使用object.MemberswiseColone方法，

只需将此函数添加到类中：

public class yourClass
{
    // ...
    // ...

    public yourClass DeepCopy()
    {
        yourClass othercopy = (yourClass)this.MemberwiseClone();
        return othercopy;
    }
}

然后要执行深度独立复制，只需调用DeepCopy方法：

yourClass newLine = oldLine.DeepCopy();

希望这有帮助。

遵循以下步骤：

使用返回T的只读Self属性和ICloneable＜out T＞定义ISelf＜T＞，ICloneale＜out T＜派生自ISelf＞并包含方法T Clone（）。然后定义一个CloneBase类型，该类型实现了一个受保护的虚拟泛型VirtualClone，将MemberwiseClone转换为传入的类型。每个派生类型都应该通过调用基本克隆方法来实现VirtualClone，然后执行所需的操作来正确克隆父VirtualClone方法尚未处理的派生类型的那些方面。

为了实现最大的继承通用性，公开公共克隆功能的类应该是密封的，但派生自一个基类，该基类在其他方面是相同的，除非缺少克隆。不要传递显式可克隆类型的变量，而是采用ICloneable＜theNonCloneableType＞类型的参数。这将允许期望Foo的可克隆衍生物与DerivedFoo的可克隆衍生物一起工作的例程，但也允许创建Foo的不可克隆衍生物。

虽然一种方法是实现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);
}

在一个方法中重铸怎么样基本上应该调用自动复制构造函数

T t = new T();
T t2 = (T)t;  //eh something like that

        List<myclass> cloneum;
        public void SomeFuncB(ref List<myclass> _mylist)
        {
            cloneum = new List<myclass>();
            cloneum = (List < myclass >) _mylist;
            cloneum.Add(new myclass(3));
            _mylist = new List<myclass>();
        }

似乎对我有用