netcore, netfx: merge WriteInt and SerializeInt

edwardneal · edwardneal · commit 878fcd46225f · 2025-08-10T00:04:46.000+01:00
netcore: removed a simple WriteInt which did nothing besides call BinaryPrimitives.
netcore: when there's space in the packet buffer, WriteInt will now write to it directly (rather than write to a stack-allocated span and copy.)
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParser.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParser.cs
@@ -1748,16 +1748,17 @@ internal byte[] SerializeInt(int v, TdsParserStateObject stateObj)
                 Debug.Assert(sizeof(int) == stateObj._bIntBytes.Length);
             }
 
-            WriteInt(stateObj._bIntBytes.AsSpan(), v);
+            BinaryPrimitives.WriteInt32LittleEndian(stateObj._bIntBytes, v);
             return stateObj._bIntBytes;
         }
 
         internal void WriteInt(int v, TdsParserStateObject stateObj)
         {
-            Span<byte> buffer = stackalloc byte[sizeof(int)];
-            WriteInt(buffer, v);
             if ((stateObj._outBytesUsed + 4) > stateObj._outBuff.Length)
             {
+                Span<byte> buffer = stackalloc byte[sizeof(int)];
+
+                BinaryPrimitives.WriteInt32LittleEndian(buffer, v);
                 // if all of the int doesn't fit into the buffer
                 for (int index = 0; index < sizeof(int); index++)
                 {
@@ -1767,16 +1768,11 @@ internal void WriteInt(int v, TdsParserStateObject stateObj)
             else
             {
                 // all of the int fits into the buffer
-                buffer.CopyTo(stateObj._outBuff.AsSpan(stateObj._outBytesUsed, sizeof(int)));
+                BinaryPrimitives.WriteInt32LittleEndian(stateObj._outBuff.AsSpan(stateObj._outBytesUsed, sizeof(int)), v);
                 stateObj._outBytesUsed += 4;
             }
         }
 
-        internal static void WriteInt(Span<byte> buffer, int value)
-        {
-            BinaryPrimitives.TryWriteInt32LittleEndian(buffer, value);
-        }
-
         //
         // Takes a float and writes it as a 32 bit float.
         //
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParser.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParser.cs
@@ -1776,33 +1776,27 @@ internal byte[] SerializeInt(int v, TdsParserStateObject stateObj)
                 Debug.Assert(sizeof(int) == stateObj._bIntBytes.Length);
             }
 
-            int current = 0;
-            byte[] bytes = stateObj._bIntBytes;
-            bytes[current++] = (byte)(v & 0xff);
-            bytes[current++] = (byte)((v >> 8) & 0xff);
-            bytes[current++] = (byte)((v >> 16) & 0xff);
-            bytes[current++] = (byte)((v >> 24) & 0xff);
-            return bytes;
+            BinaryPrimitives.WriteInt32LittleEndian(stateObj._bIntBytes, v);
+            return stateObj._bIntBytes;
         }
 
         internal void WriteInt(int v, TdsParserStateObject stateObj)
         {
             if ((stateObj._outBytesUsed + 4) > stateObj._outBuff.Length)
             {
+                Span<byte> buffer = stackalloc byte[sizeof(int)];
+
+                BinaryPrimitives.WriteInt32LittleEndian(buffer, v);
                 // if all of the int doesn't fit into the buffer
-                for (int shiftValue = 0; shiftValue < sizeof(int) * 8; shiftValue += 8)
+                for (int index = 0; index < sizeof(int); index++)
                 {
-                    stateObj.WriteByte((byte)((v >> shiftValue) & 0xff));
+                    stateObj.WriteByte(buffer[index]);
                 }
             }
             else
             {
                 // all of the int fits into the buffer
-                // NOTE: We don't use a loop here for performance
-                stateObj._outBuff[stateObj._outBytesUsed] = (byte)(v & 0xff);
-                stateObj._outBuff[stateObj._outBytesUsed + 1] = (byte)((v >> 8) & 0xff);
-                stateObj._outBuff[stateObj._outBytesUsed + 2] = (byte)((v >> 16) & 0xff);
-                stateObj._outBuff[stateObj._outBytesUsed + 3] = (byte)((v >> 24) & 0xff);
+                BinaryPrimitives.WriteInt32LittleEndian(stateObj._outBuff.AsSpan(stateObj._outBytesUsed, sizeof(int)), v);
                 stateObj._outBytesUsed += 4;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -1748,16 +1748,17 @@ internal byte[] SerializeInt(int v, TdsParserStateObject stateObj)`
`1748`	`1748`	`Debug.Assert(sizeof(int) == stateObj._bIntBytes.Length);`
`1749`	`1749`	`}`
`1750`	`1750`
`1751`		`- WriteInt(stateObj._bIntBytes.AsSpan(), v);`
	`1751`	`+ BinaryPrimitives.WriteInt32LittleEndian(stateObj._bIntBytes, v);`
`1752`	`1752`	`return stateObj._bIntBytes;`
`1753`	`1753`	`}`
`1754`	`1754`
`1755`	`1755`	`internal void WriteInt(int v, TdsParserStateObject stateObj)`
`1756`	`1756`	`{`
`1757`		`- Span<byte> buffer = stackalloc byte[sizeof(int)];`
`1758`		`- WriteInt(buffer, v);`
`1759`	`1757`	`if ((stateObj._outBytesUsed + 4) > stateObj._outBuff.Length)`
`1760`	`1758`	`{`
	`1759`	`+ Span<byte> buffer = stackalloc byte[sizeof(int)];`
	`1760`	`+`
	`1761`	`+ BinaryPrimitives.WriteInt32LittleEndian(buffer, v);`
`1761`	`1762`	`// if all of the int doesn't fit into the buffer`
`1762`	`1763`	`for (int index = 0; index < sizeof(int); index++)`
`1763`	`1764`	`{`
`@@ -1767,16 +1768,11 @@ internal void WriteInt(int v, TdsParserStateObject stateObj)`
`1767`	`1768`	`else`
`1768`	`1769`	`{`
`1769`	`1770`	`// all of the int fits into the buffer`
`1770`		`- buffer.CopyTo(stateObj._outBuff.AsSpan(stateObj._outBytesUsed, sizeof(int)));`
	`1771`	`+ BinaryPrimitives.WriteInt32LittleEndian(stateObj._outBuff.AsSpan(stateObj._outBytesUsed, sizeof(int)), v);`
`1771`	`1772`	`stateObj._outBytesUsed += 4;`
`1772`	`1773`	`}`
`1773`	`1774`	`}`
`1774`	`1775`
`1775`		`- internal static void WriteInt(Span<byte> buffer, int value)`
`1776`		`- {`
`1777`		`- BinaryPrimitives.TryWriteInt32LittleEndian(buffer, value);`
`1778`		`- }`
`1779`		`-`
`1780`	`1776`	`//`
`1781`	`1777`	`// Takes a float and writes it as a 32 bit float.`
`1782`	`1778`	`//`
Original file line number	Diff line number	Diff line change
`@@ -1776,33 +1776,27 @@ internal byte[] SerializeInt(int v, TdsParserStateObject stateObj)`
`1776`	`1776`	`Debug.Assert(sizeof(int) == stateObj._bIntBytes.Length);`
`1777`	`1777`	`}`
`1778`	`1778`
`1779`		`- int current = 0;`
`1780`		`- byte[] bytes = stateObj._bIntBytes;`
`1781`		`- bytes[current++] = (byte)(v & 0xff);`
`1782`		`- bytes[current++] = (byte)((v >> 8) & 0xff);`
`1783`		`- bytes[current++] = (byte)((v >> 16) & 0xff);`
`1784`		`- bytes[current++] = (byte)((v >> 24) & 0xff);`
`1785`		`- return bytes;`
	`1779`	`+ BinaryPrimitives.WriteInt32LittleEndian(stateObj._bIntBytes, v);`
	`1780`	`+ return stateObj._bIntBytes;`
`1786`	`1781`	`}`
`1787`	`1782`
`1788`	`1783`	`internal void WriteInt(int v, TdsParserStateObject stateObj)`
`1789`	`1784`	`{`
`1790`	`1785`	`if ((stateObj._outBytesUsed + 4) > stateObj._outBuff.Length)`
`1791`	`1786`	`{`
	`1787`	`+ Span<byte> buffer = stackalloc byte[sizeof(int)];`
	`1788`	`+`
	`1789`	`+ BinaryPrimitives.WriteInt32LittleEndian(buffer, v);`
`1792`	`1790`	`// if all of the int doesn't fit into the buffer`
`1793`		`- for (int shiftValue = 0; shiftValue < sizeof(int) * 8; shiftValue += 8)`
	`1791`	`+ for (int index = 0; index < sizeof(int); index++)`
`1794`	`1792`	`{`
`1795`		`- stateObj.WriteByte((byte)((v >> shiftValue) & 0xff));`
	`1793`	`+ stateObj.WriteByte(buffer[index]);`
`1796`	`1794`	`}`
`1797`	`1795`	`}`
`1798`	`1796`	`else`
`1799`	`1797`	`{`
`1800`	`1798`	`// all of the int fits into the buffer`
`1801`		`- // NOTE: We don't use a loop here for performance`
`1802`		`- stateObj._outBuff[stateObj._outBytesUsed] = (byte)(v & 0xff);`
`1803`		`- stateObj._outBuff[stateObj._outBytesUsed + 1] = (byte)((v >> 8) & 0xff);`
`1804`		`- stateObj._outBuff[stateObj._outBytesUsed + 2] = (byte)((v >> 16) & 0xff);`
`1805`		`- stateObj._outBuff[stateObj._outBytesUsed + 3] = (byte)((v >> 24) & 0xff);`
	`1799`	`+ BinaryPrimitives.WriteInt32LittleEndian(stateObj._outBuff.AsSpan(stateObj._outBytesUsed, sizeof(int)), v);`
`1806`	`1800`	`stateObj._outBytesUsed += 4;`
`1807`	`1801`	`}`
`1808`	`1802`	`}`