How to convert List<Double> to Byte[] in C#

Convertion from Double[] src to Byte[] dst can be efficiently done in C# by fixed pointers:

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

How can I do the same for List开发者_开发技巧 src ? I.e. how can I get fixed pointer to array Double[] included in List ? Thanks.

I have used these helper methods before:

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;
}

An example:

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();

not sure what you are intending, but I think ... you want System.Runtime.Interopservices.Marshal.StructToPtr.

You can always use the ToArray() method on the List<Double> object to get a Double[].

You can use reflection to get the reference to the private T[] _items field, in the List instance.

Warning: In your code snippet, you need to make sure dstLength is the minimum of dst and src lengths in bytes, so that you don't try to copy more bytes than what are available. Probably you do so by creating dst with exactly the needed size to match the src, but your snippet doesn't make it clear.

Use the List<T>.ToArray() method and operate on the resulting array.

This might work, but you will have a data loss- content of the array will be 3 and 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>();

Why don't you just access the list as usual?

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];
        }
    }
}

I haven't tested it thoroughly and i seldomly need unsafe code, but it seems to work fine.

Edit: here is another (imo preferable) solution, without unsafe code:

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;
    }
}