Appel de code non sécurisé à partir de managed (C#). Reading byte array

Question

J'ai cette méthode que j'ai besoin d'appeler et d'utiliser dans mon application, mais je ne sais pas vraiment comment le faire exactement.

C'est la fonction que j'ai besoin d'appeler.

[DllImport(dll_Path)] 
public static extern int DTS_GetDataToBuffer(int Position, int Length, char* Buffer, int* DataRead); 

Dans mon code, j'ai cette fonction et il me manque son implémentation.

internal static void GetDataToBuffer(int position, int length, out byte[] data, out int dataRead) 
    { 
     unsafe 
     { 
      // the code I need 
     } 
    } 

Je pense que la plupart de ceci est très auto-explicatif. J'ai besoin d'implémenter cette dernière fonction pour que je puisse lire les données dans le tampon et la quantité de données lues (ce qui devrait être le même que data.Length, mais le fabricant a ceci comme option séparée, donc j'en ai besoin). Quelqu'un peut-il aider? Est-ce assez clair?

Merci

Edit: Voici la déclaration non géré à partir du fichier .h. J'espère que cela aide.

extern NAG_DLL_EXPIMP int DTS_GetDataToBuffer(int Position, 
           int Length, 
           unsigned char *Buffer, 
           int *DataRead); 

Edit # 2: positons - la position à partir de laquelle étoile la lecture des données. Longueur - La quantité de données à lire (ce serait la taille de la mémoire tampon). DataRead - la taille réelle des données lues.

Answer 1

Je ne pense pas que vous avez vraiment besoin d'utiliser des pointeurs dangereux ici. fonction Declare comme

[DllImport(dll_Path)] 
public static extern int DTS_GetDataToBuffer(
    int  position, 
    int  length, 
    byte[] buffer, 
    ref int dataRead); 

emballage raisonnable C# pour cette fonction:

internal static byte[] GetDataToBuffer() 
{ 
    // set BufferSize to your most common data length 
    const int BufferSize = 1024 * 8; 
    // list of data blocks 
    var chunks = new List<byte[]>(); 
    int dataRead = 1; 
    int position = 0; 
    int totalBytes = 0; 
    while(true) 
    { 
     var chunk = new byte[BufferSize]; 
     // get new block of data 
     DTS_GetDataToBuffer(position, BufferSize, chunk, ref dataRead); 
     position += BufferSize; 
     if(dataRead != 0) 
     { 
      totalBytes += dataRead; 
      // append data block 
      chunks.Add(chunk); 
      if(dataRead < BufferSize) 
      { 
       break; 
      } 
     } 
     else 
     { 
      break; 
     } 
    } 
    switch(chunks.Count) 
    { 
     case 0: // no data blocks read - return empty array 
      return new byte[0]; 
     case 1: // single data block 
      if(totalBytes < BufferSize) 
      { 
       // truncate data block to actual data size 
       var data = new byte[totalBytes]; 
       Array.Copy(chunks[0], data, totalBytes); 
       return data; 
      } 
      else // single data block with size of Exactly BufferSize 
      { 
       return chunks[0]; 
      } 
     default: // multiple data blocks 
      { 
       // construct new array and copy all data blocks to it 
       var data = new byte[totalBytes]; 
       position = 0; 
       for(int i = 0; i < chunks.Count; ++i) 
       { 
        // copy data block 
        Array.Copy(chunks[i], 0, data, position, Math.Min(totalBytes, BufferSize)); 
        position += BufferSize; 
        // we need to handle last data block correctly, 
        // it might be shorted than BufferSize 
        totalBytes -= BufferSize; 
       } 
       return data; 
      } 
    } 
} 

Answer 2

Je ne peux pas tester cela, mais je pense que vous devriez laisser la conversion Marshaler-vous (s):

[DllImport(dll_Path)] 
public static extern int DTS_GetDataToBuffer(out byte[] data, out int dataRead); 

Answer 3

i vous d'accord ne pas besoin d'utiliser le bloc dangereux. vous utilisez PInvoke, j'espère liens ci-dessous pourraient être utiles: http://msdn.microsoft.com/en-us/magazine/cc164123.aspx http://www.pinvoke.net/

et il y a trop de post sur stackoverflow