Slice

src\Shared\CircularBuffer.cs (5)

99data.Slice(0, _end).CopyTo(data.Slice(1)); 107data.Slice(internalIndex, shiftLength).CopyTo(data.Slice(internalIndex + 1)); 110data.Slice(0, _end).CopyTo(data.Slice(1)); 116data.Slice(internalIndex, _end - internalIndex).CopyTo(data.Slice(internalIndex + 1)); 120data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CircularBuffer.cs (5)

99data.Slice(0, _end).CopyTo(data.Slice(1)); 107data.Slice(internalIndex, shiftLength).CopyTo(data.Slice(internalIndex + 1)); 110data.Slice(0, _end).CopyTo(data.Slice(1)); 116data.Slice(internalIndex, _end - internalIndex).CopyTo(data.Slice(internalIndex + 1)); 120data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CircularBuffer.cs (5)

99data.Slice(0, _end).CopyTo(data.Slice(1)); 107data.Slice(internalIndex, shiftLength).CopyTo(data.Slice(internalIndex + 1)); 110data.Slice(0, _end).CopyTo(data.Slice(1)); 116data.Slice(internalIndex, _end - internalIndex).CopyTo(data.Slice(internalIndex + 1)); 120data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

Utils\PasswordGenerator.cs (1)

89destination = destination.Slice(minValues);

src\Aspire.Hosting\Utils\PasswordGenerator.cs (1)

89destination = destination.Slice(minValues);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

ChunkedResponseTests.cs (1)

883secondPartOfResponse.CopyTo(span.Slice(6));

Http2\Http2StreamTests.cs (2)

4131secondPartOfResponse.CopyTo(span.Slice(6)); 4449secondPartOfResponse.CopyTo(span.Slice(6));

Http2\Http2TestBase.cs (2)

706var payload = buffer.Slice(extendedHeaderLength); 751Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency);

ResponseTests.cs (1)

3871secondPartOfResponse.CopyTo(span.Slice(6));

src\Servers\Kestrel\shared\HPackHeaderWriter.cs (4)

42if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 55var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: false, out var headersLength); 90var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: true, out var headersLength); 133buffer.Slice(currentLength),

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (2)

917destination = destination.Slice(parameterLength); 920destination = destination.Slice(valueLength);

src\Shared\UrlDecoder\UrlDecoder.cs (1)

524if (!System.Text.Rune.TryCreate(currentDecodeBits, out var rune) || !rune.TryEncodeToUtf16(buffer.Slice(destinationIndex), out var charsWritten))

BlazorPack\SequenceOfT.cs (1)

325internal Span<T> RemainingSpan => this.AvailableMemory.Span.Slice(this.End);

src\SignalR\common\Protocols.MessagePack\src\Protocol\MessagePackHubProtocolWorker.cs (1)

377memoryBufferWriter.CopyTo(span.Slice(prefixLength));

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\BufferWriter.cs (1)

152_span = _span.Slice(count);

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\MessagePackWriter.cs (28)

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequenceReader.cs (1)

485nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));

KeyManagement\KeyRingBasedDataProtector.cs (3)

388BinaryPrimitives.WriteUInt32BigEndian(targetSpan.Slice(0), MAGIC_HEADER_V0); 391BinaryPrimitives.WriteInt32BigEndian(targetSpan.Slice(4 + keySize), targetLength); 400index += targetSpan.Slice(index).Write7BitEncodedInt(purposeLengthsPool[i]);

SP800_108\ManagedSP800_108_CTR_HMACSHA512.cs (3)

91label.CopyTo(prfInput.Slice(sizeof(uint))); 92contextHeader.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1)); 93contextData.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1 + contextHeader.Length));

PathString.cs (1)

205var length = UrlDecoder.DecodeRequestLine(uriComponent.AsSpan(), pathBuffer.Slice(1));

src\Shared\UrlDecoder\UrlDecoder.cs (1)

524if (!System.Text.Rune.TryCreate(currentDecodeBits, out var rune) || !rune.TryEncodeToUtf16(buffer.Slice(destinationIndex), out var charsWritten))

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\Shared\ValueStringBuilder\ValueStringBuilder.cs (5)

143_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 163_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 164s.AsSpan().CopyTo(_chars.Slice(index)); 211s.AsSpan().CopyTo(_chars.Slice(pos)); 254value.CopyTo(_chars.Slice(_pos));

src\Shared\ValueStringBuilder\ValueStringBuilder.cs (5)

143_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 163_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 164s.AsSpan().CopyTo(_chars.Slice(index)); 211s.AsSpan().CopyTo(_chars.Slice(pos)); 254value.CopyTo(_chars.Slice(_pos));

src\Mvc\Mvc.RazorPages\src\ApplicationModels\PageRouteModelFactory.cs (2)

149span = span.Slice(1); 152span = span.Slice(areaNameValue.Length);

ApplicationModels\PageRouteModelFactory.cs (2)

149span = span.Slice(1); 152span = span.Slice(areaNameValue.Length);

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

RecyclableSequenceBuilder.cs (1)

85return MemoryMarshal.AsMemory(current).Span.Slice(_currentSegmentIndex);

src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (1)

135var idx = raw.Slice(begin).IndexOf(target);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\Http2cat\HPackHeaderWriter.cs (2)

31var done = EncodeHeaders(headersEnumerator, buffer.Slice(statusCodeLength), throwIfNoneEncoded: false, out var headersLength); 64if (!EncodeHeader(headersEnumerator.Current.Key, headersEnumerator.Current.Value, buffer.Slice(currentLength), out int headerLength))

src\Shared\Http2cat\Http2Utilities.cs (6)

259buffer = buffer.Slice(3); 263buffer = buffer.Slice(2); 333var payload = buffer.Slice(extendedHeaderLength); 376Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 429destination = destination.Slice(Http2FrameReader.SettingSize);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

RequestHeaderTests.cs (14)

src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (1)

135var idx = raw.Slice(begin).IndexOf(target);

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

Internal\Http2\Http2FrameWriter.cs (5)

929BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 930destination = destination.Slice(Http2FrameReader.SettingSize); 1001buffer = buffer.Slice(4); 1034buffer = buffer.Slice(3); 1038buffer = buffer.Slice(2);

Internal\Http3\Http3FrameWriter.cs (4)

117buffer = buffer.Slice(settingsBytesWritten); 146destination = destination.Slice(parameterLength); 149destination = destination.Slice(valueLength); 286buffer = buffer.Slice(typeLength);

Internal\Http3\QPackHeaderWriter.cs (6)

20bool doneEncode = Encode(enumerator, buffer.Slice(2), ref totalHeaderSize, out length); 35int statusCodeLength = EncodeStatusCode(statusCode, buffer.Slice(2)); 44bool done = Encode(headersEnumerator, buffer.Slice(statusCodeLength + 2), throwIfNoneEncoded: false, ref totalHeaderSize, out int headersLength); 72if (!QPackEncoder.EncodeStaticIndexedHeaderField(staticTableId, buffer.Slice(length), out headerLength)) 86if (!EncodeHeader(buffer.Slice(length), staticTableId, name, value, valueEncoding, out headerLength)) 127statusBytes.CopyTo(buffer.Slice(3));

src\Servers\Kestrel\shared\HPackHeaderWriter.cs (4)

42if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 55var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: false, out var headersLength); 90var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: true, out var headersLength); 133buffer.Slice(currentLength),

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http3\Frames\Http3Frame.cs (1)

48buffer = buffer.Slice(1);

src\Shared\runtime\Http3\QPack\QPackEncoder.cs (13)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\UrlDecoder\UrlDecoder.cs (1)

524if (!System.Text.Rune.TryCreate(currentDecodeBits, out var rune) || !rune.TryEncodeToUtf16(buffer.Slice(destinationIndex), out var charsWritten))

AsciiDecoding.cs (2)

33Test(span.Slice(i)); 130Test(span.Slice(i));

src\Servers\Kestrel\shared\HPackHeaderWriter.cs (4)

42if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 55var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: false, out var headersLength); 90var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: true, out var headersLength); 133buffer.Slice(currentLength),

src\Shared\test\Shared.Tests\runtime\Http3\QPackDecoderTest.cs (3)

166QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(":method", new string('A', 8192 / 2), buffer.Slice(length), out int bytesWritten); 168QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(":path", new string('A', 8192 / 2), buffer.Slice(length), out bytesWritten); 170QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(":scheme", "http", buffer.Slice(length), out bytesWritten);

src\Servers\Kestrel\shared\HPackHeaderWriter.cs (4)

42if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 55var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: false, out var headersLength); 90var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), canRequestLargerBuffer: true, out var headersLength); 133buffer.Slice(currentLength),

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (2)

917destination = destination.Slice(parameterLength); 920destination = destination.Slice(valueLength);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

runtime\Http3\QPackDecoderTest.cs (3)

166QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(":method", new string('A', 8192 / 2), buffer.Slice(length), out int bytesWritten); 168QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(":path", new string('A', 8192 / 2), buffer.Slice(length), out bytesWritten); 170QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(":scheme", "http", buffer.Slice(length), out bytesWritten);

src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (1)

135var idx = raw.Slice(begin).IndexOf(target);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http3\Frames\Http3Frame.cs (1)

48buffer = buffer.Slice(1);

src\Shared\runtime\Http3\QPack\QPackEncoder.cs (13)

src\Shared\ServerInfrastructure\BufferWriter.cs (1)

83_span = _span.Slice(count);

src\Shared\ServerInfrastructure\StringUtilities.cs (1)

180buffer = buffer.Slice(i);

src\Shared\UrlDecoder\UrlDecoder.cs (1)

524if (!System.Text.Rune.TryCreate(currentDecodeBits, out var rune) || !rune.TryEncodeToUtf16(buffer.Slice(destinationIndex), out var charsWritten))

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

Protocol\MessagePackHubProtocolWorker.cs (1)

377memoryBufferWriter.CopyTo(span.Slice(prefixLength));

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

265segment.Span.CopyTo(span.Slice(totalWritten)); 271_currentSegment.AsSpan(0, _position).CopyTo(span.Slice(totalWritten));

src\Shared\ValueStringBuilder\ValueStringBuilder.cs (5)

143_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 163_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 164s.AsSpan().CopyTo(_chars.Slice(index)); 211s.AsSpan().CopyTo(_chars.Slice(pos)); 254value.CopyTo(_chars.Slice(_pos));

src\Shared\UrlDecoder\UrlDecoder.cs (1)

524if (!System.Text.Rune.TryCreate(currentDecodeBits, out var rune) || !rune.TryEncodeToUtf16(buffer.Slice(destinationIndex), out var charsWritten))

ArraySortHelper.cs (1)

921values = values.Slice(nanLeft);

CryptographicHashProvider.cs (3)

263BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[1]); 264BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[2]); 265BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[3]);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (2)

96bytes = bytes.Slice(bytesWrittenInThisIteration); 149bytes = bytes.Slice(bytesWrittenFromTempBuffer);

Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (2)

96bytes = bytes.Slice(bytesWrittenInThisIteration); 149bytes = bytes.Slice(bytesWrittenFromTempBuffer);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

DataFrameColumns\ArrowStringDataFrameColumn.cs (1)

213value.CopyTo(mutableDataBuffer.RawSpan.Slice(startIndex));

PrimitiveColumnContainer.BinaryOperations.cs (4)

136arithmetic.HandleOperation(operation, leftSpan.Slice(0, availableInRetSpan), rightSpan.Slice(0, availableInRetSpan), retSpan.Slice(retOffset)); 142arithmetic.HandleOperation(operation, leftSpan, rightSpan, retSpan.Slice(retOffset)); 178arithmetic.HandleOperation(operation, leftSpan.Slice(0, availableInRetSpan), right, retSpan.Slice(retOffset)); 184arithmetic.HandleOperation(operation, leftSpan, right, retSpan.Slice(retOffset));

src\RpmHeader.cs (3)

88BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(4), (int)entry.Type); 89BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(8), entry.Offset); 90BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(12), entry.Count);

SystemdNotifier.cs (1)

76state.AsSpan(1).CopyTo(buffer.Slice(1));

Logging\Internal\HttpHeadersRedactor.cs (1)

139index += redactor.Redact(currentItem, destinationMany.Slice(index));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

StringValues.cs (1)

239value.AsSpan().CopyTo(span.Slice(offset));

Logging\JustInTimeRedactor.cs (2)

141DiscriminatorSeparator.AsSpan().CopyTo(workBuffer.Slice(charsInWorkBuffer)); 144_discriminator.AsSpan().CopyTo(workBuffer.Slice(charsInWorkBuffer));

Utilities\BigArray.cs (3)

416_entries[maMax].AsSpan(0, miLim).CopyTo(dst.Slice(BlockSize - miMin)); 430_entries[major].AsSpan(0, BlockSize).CopyTo(dst.Slice(dstSoFar)); 437_entries[maMax].AsSpan(0, miLim).CopyTo(dst.Slice(dstSoFar));

Utilities\Stream.cs (1)

718destination = destination.Slice(numElementsToReadThisChunk);

Utilities\VBufferUtils.cs (4)

342editor.Indices.Slice(idx, sliceLength).CopyTo(editor.Indices.Slice(idx + 1)); 343editor.Values.Slice(idx, sliceLength).CopyTo(editor.Values.Slice(idx + 1)); 433editor.Values.Slice(lim, sliceLength).CopyTo(editor.Values.Slice(denseCount)); 434editor.Indices.Slice(lim, sliceLength).CopyTo(editor.Indices.Slice(denseCount));

UnitTests\TestVBuffer.cs (1)

1148aEditor.Indices.Slice(boundary).CopyTo(bEditor.Indices);

AlignedArray.cs (2)

115Items.AsSpan(_base, count).CopyTo(dst.Slice(index)); 123Items.AsSpan(start + _base, count).CopyTo(dst.Slice(index));

Deprecated\Vector\VBufferMathUtils.cs (3)

254values = editor.Values.Slice(offset); 310.CopyTo(indices.Slice(dLim + gapCount)); 312.CopyTo(values.Slice(dLim + gapCount));

VBuffer.cs (1)

294_values.AsSpan(0, Length).CopyTo(destination.Slice(destinationIndex));

Model\BPETokenizer.cs (7)

937buffer = buffer.Slice(1); 968buffer = buffer.Slice(sSpan.Length); 1019buffer = buffer.Slice(specialTokenSpan.Length); 1040Span<byte> current = utf8bytes.Slice(incompleteUtf8BytesInBufferIndex + incompleteUtf8BytesInBuffer); 1053if (!Helpers.ConvertUtf8ToUtf16(current, vocabBuffer.Slice(utf16CharsInBuffer), out int utf8BytesConsumed, out int utf16CharsWritten)) 1067buffer = buffer.Slice(completeCharsWritten); 1216s.CopyTo(buffer.Slice(ContinuingSubwordPrefix.Length));

Model\CodeGenTokenizer.cs (12)

351span.CopyTo(mutatedInputSpan.Slice(1)); 608span.CopyTo(mutatedInputSpan.Slice(1)); 827span.CopyTo(mutatedInputSpan.Slice(1)); 964span.CopyTo(mutatedInputSpan.Slice(1)); 1298bytesIndex += Helpers.GetUtf8Bytes(removePrefixSpace ? specialToken.AsSpan().Slice(1) : specialToken.AsSpan(), bytes.AsSpan().Slice(bytesIndex)); 1385buffer = buffer.Slice(BeginningOfSentenceToken.Length); 1408buffer = buffer.Slice(EndOfSentenceToken.Length); 1431buffer = buffer.Slice(UnknownToken.Length); 1458buffer = buffer.Slice(specialTokenSpan.Length); 1470Span<byte> current = utf8bytes.Slice(incompleteUtf8BytesInBufferIndex + incompleteUtf8BytesInBuffer); 1483if (!Helpers.ConvertUtf8ToUtf16(current, vocabBuffer.Slice(utf16CharsInBuffer), out int utf8BytesConsumed, out int utf16CharsWritten)) 1497buffer = buffer.Slice(completeCharsWritten);

Model\EnglishRobertaTokenizer.cs (1)

814buffer = buffer.Slice(s.Length);

Model\SentencePieceBaseModel.cs (6)

403buffer = destination.Slice(charsWritten); 469buffer = destination.Slice(charsWritten); 542buffer = destination.Slice(charsWritten); 558destination.Slice(suffixIndex + 1, charsWritten - suffixIndex - 1).CopyTo(destination.Slice(suffixIndex)); 672Span<char> buffer = destination.Slice(charsConsumed); 692buffer = buffer.Slice(tokenSpan.Length);

Model\SentencePieceUnigramModel.cs (9)

Model\TiktokenTokenizer.cs (4)

824tokenBytes.Span.CopyTo(utf8Bytes.Slice(utf8ByteCount)); 923buffer = buffer.Slice(incompleteCharsWritten); 943tokenBytes.Span.CopyTo(utf8Bytes.Slice(utf8BytesIncompleteIndex + utf8BytesIncompleteCount)); 956buffer = buffer.Slice(charsConsumed);

Model\WordPieceTokenizer.cs (6)

345subStr.CopyTo(buffer.Slice(ContinuingSubwordPrefix.Length)); 486subStr.CopyTo(buffer.Slice(ContinuingSubwordPrefix.Length)); 760buffer = buffer.Slice(token.Length - ContinuingSubwordPrefix.Length); 773token.AsSpan().CopyTo(buffer.Slice(1)); 774buffer = buffer.Slice(token.Length + 1); 785buffer = buffer.Slice(token.Length);

Normalizer\SentencePieceNormalizer.cs (3)

215token.AsSpan().CopyTo(span.Slice(bufferIndex)); 409_spaceSymbol.AsSpan().CopyTo(normalized.Slice(normalizedIndex)); 471_spaceSymbol.AsSpan().CopyTo(normalized.Slice(normalizedIndex));

Utils\BytePairEncoder.cs (2)

78byteIndicesAndRanks.Slice(j + 2).CopyTo(byteIndicesAndRanks.Slice(j + 1));

Utils\ValueStringBuilder.cs (9)

176newValue.AsSpan().CopyTo(_chars.Slice(index)); 180_chars.Slice(newIndex, _pos - newIndex).CopyTo(_chars.Slice(index + newLength)); 189_chars.Slice(newIndex, _pos - newIndex).CopyTo(_chars.Slice(index + newLength)); 213_chars.Slice(start + length, remaining).CopyTo(_chars.Slice(start)); 237_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 257_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 262.CopyTo(_chars.Slice(index)); 314.CopyTo(_chars.Slice(pos)); 357value.CopyTo(_chars.Slice(_pos));

AutoFormerV2\Anchors.cs (1)

62var imageShape = torch.tensor(image.shape.AsSpan().Slice(2).ToArray());

ContentDispositionHeaderValue.cs (2)

556var bufferContent = buffer.Slice(MimePrefix.Length); 561MimeSuffix.CopyTo(bufferContent.Slice(base64ContentLength));

HeaderUtilities.cs (1)

577dt.TryFormat(span.Slice(1), out _, "r", CultureInfo.InvariantCulture);

SetCookieHeaderValue.cs (2)

267span = span.Slice(charsWritten); 326span = span.Slice(other.Length);

MS\Internal\AppModel\ResourceContainer.cs (5)

215assemblyVersion.CopyTo(key.Slice(assemblyName.Length)); 224assemblyToken.CopyTo(key.Slice(assemblyName.Length + assemblyVersion.Length)); 229assemblyToken.CopyTo(key.Slice(assemblyName.Length)); 269assemblyVersion.CopyTo(key.Slice(assemblyName.Length)); 270assemblyToken.CopyTo(key.Slice(assemblyName.Length + assemblyVersion.Length));

System\Collections\BitArray.cs (1)

796span = span.Slice(4);

System\ComponentModel\Design\DesigntimeLicenseContextSerializer.cs (1)

100return _stream.Read(buffer.Slice(1)) + 1;

src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

10if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\ConsolePal.Unix.cs (1)

508TransferBytes(readBytes.Slice(readBytesPos), r);

System\IO\CachedConsoleStream.cs (1)

67cache.Append(charBuffer.Slice(lastNewLine + 1));

System\IO\StdInReader.cs (1)

133buffer = buffer.Slice(bytesUsed);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Diagnostics\Activity.GenerateRootId.netcoreapp.cs (2)

19bool formatted = Interlocked.Increment(ref s_currentRootId).TryFormat(result.Slice(1), out int charsWritten, "x"); 21s_uniqSuffix.AsSpan().CopyTo(result.Slice(1 + charsWritten));

System\Diagnostics\Metrics\TagList.netcore.cs (2)

201tags.Slice(index, _tagsCount - index).CopyTo(tags.Slice(index + 1)); 218tags.Slice(index + 1, _tagsCount - index - 1).CopyTo(tags.Slice(index));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Diagnostics\Process.Linux.cs (1)

297int n = fs.Read(buffer.Slice(bytesRead));

System\Formats\Asn1\AsnDecoder.BitString.cs (1)

512curDest = curDest.Slice(contents.Length);

System\Formats\Asn1\AsnDecoder.OctetString.cs (1)

377curDest = curDest.Slice(contents.Length);

System\Formats\Asn1\AsnDecoder.Oid.cs (1)

204writeSpan = writeSpan.Slice(SemanticByteCount);

System\Formats\Asn1\AsnWriter.GeneralizedTime.cs (1)

137fraction.CopyTo(baseSpan.Slice(IntegerPortionLength));

System\Formats\Cbor\Reader\CborReader.String.cs (4)

341target = target.Slice(l); 366destination = destination.Slice(l); 404target = target.Slice(charsWritten); 433destination = destination.Slice(l);

System\Formats\Cbor\Writer\CborWriter.Map.cs (1)

169s = s.Slice(keyValuePairEncoding.Length);

System\Formats\Cbor\Writer\CborWriter.String.cs (1)

216s = s.Slice(length);

System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (1)

153valuesToRead = valuesToRead.Slice(sliceSize);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Formats\Tar\TarHeader.Write.cs (5)

920bytesWritten += Encoding.UTF8.GetBytes(attribute, span.Slice(bytesWritten)); 922bytesWritten += Encoding.UTF8.GetBytes(value, span.Slice(bytesWritten)); 1093bytesToWrite.CopyTo(destination.Slice(copyPos)); 1151BinaryPrimitives.WriteInt64BigEndian(destination.Slice(Offset), value); 1176return WriteRightAlignedBytesAndGetChecksum(digits.Slice(i), destination);

System\IO\Compression\DeflateManaged\DeflateManagedStream.cs (1)

111buffer = buffer.Slice(bytesRead);

System\IO\Compression\DeflateManaged\InflaterManaged.cs (1)

127bytes = bytes.Slice(copied);

System\IO\Compression\ZipArchiveEntry.cs (3)

1278BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer.Slice(relativeCrc32Location), _crc32); 1279BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeCompressedSizeLocation), _compressedSize); 1280BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeUncompressedSizeLocation), _uncompressedSize);

System\IO\Compression\dec\BrotliDecoder.cs (1)

97destination = destination.Slice(destination.Length - (int)availableOutput);

System\IO\Compression\enc\BrotliEncoder.cs (1)

179destination = destination.Slice(destination.Length - (int)availableOutput);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\IO\MemoryMappedFiles\MemoryMappedFile.Unix.cs (1)

268guid.Slice(0, MaxNameLength - NamePrefix.Length).CopyTo(span.Slice(NamePrefix.Length));

System\IO\Packaging\InterleavedZipPackagePartStream.cs (1)

132int numBytesRead = pieceStream.Read(buffer.Slice(totalBytesRead));

System\Linq\SegmentedArrayBuilder.cs (3)

146sourceSlice.CopyTo(_currentSegment.Slice(_countInCurrentSegment)); 312destination = destination.Slice(firstSegment.Length); 322destination = destination.Slice(segment.Length);

System\Buffers\BuffersExtensions.cs (1)

90destination = destination.Slice(span.Length);

System\Buffers\SequenceReader.cs (1)

445nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));

System\Text\EncodingExtensions.cs (4)

126bytes = bytes.Slice(bytesWrittenJustNow); 206remainingBytes = remainingBytes.Slice(length); 317chars = chars.Slice(charsWrittenJustNow); 392span = span.Slice(length);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HPackEncoder.cs (19)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\Frames\Http3Frame.cs (1)

48buffer = buffer.Slice(1);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackEncoder.cs (13)

src\libraries\Common\src\System\Net\MultiArrayBuffer.cs (1)

397destination = destination.Slice(block.Length);

src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

10if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Net\Http\FormUrlEncodedContent.cs (1)

58while (!Uri.TryEscapeDataString(data, builder.RawChars.Slice(builder.Length), out charsWritten))

System\Net\Http\HttpContent.cs (1)

1058destination = destination.Slice(buffer.Length);

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (1)

308buffer = buffer.Slice(bytesRead.Length);

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (9)

1129Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int))); 1308BinaryPrimitives.WriteInt64BigEndian(span.Slice(FrameHeader.Size), state.pingContent); 1320BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), (int)s.errorCode); 1673span = span.Slice(FrameHeader.Size); 1675span = span.Slice(current.Length); 1685span = span.Slice(FrameHeader.Size); 1687span = span.Slice(current.Length); 1778BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), s.amount); 1949BinaryPrimitives.WriteInt32BigEndian(destination.Slice(5), streamId);

System\Net\Http\SocketsHttpHandler\Http3Connection.cs (1)

518int integerLength = VariableLengthIntegerHelper.WriteInteger(buffer.Slice(4), settings.MaxResponseHeadersByteLength);

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (2)

1176buffer = buffer.Slice(copyLen); 1200buffer = buffer.Slice(bytesRead);

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (5)

410bool success = ((uint)requestUri.Port).TryFormat(buffer.Slice(1), out int bytesWritten); 1107ReadOnlySpan<byte> reasonBytes = line.Slice(MinStatusLineLength + 1); 1180Span<byte> valueIterator = buffer.Slice(valueStartIdx); 1212buffer = buffer.Slice(buffer.Length - valueIterator.Length + spIdx); 1221valueIterator = valueIterator.Slice(spIdx + 1);

System\Net\HttpListener.cs (3)

191":80".CopyTo(destination.Slice(indexOfNextCopy)); 196":443".CopyTo(destination.Slice(indexOfNextCopy)); 200state.uriPrefix.AsSpan(state.j).CopyTo(destination.Slice(indexOfNextCopy));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Net\BufferedReadStream.cs (1)

45return read + BaseStream.Read(buffer.Slice(read));

src\libraries\Common\src\System\Net\SocketAddress.cs (2)

179bool formatted = Size.TryFormat(result.Slice(length), out int charsWritten); 194formatted = buffer[i].TryFormat(result.Slice(length), out charsWritten);

System\Net\IPAddress.cs (1)

369BinaryPrimitives.WriteUInt16BigEndian(destination.Slice(i * 2), numbers[i]);

System\Net\IPAddressParser.cs (6)

156pos += FormatByte(address >> 16, addressString.Slice(pos)); 158pos += FormatByte(address >> 8, addressString.Slice(pos)); 160pos += FormatByte(address, addressString.Slice(pos)); 209pos += FormatIPv4Address(ExtractIPv4Address(address), destination.Slice(pos)); 232Span<TChar> used = chars.Slice(bytesPos); 233used.CopyTo(destination.Slice(pos));

src\libraries\Common\src\System\Net\MultiArrayBuffer.cs (1)

397destination = destination.Slice(block.Length);

src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (3)

117clientRandomUtf8.CopyTo(line.Slice(labelUtf8.Length + 1)); 120HexEncode(secret, line.Slice(labelUtf8.Length + 1 + clientRandomUtf8.Length + 1)); 130HexConverter.ToBytesBuffer(source[i], destination.Slice(i * 2));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (1)

764clientList = clientList.Slice(1 + length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs (1)

238protocol.Protocol.Span.CopyTo(buffer.Slice(offset));

src\libraries\Common\src\System\Net\Security\MD4.cs (3)

116input.Slice(0, partLen).CopyTo(buffer.Slice(index)); 132input.Slice(i).CopyTo(buffer.Slice(index)); 177BinaryPrimitives.WriteUInt32LittleEndian(output.Slice(j), input[i]);

src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (3)

117clientRandomUtf8.CopyTo(line.Slice(labelUtf8.Length + 1)); 120HexEncode(secret, line.Slice(labelUtf8.Length + 1 + clientRandomUtf8.Length + 1)); 130HexConverter.ToBytesBuffer(source[i], destination.Slice(i * 2));

src\libraries\Common\src\System\Text\UrlBase64Encoding.cs (2)

49dest = dest.Slice(pos); 72dest = dest.Slice(3);

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (11)

343BinaryPrimitives.WriteInt16LittleEndian(span.Slice(2), (short)length); 344BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), offset); 350data.CopyTo(payload.Slice(offset)); 356int dataLength = Encoding.Unicode.GetBytes(data, payload.Slice(offset)); 420hmac.AppendData(blob.Slice(DigestLength)); 442BinaryPrimitives.WriteInt32LittleEndian(prefix.Slice(sizeof(uint) * 4), cbtDataSize); 721BinaryPrimitives.WriteUInt32LittleEndian(signature.Slice(12), sequenceNumber); 823_serverSeal.Transform(input.Slice(SignatureLength), input.Slice(SignatureLength)); 824if (!VerifyMIC(input.Slice(SignatureLength), input.Slice(0, SignatureLength))) 826CryptographicOperations.ZeroMemory(input.Slice(SignatureLength));

System\Net\Security\SslStream.cs (1)

98public ReadOnlySpan<byte> EncryptedReadOnlySpan => _buffer.ActiveSpan.Slice(_decryptedLength + _decryptedPadding);

System\Net\WebSockets\Compression\WebSocketDeflater.cs (1)

100written += UnsafeFlush(output.Slice(written), out needsMoreOutput);

System\Net\WebSockets\ManagedWebSocket.cs (3)

1107closeStatus = (WebSocketCloseStatus)BinaryPrimitives.ReadUInt16BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset)); 1322header.PayloadLength = BinaryPrimitives.ReadUInt16BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1328header.PayloadLength = BinaryPrimitives.ReadInt64BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset));

System\Net\WebSockets\WebSocketHandle.Managed.cs (1)

499wsServerGuidBytes.CopyTo(bytes.Slice(encodedSecKeyLength));

System\Buffers\NIndex.cs (1)

179bool formatted = ((uint)Value).TryFormat(span.Slice(1), out int charsWritten);

System\Buffers\NRange.cs (2)

74bool formatted = ((uint)Start.Value).TryFormat(span.Slice(pos), out int charsWritten); 85formatted = ((uint)End.Value).TryFormat(span.Slice(pos), out charsWritten);

System\Numerics\Tensors\netcore\Tensor.cs (5)

251dstSpan = dstSpan.Slice((int)tensors[i].FlattenedLength); 273dstSpan = dstSpan.Slice((int)slice.FlattenedLength); 2455tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2492tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2529tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));

src\libraries\Common\src\System\HexConverter.cs (1)

351bool fallbackResult = TryDecodeFromUtf16_Scalar(chars.Slice((int)offset), bytes.Slice((int)(offset / 2)), out int fallbackProcessed);

src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

10if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (3)

269bytes = bytes.Slice(bytesWritten); 309bytes = bytes.Slice(localWritten); 541bytes = bytes.Slice(localWritten);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs (1)

298bytes = bytes.Slice(localWritten);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs (1)

178source.Slice(startIndexOfDigitsAfterDecimalToCopy, numDigitsAfterDecimalToCopy).CopyTo(digits.Slice(dstIndex));

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (3)

303keys = keys.Slice(nanLeft); 854keys = keys.Slice(nanLeft); 855values = values.Slice(nanLeft);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

88source.CopyTo(_span.Slice(_pos));

src\libraries\System.Private.CoreLib\src\System\Convert.cs (3)

2310return chars.Slice(i).ToString(); 2686bytes = bytes.Slice(bytesWrittenInThisIteration); 2739bytes = bytes.Slice(bytesWrittenFromTempBuffer);

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (3)

633BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(4), (int)d.Mid); 634BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(8), (int)d.High); 635BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(12), d._flags);

src\libraries\System.Private.CoreLib\src\System\Enum.cs (1)

2116Span<char> afterSeparator = destination.Slice(2); // done before copying ", " to eliminate those two bounds checks

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Invariant.cs (4)

52sortKey = sortKey.Slice(sizeof(ushort)); 71BinaryPrimitives.WriteUInt16BigEndian(tmp.Slice(sizeof(ushort)), lr); 72sortKey = sortKey.Slice(2 * sizeof(ushort)); 80sortKey = sortKey.Slice(sizeof(ushort));

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (2)

70if (!extension.IsEmpty && extension.TryCopyTo(buffer.Slice(bufferIndex))) 92name.AsSpan(collationIndex, length).CopyTo(buffer.Slice(bufferIndex));

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (1)

5900Value.Slice(i + 1).CopyTo(result.Slice(1));

src\libraries\System.Private.CoreLib\src\System\Globalization\InvariantModeCasing.cs (2)

60ToLower(src.Slice(i), destination.Slice(i)); 106ToUpper(src.Slice(i), destination.Slice(i));

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (1)

334ChangeCaseCommon<TConversion>(source.AsSpan((int)currIdx), resultSpan.Slice((int)currIdx));

src\libraries\System.Private.CoreLib\src\System\Index.cs (1)

159bool formatted = ((uint)Value).TryFormat(span.Slice(1), out int charsWritten);

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (1)

383buffer = buffer.Slice(charsRead);

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (1)

360int actualByteCount = _encoding.GetBytes(value, buffer.Slice(1));

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (1)

546destination = destination.Slice(bytesFromBuffer);

src\libraries\System.Private.CoreLib\src\System\IO\Directory.Unix.cs (1)

40pos += Encoding.UTF8.GetBytes(prefix, path.Slice(pos));

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (2)

1488int n = RandomAccess.ReadAtOffset(sfh, buffer.Slice(bytesRead), bytesRead); 1543int encoded = encoder.GetBytes(toEncode, bytes.Slice(preambleSize), flush: contents.IsEmpty);

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (1)

645path3.CopyTo(destination.Slice(charsWritten));

src\libraries\System.Private.CoreLib\src\System\IO\Path.Unix.cs (1)

108fileTemplate.CopyTo(path.Slice(pos));

src\libraries\System.Private.CoreLib\src\System\IO\RandomAccess.Unix.cs (1)

191Span<Interop.Sys.IOVector> left = vectors.Slice(buffersOffset);

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (1)

237: _strategy.Read(destination.Slice(n));

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (1)

893int read = Read(buffer.Slice(totalRead));

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (6)

379n = ReadBuffer(buffer.Slice(charsRead), out readToUserBuffer); 391new Span<char>(_charBuffer, _charPos, n).CopyTo(buffer.Slice(charsRead)); 452i = ReadSpan(buffer.Slice(n)); 1151n = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false); 1215n = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false); 1239new Span<char>(_charBuffer, _charPos, n).CopyTo(buffer.Span.Slice(charsRead));

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (12)

4803span = span.Slice(pos + 1); 4852span = span.Slice(pos + 1); 6056if (value.TryCopyTo(_destination.Slice(_pos))) 6099if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten)) 6110if (((ISpanFormattable)value).TryFormat(_destination.Slice(_pos), out int charsWritten, default, _provider)) // constrained call avoiding boxing for value types 6155if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten, format)) 6166if (((ISpanFormattable)value).TryFormat(_destination.Slice(_pos), out int charsWritten, format, _provider)) // constrained call avoiding boxing for value types 6223if (value.TryCopyTo(_destination.Slice(_pos))) 6259value.CopyTo(_destination.Slice(_pos)); 6268value.CopyTo(_destination.Slice(_pos)); 6294if (value.TryCopyTo(_destination.Slice(_pos))) 6383_destination.Slice(startingPos, charsWritten).CopyTo(_destination.Slice(startingPos + paddingNeeded));

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Trim.cs (3)

87=> span.Slice(ClampStart(span, trimElement)); 368return span.Slice(ClampStart(span, trimElements)); 826=> span.Slice(ClampStart(span));

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (1)

349Span<byte> utf8Bytes = MemoryMarshal.AsBytes(dest).Slice(dest.Length * 2 - state.byteCount);

src\libraries\System.Private.CoreLib\src\System\Random.cs (2)

238destination = destination.Slice(randomBytes.Length); 276destination = destination.Slice(i);

src\libraries\System.Private.CoreLib\src\System\Random.Xoshiro256StarStarImpl.cs (1)

153buffer = buffer.Slice(sizeof(ulong));

src\libraries\System.Private.CoreLib\src\System\Range.cs (2)

78bool formatted = ((uint)Start.Value).TryFormat(span.Slice(pos), out int charsWritten); 89formatted = ((uint)End.Value).TryFormat(span.Slice(pos), out charsWritten);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\DefaultInterpolatedStringHandler.cs (13)

src\libraries\System.Private.CoreLib\src\System\Security\SecureString.cs (2)

194span.Slice(index, _decryptedLength - index).CopyTo(span.Slice(index + 1)); 239span.Slice(index + 1, _decryptedLength - (index + 1)).CopyTo(span.Slice(index));

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (3)

1433this.AsSpan(thisIdx, count).CopyTo(dstSpan.Slice(dstIdx)); 1439newValue.CopyTo(dstSpan.Slice(dstIdx)); 1445this.AsSpan(thisIdx).CopyTo(dstSpan.Slice(dstIdx));

src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (4)

403Ascii.FromUtf16(chars.Slice(idx), bytes.Slice(idx), out int charsConsumed); 414bytes = bytes.Slice(numElementsToConvert); 692Ascii.ToUtf16(bytes.Slice(idx), chars.Slice(idx), out int bytesConsumed); 702chars = chars.Slice(numElementsToConvert);

src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (1)

276chars = chars.Slice(charsWrittenJustNow);

src\libraries\System.Private.CoreLib\src\System\Text\EncoderFallback.cs (1)

205bytes = bytes.Slice(bytesWrittenJustNow);

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (12)

500bytes: new Span<byte>(pOriginalBytes, originalByteCount).Slice(bytesWrittenSoFar), 532Span<byte> bytes = new Span<byte>(pOriginalBytes, originalByteCount).Slice(bytesWrittenSoFar); 537bytes = bytes.Slice(bytesWrittenJustNow); 556bytes = bytes.Slice(bytesWrittenJustNow); 640bytes = bytes.Slice(bytesWrittenThisIteration); 662bytes = bytes.Slice(bytesWrittenThisIteration); 1096chars: new Span<char>(pOriginalChars, originalCharCount).Slice(charsWrittenSoFar), 1134Span<char> chars = new Span<char>(pOriginalChars, originalCharCount).Slice(charsWrittenSoFar); 1143chars = chars.Slice(charsWrittenJustNow); 1159chars = chars.Slice(charsWrittenJustNow); 1244chars = chars.Slice(charsWrittenThisIteration); 1262chars = chars.Slice(charsWrittenThisIteration);

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (2)

881CopyTo(sourceIndex, new Span<char>(destination).Slice(destinationIndex), count); 921new ReadOnlySpan<char>(chunk.m_ChunkChars, chunkStartIndex, chunkCount).CopyTo(destination.Slice(curDestIndex));

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (1)

520decodedChars = decodedChars.Slice(charsConsumed);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (12)

93destination = destination.Slice((int)(pOutputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)))); 104destination = destination.Slice(3); 184destination = destination.Slice((int)(pOutputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)))); 193destination = destination.Slice(1); 284destination = destination.Slice((int)(pOutputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)))); 300destination = destination.Slice(bytesConsumedJustNow); 402Span<byte> dest = _destination.Slice(_pos); 446if (((IUtf8SpanFormattable)value).TryFormat(_destination.Slice(_pos), out int bytesWritten, format: default, _provider)) 499if (((IUtf8SpanFormattable)value).TryFormat(_destination.Slice(_pos), out int bytesWritten, format, _provider)) 564if (Encoding.UTF8.TryGetBytes(value, _destination.Slice(_pos), out int bytesWritten)) 592if (utf8Value.TryCopyTo(_destination.Slice(_pos))) 791_destination.Slice(startingPos, bytesWritten).CopyTo(_destination.Slice(startingPos + paddingNeeded));

src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (1)

652chars = chars.Slice(charsWritten);

src\libraries\System.Private.CoreLib\src\System\Text\ValueStringBuilder.AppendFormat.cs (1)

216spanFormattableArg.TryFormat(_chars.Slice(_pos), out int charsWritten, itemFormatSpan, provider))

src\libraries\System.Private.CoreLib\src\System\Version.cs (2)

238destination = destination.Slice(1); 262destination = destination.Slice(valueCharsWritten);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

88source.CopyTo(_span.Slice(_pos));

System\Xml\XmlBinaryWriter.cs (10)

System\Xml\XmlConverter.cs (1)

1102foreach (char c in chars.Slice(count + 1))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\IPv4AddressHelper.cs (2)

25numbers[i].TryFormat(stackSpace.Slice(totalChars), out charsWritten); 30numbers[3].TryFormat(stackSpace.Slice(totalChars), out charsWritten);

System\IPv6AddressHelper.cs (5)

37success = (numbers[i] >> 8).TryFormat(stackSpace.Slice(pos), out charsWritten); 42success = (numbers[i] & 0xFF).TryFormat(stackSpace.Slice(pos), out charsWritten); 47success = (numbers[i + 1] >> 8).TryFormat(stackSpace.Slice(pos), out charsWritten); 52success = (numbers[i + 1] & 0xFF).TryFormat(stackSpace.Slice(pos), out charsWritten); 81success = numbers[i].TryFormat(stackSpace.Slice(pos), out charsWritten, format: "x");

System\Uri.cs (6)

4610span.Slice(lastSlash).CopyTo(span.Slice(i + 1)); 4638span.Slice(lastSlash + 1).CopyTo(span.Slice(i + 1)); 4653span.Slice(lastSlash).CopyTo(span); 4663span.Slice(dotCount).CopyTo(span);

System\UriExt.cs (2)

656vsb = new ValueStringBuilder(destination.Slice(indexOfFirstToUnescape)); 674vsb.AsSpan().CopyTo(destination.Slice(indexOfFirstToUnescape));

System\UriHelper.cs (2)

149vsb = new ValueStringBuilder(destination.Slice(indexOfFirstToEscape)); 163vsb.AsSpan().CopyTo(destination.Slice(indexOfFirstToEscape));

src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

10if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Xml\Core\XmlUtf8RawTextWriter.cs (1)

117bom.CopyTo(new Span<byte>(_bufBytes).Slice(1));

System\Xml\Dom\XmlEntityReference.cs (1)

197state.systemId.AsSpan().Replace(dest.Slice(state.buf.Length), '\\', '/');

src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

10if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

88source.CopyTo(_span.Slice(_pos));

System\Number.BigInteger.cs (1)

331ReadOnlySpan<byte> fracDigitsSpan = number.Digits.Slice(intDigits.Length);

System\Numerics\BigIntegerCalculator.AddSub.cs (1)

16source.Slice(start).CopyTo(dest.Slice(start));

System\Numerics\BigIntegerCalculator.DivRem.cs (22)

216|| (CompareActual(left.Slice(left.Length - right.Length), right) < 0 && quotient.Length == left.Length - right.Length)); 271uint carry = SubtractDivisor(left.Slice(n), right, digit); 277carry = AddDivisor(left.Slice(n), right); 409Span<uint> dst = bits.Slice(sigmaDigit); 411dst.Slice(src.Length).Clear(); 446a.Slice((t - 2) * n).CopyTo(z); 447z.Slice(a.Length - (t - 2) * n).Clear(); 449Span<uint> quotientUpper = quotient.Slice((t - 2) * n); 459Debug.Assert(!q.Slice(quotientUpper.Length).ContainsAnyExcept(0u)); 468quotientUpper.Slice(n).Clear(); 474r.Slice(0, n).CopyTo(z.Slice(n)); 489Span<uint> rt = r.Slice(sigmaDigit); 490remainder.Slice(rt.Length).Clear(); 536remainder.Slice(left.Length).Clear(); 553quotient.Slice(left.Length).Clear(); 559remainder.Slice(1).Clear(); 573quotient.Slice(quotientLength).Clear(); 578remainder.Slice(r1.Length).Clear(); 583Debug.Assert(!r1.Slice(remainder.Length).ContainsAnyExcept(0u)); 614BurnikelZieglerD3n2n(left.Slice(right.Length), left.Slice(halfN, halfN), right, quotient.Slice(halfN), r1); 637Span<uint> r1 = remainder.Slice(n); 659b2.CopyTo(d.Slice(n));

System\Numerics\BigIntegerCalculator.FastReducer.cs (1)

62value = value.Slice(length);

System\Numerics\BigIntegerCalculator.GcdInv.cs (2)

210buffer.Slice(2).Clear(); 311bits.Slice(maxLength).Clear();

System\Numerics\BigIntegerCalculator.PowMod.cs (8)

36valueCopy.Slice(value.Length).Clear(); 40bits.Slice(result.Length).Clear(); 226valueCopy.Slice(value.Length).Clear(); 275valueCopy.Slice(value.Length).Clear(); 320bits.Slice(result.Length).Clear(); 358bits.Slice(result.Length).Clear(); 380bits.Slice(result.Length).Clear(); 418bits.Slice(result.Length).Clear();

System\Numerics\BigIntegerCalculator.SquMul.cs (5)

90Span<uint> bitsHigh = bits.Slice(n2); 124AddSelf(bits.Slice(n), core); 218Span<uint> bitsHigh = bits.Slice(n); 270Span<uint> bitsHigh = bits.Slice(n + n); 323AddSelf(bits.Slice(n), core.Slice(0, ActualLength(core)));

System\Numerics\Complex.cs (5)

2216m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider) : 2217m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out realChars, format, provider)) 2220destination = destination.Slice(1 + realChars); // + 1 for < 2227m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider) : 2228m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out imaginaryChars, format, provider))

System\Numerics\NumericsHelpers.cs (1)

116d = d.Slice(1);

src\libraries\Common\src\System\Security\Cryptography\EccKeyFormatHelper.cs (4)

781ecParameters.Curve.G.X.CopyTo(basePointBytes.Slice(1)); 782ecParameters.Curve.G.Y.CopyTo(basePointBytes.Slice(1 + ecParameters.Curve.G.X.Length)); 809ecParameters.Q.X.CopyTo(publicKeyBytes.Slice(1)); 810ecParameters.Q.Y.CopyTo(publicKeyBytes.Slice(1 + ecParameters.Q.X!.Length));

src\libraries\Common\src\System\Security\Cryptography\ECDiffieHellmanDerivation.cs (1)

226retSpan = retSpan.Slice(len);

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (1)

958tmpEndSpan.CopyTo(destination.Slice(writeOffset));

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (4)

207destination = destination.Slice(hashBuf.Length); 259destination = destination.Slice(bytes.Length); 287destination = destination.Slice(count); 290destination = destination.Slice(nullTerminator.Length);

src\libraries\Common\src\System\Security\Cryptography\RsaPaddingProcessor.cs (8)

134Span<byte> mInEM = destination.Slice(destination.Length - source.Length); 284digestInfoPrefix.CopyTo(destination.Slice(paddingLength + 3)); 285source.CopyTo(destination.Slice(paddingLength + 3 + digestInfoPrefix.Length)); 317Span<byte> db = destination.Slice(1 + hLen); 325Span<byte> mDest = db.Slice(db.Length - source.Length); 450salt.CopyTo(db.Slice(psLen + 1)); 557ReadOnlySpan<byte> salt = dbMask.Slice(dbMask.Length - sLen); 610writePtr = writePtr.Slice(bytesWritten);

src\libraries\Common\src\System\Security\Cryptography\X509Certificates\X509CertificateLoader.cs (1)

630int localRead = stream.ReadAtLeast(earlyBuf.Slice(read), toRead);

src\libraries\Common\src\System\Text\UrlBase64Encoding.cs (2)

49dest = dest.Slice(pos); 72dest = dest.Slice(3);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Security\Cryptography\AesCcm.OpenSsl.cs (1)

69ciphertext.Slice(ciphertextBytesWritten),

System\Security\Cryptography\AesGcm.OpenSsl.cs (2)

61ciphertext.Slice(ciphertextBytesWritten), 108plaintext.Slice(plaintextBytesWritten),

System\Security\Cryptography\AsymmetricAlgorithmHelpers.Der.cs (1)

211signatureField.CopyTo(response.Slice(writeOffset));

System\Security\Cryptography\Base64Transforms.cs (3)

253inputBuffer.Slice(0, whitespaceIndex).CopyTo(transformBuffer.Slice(index)); 265inputBuffer.CopyTo(transformBuffer.Slice(index)); 301transformBuffer.Slice(transformBuffer.Length - _inputIndex).CopyTo(_inputBuffer);

System\Security\Cryptography\ChaCha20Poly1305.OpenSsl.cs (2)

58ciphertext.Slice(ciphertextBytesWritten), 105plaintext.Slice(plaintextBytesWritten),

System\Security\Cryptography\HKDFManagedImplementation.cs (1)

62remainingOutput = remainingOutput.Slice(hashLength);

System\Security\Cryptography\OpenSslAsnFormatter.cs (1)

76current = current.Slice(read);

System\Security\Cryptography\OpenSslCipherLite.cs (1)

86Span<byte> outputSpan = output.Slice(written);

System\Security\Cryptography\PemEncoding.cs (5)

237label.CopyTo(destination.Slice(T.PostEBPrefix.Length)); 238T.Ending.CopyTo(destination.Slice(T.PostEBPrefix.Length + label.Length)); 594str.CopyTo(dest.Slice(offset)); 753bool success = Convert.TryToBase64Chars(bytes, destination.Slice(offset), out int base64Written); 782destination.Slice(offset),

System\Security\Cryptography\RandomNumberGenerator.cs (5)

329destination = destination.Slice(1); 330remainingRandom = remainingRandom.Slice(1); 344destination = destination.Slice(remainingRandom.Length * 2); 385destination = destination.Slice(randomBytes.Length); 423destination = destination.Slice(i);

System\Security\Cryptography\RandomNumberGeneratorImplementation.cs (5)

76Span<byte> remainder = data.Slice(first0Byte + 1); 84remainder.CopyTo(data.Slice(first0Byte)); 89remainder.Slice(0, next0Byte).CopyTo(data.Slice(first0Byte)); 92remainder = remainder.Slice(next0Byte + 1); 97data = data.Slice(data.Length - zerosFound);

System\Security\Cryptography\Rfc2898DeriveBytes.cs (2)

215bufferSpan.Slice(0, _blockSize).CopyTo(destination.Slice(offset)); 220bufferSpan.Slice(0, remainder).CopyTo(destination.Slice(offset));

System\Security\Cryptography\SP800108HmacCounterKdfImplementationManaged.cs (1)

63destination = destination.Slice(written);

System\Security\Cryptography\UniversalCryptoDecryptor.cs (2)

45outputBuffer = outputBuffer.Slice(depadDecryptLength); 99inputBuffer.CopyTo(ciphertext.Slice(_heldoverCipher.Length));

System\Security\Cryptography\UniversalCryptoOneShot.cs (2)

53CryptographicOperations.ZeroMemory(transformBuffer.Slice(bytesWritten)); 152depaddedFinalTransform.CopyTo(output.Slice(writtenToOutput));

System\Security\Cryptography\X509Certificates\OpenSslX509CertificateReader.cs (1)

810current = current.Slice(read);

System\Security\Cryptography\X509Certificates\X500NameEncoder.ManagedDecode.cs (1)

191HexConverter.EncodeToUtf16(state.Span, buff.Slice(1));

System\Security\Cryptography\X509Certificates\X509Certificate2Collection.cs (2)

629buffer = buffer.Slice(certWritten); 644buffer = buffer.Slice(1);

System\Security\Cryptography\X509Certificates\X509SubjectKeyIdentifierExtension.cs (1)

180byte[] shortSha1 = sha1.Slice(SHA1.HashSizeInBytes - 8).ToArray();

System\Security\Cryptography\XmlKeyHelper.cs (1)

119WriteCryptoBinary(name, valBuf.Slice(start), builder);

System\Security\Cryptography\Cose\CoseHelpers.cs (3)

62BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), (ushort)value); 70BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), (uint)value); 78BinaryPrimitives.WriteUInt64BigEndian(buffer.Slice(1), value);

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (3)

379CoseHelpers.WriteHeaderMap(buffer.Slice(protectedMapBytesWritten), writer, unprotectedHeaders, isProtected: false, null); 383WriteCoseSignaturesArray(writer, signer, buffer.Slice(protectedMapBytesWritten), buffer.Slice(0, protectedMapBytesWritten), associatedData, content, contentStream); 451CoseHelpers.WriteHeaderMap(buffer.Slice(signProtectedBytesWritten), writer, signer.UnprotectedHeaders, isProtected: false, null);

System\Security\Cryptography\Cose\CoseSign1Message.cs (1)

315CoseHelpers.WriteHeaderMap(buffer.Slice(protectedMapBytesWritten), writer, signer._unprotectedHeaders, isProtected: false, null);

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (1)

958tmpEndSpan.CopyTo(destination.Slice(writeOffset));

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (4)

207destination = destination.Slice(hashBuf.Length); 259destination = destination.Slice(bytes.Length); 287destination = destination.Slice(count); 290destination = destination.Slice(nullTerminator.Length);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (1)

79thisAllowedCharactersBitmap = thisAllowedCharactersBitmap.Slice(Vector<uint>.Count);

System\Text\Encodings\Web\OptimizedInboxTextEncoder.Ascii.cs (1)

48tempBuffer.Slice(encodedCharCount).Clear();

System\Text\Encodings\Web\OptimizedInboxTextEncoder.cs (5)

210if (!scalarValue.TryEncodeToUtf16(destination.Slice(dstIdx), out int utf16CodeUnitCount)) 224int charsWrittenJustNow = _scalarEscaper.EncodeUtf16(scalarValue, destination.Slice(dstIdx)); 277if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination.Slice(dstIdx), preescapedEntry)) 318if (!scalarValue.TryEncodeToUtf8(destination.Slice(dstIdx), out int utf8CodeUnitCount)) 331int bytesWrittenJustNow = _scalarEscaper.EncodeUtf8(scalarValue, destination.Slice(dstIdx));

System\Text\Encodings\Web\TextEncoder.cs (7)

87utf16ScratchBuffer = utf16ScratchBuffer.Slice(scalarUtf16CodeUnitCount); 315OperationStatus status = EncodeUtf8Core(utf8Source.Slice(idxOfFirstByteToEncode), utf8Destination.Slice(idxOfFirstByteToEncode), out int innerBytesConsumed, out int innerBytesWritten, isFinalBlock); 362utf8Destination = utf8Destination.Slice(dstIdxTemp); 374utf8Destination = utf8Destination.Slice(bytesWrittenJustNow); 445OperationStatus status = EncodeCore(source.Slice(idxOfFirstCharToEncode), destination.Slice(idxOfFirstCharToEncode), out int innerCharsConsumed, out int innerCharsWritten, isFinalBlock); 478destination = destination.Slice(charsConsumedJustNow); // reflecting input directly to the output, same # of chars written 490destination = destination.Slice(charsWrittenJustNow);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Text\Json\Document\JsonDocument.MetadataDb.cs (1)

319DbRow row = MemoryMarshal.Read<DbRow>(data.Slice(i));

System\Text\Json\Reader\JsonReaderHelper.Unescaping.cs (2)

576bool success = rune.TryEncodeToUtf8(destination.Slice(written), out int bytesWritten); 622remaining.Slice(0, nextUnescapedSegmentLength).CopyTo(destination.Slice(written));

System\Text\Json\Reader\Utf8JsonReader.MultiSegment.cs (2)

589span.Slice(0, amountToWrite).CopyTo(readSoFar.Slice(written)); 609span.Slice(0, amountToWrite).CopyTo(readSoFar.Slice(written));

System\Text\Json\Serialization\Converters\Value\HalfConverter.cs (1)

119Format(buffer.Slice(1), value, out int written);

System\Text\Json\Serialization\Converters\Value\Int128Converter.cs (1)

97Format(buffer.Slice(1), value, out int written);

System\Text\Json\Serialization\Converters\Value\UInt128Converter.cs (1)

97Format(buffer.Slice(1), value, out int written);

System\Text\Json\Writer\JsonWriterHelper.Escaping.cs (6)

120destination = destination.Slice(indexOfFirstByteToEscape); 150destination = destination.Slice(written); 193bool result = Utf8Formatter.TryFormat(value, destination.Slice(written), out int bytesWritten, format: s_hexStandardFormat); 238destination = destination.Slice(indexOfFirstByteToEscape); 268destination = destination.Slice(written); 314intChar.TryFormat(destination.Slice(written), out int charsWritten, HexFormatString);

System\Text\Json\Writer\Utf8JsonWriter.cs (2)

685WriteIndentation(output.Slice(BytesPending), indent); 1119WriteIndentation(output.Slice(BytesPending), indent);

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Bytes.cs (4)

264escapedPropertyName.CopyTo(output.Slice(BytesPending)); 309WriteIndentation(output.Slice(BytesPending), indent); 359WriteIndentation(output.Slice(BytesPending), indent); 364escapedPropertyName.CopyTo(output.Slice(BytesPending));

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.DateTime.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.DateTimeOffset.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Decimal.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Double.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Float.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Guid.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Helpers.cs (5)

95escapedPropertyName.CopyTo(output.Slice(BytesPending)); 132WriteIndentation(output.Slice(BytesPending), indent); 137escapedPropertyName.CopyTo(output.Slice(BytesPending)); 205WriteIndentation(output.Slice(BytesPending), indent); 222OperationStatus status = JsonWriterHelper.ToUtf8(escapedPropertyName, output.Slice(BytesPending), out int written);

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Literal.cs (10)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.SignedNumber.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.String.cs (17)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.UnsignedNumber.cs (8)

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Bytes.cs (1)

127WriteIndentation(output.Slice(BytesPending), indent);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Comment.cs (6)

96OperationStatus status = JsonWriterHelper.ToUtf8(value, output.Slice(BytesPending), out int written); 130WriteIndentation(output.Slice(BytesPending), indent); 137OperationStatus status = JsonWriterHelper.ToUtf8(value, output.Slice(BytesPending), out int written); 209utf8Value.CopyTo(output.Slice(BytesPending)); 237WriteIndentation(output.Slice(BytesPending), indent); 244utf8Value.CopyTo(output.Slice(BytesPending));

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.DateTime.cs (3)

60JsonWriterHelper.WriteDateTimeTrimmed(output.Slice(BytesPending), value, out int bytesWritten); 92WriteIndentation(output.Slice(BytesPending), indent); 98JsonWriterHelper.WriteDateTimeTrimmed(output.Slice(BytesPending), value, out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.DateTimeOffset.cs (3)

61JsonWriterHelper.WriteDateTimeOffsetTrimmed(output.Slice(BytesPending), value, out int bytesWritten); 93WriteIndentation(output.Slice(BytesPending), indent); 99JsonWriterHelper.WriteDateTimeOffsetTrimmed(output.Slice(BytesPending), value, out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Decimal.cs (3)

58bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten); 88WriteIndentation(output.Slice(BytesPending), indent); 92bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Double.cs (3)

62bool result = TryFormatDouble(value, output.Slice(BytesPending), out int bytesWritten); 92WriteIndentation(output.Slice(BytesPending), indent); 96bool result = TryFormatDouble(value, output.Slice(BytesPending), out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Float.cs (3)

62bool result = TryFormatSingle(value, output.Slice(BytesPending), out int bytesWritten); 92WriteIndentation(output.Slice(BytesPending), indent); 96bool result = TryFormatSingle(value, output.Slice(BytesPending), out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.FormattedNumber.cs (3)

63utf8Value.CopyTo(output.Slice(BytesPending)); 94WriteIndentation(output.Slice(BytesPending), indent); 98utf8Value.CopyTo(output.Slice(BytesPending));

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Guid.cs (3)

60bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten); 93WriteIndentation(output.Slice(BytesPending), indent); 99bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Helpers.cs (1)

130Span<byte> destination = output.Slice(BytesPending);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Literal.cs (3)

82utf8Value.CopyTo(output.Slice(BytesPending)); 112WriteIndentation(output.Slice(BytesPending), indent); 116utf8Value.CopyTo(output.Slice(BytesPending));

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Raw.cs (2)

187utf8Json.CopyTo(output.Slice(BytesPending)); 275utf8Json.CopyTo(output.Slice(BytesPending));

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.SignedNumber.cs (3)

71bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten); 101WriteIndentation(output.Slice(BytesPending), indent); 105bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.String.cs (4)

172WriteIndentation(output.Slice(BytesPending), indent); 283escapedValue.CopyTo(output.Slice(BytesPending)); 318WriteIndentation(output.Slice(BytesPending), indent); 324escapedValue.CopyTo(output.Slice(BytesPending));

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.StringSegment.cs (2)

343escapedValue.CopyTo(output.Slice(BytesPending)); 498WriteIndentation(output.Slice(BytesPending), indent);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.UnsignedNumber.cs (3)

73bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten); 103WriteIndentation(output.Slice(BytesPending), indent); 107bool result = Utf8Formatter.TryFormat(value, output.Slice(BytesPending), out int bytesWritten);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

88source.CopyTo(_span.Slice(_pos));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

88source.CopyTo(_span.Slice(_pos));

System\Text\RegularExpressions\Regex.Replace.cs (1)

235dest = dest.Slice(segment.Length);

System\Text\RegularExpressions\RegexCharClass.cs (3)

580state.set.AsSpan(2).CopyTo(span.Slice(SetStartIndex)); 588state.set.AsSpan().CopyTo(span.Slice(SetStartIndex)); 592state.category.AsSpan().CopyTo(span.Slice(index));

System\Text\RegularExpressions\RegexReplacement.cs (2)

280dest = dest.Slice(state.replacement.Length); 285dest = dest.Slice(count);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (1)

88source.CopyTo(_span.Slice(_pos));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (3)

580state.set.AsSpan(2).CopyTo(span.Slice(SetStartIndex)); 588state.set.AsSpan().CopyTo(span.Slice(SetStartIndex)); 592state.category.AsSpan().CopyTo(span.Slice(index));

src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

10if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

142_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 162_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 167.CopyTo(_chars.Slice(index)); 219.CopyTo(_chars.Slice(pos)); 246value.CopyTo(_chars.Slice(_pos));

System\Web\Util\HttpEncoder.cs (1)

633_numChars += _encoding.GetChars(_byteBuffer.Slice(0, _numBytes), _charBuffer.Slice(_numChars));