Самый быстрый способ сделать неглубокое копирование в C#

Это сложная тема с множеством возможных решений и множеством плюсов и минусов для каждого. Существует замечательная статья здесь, в которой описываются несколько различных способов создания копии в С#. Обобщить:

1. Клонировать вручную
   Утомительно, но высокий уровень контроля.

2. Клонирование с помощью MemberwiseClone
   Создает только поверхностную копию, т. е. для полей ссылочного типа исходный объект и его клон ссылаются на один и тот же объект.

3. Клонирование с отражением
   Неглубокое копирование по умолчанию, его можно переписать для глубокого копирования. Преимущество: автоматизировано. Недостаток: отражение медленное.

4. Клонирование с сериализацией
   Простота, автоматизация. Откажитесь от некоторого контроля, и сериализация будет самой медленной из всех.

5. Клонировать с помощью IL, клонировать с помощью методов расширения
   Более продвинутые решения, не такие распространенные.

Хочу начать с нескольких цитат:

Фактически, MemberwiseClone обычно намного лучше других, особенно для сложного типа.

а также

Я запутался. MemberwiseClone() должен аннулировать производительность всего остального для мелкой копии. [...]

Теоретически наилучшей реализацией неглубокой копии является конструктор копирования C++: он знает размер во время компиляции, а затем выполняет клонирование всех полей по элементам. Следующим лучшим вариантом является использование memcpy или чего-то подобного, что в основном должно работать MemberwiseClone. Это означает, что теоретически он должен уничтожить все другие возможности с точки зрения производительности. Правильно?

... но, по-видимому, это не так быстро и не стирает все другие решения. Внизу я разместил решение, которое более чем в 2 раза быстрее. Итак: Неправильно.

Тестирование внутренних компонентов MemberwiseClone

Давайте начнем с небольшого теста, используя простой преобразовываемый тип, чтобы проверить основные предположения о производительности:

[StructLayout(LayoutKind.Sequential)]
public class ShallowCloneTest
{
    public int Foo;
    public long Bar;

    public ShallowCloneTest Clone()
    {
        return (ShallowCloneTest)base.MemberwiseClone();
    }
}

Тест разработан таким образом, что мы можем проверить производительность MemberwiseClone против сырого memcpy, что возможно, потому что это преобразуемый тип.

Чтобы протестировать самостоятельно, скомпилируйте с небезопасным кодом, отключите подавление JIT, скомпилируйте режим выпуска и протестируйте. Я также указал время после каждой соответствующей строки.

Реализация 1:

ShallowCloneTest t1 = new ShallowCloneTest() { Bar = 1, Foo = 2 };
Stopwatch sw = Stopwatch.StartNew();
int total = 0;
for (int i = 0; i < 10000000; ++i)
{
    var cloned = t1.Clone();                                    // 0.40s
    total += cloned.Foo;
}

Console.WriteLine("Took {0:0.00}s", sw.Elapsed.TotalSeconds);

По сути, я запускал эти тесты несколько раз, проверял вывод сборки, чтобы убедиться, что вещь не была оптимизирована, и т. д. Конечным результатом является то, что я приблизительно знаю, сколько секунд стоит эта одна строка кода, что составляет 0,40 с на мой компьютер. Это наш базовый уровень с использованием MemberwiseClone.

Реализация 2:

sw = Stopwatch.StartNew();

total = 0;
uint bytes = (uint)Marshal.SizeOf(t1.GetType());
GCHandle handle1 = GCHandle.Alloc(t1, GCHandleType.Pinned);
IntPtr ptr1 = handle1.AddrOfPinnedObject();

for (int i = 0; i < 10000000; ++i)
{
    ShallowCloneTest t2 = new ShallowCloneTest();               // 0.03s
    GCHandle handle2 = GCHandle.Alloc(t2, GCHandleType.Pinned); // 0.75s (+ 'Free' call)
    IntPtr ptr2 = handle2.AddrOfPinnedObject();                 // 0.06s
    memcpy(ptr2, ptr1, new UIntPtr(bytes));                     // 0.17s
    handle2.Free();

    total += t2.Foo;
}

handle1.Free();
Console.WriteLine("Took {0:0.00}s", sw.Elapsed.TotalSeconds);

Если вы внимательно посмотрите на эти цифры, вы заметите несколько вещей:

• Создание объекта и его копирование займет примерно 0,20 с. При нормальных обстоятельствах это самый быстрый код, который вы можете иметь.
• Однако для этого вам нужно закрепить и открепить объект. Это займет у вас 0,81 секунды.

Так почему же все это так медленно?

Мое объяснение состоит в том, что это связано с GC. По сути, реализации не могут полагаться на то, что память останется неизменной до и после полной сборки мусора (адрес памяти может быть изменен во время сборки мусора, что может произойти в любой момент, в том числе во время вашей мелкой копии). Это означает, что у вас есть только 2 возможных варианта:

1. Закрепление данных и копирование. Обратите внимание, что GCHandle.Alloc — это только один из способов сделать это, хорошо известно, что такие вещи, как C++/CLI, дадут вам лучшую производительность.
2. Перечисление полей. Это гарантирует, что между сборками мусора вам не нужно будет делать ничего особенного, а во время сборов мусора вы сможете использовать возможности сборщика мусора для изменения адресов в стеке перемещаемых объектов.

MemberwiseClone будет использовать метод 1, что означает снижение производительности из-за процедуры закрепления.

(Намного) более быстрая реализация

Во всех случаях наш неуправляемый код не может делать предположения о размере типов и должен закреплять данные. Предположения о размере позволяют компилятору лучше выполнять оптимизацию, например развертывание цикла, выделение регистров и т. д. (точно так же, как ctor копирования C++ работает быстрее, чем memcpy). Отсутствие необходимости закреплять данные означает, что мы не получаем дополнительного удара по производительности. Поскольку .NET JIT относится к ассемблеру, теоретически это означает, что мы должны иметь возможность сделать более быструю реализацию, используя простую передачу IL и позволив компилятору оптимизировать ее.

Итак, подведем итог, почему это может быть быстрее, чем нативная реализация?

1. Он не требует закрепления объекта; объекты, которые перемещаются, обрабатываются сборщиком мусора — и на самом деле он безжалостно оптимизируется.
2. Он может делать предположения о размере копируемой структуры и, следовательно, позволяет лучше распределять регистры, развертывать циклы и т. д.

Мы стремимся к производительности memcpy или лучше: 0,17 с.

Для этого мы в основном не можем использовать больше, чем просто call, создать объект и выполнить набор copy инструкций. Это немного похоже на реализацию Cloner выше, но есть несколько важных отличий (наиболее существенные: нет Dictionary и нет избыточных вызовов CreateDelegate). Вот оно:

public static class Cloner<T>
{
    private static Func<T, T> cloner = CreateCloner();

    private static Func<T, T> CreateCloner()
    {
        var cloneMethod = new DynamicMethod("CloneImplementation", typeof(T), new Type[] { typeof(T) }, true);
        var defaultCtor = typeof(T).GetConstructor(new Type[] { });

        var generator = cloneMethod .GetILGenerator();

        var loc1 = generator.DeclareLocal(typeof(T));

        generator.Emit(OpCodes.Newobj, defaultCtor);
        generator.Emit(OpCodes.Stloc, loc1);

        foreach (var field in typeof(T).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
        {
            generator.Emit(OpCodes.Ldloc, loc1);
            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(OpCodes.Ldfld, field);
            generator.Emit(OpCodes.Stfld, field);
        }

        generator.Emit(OpCodes.Ldloc, loc1);
        generator.Emit(OpCodes.Ret);

        return ((Func<T, T>)cloneMethod.CreateDelegate(typeof(Func<T, T>)));
    }

    public static T Clone(T myObject)
    {
        return cloner(myObject);
    }
}

Я протестировал этот код с результатом: 0,16 с. Это означает, что он примерно в 2,5 раза быстрее, чем MemberwiseClone.

Что еще более важно, эта скорость соответствует memcpy, что является более или менее «оптимальным решением при нормальных обстоятельствах».

Лично я считаю, что это самое быстрое решение, и самое приятное то, что если среда выполнения .NET ускорится (надлежащая поддержка инструкций SSE и т. д.), то и это решение ускорится.

Примечание редакции. В приведенном выше примере кода предполагается, что конструктор по умолчанию является общедоступным. Если это не так, вызов GetConstructor возвращает null. В этом случае используйте одну из других подписей GetConstructor для получения защищенных или закрытых конструкторов. См. https://docs.microsoft.com/en-us/dotnet/api/system.type.getconstructor?view=netframework-4.8

Я запутался. MemberwiseClone() должен аннулировать производительность всего остального для мелкой копии. В CLI любой тип, кроме RCW, должен иметь возможность поверхностного копирования в следующей последовательности:

• Выделить память в питомнике под тип.
• memcpy данные из оригинала в новые. Поскольку цель находится в питомнике, барьеры записи не требуются.
• If the object has a user-defined finalizer, add it to the GC list of items pending finalization.
  • If the source object has SuppressFinalize called on it and such a flag is stored in the object header, unset it in the clone.

Может ли кто-нибудь из группы внутренней разработки CLR объяснить, почему это не так?

Зачем все усложнять? MemberwiseClone будет достаточно.

public class ClassA : ICloneable
{
   public object Clone()
   {
      return this.MemberwiseClone();
   }
}

// let's say you want to copy the value (not reference) of the member of that class.
public class Main()
{
    ClassA myClassB = new ClassA();
    ClassA myClassC = new ClassA();
    myClassB = (ClassA) myClassC.Clone();
}

Это способ сделать это с помощью динамической генерации IL. Я нашел это где-то в Интернете:

public static class Cloner
{
    static Dictionary<Type, Delegate> _cachedIL = new Dictionary<Type, Delegate>();

    public static T Clone<T>(T myObject)
    {
        Delegate myExec = null;

        if (!_cachedIL.TryGetValue(typeof(T), out myExec))
        {
            var dymMethod = new DynamicMethod("DoClone", typeof(T), new Type[] { typeof(T) }, true);
            var cInfo = myObject.GetType().GetConstructor(new Type[] { });

            var generator = dymMethod.GetILGenerator();

            var lbf = generator.DeclareLocal(typeof(T));

            generator.Emit(OpCodes.Newobj, cInfo);
            generator.Emit(OpCodes.Stloc_0);

            foreach (var field in myObject.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                // Load the new object on the eval stack... (currently 1 item on eval stack)
                generator.Emit(OpCodes.Ldloc_0);
                // Load initial object (parameter)          (currently 2 items on eval stack)
                generator.Emit(OpCodes.Ldarg_0);
                // Replace value by field value             (still currently 2 items on eval stack)
                generator.Emit(OpCodes.Ldfld, field);
                // Store the value of the top on the eval stack into the object underneath that value on the value stack.
                //  (0 items on eval stack)
                generator.Emit(OpCodes.Stfld, field);
            }

            // Load new constructed obj on eval stack -> 1 item on stack
            generator.Emit(OpCodes.Ldloc_0);
            // Return constructed object.   --> 0 items on stack
            generator.Emit(OpCodes.Ret);

            myExec = dymMethod.CreateDelegate(typeof(Func<T, T>));

            _cachedIL.Add(typeof(T), myExec);
        }

        return ((Func<T, T>)myExec)(myObject);
    }
}

Фактически, MemberwiseClone обычно намного лучше других, особенно для сложного типа.

Причина в том, что: если вы вручную создаете копию, она должна вызывать один из конструкторов типа, но использовать клонирование по элементам, я думаю, это просто копирует блок памяти. для этих типов есть очень дорогие действия построения, клонирование по члену - абсолютно лучший способ.

Однажды я написал такой тип: {string A = Guid.NewGuid().ToString()}, я обнаружил, что клонирование по элементам намного быстрее, чем создание нового экземпляра и ручное назначение членов.

Результат кода ниже:

Копирование вручную: 00:00:00.0017099

MemberwiseClone:00:00:00.0009911

namespace MoeCard.TestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program() { AAA = Guid.NewGuid().ToString(), BBB = 123 };
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < 10000; i++)
            {
                p.Copy1();
            }
            sw.Stop();
            Console.WriteLine("Manual Copy:" + sw.Elapsed);

            sw.Restart();
            for (int i = 0; i < 10000; i++)
            {
                p.Copy2();
            }
            sw.Stop();
            Console.WriteLine("MemberwiseClone:" + sw.Elapsed);
            Console.ReadLine();
        }

        public string AAA;

        public int BBB;

        public Class1 CCC = new Class1();

        public Program Copy1()
        {
            return new Program() { AAA = AAA, BBB = BBB, CCC = CCC };
        }
        public Program Copy2()
        {
            return this.MemberwiseClone() as Program;
        }

        public class Class1
        {
            public DateTime Date = DateTime.Now;
        }
    }

}

наконец, я предоставляю свой код здесь:

    #region 数据克隆
    /// <summary>
    /// 依据不同类型所存储的克隆句柄集合
    /// </summary>
    private static readonly Dictionary<Type, Func<object, object>> CloneHandlers = new Dictionary<Type, Func<object, object>>();

    /// <summary>
    /// 根据指定的实例,克隆一份新的实例
    /// </summary>
    /// <param name="source">待克隆的实例</param>
    /// <returns>被克隆的新的实例</returns>
    public static object CloneInstance(object source)
    {
        if (source == null)
        {
            return null;
        }
        Func<object, object> handler = TryGetOrAdd(CloneHandlers, source.GetType(), CreateCloneHandler);
        return handler(source);
    }

    /// <summary>
    /// 根据指定的类型,创建对应的克隆句柄
    /// </summary>
    /// <param name="type">数据类型</param>
    /// <returns>数据克隆句柄</returns>
    private static Func<object, object> CreateCloneHandler(Type type)
    {
        return Delegate.CreateDelegate(typeof(Func<object, object>), new Func<object, object>(CloneAs<object>).Method.GetGenericMethodDefinition().MakeGenericMethod(type)) as Func<object, object>;
    }

    /// <summary>
    /// 克隆一个类
    /// </summary>
    /// <typeparam name="TValue"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    private static object CloneAs<TValue>(object value)
    {
        return Copier<TValue>.Clone((TValue)value);
    }
    /// <summary>
    /// 生成一份指定数据的克隆体
    /// </summary>
    /// <typeparam name="TValue">数据的类型</typeparam>
    /// <param name="value">需要克隆的值</param>
    /// <returns>克隆后的数据</returns>
    public static TValue Clone<TValue>(TValue value)
    {
        if (value == null)
        {
            return value;
        }
        return Copier<TValue>.Clone(value);
    }

    /// <summary>
    /// 辅助类,完成数据克隆
    /// </summary>
    /// <typeparam name="TValue">数据类型</typeparam>
    private static class Copier<TValue>
    {
        /// <summary>
        /// 用于克隆的句柄
        /// </summary>
        internal static readonly Func<TValue, TValue> Clone;

        /// <summary>
        /// 初始化
        /// </summary>
        static Copier()
        {
            MethodFactory<Func<TValue, TValue>> method = MethodFactory.Create<Func<TValue, TValue>>();
            Type type = typeof(TValue);
            if (type == typeof(object))
            {
                method.LoadArg(0).Return();
                return;
            }
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Object:
                    if (type.IsClass)
                    {
                        method.LoadArg(0).Call(Reflector.GetMethod(typeof(object), "MemberwiseClone")).Cast(typeof(object), typeof(TValue)).Return();
                    }
                    else
                    {
                        method.LoadArg(0).Return();
                    }
                    break;
                default:
                    method.LoadArg(0).Return();
                    break;
            }
            Clone = method.Delegation;
        }

    }
    #endregion

MemberwiseClone требует меньше обслуживания. Я не знаю, помогают ли значения свойств по умолчанию, может быть, если бы можно было игнорировать элементы со значениями по умолчанию.

Вот небольшой вспомогательный класс, который использует отражение для доступа к MemberwiseClone, а затем кэширует делегат, чтобы избежать использования отражения больше, чем необходимо.

public static class CloneUtil<T>
{
    private static readonly Func<T, object> clone;

    static CloneUtil()
    {
        var cloneMethod = typeof(T).GetMethod("MemberwiseClone", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
        clone = (Func<T, object>)cloneMethod.CreateDelegate(typeof(Func<T, object>));
    }

    public static T ShallowClone(T obj) => (T)clone(obj);
}

public static class CloneUtil
{
    public static T ShallowClone<T>(this T obj) => CloneUtil<T>.ShallowClone(obj);
}

Вы можете назвать это так:

Person b = a.ShallowClone();