fix(bson): correct deserialization of primitive arrays using BinaryPrimitives for Big Endian support

Signed-off-by: Medha Tiwari <medhavns1@gmail.com>

Author: medhatiwari

src/MongoDB.Bson/Serialization/Serializers/PrimitivesArrayReader.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using MongoDB.Bson.IO;
@@ -77,6 +78,7 @@ private static T[] ReadBsonArray<T>(
 
             var result = new List<T>();
 
+		
             var index = 4; // 4 first bytes are array object size in bytes
             var maxIndex = array.Length - 1;
 
@@ -85,7 +87,7 @@ private static T[] ReadBsonArray<T>(
                 ValidateBsonType(bsonDataType);
 
                 // Skip name
-                while (bytes[index] != 0) { index++; };
+                while (bytes[index] != 0) { index++; }
                 index++; // Skip string terminating 0
 
                 T value = default;
@@ -95,85 +97,81 @@ private static T[] ReadBsonArray<T>(
                 {
                     case ConversionType.DoubleToSingle:
                         {
-                            var v = (float)BitConverter.ToDouble(bytes, index);
-
+                            var v = (float)BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(bytes.AsSpan(index)));
                             value = Unsafe.As<float, T>(ref v);
                             break;
                         }
                     case ConversionType.DoubleToDouble:
                         {
-                            var v = BitConverter.ToDouble(bytes, index);
+                            var v = BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(bytes.AsSpan(index)));
                             value = Unsafe.As<double, T>(ref v);
                             break;
                         }
                     case ConversionType.Decimal128ToDecimal128:
                         {
-                            var lowBits = (ulong)BitConverter.ToInt64(bytes, index);
-                            var highBits = (ulong)BitConverter.ToInt64(bytes, index + 8);
+                            var lowBits = BinaryPrimitives.ReadUInt64LittleEndian(bytes.AsSpan(index));
+                            var highBits = BinaryPrimitives.ReadUInt64LittleEndian(bytes.AsSpan(index + 8));
                             var v = Decimal128.ToDecimal(Decimal128.FromIEEEBits(highBits, lowBits));
-
                             value = Unsafe.As<decimal, T>(ref v);
                             break;
                         }
                     case ConversionType.BoolToBool:
                         {
                             var v = bytes[index] != 0;
-
                             value = Unsafe.As<bool, T>(ref v);
                             break;
                         }
                     case ConversionType.Int32ToInt8:
                         {
-                            var v = (sbyte)BitConverter.ToInt32(bytes, index);
+                            var v = (sbyte)BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<sbyte, T>(ref v);
-
                             break;
                         }
                     case ConversionType.Int32ToUInt8:
                         {
-                            var v = (byte)BitConverter.ToInt32(bytes, index);
+                            var v = (byte)BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<byte, T>(ref v);
                             break;
                         }
                     case ConversionType.Int32ToInt16:
                         {
-                            var v = (short)BitConverter.ToInt32(bytes, index);
+                            var v = (short)BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<short, T>(ref v);
                             break;
                         }
                     case ConversionType.Int32ToUInt16:
                         {
-                            var v = (ushort)BitConverter.ToInt32(bytes, index);
+                            var v = (ushort)BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<ushort, T>(ref v);
                             break;
                         }
                     case ConversionType.Int32ToChar:
                         {
-                            var v = BitConverter.ToChar(bytes, index);
+                            var v = (char)(ushort)BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<char, T>(ref v);
                             break;
                         }
                     case ConversionType.Int32ToInt32:
                         {
-                            var v = BitConverter.ToInt32(bytes, index);
+                            var v = BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<int, T>(ref v);
                             break;
                         }
                     case ConversionType.Int32ToUInt32:
                         {
-                            var v = BitConverter.ToUInt32(bytes, index);
+                            var v = BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<uint, T>(ref v);
                             break;
                         }
                     case ConversionType.Int64ToInt64:
                         {
-                            var v = BitConverter.ToInt64(bytes, index);
+                            var v = BinaryPrimitives.ReadInt64LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<long, T>(ref v);
                             break;
                         }
                     case ConversionType.Int64ToUInt64:
                         {
-                            var v = BitConverter.ToUInt64(bytes, index);
+                            var v = BinaryPrimitives.ReadUInt64LittleEndian(bytes.AsSpan(index));
                             value = Unsafe.As<ulong, T>(ref v);
                             break;
                         }
@@ -182,12 +180,10 @@ private static T[] ReadBsonArray<T>(
                 }
 
                 result.Add(value);
-
                 index += bsonDataSize;
             }
 
             ValidateBsonType(BsonType.EndOfDocument);
-
             return result.ToArray();
 
             void ValidateBsonType(BsonType bsonType)