C # 'da [] bayttan IntPtr nasıl alınır

byte[]Bir yönteme geçmek istiyorum IntPtrC # bir Parametre alır , bu mümkün mü ve nasıl?

Bir diziye bir IntPtr alma konusunda emin değilsiniz, ancak Mashal.Copy kullanarak verileri yönetilmeyen kodla kullanmak için kopyalayabilirsiniz:

IntPtr unmanagedPointer = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, unmanagedPointer, bytes.Length);
// Call unmanaged code
Marshal.FreeHGlobal(unmanagedPointer);

Alternatif olarak, bir özellik içeren bir yapı bildirebilir ve ardından Marshal.PtrToStructure kullanabilirsiniz, ancak bu yine de yönetilmeyen bellek ayırmayı gerektirir.

Düzenleme: Ayrıca, Tyalis'in belirttiği gibi, güvenli olmayan kod sizin için bir seçenekse, düzeltildi de kullanabilirsiniz.

Diğer yol,

GCHandle pinnedArray = GCHandle.Alloc(byteArray, GCHandleType.Pinned);
IntPtr pointer = pinnedArray.AddrOfPinnedObject();
// Do your stuff...
pinnedArray.Free();

Bu işe yaramalı ancak güvenli olmayan bir bağlamda kullanılmalıdır:

byte[] buffer = new byte[255];
fixed (byte* p = buffer)
{
    IntPtr ptr = (IntPtr)p;
    // do you stuff here
}

dikkat edin, sabit bloktaki işaretçiyi kullanmanız gerekir! Artık sabit blokta olmadığınızda gc nesneyi hareket ettirebilir.

Marshal.UnsafeAddrOfPinnedArrayElement(array, 0)Diziye bir bellek işaretçisi almak için kullanabilirsiniz .

İşte @ user65157'nin cevabında bir değişiklik (bunun için +1, BTW):

Sabitlenmiş nesne için IDisposable bir sarmalayıcı oluşturdum:

class AutoPinner : IDisposable
{
   GCHandle _pinnedArray;
   public AutoPinner(Object obj)
   {
      _pinnedArray = GCHandle.Alloc(obj, GCHandleType.Pinned);
   }
   public static implicit operator IntPtr(AutoPinner ap)
   {
      return ap._pinnedArray.AddrOfPinnedObject(); 
   }
   public void Dispose()
   {
      _pinnedArray.Free();
   }
}

sonra bunu şu şekilde kullanın:

using (AutoPinner ap = new AutoPinner(MyManagedObject))
{
   UnmanagedIntPtr = ap;  // Use the operator to retrieve the IntPtr
   //do your stuff
}

Bunu Free () aramayı unutmamanın güzel bir yolu olarak buldum :)

Marshal.Copy işe yarıyor ama oldukça yavaş. Daha hızlı, baytları bir for döngüsünde kopyalamaktır. Daha da hızlı olanı, bayt dizisini çok uzun bir diziye dönüştürmek, bayt dizisine sığabildiği kadar çok sayıda kopyalamak ve ardından kalan olası 7 baytı (8 bayt hizalı olmayan iz) kopyalamaktır. En hızlısı, yukarıda Tyalis'in cevabında önerildiği gibi bayt dizisini sabit bir ifadeye sabitlemektir.

IntPtr GetIntPtr(Byte[] byteBuf)
{
    IntPtr ptr = Marshal.AllocHGlobal(byteBuf.Length);
    for (int i = 0; i < byteBuf.Length; i++)
    {
       Marshal.WriteByte(ptr, i, byteBuf[i]);
    }
    return ptr;
}

Bazı durumlarda, IntPtr durumunda bir Int32 türü (veya Int64) kullanabilirsiniz. Yapabiliyorsanız, başka bir kullanışlı sınıf BitConverter'dır. İstediğiniz şey için örneğin BitConverter.ToInt32'yi kullanabilirsiniz.