C# 如何在C中将List转换为Byte[]

从双[]src到字节[]dst的转换 可以通过固定指针在C中高效完成：

fixed( Double* pSrc = src)
{
  fixed( Byte* pDst = dst)
  {
    Byte* ps = (Byte*)pSrc;
    for (int i=0; i < dstLength; i++)
    {
      *(pDst + i) = *(ps +i);
    }
  }
}

如何对列表src执行相同的操作？ 即，如何获得指向数组Double[]的固定指针 列入名单？

---

谢谢。

我不知道你想要什么，但我想。。。你想要

---

System.Runtime.Interopservices.Marshal.StructToPtr.

不确定您的意图，但我认为。。。你想要

---

System.Runtime.Interopservices.Marshal.StructOptr.

使用List.ToArray方法并对结果数组进行操作。

使用List.ToArray方法并对结果数组进行操作。

始终可以对List对象使用ToArray方法来获得双精度[].

您可以始终在列表对象上使用ToArray方法来获取双[]。

您可以使用反射来获取对列表实例中私有T[]\u项字段的引用

---

警告：在代码段中，您需要确保dstLength是dst和src长度（以字节为单位）中的最小值，这样您就不会试图复制比可用字节更多的字节。可能是通过创建与src完全匹配所需大小的dst来实现的，但是您的代码片段没有明确说明这一点。

您可以使用反射来获取对列表实例中私有t[]\u items字段的引用

---

警告：在代码段中，您需要确保dstLength是dst和src长度（以字节为单位）中的最小值，这样您就不会试图复制比可用字节更多的字节。您可能是通过创建与src完全匹配所需大小的dst来实现的，但是您的代码片段没有明确说明这一点。

为什么不像往常一样访问列表呢

List<double> list = new List<double>();
list.Add(Math.PI);
list.Add(34.22);

byte[] res = new byte[list.Count * sizeof(double)];

unsafe
{
    fixed (byte* pres = res)
    {
        for (int i = 0; i < list.Count; i++)
        {
            *(((double*)pres) + i) = list[i];
        }
    }
}

我还没有对它进行彻底的测试，而且我很少需要不安全的代码，但它似乎工作得很好

编辑：这是另一个imo首选的解决方案，没有不安全的代码：

int offset = 0;
for (int i = 0; i < list.Count; i++)
{
    long num = BitConverter.DoubleToInt64Bits(list[i]);

    for (int j = 0; j < 8; j++)
    {
        res[offset++] = (byte)num;
        num >>= 8;
    }
}

---

你为什么不像往常一样访问列表呢

List<double> list = new List<double>();
list.Add(Math.PI);
list.Add(34.22);

byte[] res = new byte[list.Count * sizeof(double)];

unsafe
{
    fixed (byte* pres = res)
    {
        for (int i = 0; i < list.Count; i++)
        {
            *(((double*)pres) + i) = list[i];
        }
    }
}

我还没有对它进行彻底的测试，而且我很少需要不安全的代码，但它似乎工作得很好

编辑：这是另一个imo首选的解决方案，没有不安全的代码：

int offset = 0;
for (int i = 0; i < list.Count; i++)
{
    long num = BitConverter.DoubleToInt64Bits(list[i]);

    for (int j = 0; j < 8; j++)
    {
        res[offset++] = (byte)num;
        num >>= 8;
    }
}

---

这可能会起作用，但会丢失数据—数组的内容将是3和34

    List<double> list = new List<double>();
    list.Add(Math.PI);
    list.Add(34.22);

    byte[] arr = (from l in list
                  select (byte)l).ToArray<byte>();

---

这可能会起作用，但会丢失数据—数组的内容将是3和34

    List<double> list = new List<double>();
    list.Add(Math.PI);
    list.Add(34.22);

    byte[] arr = (from l in list
                  select (byte)l).ToArray<byte>();

---

我以前使用过这些帮助器方法：

byte[] GetBytesBlock(double[] values)
{
   var result = new byte[values.Length * sizeof(double)];
   Buffer.BlockCopy(values, 0, result, 0, result.Length);
   return result;
}

double[] GetDoublesBlock(byte[] bytes)
{
   var result = new double[bytes.Length / sizeof(double)];
   Buffer.BlockCopy(bytes, 0, result, 0, bytes.Length);
   return result;
}

例如：

List<double> myList = new List<double>(){ 1.0, 2.0, 3.0};

//to byte[]
var byteResult = GetBytesBlock(myList.ToArray());

//back to List<double>
var doubleResult = GetDoublesBlock(byteResult).ToList();

---

我以前使用过这些帮助器方法：

byte[] GetBytesBlock(double[] values)
{
   var result = new byte[values.Length * sizeof(double)];
   Buffer.BlockCopy(values, 0, result, 0, result.Length);
   return result;
}

double[] GetDoublesBlock(byte[] bytes)
{
   var result = new double[bytes.Length / sizeof(double)];
   Buffer.BlockCopy(bytes, 0, result, 0, bytes.Length);
   return result;
}

例如：

List<double> myList = new List<double>(){ 1.0, 2.0, 3.0};

//to byte[]
var byteResult = GetBytesBlock(myList.ToArray());

//back to List<double>
var doubleResult = GetDoublesBlock(byteResult).ToList();

---

我甚至不知道有这样的东西存在…我更好奇的是，你为什么要通过指针这样做？我甚至不知道有这样的东西存在…我更好奇的是，你为什么要通过指针这样做？我不认为这是可取的，因为这意味着创建了第三个数组，并将值复制到其中，因此，工作和内存消耗翻了一番。我认为这是不可取的，因为这意味着创建了第三个数组并将值复制到其中，因此工作和内存消耗翻了一番。转换double*pres驻留在循环中。因此，在列表实例中获取指向私有T[]_items字段的指针并将其转换为Byte*是否会更有效？据我所知，@user536443“转换”实际上是不可操作的，因此不会影响性能。内存中的数据只是以不同的方式复制和解释。您的代码一次执行一个字节，我的代码一次执行一个双字节。@user536443由于范围检查的原因，以这种方式访问列表可能比使用指针要贵一些。除此之外，我认为基本上是一样的。如果您>确实<需要性能，则测量执行时间。其他一切都是推测性的。如果没有必要，请不要进行优化。谢谢。我将尝试这两种解决方案转换双*压力驻留在循环中。因此，在列表实例中获取指向私有T[]_items字段的指针并将其转换为Byte*是否会更有效？据我所知，@user536443“转换”实际上是不可操作的，因此不会影响性能。内存中的数据只是以不同的方式复制和解释。您的代码一次执行一个字节，我的代码一次执行一个双字节。@user536443由于范围检查的原因，以这种方式访问列表可能比使用指针要贵一些。除此之外，我认为基本上是一样的。如果您>确实<需要性能，则测量执行时间。其他一切都是推测性的。如果没有必要，请不要进行优化。谢谢。我将尝试两种解决方案