Slice

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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = 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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = 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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = 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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = 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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = buffer.Slice(i);

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

83_span = _span.Slice(count);

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

534buffer = 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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = buffer.Slice(i);

ChunkedResponseTests.cs (1)

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

Http2\Http2StreamTests.cs (2)

3557secondPartOfResponse.CopyTo(span.Slice(6)); 3875secondPartOfResponse.CopyTo(span.Slice(6));

Http2\Http2TestBase.cs (2)

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

ResponseTests.cs (1)

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

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

30if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 43var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: false, out var headersLength); 66var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: true, out var headersLength); 109buffer.Slice(currentLength),

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

912destination = destination.Slice(parameterLength); 915destination = 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));

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)

534buffer = 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)

252buffer = buffer.Slice(3); 256buffer = buffer.Slice(2); 326var payload = buffer.Slice(extendedHeaderLength); 369Bitshifter.WriteUInt31BigEndian(extendedHeader.Slice(1), (uint)streamDependency); 421BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 422destination = 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)

534buffer = buffer.Slice(i);

Internal\Http2\Http2FrameWriter.cs (5)

797BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 798destination = destination.Slice(Http2FrameReader.SettingSize); 869buffer = buffer.Slice(4); 902buffer = buffer.Slice(3); 906buffer = 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)

30if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 43var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: false, out var headersLength); 66var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: true, out var headersLength); 109buffer.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)

534buffer = 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)); 131Test(span.Slice(i));

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

30if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 43var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: false, out var headersLength); 66var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: true, out var headersLength); 109buffer.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)

30if (!EncodeStatusHeader(statusCode, hpackEncoder, buffer.Slice(length), out var statusCodeLength)) 43var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: false, out var headersLength); 66var done = EncodeHeadersCore(hpackEncoder, headersEnumerator, buffer.Slice(length), throwIfNoneEncoded: true, out var headersLength); 109buffer.Slice(currentLength),

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

912destination = destination.Slice(parameterLength); 915destination = destination.Slice(valueLength);

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

534buffer = 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)

534buffer = 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))

Logging\OptimizedStringIndenter.cs (3)

79output = output.Slice(state.indent); 83output = output.Slice(segment.Length); 87output = output.Slice(Environment.NewLine.Length);

ArraySortHelper.cs (1)

921values = values.Slice(nanLeft);

SystemdNotifier.cs (1)

70state.AsSpan(1).CopyTo(buffer.Slice(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)); 262value.CopyTo(_chars.Slice(_pos));

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

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

StringValues.cs (1)

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

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);

System\Collections\BitArray.cs (1)

796span = span.Slice(4);

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

99return _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)); 262value.CopyTo(_chars.Slice(_pos));

System\ConsolePal.Unix.cs (1)

521TransferBytes(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)); 262value.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));

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)); 262value.CopyTo(_chars.Slice(_pos));

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

292int n = fs.Read(buffer.Slice(bytesRead)); 311argRemainder = argRemainder.Slice(argEnd + 1); 343string argString = Encoding.UTF8.GetString(arg.Slice(nameStart));

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)

167writeSpan = 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)

222s = s.Slice(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)); 262value.CopyTo(_chars.Slice(_pos));

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

870bytesWritten += Encoding.UTF8.GetBytes(attribute, span.Slice(bytesWritten)); 872bytesWritten += Encoding.UTF8.GetBytes(value, span.Slice(bytesWritten)); 1007bytesToWrite.CopyTo(destination.Slice(copyPos)); 1040return 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\dec\BrotliDecoder.cs (1)

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

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

184destination = 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)); 262value.CopyTo(_chars.Slice(_pos));

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

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

System\Linq\SegmentedArrayBuilder.cs (3)

145sourceSlice.CopyTo(_currentSegment.Slice(_countInCurrentSegment)); 290destination = destination.Slice(firstSegment.Length); 300destination = 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)); 262value.CopyTo(_chars.Slice(_pos));

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

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

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

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

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

1116Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int))); 1295BinaryPrimitives.WriteInt64BigEndian(span.Slice(FrameHeader.Size), state.pingContent); 1307BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), (int)s.errorCode); 1655span = span.Slice(FrameHeader.Size); 1657span = span.Slice(current.Length); 1667span = span.Slice(FrameHeader.Size); 1669span = span.Slice(current.Length); 1760BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), s.amount); 1944BinaryPrimitives.WriteInt32BigEndian(destination.Slice(5), streamId);

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

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

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

1121buffer = buffer.Slice(copyLen); 1145buffer = buffer.Slice(bytesRead);

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

374bool success = ((uint)requestUri.Port).TryFormat(buffer.Slice(1), out int bytesWritten); 1067ReadOnlySpan<byte> reasonBytes = line.Slice(MinStatusLineLength + 1); 1140Span<byte> valueIterator = buffer.Slice(valueStartIdx); 1172buffer = buffer.Slice(buffer.Length - valueIterator.Length + spIdx); 1181valueIterator = 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)); 262value.CopyTo(_chars.Slice(_pos));

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

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

System\Net\IPAddress.cs (1)

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

System\Net\IPAddressParser.cs (6)

116pos += FormatByte(address >> 16, addressString.Slice(pos)); 118pos += FormatByte(address >> 8, addressString.Slice(pos)); 120pos += FormatByte(address, addressString.Slice(pos)); 168pos += FormatIPv4Address(ExtractIPv4Address(address), destination.Slice(pos)); 191Span<TChar> used = chars.Slice(bytesPos); 192used.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)

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

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

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

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

114input.Slice(0, partLen).CopyTo(buffer.Slice(index)); 130input.Slice(i).CopyTo(buffer.Slice(index)); 175BinaryPrimitives.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 (1)

1467BitConverter.ToInt32(buffer.Slice(maskOffset));

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

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

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

324bool 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)); 262value.CopyTo(_chars.Slice(_pos));

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

285bytes = bytes.Slice(bytesWritten); 325bytes = bytes.Slice(localWritten); 554bytes = 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); 855keys = keys.Slice(nanLeft); 856values = values.Slice(nanLeft);

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

85source.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 (2)

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

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

183dest = dest.Slice(source.Length);

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

52sortKey = sortKey.Slice(sizeof(ushort)); 72sortKey = sortKey.Slice(2 * sizeof(ushort)); 79sortKey = sortKey.Slice(sizeof(ushort));

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

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

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

5881Value.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)

335ChangeCaseCommon<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)

1252int n = RandomAccess.ReadAtOffset(sfh, buffer.Slice(bytesRead), bytesRead); 1308int encoded = encoder.GetBytes(toEncode, bytes.Slice(preambleSize), flush: remaining.IsEmpty);

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

645path3.CopyTo(destination.Slice(charsWritten)); 758destination = destination.Slice(1); 768destination = destination.Slice(1); 778destination = destination.Slice(1);

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

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

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)

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

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

381n = ReadBuffer(buffer.Slice(charsRead), out readToUserBuffer); 393new Span<char>(_charBuffer, _charPos, n).CopyTo(buffer.Slice(charsRead)); 454i = ReadSpan(buffer.Slice(n)); 1153n = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false); 1217n = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false); 1241new Span<char>(_charBuffer, _charPos, n).CopyTo(buffer.Span.Slice(charsRead));

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

4304if (value.TryCopyTo(_destination.Slice(_pos))) 4347if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten)) 4358if (((ISpanFormattable)value).TryFormat(_destination.Slice(_pos), out int charsWritten, default, _provider)) // constrained call avoiding boxing for value types 4403if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten, format)) 4414if (((ISpanFormattable)value).TryFormat(_destination.Slice(_pos), out int charsWritten, format, _provider)) // constrained call avoiding boxing for value types 4471if (value.TryCopyTo(_destination.Slice(_pos))) 4507value.CopyTo(_destination.Slice(_pos)); 4516value.CopyTo(_destination.Slice(_pos)); 4542if (value.TryCopyTo(_destination.Slice(_pos))) 4631_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\Random.cs (1)

224destination = destination.Slice(randomBytes.Length);

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

155buffer = 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)

1431this.AsSpan(thisIdx, count).CopyTo(dstSpan.Slice(dstIdx)); 1437newValue.CopyTo(dstSpan.Slice(dstIdx)); 1443this.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)

880CopyTo(sourceIndex, new Span<char>(destination).Slice(destinationIndex), count); 920new 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)

95destination = destination.Slice((int)(pOutputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)))); 106destination = destination.Slice(3); 186destination = destination.Slice((int)(pOutputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)))); 195destination = destination.Slice(1); 285destination = destination.Slice((int)(pOutputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)))); 301destination = destination.Slice(bytesConsumedJustNow); 403Span<byte> dest = _destination.Slice(_pos); 447if (((IUtf8SpanFormattable)value).TryFormat(_destination.Slice(_pos), out int bytesWritten, format: default, _provider)) 500if (((IUtf8SpanFormattable)value).TryFormat(_destination.Slice(_pos), out int bytesWritten, format, _provider)) 565if (Encoding.UTF8.TryGetBytes(value, _destination.Slice(_pos), out int bytesWritten)) 593if (utf8Value.TryCopyTo(_destination.Slice(_pos))) 792_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)

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

System\Xml\XmlBinaryWriter.cs (10)

System\Xml\XmlConverter.cs (1)

1104foreach (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)); 262value.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)

4605span.Slice(lastSlash).CopyTo(span.Slice(i + 1)); 4633span.Slice(lastSlash + 1).CopyTo(span.Slice(i + 1)); 4648span.Slice(lastSlash).CopyTo(span); 4658span.Slice(dotCount).CopyTo(span);

System\UriExt.cs (2)

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

System\UriHelper.cs (2)

151vsb = new ValueStringBuilder(destination.Slice(indexOfFirstToEscape)); 165vsb.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)); 262value.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)); 262value.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)); 262value.CopyTo(_chars.Slice(_pos));

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

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

System\Number.BigInteger.cs (2)

503Span<uint> curBuffer = buffer.Slice(i); 504Span<uint> curNewBuffer = newBuffer.Slice(i);

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

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

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

174uint carry = SubtractDivisor(left.Slice(n), right, digit); 180carry = AddDivisor(left.Slice(n), right);

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)

2227m_real.TryFormat(MemoryMarshal.Cast<TChar, char>(destination.Slice(1)), out realChars, format, provider) : 2228m_real.TryFormat(MemoryMarshal.Cast<TChar, byte>(destination.Slice(1)), out realChars, format, provider)) 2231destination = destination.Slice(1 + realChars); // + 1 for < 2238m_imaginary.TryFormat(MemoryMarshal.Cast<TChar, char>(destination.Slice(2)), out imaginaryChars, format, provider) : 2239m_imaginary.TryFormat(MemoryMarshal.Cast<TChar, 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)

223retSpan = retSpan.Slice(len);

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

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

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

208destination = destination.Slice(hashBuf.Length); 260destination = destination.Slice(bytes.Length); 288destination = destination.Slice(count); 291destination = 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); 448salt.CopyTo(db.Slice(psLen + 1)); 555ReadOnlySpan<byte> salt = dbMask.Slice(dbMask.Length - sLen); 607writePtr = writePtr.Slice(bytesWritten);

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)); 262value.CopyTo(_chars.Slice(_pos));

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

69ciphertext.Slice(ciphertextBytesWritten),

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

59ciphertext.Slice(ciphertextBytesWritten), 106plaintext.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\HKDF.cs (1)

173remainingOutput = 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 (4)

173label.CopyTo(destination.Slice(PostEBPrefix.Length)); 174Ending.CopyTo(destination.Slice(PostEBPrefix.Length + label.Length)); 399str.CopyTo(dest.Slice(offset)); 405bool success = Convert.TryToBase64Chars(bytes, dest.Slice(offset), out int base64Written);

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

332destination = destination.Slice(1); 333remainingRandom = remainingRandom.Slice(1); 347destination = destination.Slice(remainingRandom.Length * 2); 381destination = destination.Slice(randomBytes.Length);

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)

212bufferSpan.Slice(0, _blockSize).CopyTo(destination.Slice(offset)); 217bufferSpan.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)

44CryptographicOperations.ZeroMemory(transformBuffer.Slice(bytesWritten)); 144depaddedFinalTransform.CopyTo(output.Slice(writtenToOutput));

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

727current = 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)

557buffer = buffer.Slice(certWritten); 572buffer = 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)

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

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

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

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)); 262value.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)

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

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

194if (!scalarValue.TryEncodeToUtf16(destination.Slice(dstIdx), out int utf16CodeUnitCount)) 208int charsWrittenJustNow = _scalarEscaper.EncodeUtf16(scalarValue, destination.Slice(dstIdx)); 302if (!scalarValue.TryEncodeToUtf8(destination.Slice(dstIdx), out int utf8CodeUnitCount)) 315int 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)); 262value.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)

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

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

593span.Slice(0, amountToWrite).CopyTo(readSoFar.Slice(written)); 613span.Slice(0, amountToWrite).CopyTo(readSoFar.Slice(written));

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

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

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

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

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

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

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

110destination = destination.Slice(indexOfFirstByteToEscape); 138destination = destination.Slice(written); 181bool result = Utf8Formatter.TryFormat(value, destination.Slice(written), out int bytesWritten, format: s_hexStandardFormat); 221destination = destination.Slice(indexOfFirstByteToEscape); 249destination = destination.Slice(written); 295intChar.TryFormat(destination.Slice(written), out int charsWritten, HexFormatString);

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

581WriteIndentation(output.Slice(BytesPending), indent); 1019WriteIndentation(output.Slice(BytesPending), indent);

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

267escapedPropertyName.CopyTo(output.Slice(BytesPending)); 312WriteIndentation(output.Slice(BytesPending), indent); 362WriteIndentation(output.Slice(BytesPending), indent); 367escapedPropertyName.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)

81escapedPropertyName.CopyTo(output.Slice(BytesPending)); 118WriteIndentation(output.Slice(BytesPending), indent); 123escapedPropertyName.CopyTo(output.Slice(BytesPending)); 191WriteIndentation(output.Slice(BytesPending), indent); 208OperationStatus 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)

92OperationStatus status = JsonWriterHelper.ToUtf8(value, output.Slice(BytesPending), out int written); 126WriteIndentation(output.Slice(BytesPending), indent); 133OperationStatus status = JsonWriterHelper.ToUtf8(value, output.Slice(BytesPending), out int written); 205utf8Value.CopyTo(output.Slice(BytesPending)); 233WriteIndentation(output.Slice(BytesPending), indent); 240utf8Value.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)

40Span<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)

190utf8Json.CopyTo(output.Slice(BytesPending)); 278utf8Json.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.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)

85source.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)); 262value.CopyTo(_chars.Slice(_pos));

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

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

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

239dest = 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)

283dest = dest.Slice(state.replacement.Length); 288dest = 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)); 262value.CopyTo(_chars.Slice(_pos));

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

85source.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));