.NET + Copia di grandi quantità di trucchi di memoria

Question

Ai vecchi tempi, c'erano dei trucchi usati (spesso per blitting framebuffer fuori schermo), per copiare grossi pezzi di memoria da una posizione all'altra.

Ora che sto lavorando in C #, ho trovato la necessità di spostare una matrice di byte (circa 32k di dimensione) da una posizione di memoria a un'altra circa 60 volte al secondo.

In qualche modo, non credo che una copia byte per byte in un ciclo for sia ottimale qui.

Qualcuno conosce un buon trucco per fare questo tipo di lavoro pur rimanendo in codice puramente gestito?

In caso contrario, sono disposto a fare un po 'di P / Invoking o andare in modalità non sicura, ma mi piacerebbe rimanere gestito se possibile per motivi multipiattaforma.

EDIT: Alcuni codici di benchmarking che ho scritto solo per divertimento:

  

Byte by Byte: 15.6192

     

4 byte per loop: 15.6192

     

Copia blocco: 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

Penso che puoi contare su Buffer.BlockCopy () per fare la cosa giusta

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