.NET + Copier un grand nombre de tours de mémoire

Question

Autrefois, on utilisait des astuces (souvent pour masquer les framebuffers offscreen), pour copier de gros morceaux de mémoire d'un emplacement à un autre.

Maintenant que je travaille en C #, j'ai découvert la nécessité de déplacer un tableau d'octets (d'une taille d'environ 32 Ko) d'un emplacement de mémoire à un autre environ 60 fois par seconde.

D'une certaine manière, je ne pense pas qu'une copie octet par octet dans une boucle for soit optimale ici.

Est-ce que quelqu'un connaît un bon truc pour faire ce genre de travail tout en restant dans du code purement géré?

Si ce n'est pas le cas, je suis disposé à faire un peu de P / Invoking ou à passer en mode non sécurisé, mais j'aimerais rester géré si je le peux pour des raisons multi-plateformes.

EDIT: Un code de benchmarking que j'ai écrit juste pour le fun:

  

Octet par octet: 15.6192

     

4 octets par boucle: 15.6192

     

Bloquer la copie: 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

Je pense que vous pouvez compter sur Buffer.BlockCopy () pour faire le bon choix

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