@@ -930,9 +930,28 @@ internal void WriteByte(byte b)
930930 // set byte in buffer and increment the counter for number of bytes used in the out buffer
931931 _outBuff [ _outBytesUsed ++ ] = b ;
932932 }
933+ internal Task WriteByteSpan ( ReadOnlySpan < byte > span , bool canAccumulate = true , TaskCompletionSource < object > completion = null )
934+ {
935+ return WriteBytes ( span , span . Length , 0 , canAccumulate , completion ) ;
936+ }
933937
934938 internal Task WriteByteArray ( byte [ ] b , int len , int offsetBuffer , bool canAccumulate = true , TaskCompletionSource < object > completion = null )
935939 {
940+ return WriteBytes ( ReadOnlySpan < byte > . Empty , len , offsetBuffer , canAccumulate , completion , b ) ;
941+ }
942+
943+ //
944+ // Takes a span or a byte array and writes it to the buffer
945+ // If you pass in a span and a null array then the span wil be used.
946+ // If you pass in a non-null array then the array will be used and the span is ignored.
947+ // if the span cannot be written into the current packet then the remaining contents of the span are copied to a
948+ // new heap allocated array that will used to callback into the method to continue the write operation.
949+ private Task WriteBytes ( ReadOnlySpan < byte > b , int len , int offsetBuffer , bool canAccumulate = true , TaskCompletionSource < object > completion = null , byte [ ] array = null )
950+ {
951+ if ( array != null )
952+ {
953+ b = new ReadOnlySpan < byte > ( array , offsetBuffer , len ) ;
954+ }
936955 try
937956 {
938957 TdsParser . ReliabilitySection . Assert ( "unreliable call to WriteByteArray" ) ; // you need to setup for a thread abort somewhere before you call this method
@@ -949,7 +968,7 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
949968
950969 int offset = offsetBuffer;
951970
952- Debug. Assert( b . Length > = len , "Invalid length sent to WriteByteArray ()!" ) ;
971+ Debug. Assert( b . Length > = len , "Invalid length sent to WriteBytes ()!" ) ;
953972
954973 // loop through and write the entire array
955974 do
@@ -963,12 +982,17 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
963982 int remainder = _outBuff. Length - _outBytesUsed;
964983
965984 // write the remainder
966- Buffer . BlockCopy( b , offset , _outBuff , _outBytesUsed , remainder ) ;
985+ Span < byte > copyTo = _outBuff. AsSpan( _outBytesUsed , remainder ) ;
986+ ReadOnlySpan < byte > copyFrom = b . Slice ( 0 , remainder ) ;
987+
988+ Debug . Assert ( copyTo . Length = = copyFrom . Length , $"copyTo.Length:{copyTo.Length} and copyFrom.Length{copyFrom.Length:D} should be the same" ) ;
989+
990+ copyFrom . CopyTo ( copyTo ) ;
967991
968- // handle counters
969992 offset += remainder ;
970993 _outBytesUsed += remainder ;
971994 len -= remainder ;
995+ b = b . Slice ( remainder , len ) ;
972996
973997 Task packetTask = WritePacket ( TdsEnums . SOFTFLUSH , canAccumulate ) ;
974998
@@ -981,18 +1005,35 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
9811005 completion = new TaskCompletionSource < object > ( ) ;
9821006 task = completion . Task ; // we only care about return from topmost call, so do not access Task property in other cases
9831007 }
984- WriteByteArraySetupContinuation ( b , len , completion , offset , packetTask ) ;
1008+
1009+ if ( array == null )
1010+ {
1011+ byte [ ] tempArray = new byte [ len ] ;
1012+ Span < byte > copyTempTo = tempArray. AsSpan( ) ;
1013+
1014+ Debug . Assert ( copyTempTo . Length = = b . Length , $"copyTempTo.Length:{copyTempTo.Length} and copyTempFrom.Length:{b.Length:D} should be the same" ) ;
1015+
1016+ b . CopyTo ( copyTempTo ) ;
1017+ array = tempArray ;
1018+ offset = 0 ;
1019+ }
1020+
1021+ WriteBytesSetupContinuation( array , len , completion , offset , packetTask ) ;
9851022 return task;
9861023 }
987-
9881024 }
9891025 else
9901026 {
9911027 //((stateObj._outBytesUsed + len) <= stateObj._outBuff.Length )
9921028 // Else the remainder of the string will fit into the buffer, so copy it into the
9931029 // buffer and then break out of the loop.
9941030
995- Buffer . BlockCopy( b, offset , _outBuff , _outBytesUsed , len ) ;
1031+ Span< byte > copyTo = _outBuff . AsSpan ( _outBytesUsed , len ) ;
1032+ ReadOnlySpan < byte > copyFrom = b . Slice ( 0 , len ) ;
1033+
1034+ Debug. Assert ( copyTo . Length == copyFrom . Length , $ "copyTo.Length:{ copyTo . Length } and copyFrom.Length:{ copyFrom . Length : D} should be the same") ;
1035+
1036+ copyFrom. CopyTo ( copyTo ) ;
9961037
9971038 // handle out buffer bytes used counter
9981039 _outBytesUsed += len;
@@ -1021,7 +1062,7 @@ internal Task WriteByteArray(byte[] b, int len, int offsetBuffer, bool canAccumu
10211062 }
10221063
10231064 // 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 )
1065+ private void WriteBytesSetupContinuation ( byte [ ] b , int len , TaskCompletionSource < object > completion , int offset , Task packetTask )
10251066 {
10261067 AsyncHelper. ContinueTask ( packetTask , completion ,
10271068 ( ) => WriteByteArray ( b , len : len , offsetBuffer : offset , canAccumulate : false , completion : completion ) ,
0 commit comments