unsafe C#: Wie kann ich ein int [] von einem Zeiger auf einen bereits vorhandenen Speicherort erstellen?

Question

Ich verwende Shared Memory für Interprozesskommunikation in einer unsicheren Klasse. Ein Teil des Speichers ist reserviert, um ein festes Array von int zu halten.

Grundsätzlich habe ich eine Methode, die den gemeinsamen Speicher einrichtet. Etwas wie folgt aus:

private int* sizePtr; 

private ???* arrayPtr; 

void SetupMemory(byte *pointerToSharedMem) 

{ 

    this.sizePtr = (int*)pointerToSharedMem; 
    pointerToSharedMem += sizeof(int); 

    this.arrayPtr = (???*)pointerToSharedMem; 
    pointerToSharedMem += sizeof(int) * FixedSizeOfArray; 
} 

Wie muss ich den Zeiger erklären, dass ich eine Eigenschaft verwenden können

public int[] MyArray 
{ 
    get 
    { 
     return some magic with this.arrayPtr; 
    } 
} 

ETA: Wenn möglich, möchte ich structs vermeiden, und ich möchte auf jeden Fall Vermeiden Sie es, Daten zu kopieren. Ich hoffte auf eine Art von Cast-Konstrukt, um einen Zeiger auf die Daten im Shared Memory zu verwenden, so dass die Daten sofort verwendet werden können (d. H. Ohne zu kopieren).

Answer 1

Muss es ein Zeiger sein, oder können Sie die Daten kopieren?

Wenn das in Ordnung ist, dann auf diesen Link überprüfen

http://msdn.microsoft.com/en-us/library/aa330463(v=vs.71).aspx

Answer 2

In C# 2.0 und höher, ein struct kann mit einem eingebetteten Array deklariert werden, in einem unsafe Kontext:

namespace FixedSizeBuffers 
{ 
    internal unsafe struct MyBuffer 
    { 
     public fixed int fixedBuffer[128]; 
    } 

    internal unsafe class MyClass 
    { 
     public MyBuffer myBuffer = default(MyBuffer); 
    } 

    internal class Program 
    { 
     static void Main() 
     { 
      MyClass myClass = new MyClass(); 

      unsafe 
      { 
       // Pin the buffer to a fixed location in memory. 
       fixed (int* intPtr = myClass.myBuffer.fixedBuffer) 
       { 
        *intPtr = someIntValue; 
       } 
      } 
     } 
    } 
} 

http://msdn.microsoft.com/en-us/library/zycewsya(v=vs.100).aspx

Answer 3

Ich kann mir nichts besseres vorstellen als memcpy.

[DllImport("msvcrt.dll", EntryPoint = "memcpy", CallingConvention = CallingConvention.Cdecl, SetLastError = false)] 
public static extern IntPtr memcpy(IntPtr dest, IntPtr src, UIntPtr count); 

private static unsafe int[] GetArray(int* ptr, uint length) 
{ 
    var ints = new int[length]; 

    fixed (int* pInts = ints) 
    { 
     memcpy(new IntPtr(pInts), new IntPtr(ptr), new UIntPtr(length)); 
    } 

    return ints; 
} 

Answer 4

Eigentlich kann ich an eine andere Antwort denken.

Dies kann sehr gut hässlich werden, wenn Sie es nicht richtig verwenden.

Vorsicht!

public unsafe class UnsafeArray 
{ 
    private readonly int* _start; 
    public readonly int Length; 

    public UnsafeArray(int* start, int enforceLength = 0) 
    { 
     this._start = start; 
     this.Length = enforceLength > 0 ? enforceLength : int.MaxValue; 
    } 

    public int this[int index] 
    { 
     get { return _start[index]; } 
     set 
     { 
      if (index >= this.Length) 
      { 
       throw new IndexOutOfRangeException(); 
      } 

      _start[index] = value; 
     } 
    } 
}