MemberwiseClone 等效于现有对象？

Question

这里有很多关于 MemberwiseClone 的问题，但我找不到确切的内容。

据我了解，MemberwiseClone 基本上只是复制一个对象的内存区域，将其转储到其他地方，然后将其称为该对象的新实例。显然非常快，对于大型对象，这是制作副本的最快方法。对于具有简单构造函数的小对象，创建实例并复制各个属性会更快。

现在，我有一个使用 MemberwiseClone 的紧密循环。由于 MemberwiseClone 总是创建一个新实例，这会导致大量内存分配和重新分配，这对性能不利。我为一个非常大的对象编写了一个自定义副本，它将所有属性单独复制到现有对象上，总体上比使用 MemberwiseClone 快一点，

我觉得如果我可以抓取整个内存块并将其转储到现有对象上，我将获得不错的性能提升，因为 GC 不必担心任何事情。希望我也能摆脱这条消息：

澄清一下，我想尽快将属性从一个现有对象复制到另一个对象。我只需要一个浅拷贝。

消息 2 DA0023：（平均）% GC 时间 = 19.30； % Time in GC 相对较高。这种垃圾收集开销过多的迹象可能会影响 您的应用程序的响应能力。您可以收集 .NET 内存 分配数据和对象生命周期信息以了解 您的应用程序使用更好的内存分配模式。

我对代码安全没有限制，这里的游戏目标是速度。

没有 cmets 询问这是否真的有必要或谈论过早的优化。

感谢您的帮助。

回答

采取下面的建议，在对象中嵌入一个结构并将所有属性存储在其中。然后我可以获取该结构的副本以在单个分配中复制所有属性。与逐个字段复制相比，这使速度提高了 50% 以上，与每次使用 MemberwiseClone 创建新对象相比，速度提高了约 60%。

Answer 1

如果您的类不可继承，您可以将类的整个状态存储在公开字段结构中（公开字段，而不是属性！）。这将要求您在所有字段名称前加上结构名称，这在源代码中会很丑陋，但访问该结构中的字段将与访问直接放置在封闭类中的字段一样快。但是，这样做将使您能够使用简单的赋值语句将结构从一个对象实例复制到另一个对象实例中。

Answer 2

一般来说，你不能比逐个字段地复制更快。

一般来说。有一个例外：如果您的类是 blittable （因此不包含对非 blittable 类的任何引用）并且它是用 [StructLayout(LayoutKind.Sequential)] （或 [StructLayout(LayoutKind.Explicit)] 声明的，但测试起来更复杂）那么你可以别针了

GCHandle handle = GCHandle.Alloc(refToYourClass, GCHandleType.Pinned);

从那里打开一个新世界......您可以直接逐字节复制您的课程内容，其中包含一些不安全的内容（作为unsafe 键盘和 unsafe 作为“正在运行- with-scissors") 代码。

但要使其正常工作，您的课程必须是 blittable！

最快的方法是UnsafeCopy8，它复制 8 字节的块（32 位和 64 位）。最快的 PInvoke 方法是memcpy。

[StructLayout(LayoutKind.Sequential)]
class MyClass
{
    public int A { get; set; }
    public int B { get; set; }
    public int C { get; set; }
    public int D { get; set; }
    public int E { get; set; }
    public int F { get; set; }
    public int G { get; set; }
    public byte H { get; set; }
}

class Program
{
    [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl, SetLastError = false)]
    static extern IntPtr memcpy(IntPtr dest, IntPtr src, UIntPtr count);

    [DllImport("kernel32.dll", SetLastError = false)]
    static extern void CopyMemory(IntPtr dest, IntPtr src, UIntPtr count);

    static void Main()
    {
        MyClass mc = new MyClass { A = 1, B = 2, C = 3, D = 4, E = 5, F = 6, G = 7, H = 8 };
        MyClass mc2 = new MyClass();

        int size = Marshal.SizeOf(typeof(MyClass));

        var gc = GCHandle.Alloc(mc, GCHandleType.Pinned);
        var gc2 = GCHandle.Alloc(mc2, GCHandleType.Pinned);

        IntPtr dest = gc2.AddrOfPinnedObject();
        IntPtr src = gc.AddrOfPinnedObject();

        // Pre-caching
        memcpy(dest, src, (UIntPtr)size);
        CopyMemory(dest, src, (UIntPtr)size);
        UnsafeCopy(dest, src, size);
        UnsafeCopy8(dest, src, size);

        int cycles = 10000000;

        Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;

        var sw1 = Stopwatch.StartNew();

        for (int i = 0; i < cycles; i++)
        {
            memcpy(dest, src, (UIntPtr)size);
        }

        sw1.Stop();

        var sw2 = Stopwatch.StartNew();

        for (int i = 0; i < cycles; i++)
        {
            CopyMemory(dest, src, (UIntPtr)size);
        }

        sw2.Stop();

        var sw3 = Stopwatch.StartNew();

        for (int i = 0; i < cycles; i++)
        {
            UnsafeCopy(dest, src, size);
        }

        sw3.Stop();

        var sw4 = Stopwatch.StartNew();

        for (int i = 0; i < cycles; i++)
        {
            UnsafeCopy8(dest, src, size);
        }

        sw4.Stop();

        gc.Free();
        gc2.Free();

        Console.WriteLine("IntPtr.Size: {0}", IntPtr.Size);
        Console.WriteLine("memcpy:      {0}", sw1.ElapsedTicks);
        Console.WriteLine("CopyMemory:  {0}", sw2.ElapsedTicks);
        Console.WriteLine("UnsafeCopy:  {0}", sw3.ElapsedTicks);
        Console.WriteLine("UnsafeCopy8: {0}", sw4.ElapsedTicks);
        Console.ReadKey();
    }

    static unsafe void UnsafeCopy(IntPtr dest, IntPtr src, int size)
    {
        while (size >= sizeof(int))
        {
            *((int*)dest) = *((int*)src);

            dest = (IntPtr)(((byte*)dest) + sizeof(int));
            src = (IntPtr)(((byte*)src) + sizeof(int));
            size -= sizeof(int);
        }

        if (size >= sizeof(short))
        {
            *((short*)dest) = *((short*)src);

            dest = (IntPtr)(((byte*)dest) + sizeof(short));
            src = (IntPtr)(((byte*)src) + sizeof(short));
            size -= sizeof(short);
        }

        if (size == sizeof(byte))
        {
            *((byte*)dest) = *((byte*)src);
        }
    }

    static unsafe void UnsafeCopy8(IntPtr dest, IntPtr src, int size)
    {
        while (size >= sizeof(long))
        {
            *((long*)dest) = *((long*)src);

            dest = (IntPtr)(((byte*)dest) + sizeof(long));
            src = (IntPtr)(((byte*)src) + sizeof(long));
            size -= sizeof(long);
        }

        if (size >= sizeof(int))
        {
            *((int*)dest) = *((int*)src);

            dest = (IntPtr)(((byte*)dest) + sizeof(int));
            src = (IntPtr)(((byte*)src) + sizeof(int));
            size -= sizeof(int);
        }

        if (size >= sizeof(short))
        {
            *((short*)dest) = *((short*)src);

            dest = (IntPtr)(((byte*)dest) + sizeof(short));
            src = (IntPtr)(((byte*)src) + sizeof(short));
            size -= sizeof(short);
        }

        if (size == sizeof(byte))
        {
            *((byte*)dest) = *((byte*)src);
        }
    }
}