@@ -931,12 +931,30 @@ internal void WriteByte(byte b)
931931 _outBuff [ _outBytesUsed ++ ] = b ;
932932 }
933933
934+ internal Task WriteByteSpan ( ReadOnlySpan < byte > span , bool canAccumulate = true , TaskCompletionSource < object > completion = null )
935+ {
936+ return WriteBytes ( span , span . Length , 0 , canAccumulate , completion ) ;
937+ }
938+
934939 internal Task WriteByteArray ( byte [ ] b , int len , int offsetBuffer , bool canAccumulate = true , TaskCompletionSource < object > completion = null )
935940 {
941+ return WriteBytes ( ReadOnlySpan < byte > . Empty , len , offsetBuffer , canAccumulate , completion , b ) ;
942+ }
943+
944+ //
945+ // Takes a span or a byte array and writes it to the buffer
946+ // If you pass in a span and a null array then the span wil be used.
947+ // If you pass in a non-null array then the array will be used and the span is ignored.
948+ // if the span cannot be written into the current packet then the remaining contents of the span are copied to a
949+ // new heap allocated array that will used to callback into the method to continue the write operation.
950+ private Task WriteBytes ( ReadOnlySpan < byte > b , int len , int offsetBuffer , bool canAccumulate = true , TaskCompletionSource < object > completion = null , byte [ ] array = null )
951+ {
952+ if ( array != null )
953+ {
954+ b = new ReadOnlySpan < byte > ( array , offsetBuffer , len ) ;
955+ }
936956 try
937957 {
938- TdsParser . ReliabilitySection . Assert ( "unreliable call to WriteByteArray" ) ; // you need to setup for a thread abort somewhere before you call this method
939-
940958 bool async = _parser . _asyncWrite ; // NOTE: We are capturing this now for the assert after the Task is returned, since WritePacket will turn off async if there is an exception
941959 Debug . Assert ( async || _asyncWriteCount == 0 ) ;
942960 // Do we have to send out in packet size chunks, or can we rely on netlib layer to break it up?
@@ -949,7 +967,7 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
949967
950968 int offset = offsetBuffer;
951969
952- Debug. Assert( b . Length > = len , "Invalid length sent to WriteByteArray ()!" ) ;
970+ Debug. Assert( b . Length > = len , "Invalid length sent to WriteBytes ()!" ) ;
953971
954972 // loop through and write the entire array
955973 do
@@ -963,12 +981,17 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
963981 int remainder = _outBuff. Length - _outBytesUsed;
964982
965983 // write the remainder
966- Buffer . BlockCopy( b , offset , _outBuff , _outBytesUsed , remainder ) ;
984+ Span < byte > copyTo = _outBuff. AsSpan( _outBytesUsed , remainder ) ;
985+ ReadOnlySpan < byte > copyFrom = b . Slice ( 0 , remainder ) ;
986+
987+ Debug . Assert ( copyTo . Length = = copyFrom . Length , $"copyTo.Length:{copyTo.Length} and copyFrom.Length{copyFrom.Length:D} should be the same" ) ;
988+
989+ copyFrom . CopyTo ( copyTo ) ;
967990
968- // handle counters
969991 offset += remainder ;
970992 _outBytesUsed += remainder ;
971993 len -= remainder ;
994+ b = b . Slice ( remainder , len ) ;
972995
973996 Task packetTask = WritePacket ( TdsEnums . SOFTFLUSH , canAccumulate ) ;
974997
@@ -981,18 +1004,35 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
9811004 completion = new TaskCompletionSource < object > ( ) ;
9821005 task = completion . Task ; // we only care about return from topmost call, so do not access Task property in other cases
9831006 }
984- WriteByteArraySetupContinuation ( b , len , completion , offset , packetTask ) ;
1007+
1008+ if ( array == null )
1009+ {
1010+ byte [ ] tempArray = new byte [ len ] ;
1011+ Span < byte > copyTempTo = tempArray. AsSpan( ) ;
1012+
1013+ Debug . Assert ( copyTempTo . Length = = b . Length , $"copyTempTo.Length:{copyTempTo.Length} and copyTempFrom.Length:{b.Length:D} should be the same" ) ;
1014+
1015+ b . CopyTo ( copyTempTo ) ;
1016+ array = tempArray ;
1017+ offset = 0 ;
1018+ }
1019+
1020+ WriteBytesSetupContinuation( array , len , completion , offset , packetTask ) ;
9851021 return task;
9861022 }
987-
9881023 }
9891024 else
9901025 {
9911026 //((stateObj._outBytesUsed + len) <= stateObj._outBuff.Length )
9921027 // Else the remainder of the string will fit into the buffer, so copy it into the
9931028 // buffer and then break out of the loop.
9941029
995- Buffer . BlockCopy( b, offset , _outBuff , _outBytesUsed , len ) ;
1030+ Span< byte > copyTo = _outBuff . AsSpan ( _outBytesUsed , len ) ;
1031+ ReadOnlySpan < byte > copyFrom = b . Slice ( 0 , len ) ;
1032+
1033+ Debug. Assert ( copyTo . Length == copyFrom . Length , $ "copyTo.Length:{ copyTo . Length } and copyFrom.Length:{ copyFrom . Length : D} should be the same") ;
1034+
1035+ copyFrom. CopyTo ( copyTo ) ;
9961036
9971037 // handle out buffer bytes used counter
9981038 _outBytesUsed += len;
@@ -1021,12 +1061,11 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
10211061 }
10221062
10231063 // This is in its own method to avoid always allocating the lambda in WriteByteArray
1024- private void WriteByteArraySetupContinuation ( byte [ ] b , int len , TaskCompletionSource < object > completion , int offset , Task packetTask )
1064+ private void WriteBytesSetupContinuation ( byte [ ] array , int len , TaskCompletionSource < object > completion , int offset , Task packetTask )
10251065 {
10261066 AsyncHelper. ContinueTask ( packetTask , completion ,
1027- ( ) => WriteByteArray ( b , len : len , offsetBuffer : offset , canAccumulate : false , completion : completion ) ,
1028- connectionToDoom : _parser. Connection
1029- ) ;
1067+ onSuccess : ( ) => WriteBytes ( ReadOnlySpan < byte > . Empty , len : len , offsetBuffer : offset , canAccumulate : false , completion : completion , array )
1068+ ) ;
10301069 }
10311070
10321071 // Dumps contents of buffer to SNI for network write.
0 commit comments