resolved all the review comments

Signed-off-by: Medha Tiwari <[email protected]>

Author: medhatiwari

src/MongoDB.Bson/IO/BinaryPrimitivesCompat.cs

@@ -15,6 +15,7 @@
 
 using System;
 using System.Buffers.Binary;
+using System.Runtime.InteropServices;
 
 namespace MongoDB.Bson.IO
 {
@@ -31,35 +32,79 @@ public static void WriteDoubleLittleEndian(Span<byte> destination, double value)
         {
             BinaryPrimitives.WriteInt64LittleEndian(destination, BitConverter.DoubleToInt64Bits(value));
         }
+
         public static float ReadSingleLittleEndian(ReadOnlySpan<byte> source)
         {
+#if NET6_0_OR_GREATER
+            return BinaryPrimitives.ReadSingleLittleEndian(source);
+#else
             if (source.Length < 4)
             {
                 throw new ArgumentOutOfRangeException(nameof(source), "Source span is too small to contain a float.");
             }
 
+            // Manually construct a 32-bit integer from 4 bytes in Little Endian order.
+            // BSON mandates that all multibyte values-including float32-must be encoded
+            // using Little Endian byte order, regardless of the system architecture.
+            //
+            // This method ensures platform-agnostic behavior by explicitly assembling
+            // the bytes in the correct order, rather than relying on the system's native endianness.
+            //
+            // Given a byte sequence [a, b, c, d], representing a float encoded in Little Endian,
+            // the expression below constructs the 32-bit integer as:
+            //     intValue = a + (b << 8) + (c << 16) + (d << 24)
+            //
+            // This preserves the intended bit pattern when converting back to float using
+            // BitConverter.Int32BitsToSingle.
+            //
+            // Example:
+            //   A float value of 1.0f is represented in IEEE-754 binary32 format as:
+            //       [0x00, 0x00, 0x80, 0x3F]  (Little Endian)
+            //   On a Big Endian system, naive interpretation would yield an incorrect value,
+            //   but this method assembles the int as:
+            //       0x00 + (0x00 << 8) + (0x80 << 16) + (0x3F << 24) = 0x3F800000,
+            //   which correctly maps to 1.0f.
+            //
+            // This guarantees BSON-compliant serialization across all platforms.
             int intValue =
                 source[0] |
                 (source[1] << 8) |
                 (source[2] << 16) |
                 (source[3] << 24);
 
-            return BitConverter.Int32BitsToSingle(intValue);
+            // This struct emulates BitConverter.Int32BitsToSingle for platforms like net472.
+            return new FloatIntUnion { IntValue = intValue }.FloatValue;
+#endif
         }
 
         public static void WriteSingleLittleEndian(Span<byte> destination, float value)
         {
+#if NET6_0_OR_GREATER
+            BinaryPrimitives.WriteSingleLittleEndian(destination, value);
+#else
             if (destination.Length < 4)
             {
                 throw new ArgumentOutOfRangeException(nameof(destination), "Destination span is too small to hold a float.");
             }
 
-            int intValue = BitConverter.SingleToInt32Bits(value);
+            // This struct emulates BitConverter.SingleToInt32Bits for platforms like net472.
+            int intValue = new FloatIntUnion { FloatValue = value }.IntValue;
+
             destination[0] = (byte)(intValue);
             destination[1] = (byte)(intValue >> 8);
             destination[2] = (byte)(intValue >> 16);
             destination[3] = (byte)(intValue >> 24);
+#endif
         }
 
+        // This layout trick allows safely reinterpreting float as int and vice versa.
+        // It ensures identical memory layout for both fields, used for low-level bit conversion
+        // in environments like net472 which lack BitConverter.SingleToInt32Bits and its inverse.
+        [StructLayout(LayoutKind.Explicit)]
+        private struct FloatIntUnion
+        {
+            [FieldOffset(0)] public float FloatValue;
+            [FieldOffset(0)] public int IntValue;
+        }
     }
 }

src/MongoDB.Bson/Serialization/BinaryVectorReader.cs

@@ -48,9 +48,7 @@ public static (TItem[] Items, byte Padding, BinaryVectorDataType VectorDataType)
                         throw new FormatException("Data length of binary vector of type Float32 must be a multiple of 4 bytes.");
                     }
 
-                    var floatArray = BitConverter.IsLittleEndian                                 // We need not to use this condition here, just doing to keep the little endian logic intact
-                        ? MemoryMarshal.Cast<byte, float>(vectorDataBytes.Span).ToArray()
-                        : ToFloatArrayBigEndian(vectorDataBytes.Span);
+                    var floatArray = ReadSinglesArrayLittleEndian(vectorDataBytes.Span);
                     items = (TItem[])(object)floatArray;
                     break;
                 case BinaryVectorDataType.Int8:
@@ -119,6 +117,28 @@ TExpectedItem[] AsTypedArrayOrThrow<TExpectedItem>()
                 return result;
             }
         }
+        
+        private static float[] ReadSinglesArrayLittleEndian(ReadOnlySpan<byte> span)
+        {
+            if ((span.Length & 3) != 0)
+            {
+                throw new FormatException("Data length of binary vector of type Float32 must be a multiple of 4 bytes.");
+            }
+            int count = span.Length / 4;
+            float[] result = new float[count];
+            if (BitConverter.IsLittleEndian)
+            {
+                MemoryMarshal.Cast<byte, float>(span).CopyTo(result);
+            }
+            else
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    result[i] = BinaryPrimitivesCompat.ReadSingleLittleEndian(span.Slice(i * 4, 4));
+                }
+            }
+            return result;
+        }
 
         public static void ValidateItemType<TItem>(BinaryVectorDataType binaryVectorDataType)
         {
@@ -143,15 +163,5 @@ private static void ValidateItemTypeForBinaryVector<TItem, TItemExpectedType, TB
                 throw new NotSupportedException($"Expected {typeof(TItemExpectedType)} for {typeof(TBinaryVectorType)}, but found {typeof(TItem)}.");
             }
         }
-        private static float[] ToFloatArrayBigEndian(ReadOnlySpan<byte> span)
-        {
-            var count = span.Length / 4;
-            var result = new float[count];
-            for (int i = 0; i < count; i++)
-            {
-                result[i] = BinaryPrimitivesCompat.ReadSingleLittleEndian(span.Slice(i * 4, 4));
-            }
-            return result;
-        }
     }
 }

src/MongoDB.Bson/Serialization/BinaryVectorWriter.cs

@@ -41,18 +41,24 @@ public static byte[] WriteToBytes<TItem>(ReadOnlySpan<TItem> vectorData, BinaryV
             switch (binaryVectorDataType)
             {
                 case BinaryVectorDataType.Float32:
-                    int length = vectorData.Length * sizeof(float);
+                    var length = vectorData.Length * sizeof(float);
                     resultBytes = new byte[2 + length];
                     resultBytes[0] = (byte)binaryVectorDataType;
                     resultBytes[1] = padding;
 
                     var floatSpan = MemoryMarshal.Cast<TItem, float>(vectorData);
                     Span<byte> floatOutput = resultBytes.AsSpan(2);
 
-                    for (int i = 0; i < floatSpan.Length; i++)
+                    if (BitConverter.IsLittleEndian)
                     {
-                        BinaryPrimitivesCompat.WriteSingleLittleEndian(floatOutput, floatSpan[i]);
-                        floatOutput = floatOutput.Slice(4);
+                        MemoryMarshal.Cast<float, byte>(floatSpan).CopyTo(floatOutput);
+                    }
+                    else
+                    {
+                        for (int i = 0; i < floatSpan.Length; i++)
+                        {
+                            BinaryPrimitivesCompat.WriteSingleLittleEndian(floatOutput.Slice(i * 4, 4), floatSpan[i]);
+                        }
                     }
 
                     return resultBytes;

tests/MongoDB.Bson.Tests/Serialization/Serializers/BinaryVectorSerializerTests.cs

@@ -365,35 +365,16 @@ private BsonBinaryData SerializeToBinaryData<TCollection>(TCollection collection
         private static (T[], byte[] VectorBson) GetTestData<T>(BinaryVectorDataType dataType, int elementsCount, byte bitsPadding)
             where T : struct
         {
-            var elementsSpan = new ReadOnlySpan<T>(
-            Enumerable.Range(0, elementsCount)
-                .Select(i => Convert.ChangeType(i, typeof(T)).As<T>())
-                .ToArray());
-            if (typeof(T) == typeof(float) && dataType == BinaryVectorDataType.Float32)
-            {
-                var buffer = new byte[2 + elementsCount * 4]; // 4 bytes per float
-                buffer[0] = (byte)dataType;
-                buffer[1] = bitsPadding;
-                for (int i = 0; i < elementsCount; i++)
-                {
-                    var floatBytes = BitConverter.GetBytes((float)(object)elementsSpan[i]);
-                    if (!BitConverter.IsLittleEndian)
-                    {
-                        Array.Reverse(floatBytes);
-                    }
-                    Buffer.BlockCopy(floatBytes, 0, buffer, 2 + i * 4, 4);
-                }
-                return (elementsSpan.ToArray(), buffer);
-            }
-            else if ((typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte)) && (dataType == BinaryVectorDataType.Int8 || dataType == BinaryVectorDataType.PackedBit))
-            {
-                byte[] vectorBsonData = [(byte)dataType, bitsPadding, .. MemoryMarshal.Cast<T, byte>(elementsSpan)];
+                var elementsSpan = new ReadOnlySpan<T>(
+                    Enumerable.Range(0, elementsCount)
+                    .Select(i => Convert.ChangeType(i, typeof(T)).As<T>())
+                    .ToArray());
+                var elementsBytesLittleEndian = BitConverter.IsLittleEndian
+                    ? MemoryMarshal.Cast<T, byte>(elementsSpan)
+                    : ToLittleEndian(elementsSpan, dataType);
+                
+                byte[] vectorBsonData = [(byte)dataType, bitsPadding, .. elementsBytesLittleEndian];
                 return (elementsSpan.ToArray(), vectorBsonData);
-            }
-            else
-            {
-                throw new NotSupportedException($"Type {typeof(T)} is not supported for data type {dataType}.");
-            }      
         }
 
         private static (BinaryVector<T>, byte[] VectorBson) GetTestDataBinaryVector<T>(BinaryVectorDataType dataType, int elementsCount, byte bitsPadding)
@@ -442,5 +423,23 @@ public class BinaryVectorNoAttributeHolder
 
             public BinaryVectorFloat32 ValuesFloat { get; set; }
         }
+
+        private static byte[] ToLittleEndian<T>(ReadOnlySpan<T> span, BinaryVectorDataType dataType) where T : struct
+        {
+            // Types that do NOT need conversion safe on BE
+            if (dataType == BinaryVectorDataType.Int8 || dataType == BinaryVectorDataType.PackedBit)
+            {
+                return MemoryMarshal.Cast<T, byte>(span).ToArray();
+            }
+            int elementSize = Marshal.SizeOf<T>();
+            byte[] result = new byte[span.Length * elementSize];
+            for (int i = 0; i < span.Length; i++)
+            {
+                byte[] bytes = BitConverter.GetBytes((dynamic)span[i]);
+                Array.Reverse(bytes); // Ensure LE order
+                Buffer.BlockCopy(bytes, 0, result, i * elementSize, elementSize);
+            }
+            return result;
+        }
     }
 }