因为我的目标是超越 List<T> 我正在测试数组，发现很少有开始测试的起点在尝试从屏幕上捕获位图之前，我已经测试了这个，经试验证明，使用效果良好。我的问题是什么数据类型可以使用这个Copy()代码，除了byte[]

说我想要一个数据存储单元利用非托管/不安全的优势

        public unsafe struct NusT
        {
            public unsafe int vi;
            public unsafe bool vb;
        }

而不是填充列表

i按如下方式初始化结构体:

NusT n; 
n.vi= 90;
n.vb=true

我在测试了以下内容之后测试了这个:

NusT n = new NusT(){vi=90, vb=true};

3)

NusT n = new NusT("90", true);

我认为最后两个都有相同的结果，但第一个非常快，因为我没有创建对象，所以

NusT n-> instructions- 1
n.vi=90 -> instructions- 1
n.vb=true -> instructions- 1 

现在我最小化了我能做到的，这是从一个类开始的:这比2 & &;因为它也使用属性

class bigAndSlow
{
     public int a { get; private set;}
     public bool b { get; private set;}
     public string  c { get; private set;}
     public bigAndSlow(int .. ,boo .. , string.. )
     {
        initialise ...
     }
}

所以现在当最终决定是

        public unsafe struct NusT
        {
            public unsafe int vi;
            public unsafe bool vb;
        }

我如何实现这个极快的数据单元在

上使用Copy()

NusT[] NustyArr;

    static unsafe void Copy(byte[] src, int srcIndex,
            byte[] dst, int dstIndex, int count)
        {
            if (src == null || srcIndex < 0 ||
                dst == null || dstIndex < 0 || count < 0)
            {
                throw new ArgumentException();
            }
            int srcLen = src.Length;
            int dstLen = dst.Length;
            if (srcLen - srcIndex < count ||
                dstLen - dstIndex < count)
            {
                throw new ArgumentException();
            }

            // The following fixed statement pins the location of
            // the src and dst objects in memory so that they will
            // not be moved by garbage collection.          
            fixed (byte* pSrc = src, pDst = dst)
            {
                byte* ps = pSrc;
                byte* pd = pDst;
                // Loop over the count in blocks of 4 bytes, copying an
                // integer (4 bytes) at a time:
                for (int n = 0; n < count / 4; n++)
                {
                    *((int*)pd) = *((int*)ps);
                    pd += 4;
                    ps += 4;
                }
                // Complete the copy by moving any bytes that weren't
                // moved in blocks of 4:
                for (int n = 0; n < count % 4; n++)
                {
                    *pd = *ps;
                    pd++;
                    ps++;
                }
            }
        }

        static void Main(string[] args)
        {
            byte[] a = new byte[100];
            byte[] b = new byte[100];
            for (int i = 0; i < 100; ++i)
                a[i] = (byte)i;
            Copy(a, 0, b, 0, 100);
            Console.WriteLine("The first 10 elements are:");
            for (int i = 0; i < 10; ++i)
                Console.Write(b[i] + " ");
            Console.WriteLine("'n");
        }

static unsafe void UnsafeCopy<T>(T[] src, int srcIndex, T[] dst, int dstIndex, int count) where T : struct
{
    if (src == null || srcIndex < 0 || dst == null || dstIndex < 0 || count < 0 || srcIndex + count > src.Length || dstIndex + count > dst.Length)
    {
        throw new ArgumentException();
    }
    int elem_size = Marshal.SizeOf(typeof(T));
    GCHandle gch1 = GCHandle.Alloc(src, GCHandleType.Pinned);
    GCHandle gch2 = GCHandle.Alloc(dst, GCHandleType.Pinned);
    byte* ps = (byte*)gch1.AddrOfPinnedObject().ToPointer() + srcIndex * elem_size;
    byte* pd = (byte*)gch2.AddrOfPinnedObject().ToPointer() + dstIndex * elem_size;
    int len = count * elem_size;
    try
    {
        // Loop over the count in blocks of 4 bytes, copying an
        // integer (4 bytes) at a time:
        for (int n = 0; n < len / 4; n++)
        {
            *((int*)pd) = *((int*)ps);
            pd += 4;
            ps += 4;
        }
        // Complete the copy by moving any bytes that weren't
        // moved in blocks of 4:
        for (int n = 0; n < len % 4; n++)
        {
            *pd = *ps;
            pd++;
            ps++;
        }
    }
    finally
    {
        gch1.Free();
        gch2.Free();
    }
}