public void GetArrayOrPointer()
{
var original = new int[] { 1, 2, 3 };
ArraySegment <int> array;
UnsafeMemory <int> slice;
slice = new UnsafeMemory <int>(original, 1, 2);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(2, array.Array[array.Offset + 0]);
Assert.Equal(3, array.Array[array.Offset + 1]);
slice = new UnsafeMemory <int>(original, 0, 3);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(1, array.Array[array.Offset + 0]);
Assert.Equal(2, array.Array[array.Offset + 1]);
Assert.Equal(3, array.Array[array.Offset + 2]);
slice = new UnsafeMemory <int>(original, 0, 0);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(0, array.Offset);
Assert.Equal(original, array.Array);
Assert.Equal(0, array.Count);
unsafe
{
fixed(int *pBytes = original)
{
slice = new UnsafeMemory <int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void *p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
unsafe
{
fixed(int *pBytes = original)
{
var roSlice = new ReadOnlySpan <int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void *p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
}
public unsafe void TryWrite(UnsafeMemory <byte> data)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
EnsureNotDisposed();
void *pointer;
if (!data.TryGetPointer(out pointer))
{
throw new InvalidOperationException("Pointer not available");
}
IntPtr ptrData = (IntPtr)pointer;
var length = data.Length;
if (IsUnix)
{
var buffer = new UVBuffer.Unix(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
else
{
var buffer = new UVBuffer.Windows(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
}
public unsafe void TryWrite(UnsafeMemory<byte> data)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
EnsureNotDisposed();
void* pointer;
if (!data.TryGetPointer(out pointer))
{
throw new InvalidOperationException("Pointer not available");
}
IntPtr ptrData = (IntPtr)pointer;
var length = data.Length;
if (IsUnix)
{
var buffer = new UVBuffer.Unix(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
else
{
var buffer = new UVBuffer.Windows(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
}
public void TryGetPointerReturnsFalseIfNotPinned()
{
var data = new byte[10];
var memory = new UnsafeMemory <byte>(data, 0, data.Length);
unsafe
{
void *pointer;
Assert.False(memory.TryGetPointer(out pointer));
}
}
public void TryGetPointerReturnsTrueIfPointerUsed()
{
unsafe
{
IntPtr raw = Marshal.AllocHGlobal(10);
var memory = new UnsafeMemory <byte>((void *)raw, 10);
void * pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(raw.ToPointer() == pointer);
Marshal.FreeHGlobal(raw);
}
}
public void TryGetPointerReturnsTrueIfArrayAndPrePinned()
{
unsafe
{
var data = new byte[10];
fixed(byte *ptr = data)
{
var memory = new UnsafeMemory <byte>(data, 0, data.Length, ptr);
void *pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(ptr == pointer);
}
}
}
public int Send(UnsafeMemory <byte> buffer)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
unsafe {
ArraySegment <byte> segment;
if (buffer.TryGetArray(out segment))
{
return(Send(segment));
}
else
{
void *pointer;
buffer.TryGetPointer(out pointer);
return(SendPinned(new IntPtr(pointer), buffer.Length));
}
}
}
public int Receive(UnsafeMemory<byte> buffer)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
unsafe
{
ArraySegment<byte> segment;
if (buffer.TryGetArray(out segment)) {
return Receive(segment);
}
else {
void* pointer;
buffer.TryGetPointer(out pointer);
return ReceivePinned(new IntPtr(pointer), buffer.Length);
}
}
}
public void TryGetPointerReturnsTrueIfArrayAndPrePinned()
{
unsafe
{
var data = new byte[10];
fixed (byte* ptr = data)
{
var memory = new UnsafeMemory<byte>(data, 0, data.Length, ptr);
void* pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(ptr == pointer);
}
}
}
public void TryGetPointerReturnsTrueIfPointerUsed()
{
unsafe
{
IntPtr raw = Marshal.AllocHGlobal(10);
var memory = new UnsafeMemory<byte>((void*)raw, 10);
void* pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(raw.ToPointer() == pointer);
Marshal.FreeHGlobal(raw);
}
}
public void TryGetPointerReturnsFalseIfNotPinned()
{
var data = new byte[10];
var memory = new UnsafeMemory<byte>(data, 0, data.Length);
unsafe
{
void* pointer;
Assert.False(memory.TryGetPointer(out pointer));
}
}
public void GetArrayOrPointer()
{
var original = new int[] { 1, 2, 3 };
ArraySegment<int> array;
UnsafeMemory<int> slice;
slice = new UnsafeMemory<int>(original, 1, 2);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(2, array.Array[array.Offset + 0]);
Assert.Equal(3, array.Array[array.Offset + 1]);
slice = new UnsafeMemory<int>(original, 0, 3);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(1, array.Array[array.Offset + 0]);
Assert.Equal(2, array.Array[array.Offset + 1]);
Assert.Equal(3, array.Array[array.Offset + 2]);
slice = new UnsafeMemory<int>(original, 0, 0);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(0, array.Offset);
Assert.Equal(original, array.Array);
Assert.Equal(0, array.Count);
unsafe
{
fixed (int* pBytes = original)
{
slice = new UnsafeMemory<int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void* p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
unsafe
{
fixed (int* pBytes = original)
{
var roSlice = new ReadOnlySpan<int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void* p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
}
