.NET + Copiar grandes cantidades de memoria trucos

Question

En tiempos de antaño, hubo trucos utilizados (a menudo para la fusión fuera de la pantalla framebuffers), para copiar grandes fragmentos de la memoria de un lugar a otro.

Ahora que estoy trabajando en C#, he encontrado la necesidad de mover un array de bytes (aproximadamente 32 kb de tamaño) desde una ubicación de memoria a otro de aproximadamente 60 veces por segundo.

De alguna manera, no creo que un byte por byte copia en un bucle for es la óptima aquí.

¿Alguien sabe de un buen truco para hacer esto un poco de trabajo, mientras que todavía se mantiene en puramente código administrado?

Si no, estoy dispuesto a hacer algunos P/Invocar o entrar en modo no seguro, pero me gustaría quedarme administrado si puedo para la plataforma de la cruz razones.

EDITAR:Algunos de benchmarking código escribí sólo para la diversión:

Byte por Byte:15.6192

4 Bytes por bucle:15.6192

Bloque De Copia:0

Byte[] src = new byte[65535];
            Byte[] dest = new byte[65535];
            DateTime startTime, endTime;

            startTime = DateTime.Now;
            for (int k = 0; k < 60; k++)
            {
                for (int i = 0; i < src.Length; i++)
                {
                    dest[i] = src[i];
                }
            }
            endTime = DateTime.Now;

            Console.WriteLine("Byte by Byte: " + endTime.Subtract(startTime).TotalMilliseconds);

            startTime = DateTime.Now;
            for (int k = 0; k < 60; k++)
            {
                int i = 0;
                while (i < src.Length)
                {
                    if (i + 4 > src.Length)
                    {
                        // Copy the remaining bytes one at a time.
                        while(i < src.Length)
                        {
                            dest[i] = src[i];
                            i++;
                        }
                        break;
                    }

                    dest[i] = src[i];
                    dest[i + 1] = src[i + 1];
                    dest[i + 2] = src[i + 2];
                    dest[i + 3] = src[i + 3];

                    i += 4;                    
                }
            }
            endTime = DateTime.Now;

            Console.WriteLine("4 Bytes per loop: " + endTime.Subtract(startTime).TotalMilliseconds);

            startTime = DateTime.Now;
            for (int k = 0; k < 60; k++)
            {
                Buffer.BlockCopy(src, 0, dest,0, src.Length);
            }
            endTime = DateTime.Now;

            Console.WriteLine("Block Copy: " + endTime.Subtract(startTime).TotalMilliseconds);

Answer 1

Creo que se puede contar en el Búfer.BlockCopy() para hacer lo correcto

http://msdn.microsoft.com/en-us/library/system.buffer.blockcopy.aspx