Merge ClearAllWritePackets, AddPacketToPendingList, RemovePacketFromPendingList

Author: edwardneal

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParserStateObject.netcore.cs

@@ -100,12 +100,6 @@ internal abstract void CreatePhysicalSNIHandle(
 
         internal abstract uint CheckConnection();
 
-        internal abstract void ClearAllWritePackets();
-
-        internal abstract PacketHandle AddPacketToPendingList(PacketHandle packet);
-
-        protected abstract void RemovePacketFromPendingList(PacketHandle pointer);
-
         internal int DecrementPendingCallbacks(bool release)
         {
             int remaining = Interlocked.Decrement(ref _pendingCallbacks);

src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParserStateObject.netfx.cs

@@ -23,10 +23,9 @@ internal partial class TdsParserStateObject
         protected SNIHandle _sessionHandle = null;              // the SNI handle we're to work on
 
         // SNI variables                                                     // multiple resultsets in one batch.
-        private SNIPacket _sniPacket = null;                // Will have to re-vamp this for MARS
+        protected SNIPacket _sniPacket = null;                // Will have to re-vamp this for MARS
         internal SNIPacket _sniAsyncAttnPacket = null;                // Packet to use to send Attn
-        private readonly WritePacketCache _writePacketCache = new WritePacketCache(); // Store write packets that are ready to be re-used
-        private readonly Dictionary<IntPtr, SNIPacket> _pendingWritePackets = new Dictionary<IntPtr, SNIPacket>(); // Stores write packets that have been sent to SNI, but have not yet finished writing (i.e. we are waiting for SNI's callback)
+        protected readonly WritePacketCache _writePacketCache = new WritePacketCache(); // Store write packets that are ready to be re-used
 
         // Async variables
         private GCHandle _gcHandle;                                    // keeps this object alive until we're closed.
@@ -906,57 +905,6 @@ private Task WriteSni(bool canAccumulate)
             return task;
         }
 
-        internal void ClearAllWritePackets()
-        {
-            if (_sniPacket != null)
-            {
-                _sniPacket.Dispose();
-                _sniPacket = null;
-            }
-            lock (_writePacketLockObject)
-            {
-                Debug.Assert(_pendingWritePackets.Count == 0 && _asyncWriteCount == 0, "Should not clear all write packets if there are packets pending");
-                _writePacketCache.Clear();
-            }
-        }
-
-        private PacketHandle AddPacketToPendingList(PacketHandle packetToAdd)
-        {
-            Debug.Assert(packetToAdd.Type == PacketHandle.NativePacketType, "unexpected packet type when requiring NativePacket");
-            SNIPacket packet = packetToAdd.NativePacket;
-            Debug.Assert(packet == _sniPacket, "Adding a packet other than the current packet to the pending list");
-            _sniPacket = null;
-            IntPtr pointer = packet.DangerousGetHandle();
-
-            lock (_writePacketLockObject)
-            {
-                _pendingWritePackets.Add(pointer, packet);
-            }
-
-            return PacketHandle.FromNativePointer(pointer);
-        }
-
-        private void RemovePacketFromPendingList(PacketHandle ptr)
-        {
-            Debug.Assert(ptr.Type == PacketHandle.NativePointerType, "unexpected packet type when requiring NativePointer");
-            IntPtr pointer = ptr.NativePointer;
-
-            lock (_writePacketLockObject)
-            {
-                if (_pendingWritePackets.TryGetValue(pointer, out SNIPacket recoveredPacket))
-                {
-                    _pendingWritePackets.Remove(pointer);
-                    _writePacketCache.Add(recoveredPacket);
-                }
-#if DEBUG
-                else
-                {
-                    Debug.Assert(false, "Removing a packet from the pending list that was never added to it");
-                }
-#endif
-            }
-        }
-
         //////////////////////////////////////////////
         // Statistics, Tracing, and related methods //
         //////////////////////////////////////////////

src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParserStateObjectNative.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using Interop.Windows.Sni;
@@ -12,6 +13,8 @@ namespace Microsoft.Data.SqlClient
 {
     internal class TdsParserStateObjectNative : TdsParserStateObject
     {
+        private readonly Dictionary<IntPtr, SNIPacket> _pendingWritePackets = new Dictionary<IntPtr, SNIPacket>(); // Stores write packets that have been sent to SNI, but have not yet finished writing (i.e. we are waiting for SNI's callback)
+
         internal TdsParserStateObjectNative(TdsParser parser, TdsParserStateObject physicalConnection, bool async)
             : base(parser, physicalConnection.Handle, async)
         {
@@ -47,6 +50,27 @@ protected override bool CheckPacket(PacketHandle packet, TaskCompletionSource<ob
             return IntPtr.Zero == ptr || IntPtr.Zero != ptr && source != null;
         }
 
+        protected override void RemovePacketFromPendingList(PacketHandle ptr)
+        {
+            Debug.Assert(ptr.Type == PacketHandle.NativePointerType, "unexpected packet type when requiring NativePointer");
+            IntPtr pointer = ptr.NativePointer;
+
+            lock (_writePacketLockObject)
+            {
+                if (_pendingWritePackets.TryGetValue(pointer, out SNIPacket recoveredPacket))
+                {
+                    _pendingWritePackets.Remove(pointer);
+                    _writePacketCache.Add(recoveredPacket);
+                }
+#if DEBUG
+                else
+                {
+                    Debug.Fail("Removing a packet from the pending list that was never added to it");
+                }
+#endif
+            }
+        }
+
         internal override bool IsFailedHandle() => _sessionHandle.Status != TdsEnums.SNI_SUCCESS;
 
         internal override bool IsPacketEmpty(PacketHandle readPacket)
@@ -82,6 +106,22 @@ internal override uint WritePacket(PacketHandle packet, bool sync)
             return SniNativeWrapper.SniWritePacket(Handle, packet.NativePacket, sync);
         }
 
+        internal override PacketHandle AddPacketToPendingList(PacketHandle packetToAdd)
+        {
+            Debug.Assert(packetToAdd.Type == PacketHandle.NativePacketType, "unexpected packet type when requiring NativePacket");
+            SNIPacket packet = packetToAdd.NativePacket;
+            Debug.Assert(packet == _sniPacket, "Adding a packet other than the current packet to the pending list");
+            _sniPacket = null;
+            IntPtr pointer = packet.DangerousGetHandle();
+
+            lock (_writePacketLockObject)
+            {
+                _pendingWritePackets.Add(pointer, packet);
+            }
+
+            return PacketHandle.FromNativePointer(pointer);
+        }
+
         internal override bool IsValidPacket(PacketHandle packetPointer)
         {
             Debug.Assert(packetPointer.Type == PacketHandle.NativePointerType || packetPointer.Type == PacketHandle.NativePacketType, "unexpected packet type when requiring NativePointer");
@@ -108,6 +148,20 @@ internal override PacketHandle GetResetWritePacket(int dataSize)
             return PacketHandle.FromNativePacket(_sniPacket);
         }
 
+        internal override void ClearAllWritePackets()
+        {
+            if (_sniPacket != null)
+            {
+                _sniPacket.Dispose();
+                _sniPacket = null;
+            }
+            lock (_writePacketLockObject)
+            {
+                Debug.Assert(_pendingWritePackets.Count == 0 && _asyncWriteCount == 0, "Should not clear all write packets if there are packets pending");
+                _writePacketCache.Clear();
+            }
+        }
+
         internal override uint SniGetConnectionId(ref Guid clientConnectionId)
             => SniNativeWrapper.SniGetConnectionId(Handle, ref clientConnectionId);
 

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs

@@ -499,6 +499,12 @@ internal long TimeoutTime
 
         internal abstract uint WritePacket(PacketHandle packet, bool sync);
 
+        internal abstract PacketHandle AddPacketToPendingList(PacketHandle packet);
+
+        protected abstract void RemovePacketFromPendingList(PacketHandle pointer);
+
+        internal abstract void ClearAllWritePackets();
+
         internal abstract bool IsValidPacket(PacketHandle packetPointer);
 
         internal abstract PacketHandle ReadAsync(SessionHandle handle, out uint error);