Existe-t-il un moyen portable de copier un bloc de mémoire en C#?

Question

Si vous voulez faire une copie de la mémoire entre les deux tableaux, il y a une fonction Array.Copy pour que .NET:

char[] GetCopy(char[] buf) 
{ 
    char[] result = new char[buf.Length]; 
    Array.Copy(buf, result); 
    return result; 
} 

Ceci est généralement plus rapide que manuellement-boucle pour copier tous les personnages buf à result, parce que c'est une opération de copie de bloc qui prend simplement un morceau de mémoire et l'écrit à la destination.

De même, si on me donnait à la place un char* et un int en précisant sa taille, quelles sont mes options? Voici ceux que j'ai pris en compte:

• Buffer.BlockCopy: nécessite src et dst être des tableaux
• Buffer.MemoryCopy: exactement ce que je cherche, mais seulement disponible sur. NET bureau
• Marshal.Copy: cessé d'être pris en charge dans la version 2.0
.NET

Ou, s'il n'y a pas alter natif, existe-t-il un moyen de construire un tableau à partir d'un pointeur char* et d'une longueur int? Si je pouvais le faire, je pourrais juste convertir les pointeurs en tableaux et les passer dans Array.Copy.

Je ne cherche pas de boucles car, comme je l'ai dit, elles ne sont pas très efficaces par rapport aux copies de blocs, mais si c'est la seule façon que je devrais faire. Je recherche essentiellement memcpy(), mais en C# et peut être utilisé dans les PCL.

Answer 1

Vous indiquez que Marshal.Copy ne serait plus supporté, mais sur la documentation de la classe Marshal je ne trouve aucune indication à ce sujet.

Bien au contraire, la classe est disponible pour les versions générales suivantes: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1

Une mise en oeuvre possible d'une fonction d'utilité à partir de cette méthode serait:

public static void CopyFromPtrToPtr(IntPtr src, uint srcLen, 
            IntPtr dst, uint dstLen) 
{ 
    var buffer = new byte[srcLen]; 
    Marshal.Copy(src, buffer, 0, buffer.Length); 
    Marshal.Copy(buffer, 0, dst, (int)Math.Min(buffer.Length, dstLen)); 
} 

Cependant, il est tout à fait possible que la copie des octets de IntPtr à byte[] et retour annule tout gain possible de performances par rapport épinglant la mémoire dangereuse et la copie dans une boucle.

En fonction de la portabilité du code, vous pouvez également utiliser P/Invoke pour utiliser réellement la méthode memcpy. Cela devrait fonctionner correctement sur Windows 2000 et versions ultérieures (tous les systèmes sur lesquels Microsoft Visual C Run-Time Library est installé). Edit: La deuxième approche ne serait pas adaptée aux bibliothèques de classes portables, la première serait cependant.

Answer 2

Je ne me souviens pas des API intégrées de la BCL, mais vous pouvez copier le code BCL memcpy et l'utiliser. Utilisez Reflector et recherchez "memcpy" pour le trouver.Le code dangereux est parfaitement défini et portable.