如何在 C# 中传递指向整数的指针

Question

I have a C API with the signature:

int GetBuffer(char* buffer, int* maxSize)

In C, I will call it this way:

char buffer[4096];
int maxSize = 4096;
GetBuffer(buffer, &maxSize);

maxSize is set to the buffer size, and set with the actual size filled.

I need to call it from C#. How do I do that under "safe mode"?

Answer 1

One option is simply to use C# pointer types - this requires unsafe block (or modifier on method/class), and compiling with /unsafe :

[DllImport(...)]
static extern int GetBuffer(byte* buffer, ref int maxSize);

Buffer can be allocated in several different ways. One would be to use a pinned heap array:

fixed (byte* buffer = new byte[4096])
{
    int maxSize = buffer.Length;
    GetBuffer(buffer, ref maxSize);
}

Another is to use stackalloc , though this is only feasible for small buffers:

byte* buffer = stackalloc byte[4096];
int maxSize = 4096;
GetBuffer(buffer, ref maxSize);

This particular approach is virtually identical to your C code in terms of performance and allocation patterns.

Another option altogether is to use marshaling for heap arrays, and avoid pointers entirely.

[DllImport(...)]
static extern int GetBuffer([Out] byte[] buffer, ref int maxSize);

byte[] buffer = new byte[4096];
int maxSize = buffer.Length;
GetBuffer(buffer, ref maxSize);

Answer 2

Having a handle to the pointer doesn't fit the "safe mode" model at all; if the resource isn't managed by the Framework, it is unsafe.

Answer 3

This should work without unsafe code.

extern int GetBuffer(IntPtr buffer, ref int bufSize);

// ...
byte[] buf = new byte[kBufSize];
GCHandle handle = GCHandle.Alloc(buf, GCHandleType.Pinned); // possibly expensive call 
IntPtr p = handle.AddrOfPinnedObject();
int size = buf.Length;
int ret = GetBuffer(p, ref size);
handle.Free();

Answer 4

You need to use what is called P\\Invoke , and generate a function declaration that to reference the C function in the Dll from C#.

However, you have to be very careful when passing buffers in/out of unmanaged code. The framework will take care of some things for you but you may need to ensure that memory that you pass into the unmanaged call doesn't get moved by the Garbage collector.

[DllImport("Kernel32.dll", SetLastError=true)]
static extern Int32 GetBuffer(byte[] buffer,ref Int32 maxSize);

And to use it:

byte[] myBuf = new myBuf[4096];
Int32 maxSize = myBuf.Length;

GetBuffer(myBuf, ref maxSize);

Answer 5

One easy and safe option is to create a simple class that wraps the value, or any value like the following code:

public class Value<T> where T: struct 
{ 
    public static implicit operator T(Value<T> val) 
    { 
        return val.Value; 
    }

    private T _value;
 
    public Value(T value) 
    { 
        _value = value; 
    } 

    public Value() : this(default)
    { 
    }
 
    public T Value 
    { 
        get 
        { 
            return _value; 
        } 
        set 
        { 
            _value = value; 
        } 
    } 
 
    public override string ToString() 
    { 
        return _value.ToString(); 
    }
} 

Passing on instances of this class instead of the value itself works almost like working with pointers.