Question

这可能是一个非常开始的问题，但我一直在阅读这个问题，而且我发现它很难理解。

这是msdn页面中有关此主题的示例（稍微小一些）。

using System;

class SetByteDemo
{
    // Display the array contents in hexadecimal.
    public static void DisplayArray(Array arr, string name)
    {
        // Get the array element width; format the formatting string.
        int elemWidth = Buffer.ByteLength(arr) / arr.Length;
        string format = String.Format(" {{0:X{0}}}", 2 * elemWidth);

        // Display the array elements from right to left.
        Console.Write("{0,7}:", name);
        for (int loopX = arr.Length - 1; loopX >= 0; loopX--)
            Console.Write(format, arr.GetValue(loopX));
        Console.WriteLine();
    }

    public static void Main()
    {
        // These are the arrays to be modified with SetByte.
        short[] shorts = new short[2];

        Console.WriteLine("Initial values of arrays:\n");

        // Display the initial values of the arrays.
        DisplayArray(shorts, "shorts");

        // Copy two regions of source array to destination array,
        // and two overlapped copies from source to source.
        Console.WriteLine("\n" +
            "  Array values after setting byte 1 = 1 and byte 3 = 200\n");
        Buffer.SetByte(shorts, 1, 1);
        Buffer.SetByte(shorts, 3, 10);

        // Display the arrays again.
        DisplayArray(shorts, "shorts");
        Console.ReadKey();
    }
}

SetByte应该很容易理解，但是如果我在执行SetByte操作之前打印short数组，那么数组就像这样

{short[2]}
    [0]: 0
    [1]: 0

完成第一个Buffer.SetByte(shorts, 1, 1);后，数组变为

{short[2]}
    [0]: 256
    [1]: 0

设置Buffer.SetByte(shorts, 3, 10);后，数组变为

{short[2]}
    [0]: 256
    [1]: 2560

最后，在示例中，他们从右到左打印数组：

0A00 0100

我不明白这是如何运作的，有人能告诉我一些有关此事的信息吗？

Answer 1

Buffer类允许你像在c中使用void指针那样操作内存，它就像memcpy，memset等的总和，以快速的方式操作.net上的内存。

当你传递“shorts”数组时，Buffer类“看到”它作为指向四个连续字节的指针（两个短路，每个短路两个字节）：

  |[0][1]|[2][3]|
   short  short

所以未初始化的数组看起来像这样：

 |[0][0]|[0][0]|
  short  short

执行Buffer.SetByte(shorts, 1, 1);时，指示Buffer类更改字节数组上的第二个字节，因此它将是：

|[0][1]|[0][0]|
 short  short

如果将两个字节（0x00,0x01）转换为short，则为0x0100（注意，这些是一个接一个的两个字节，但顺序相反，那是因为C＃编译器使用的是小字节序），或者256 < / p>

第二行基本上执行相同的Buffer.SetByte(shorts, 3, 10);将第三个字节更改为10：

|[0][1]|[0][10]|
 short  short

然后0x00,0x0A作为短路是0x0A00或2560。

Answer 2

.NET类型使用little endianness。这意味着.then()，short等的第一个字节（实际上是第0个）包含最低有效位。

设置数组后，它看起来像int：

byte[]

作为0, 1, 0, 10，它的解释如下：

short[]

Answer 3

我认为人们可能会遇到的部分是Buffer.SetByte()方法基本上是对数组进行迭代而不是使用数组indexer []的常规赋值，这将根据数组的宽度分离数组。包含类型（短/双/等）而不是字节...使用您的示例：短阵列通常被视为 arr = [xxxx, yyyy]（基数为16）但是SetByte方法“看到”它： arr = [xx, yy, zz, ww]

所以像Buffer.SetByte(arr, 1, 5)这样的调用会解决arry中的第二个字节，它仍然在第一个短字节内。在那里设置值，就是这样。结果应如下所示：

[05 00,00 00]十六进制或[1280,0]。

c＃缓冲说明

3 个答案: