public const int width = 2056;
    public const int height = 2048;
    public const int depth = 2;
    public system.intPtr rawbits;

public ushort[] bits()
{
    ushort[] output = new ushort[width * height];
    short[] temp = new short[width * height];
    Marshal.copy(rawbits,temp,width * height);
    System.Buffer.Blockcopy(temp,output,width * height * depth);
    return output;
}

以下问题中给出的建议没有帮助. (编译错误).

C# Marshal.Copy Intptr to 16 bit managed unsigned integer array

[顺便说一句,短阵列中确实有无符号的16位数据. Marshal.copy()不尊重标志,这就是我想要的.但我宁愿不只是假装短[]是一个ushort []]

[DllImport("kernel32.dll",SetLastError = false)]
static extern void copyMemory(IntPtr destination,IntPtr source,UIntPtr length);

public static void copy<T>(IntPtr source,T[] destination,int startIndex,int length)
    where T : struct
{
    var gch = GCHandle.Alloc(destination,GCHandleType.Pinned);
    try
    {
        var targetPtr = Marshal.UnsafeAddrOfPinnedArrayElement(destination,startIndex);
        var bytesTocopy = Marshal.SizeOf(typeof(T)) * length;

        copyMemory(targetPtr,source,(UIntPtr)bytesTocopy);
    }
    finally
    {
        gch.Free();
    }
}

不便携,但性能不错.

选项2 – 不安全和指针：

public static void copy(IntPtr source,ushort[] destination,int length)
{
    unsafe
    {
        var sourcePtr = (ushort*)source;
        for(int i = startIndex; i < startIndex + length; ++i)
        {
            destination[i] = *sourcePtr++;
        }
    }
}

需要在项目构建属性中启用不安全选项.

选项3 – 反思(只是为了好玩,不要在生产中使用)：

Marshal类在内部对所有copy(IntPtr,< array>,int,int)重载使用copyToManaged(IntPtr,object,int)方法(至少在.NET 4.5中).使用反射我们可以直接调用该方法：

private static readonly Action<IntPtr,int> _copyToManaged =
    GetcopyToManagedMethod();

private static Action<IntPtr,int> GetcopyToManagedMethod()
{
    var method = typeof(Marshal).getmethod("copyToManaged",System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
    return (Action<IntPtr,int>)method.CreateDelegate(
        typeof(Action<IntPtr,int>),null);
}

public static void copy<T>(IntPtr source,int length)
    where T : struct
{
    _copyToManaged(source,destination,startIndex,length);
}

由于Marshal类的内部结构可以更改,因此该方法不可靠且不应使用,尽管此实现可能最接近其他Marshal.copy()方法重载.

unsighed short s_int = 2;

我想将这个数字复制到char数组到char数组的第一个和第二个位置.

假设我们有char缓冲区[10];我们希望将s_int的两个字节复制到缓冲区[0]和缓冲区[1].

我该怎么做？

b[0] = si & 0xff;
b[1] = (si >> 8) & 0xff;

虽然这应该完成在unsigned char中,而不是普通的char,因为它们在大多数系统上都已签名.

存储较大的整数可以以类似的方式或循环来完成.

MyClass<T>
{
  public T Value = default(T);

  public MyClass(byte[] bytes)
  {
    // how to copy `bytes` into `Value`?
  }
}

我宁愿不使用拳击.有没有办法使用编组,反射或非托管/不安全代码？

我确实找到了this other post,但唯一建议的答案是行不通的,因为它使用拳击.

class MyClass<T> where T : struct
{
    public T Value = default(T);

    public MyClass(byte[] bytes)
    {
        Value = MemoryMarshal.Cast<byte,T>(bytes)[0];
    }
}

您还可以在最近的C#版本中使用unsafe(对于T：非托管约束)：

class MyClass<T> where T : unmanaged
{
    public T Value = default(T);

    public unsafe MyClass(byte[] bytes)
    {
        fixed (byte* ptr = bytes)
        {
            Value = *(T*)ptr; // note: no out-of-range check here; dangerous
        }
    }
}

你也可以使用Unsafe.*方法(System.Runtime.CompilerServices.Unsafe)做一些事情.例如(注意没有约束)：

class MyClass<T>
{
    public T Value = default(T);

    public unsafe MyClass(byte[] bytes)
    {
        T local = default(T);
        fixed (byte* ptr = bytes)
        {
            Unsafe.copy(ref local,ptr); // note: no out-of-range check here; dangerous
        }
        Value = local;
    }
}

如果要检查超出范围的问题：

if (bytes.Length < Unsafe.SizeOf<T>())
    throw new InvalidOperationException("Not enough data,fool!");

或者如果你有T：unmanaged约束,你可以使用sizeof(T).您不需要使用Span< T>解决方案(第一个),因为原始的Cast< byte,T>在这种情况下,将产生一个长度为零的跨度,[0]将适当地抛出.

我认为这也应该有效！

public unsafe MyClass(byte[] bytes)
{
    Value = Unsafe.As<byte,T>(ref bytes[0]); // note: no out-of-range check here; dangerous
}

完整示例(适用于net462)：

using System;
using System.Runtime.CompilerServices;


struct Foo
{
    public int x,y;
}
class MyClass<T>
{
    public T Value = default(T);

    public unsafe MyClass(byte[] bytes)
    {
        if (bytes.Length < Unsafe.SizeOf<T>())
            throw new InvalidOperationException("not enough data");
        Value = Unsafe.As<byte,T>(ref bytes[0]);
    }
}
static class P
{
    static void Main() {
        byte[] bytes = new byte[] { 1,2,3,4,5,6,7,8 };
        var obj = new MyClass<Foo>(bytes);
        var val = obj.Value;
        Console.WriteLine(val.x); // 67305985 = 0x04030201
        Console.WriteLine(val.y); // 134678021 = 0x08070605 
    }
}