Slice

src\Shared\CircularBuffer.cs (5)

102data.Slice(0, _end).CopyTo(data.Slice(1)); 110data.Slice(internalIndex, shiftLength).CopyTo(data.Slice(internalIndex + 1)); 113data.Slice(0, _end).CopyTo(data.Slice(1)); 119data.Slice(internalIndex, _end - internalIndex).CopyTo(data.Slice(internalIndex + 1)); 123data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CircularBuffer.cs (5)

102data.Slice(0, _end).CopyTo(data.Slice(1)); 110data.Slice(internalIndex, shiftLength).CopyTo(data.Slice(internalIndex + 1)); 113data.Slice(0, _end).CopyTo(data.Slice(1)); 119data.Slice(internalIndex, _end - internalIndex).CopyTo(data.Slice(internalIndex + 1)); 123data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CircularBuffer.cs (5)

102data.Slice(0, _end).CopyTo(data.Slice(1)); 110data.Slice(internalIndex, shiftLength).CopyTo(data.Slice(internalIndex + 1)); 113data.Slice(0, _end).CopyTo(data.Slice(1)); 119data.Slice(internalIndex, _end - internalIndex).CopyTo(data.Slice(internalIndex + 1)); 123data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\PasswordGenerator.cs (1)

85destination = destination.Slice(minValues);

src\Shared\PasswordGenerator.cs (1)

85destination = destination.Slice(minValues);

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

923values = values.Slice(nanLeft);

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

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

Compiler\ObjectWriter\CodeView\CodeViewFileTableBuilder.cs (1)

51BinaryPrimitives.WriteUInt32LittleEndian(fileTableEntry.Slice(4), 0);

Compiler\ObjectWriter\CodeView\CodeViewSymbolsBuilder.cs (1)

321BinaryPrimitives.WriteUInt32LittleEndian(subsectionHeader.Slice(4), _size);

Compiler\ObjectWriter\ElfObjectWriter.Aot.cs (2)

131armUnwindInfo = armUnwindInfo.Slice(2); 153armUnwindInfo = armUnwindInfo.Length > 3 ? armUnwindInfo.Slice(4) : Span<byte>.Empty;

Compiler\ObjectWriter\MachObjectWriter.Aot.cs (1)

88BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer.Slice(4), cu.Code);

Compiler\TypePreinit.cs (1)

3518value.CopyTo(MemoryMarshal.Cast<byte, char>(((Span<byte>)bytes).Slice(firstCharField.Offset.AsInt)));

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_Wasm\WasmTypes.cs (4)

107Span<byte> rest = buffer.Slice(sizeLength); 222foreach (CorInfoWasmType paramType in types.AsSpan().Slice(1)) 246int paramSize = _params.Encode(buffer.Slice(1)); 247int returnSize = _returns.Encode(buffer.Slice(1 + paramSize));

src\runtime\src\coreclr\tools\Common\Compiler\NativeAotNameMangler.cs (1)

157bool b = iter.TryFormat(new Span<byte>(buffer).Slice(origName.Length + 1), out _);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (34)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (45)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (2)

1175BinaryPrimitives.WriteUInt32LittleEndian(relocationBuffer.Slice(4), info); 1197BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(8), Value);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\SectionData.cs (1)

153buffer = buffer.Slice(currentBuffer.Length);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\StringTableBuilder.cs (1)

113MultiKeySort(input.Slice(h), pos);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Wasm\WasmSection.cs (1)

87DwarfHelper.WriteULEB128(headerBuffer.Slice(1), contentSize);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WasmInstructions.cs (19)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WasmNative.cs (5)

120pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), 1); // Requires 1 table entry 157pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), _min); 160pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), _max!.Value); 195return 1 + DwarfHelper.WriteULEB128(buffer.Slice(1), (ulong)_typeIndex); 246return 2 + _initExpr.Encode(buffer.Slice(2));

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8String.cs (1)

103resultSpan = resultSpan.Slice(s.Length);

src\runtime\src\coreclr\tools\Common\TypeSystem\Interop\IL\Marshaller.Aot.cs (2)

970codeStream.EmitLdc(BinaryPrimitives.ReadInt16LittleEndian(bytes.Slice(4))); 971codeStream.EmitLdc(BinaryPrimitives.ReadInt16LittleEndian(bytes.Slice(6)));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_Wasm\WasmTypes.cs (4)

107Span<byte> rest = buffer.Slice(sizeLength); 222foreach (CorInfoWasmType paramType in types.AsSpan().Slice(1)) 246int paramSize = _params.Encode(buffer.Slice(1)); 247int returnSize = _returns.Encode(buffer.Slice(1 + paramSize));

src\runtime\src\coreclr\tools\Common\Compiler\NativeAotNameMangler.cs (1)

157bool b = iter.TryFormat(new Span<byte>(buffer).Slice(origName.Length + 1), out _);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (34)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (45)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (2)

1175BinaryPrimitives.WriteUInt32LittleEndian(relocationBuffer.Slice(4), info); 1197BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(8), Value);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\SectionData.cs (1)

153buffer = buffer.Slice(currentBuffer.Length);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\StringTableBuilder.cs (1)

113MultiKeySort(input.Slice(h), pos);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Wasm\WasmDataSection.cs (3)

49DwarfHelper.WritePaddedULEB128(headerBuffer.Slice(1), (ulong)ContentSize); 50Debug.Assert(headerBuffer.Slice(1).Length == Relocation.WASM_PADDED_RELOC_SIZE_32); 51ulong readCheck = DwarfHelper.ReadULEB128(headerBuffer.Slice(1));

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Wasm\WasmDataSegment.cs (8)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Wasm\WasmSection.cs (1)

87DwarfHelper.WriteULEB128(headerBuffer.Slice(1), contentSize);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WasmInstructions.cs (19)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WasmNative.cs (5)

120pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), 1); // Requires 1 table entry 157pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), _min); 160pos += DwarfHelper.WriteULEB128(buffer.Slice(pos), _max!.Value); 195return 1 + DwarfHelper.WriteULEB128(buffer.Slice(1), (ulong)_typeIndex); 246return 2 + _initExpr.Encode(buffer.Slice(2));

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WebCilObjectWriter.cs (1)

442BinaryPrimitives.WriteUInt32LittleEndian(lengthBuffer.AsSpan().Slice(4), (uint)MethodCount);

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8String.cs (1)

103resultSpan = resultSpan.Slice(s.Length);

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\TypeSystemHelpers.cs (9)

441s2.AsSpan().CopyTo(buffer.Slice(s1.Length)); 451s2.AsSpan().CopyTo(buffer.Slice(s1.Length)); 461s2.CopyTo(buffer.Slice(s1.Length)); 462s3.CopyTo(buffer.Slice(s1.Length + s2.Length)); 475s2Span.CopyTo(buffer.Slice(s1Span.Length)); 476s3Span.CopyTo(buffer.Slice(s1Span.Length + s2Span.Length)); 489s2.AsSpan().CopyTo(buffer.Slice(s1.Length)); 490s3.AsSpan().CopyTo(buffer.Slice(s1.Length + s2.Length)); 491s4.Slice(0, s4length).CopyTo(buffer.Slice(s1.Length + s2.Length + s3.Length));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

Internal\DefaultClaimUidExtractor.cs (1)

138offset += span.Slice(offset).Write7BitEncodedString(parameters[i]);

src\aspnetcore\src\Shared\Buffers\RefPooledArrayBufferWriter.cs (1)

87return _buffer.Slice(_index);

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

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

src\aspnetcore\src\Shared\Buffers\RefPooledArrayBufferWriter.cs (1)

87return _buffer.Slice(_index);

BlazorPack\SequenceOfT.cs (1)

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

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

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

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

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

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

152_span = _span.Slice(count);

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

src\aspnetcore\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)

393BinaryPrimitives.WriteUInt32BigEndian(targetSpan.Slice(0), MAGIC_HEADER_V0); 396BinaryPrimitives.WriteInt32BigEndian(targetSpan.Slice(4 + keySize), targetLength); 405index += targetSpan.Slice(index).Write7BitEncodedInt(purposeLengthsPool[i]);

SP800_108\ManagedSP800_108_CTR_HMACSHA512.cs (3)

118label.CopyTo(prfInput.Slice(sizeof(uint))); 119contextHeader.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1)); 120contextData.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1 + contextHeader.Length));

src\aspnetcore\src\Shared\Buffers\RefPooledArrayBufferWriter.cs (1)

87return _buffer.Slice(_index);

src\aspnetcore\src\Shared\Buffers\RefPooledArrayBufferWriter.cs (1)

87return _buffer.Slice(_index);

PathString.cs (1)

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

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

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

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

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

src\aspnetcore\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\aspnetcore\src\Shared\Buffers\RefPooledArrayBufferWriter.cs (1)

87return _buffer.Slice(_index);

src\aspnetcore\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\aspnetcore\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\aspnetcore\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\aspnetcore\src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (1)

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

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

180buffer = buffer.Slice(i);

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

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

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

83_span = _span.Slice(count);

src\aspnetcore\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\aspnetcore\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\aspnetcore\src\Shared\Buffers\RefPooledArrayBufferWriter.cs (1)

87return _buffer.Slice(_index);

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

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

48buffer = buffer.Slice(1);

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

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

83_span = _span.Slice(count);

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

180buffer = buffer.Slice(i);

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

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

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

180buffer = buffer.Slice(i);

src\aspnetcore\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\aspnetcore\src\SignalR\common\Shared\MemoryBufferWriter.cs (2)

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

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

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

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

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

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

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

src\aspnetcore\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\aspnetcore\src\Shared\UrlDecoder\UrlDecoder.cs (1)

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

Construction\Solution\ProjectInSolution.cs (1)

527dest = dest.Slice(pos + 1);

Logging\OptimizedStringIndenter.cs (3)

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

src\msbuild\artifacts\.packages\microsoft.codeanalysis.collections\5.0.0-1.25277.114\contentFiles\cs\net9.0\Internal\ArraySortHelper.cs (1)

923values = values.Slice(nanLeft);

Collections\RefArrayBuilder.cs (3)

183source.CopyTo(span.Slice(start: count)); 249source.CopyTo(span.Slice(index)); 322span[startIndex.._count].CopyTo(destination.Slice(startIndex + size));

Utilities\ProcessExtensions.cs (1)

184int charsWritten = Encoding.UTF8.GetChars(segment, charBuffer.AsSpan().Slice(totalChars));

CryptographicHashProvider.cs (3)

281BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[1]); 282BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[2]); 283BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[3]);

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

923values = values.Slice(nanLeft);

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

923values = values.Slice(nanLeft);

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

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

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

923values = values.Slice(nanLeft);

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

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

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

923values = values.Slice(nanLeft);

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

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

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

923values = values.Slice(nanLeft);

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

923values = values.Slice(nanLeft);

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

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

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

923values = values.Slice(nanLeft);

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

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

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 (5)

88BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(4), (int)entry.Type); 89BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(8), entry.Offset); 90BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(12), entry.Count); 121indexEntries[i] = ReadIndexEntry(indexBytesSpan.Slice(i * sizeof(IndexEntry))); 135IndexEntry indexEntry = ReadIndexEntry(store.AsSpan().Slice(entry.Offset));

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadManifestReader.SystemTextJson.cs (1)

93span.Slice((int)reader.BytesConsumed).CopyTo(newBuffer);

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

Chunkers\ValueStringBuilder.cs (5)

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

SystemdNotifier.cs (1)

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

Logging\Internal\HttpHeadersRedactor.cs (1)

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

StringValues.cs (1)

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

Resolver\DnsDataWriter.cs (5)

24if (!DnsPrimitives.TryWriteMessageHeader(_buffer.Span.Slice(_position), header, out int written)) 65if (DnsPrimitives.TryWriteQName(_buffer.Span.Slice(_position), name, out int written)) 93BinaryPrimitives.WriteUInt16BigEndian(_buffer.Span.Slice(_position), value); 105BinaryPrimitives.WriteUInt32BigEndian(_buffer.Span.Slice(_position), value); 117value.CopyTo(_buffer.Span.Slice(_position));

Resolver\DnsPrimitives.cs (10)

50BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(2), (ushort)header.QueryFlags); 51BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(4), header.QueryCount); 52BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(6), header.AnswerCount); 53BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(8), header.AuthorityCount); 54BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(10), header.AdditionalRecordCount); 100!Encoding.ASCII.TryGetBytes(name, destination.Slice(1), out int length) || 112int index = nameBuffer.Slice(1).IndexOf((byte)'.'); 113label = index == -1 ? nameBuffer.Slice(1) : nameBuffer.Slice(1, index); 132label.Slice(1).Contains((byte)'_') || 148nameBuffer = nameBuffer.Slice(index + 1);

Fuzzers\DnsResponseFuzzer.cs (1)

31_buffer.AsSpan(0, Math.Min(_length, buffer.Length - 2)).CopyTo(buffer.Span.Slice(2));

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 (8)

941buffer = buffer.Slice(1); 972buffer = buffer.Slice(sSpan.Length); 1023buffer = buffer.Slice(specialTokenSpan.Length); 1044Span<byte> current = utf8bytes.Slice(incompleteUtf8BytesInBufferIndex + incompleteUtf8BytesInBuffer); 1057if (!Helpers.ConvertUtf8ToUtf16(current, vocabBuffer.Slice(utf16CharsInBuffer), out int utf8BytesConsumed, out int utf16CharsWritten)) 1071buffer = buffer.Slice(completeCharsWritten); 1220s.CopyTo(buffer.Slice(ContinuingSubwordPrefix.Length)); 1240EndOfWordSuffix.AsSpan().CopyTo(buffer.Slice(s.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)

447buffer = destination.Slice(charsWritten); 513buffer = destination.Slice(charsWritten); 586buffer = destination.Slice(charsWritten); 602destination.Slice(suffixIndex + 1, charsWritten - suffixIndex - 1).CopyTo(destination.Slice(suffixIndex)); 716Span<char> buffer = destination.Slice(charsConsumed); 736buffer = 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)

263token.AsSpan().CopyTo(span.Slice(bufferIndex)); 490_spaceSymbol.AsSpan().CopyTo(normalized.Slice(normalizedIndex)); 552_spaceSymbol.AsSpan().CopyTo(normalized.Slice(normalizedIndex));

Utils\BytePairEncoder.cs (2)

87byteIndicesAndRanks.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());

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadManifestReader.SystemTextJson.cs (1)

93span.Slice((int)reader.BytesConsumed).CopyTo(newBuffer);

MachO\BinaryFormat\Blobs\CodeDirectoryBlob.cs (1)

35int nullTerminatorIndex = data.AsSpan().Slice(identifierDataOffset).IndexOf((byte)0x00);

ContentDispositionHeaderValue.cs (2)

555var bufferContent = buffer.Slice(MimePrefix.Length); 560MimeSuffix.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);

Utils\Globbing\StaticWebAssetGlobMatcher.cs (1)

134segment.CopyTo(span.Slice(index));

WorkloadManifestReader.SystemTextJson.cs (1)

93span.Slice((int)reader.BytesConsumed).CopyTo(newBuffer);

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

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

923values = values.Slice(nanLeft);

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

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

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

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

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

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

System\ConsolePal.Unix.cs (1)

518TransferBytes(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\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.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)

205tags.Slice(index, _tagsCount - index).CopyTo(tags.Slice(index + 1)); 222tags.Slice(index + 1, _tagsCount - index - 1).CopyTo(tags.Slice(index));

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ForkAndExecProcess.cs (3)

142int bytesWritten = Encoding.UTF8.GetBytes(arr[i], data.Slice(dataOffset)); 189int keyBytes = Encoding.UTF8.GetBytes(pair.Key, data.Slice(dataOffset)); 191int valueBytes = Encoding.UTF8.GetBytes(pair.Value, data.Slice(dataOffset + keyBytes + 1));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

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

System\DirectoryServices\Protocols\common\DirectoryControl.cs (10)

176asnSpan = asnSpan.Slice(bytesConsumed); 181asnSpan = asnSpan.Slice(bytesConsumed); 214asnSpan = asnSpan.Slice(bytesConsumed); 218asnSpan = asnSpan.Slice(bytesConsumed); 238asnSpan = asnSpan.Slice(bytesConsumed); 257asnSpan = asnSpan.Slice(bytesConsumed); 280asnSpan = asnSpan.Slice(bytesConsumed); 284asnSpan = asnSpan.Slice(bytesConsumed); 287asnSpan = asnSpan.Slice(bytesConsumed); 295asnSpan = asnSpan.Slice(bytesConsumed);

System\Formats\Asn1\AsnCharacterStringEncodings.net.cs (8)

65destination = destination.Slice(Vector<byte>.Count); 102upper.CopyTo(destination.Slice(Vector<ushort>.Count)); 103destination = destination.Slice(Vector<byte>.Count); 310destination = destination.Slice(Vector<byte>.Count); 351upper.CopyTo(destination.Slice(Vector<ushort>.Count)); 352destination = destination.Slice(Vector<byte>.Count); 511destination = destination.Slice(Vector<ushort>.Count); 547destination = destination.Slice(Vector<ushort>.Count);

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)

343target = target.Slice(l); 368destination = destination.Slice(l); 406target = target.Slice(charsWritten); 435destination = destination.Slice(chunkCharsWritten);

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

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

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

220s = s.Slice(length);

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

153valuesToRead = valuesToRead.Slice(sliceSize);

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

869bytesWritten += Encoding.UTF8.GetBytes(attribute, span.Slice(bytesWritten)); 871bytesWritten += Encoding.UTF8.GetBytes(value, span.Slice(bytesWritten)); 984bytesToWrite.CopyTo(destination.Slice(copyPos)); 1074BinaryPrimitives.WriteInt64BigEndian(destination.Slice(Offset), value); 1099return WriteRightAlignedBytesAndGetChecksum(digits.Slice(i), destination);

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

111buffer = buffer.Slice(bytesRead);

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

133bytes = bytes.Slice(copied);

System\IO\Compression\WinZipAesStream.cs (1)

306buffer = buffer.Slice(bytesToProcess);

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

2115BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer.Slice(relativeCrc32Location), crcToWrite); 2116BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeCompressedSizeLocation), _compressedSize); 2117BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeUncompressedSizeLocation), _uncompressedSize);

System\IO\Compression\ZipBlocks.cs (4)

846BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(0), HeaderId); 847BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(2), DataSize); 848BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4), VendorVersion); 852BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(9), CompressionMethod);

System\IO\Compression\ZipCryptoStream.cs (2)

158BinaryPrimitives.WriteUInt16LittleEndian(header.Slice(10), (ushort)(crc >> 16)); 162BinaryPrimitives.WriteUInt16LittleEndian(header.Slice(10), _verifierLow2Bytes);

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\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

System\IO\FileSystemWatcher.Linux.cs (1)

1394path.CopyTo(pathBuffer.Slice(length));

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

262guid.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\Range.cs (1)

91destination = destination.Slice(Vector<T>.Count);

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\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HPackEncoder.cs (19)

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

48buffer = buffer.Slice(1);

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

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

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

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

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.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)

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

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

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

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

1150Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int))); 1344BinaryPrimitives.WriteInt64BigEndian(span.Slice(FrameHeader.Size), state.pingContent); 1359BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), (int)s.errorCode); 1731span = span.Slice(FrameHeader.Size); 1733span = span.Slice(current.Length); 1743span = span.Slice(FrameHeader.Size); 1745span = span.Slice(current.Length); 1836BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), s.amount); 2031BinaryPrimitives.WriteInt32BigEndian(destination.Slice(5), streamId);

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

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

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

1223buffer = buffer.Slice(copyLen); 1247buffer = buffer.Slice(bytesRead);

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

411bool success = ((uint)requestUri.Port).TryFormat(buffer.Slice(1), out int bytesWritten); 1110ReadOnlySpan<byte> reasonBytes = line.Slice(MinStatusLineLength + 1); 1183Span<byte> valueIterator = buffer.Slice(valueStartIdx); 1215buffer = buffer.Slice(buffer.Length - valueIterator.Length + spIdx); 1224valueIterator = 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\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

System\Net\BufferedReadStream.cs (1)

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

System\Net\DnsResolverPal.Managed.cs (1)

785int received = socket.Receive(buffer.Slice(totalReceived));

src\runtime\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)

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

System\Net\IPAddressParser.cs (6)

143pos += FormatByte(address >> 16, addressString.Slice(pos)); 145pos += FormatByte(address >> 8, addressString.Slice(pos)); 147pos += FormatByte(address, addressString.Slice(pos)); 197pos += FormatIPv4Address(ExtractIPv4Address(address), destination.Slice(pos)); 213scopeId.TryFormat(MemoryMarshal.Cast<TChar, byte>(destination).Slice(pos), out bytesWritten) : 214scopeId.TryFormat(MemoryMarshal.Cast<TChar, char>(destination).Slice(pos), out bytesWritten);

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

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

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

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

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

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

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

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

src\runtime\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\runtime\src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (3)

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

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

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

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

404data.CopyTo(payload.Slice(offset)); 410int dataLength = Encoding.Unicode.GetBytes(data, payload.Slice(offset)); 474hmac.AppendData(blob.Slice(DigestLength)); 496BinaryPrimitives.WriteInt32LittleEndian(prefix.Slice(sizeof(uint) * 4), cbtDataSize); 797BinaryPrimitives.WriteUInt32LittleEndian(signature.Slice(12), sequenceNumber); 899_serverSeal.Transform(input.Slice(SignatureLength), input.Slice(SignatureLength)); 900if (!VerifyMIC(input.Slice(SignatureLength), input.Slice(0, SignatureLength))) 902CryptographicOperations.ZeroMemory(input.Slice(SignatureLength));

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

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

System\Net\Security\TlsSession.cs (2)

1294.CopyTo(plaintext.Slice(decBytesWritten)); 1380.CopyTo(plaintext.Slice(decBytesWritten));

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

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

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

1102closeStatus = (WebSocketCloseStatus)BinaryPrimitives.ReadUInt16BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset)); 1333header.PayloadLength = BinaryPrimitives.ReadUInt16BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1339header.PayloadLength = BinaryPrimitives.ReadInt64BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset));

System\Buffers\NIndex.cs (1)

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

System\Buffers\NRange.cs (2)

73bool formatted = ((nuint)Start.Value).TryFormat(span.Slice(pos), out int charsWritten); 84formatted = ((nuint)End.Value).TryFormat(span.Slice(pos), out charsWritten);

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

286dstSpan = dstSpan.Slice((int)tensors[i].FlattenedLength); 308dstSpan = dstSpan.Slice((int)slice.FlattenedLength); 2415tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2427tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2452tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2464tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2489tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2501tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

src\runtime\src\libraries\Common\src\System\HexConverter.cs (2)

443fallbackResult = TryDecodeFromUtf8_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed); 448fallbackResult = TryDecodeFromUtf16_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed);

src\runtime\src\libraries\Common\src\System\Sha1ForNonSecretPurposes.cs (4)

55BinaryPrimitives.WriteUInt64BigEndian(tail.Slice(pos), (ulong)originalLength * 8); 63tail = tail.Slice(4); 71destination = destination.Slice(4); 160output = output.Slice(4);

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

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

284bytes = bytes.Slice(bytesWritten); 329bytes = bytes.Slice(localWritten); 608bytes = bytes.Slice(localWritten); 712bytes = bytes.Slice(localWritten);

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

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (1)

685intSpan.Slice(0, lastIndex + 1 - lengthToClear).CopyTo(intSpan.Slice(lengthToClear));

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Convert.cs (2)

2309return chars.Slice(i).ToString(); 2463OperationStatus status = Base64.EncodeToChars(source.Slice(0, chunkSize), destination.Slice(writeOffset), out int bytesConsumed, out int charsWritten);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Decimal.cs (5)

627BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(4), (int)d.Mid); 628BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(8), (int)d.High); 629BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(12), d._flags); 1173BinaryPrimitives.WriteUInt64BigEndian(destination.Slice(sizeof(uint)), _lo64); 1190BinaryPrimitives.WriteUInt32LittleEndian(destination.Slice(sizeof(ulong)), _hi32);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Decimal.DecCalc.cs (1)

2285=> ref MemoryMarshal.Cast<uint, TWindow>(buf.Slice(index))[0];

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

1781Encoding.BigEndianUnicode.GetBytes(name, source.Slice(namespaceBytes.Length));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Enum.cs (2)

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

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

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

src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (1)

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

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (1)

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Guid.cs (1)

981srcUtf8Span.Slice(i, bytesConsumed).CopyTo(destUtf8Span.Slice(newLength));

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

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

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

383buffer = buffer.Slice(charsRead);

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

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

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

546destination = destination.Slice(bytesFromBuffer);

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

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

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

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

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

611path2.CopyTo(destination.Slice(path1.Length + (needsSeparator ? 1 : 0))); 645path3.CopyTo(destination.Slice(charsWritten)); 752destination = destination.Slice(first.Length); 757destination = destination.Slice(1); 762destination = destination.Slice(second.Length); 767destination = destination.Slice(1); 772destination = destination.Slice(third.Length); 777destination = destination.Slice(1);

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

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

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

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

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

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

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

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

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

409n = ReadBuffer(buffer.Slice(charsRead), out readToUserBuffer); 421new Span<char>(_charBuffer, _charPos, n).CopyTo(buffer.Slice(charsRead)); 482i = ReadSpan(buffer.Slice(n)); 1189n = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false); 1253n = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false); 1277new Span<char>(_charBuffer, _charPos, n).CopyTo(buffer.Span.Slice(charsRead));

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

154buffer = buffer.Slice(totalBytesWritten); 210Span<byte> flushTarget = buffer.Slice(bufferBytesWritten);

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

268buffer.CopyTo(_memory.Span.Slice(_position));

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

4858span = span.Slice(pos + 1); 4907span = span.Slice(pos + 1); 6117if (value.TryCopyTo(_destination.Slice(_pos))) 6165if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten)) 6176if (((ISpanFormattable)value).TryFormat(_destination.Slice(_pos), out int charsWritten, default, _provider)) // constrained call avoiding boxing for value types 6226if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten, format)) 6237if (((ISpanFormattable)value).TryFormat(_destination.Slice(_pos), out int charsWritten, format, _provider)) // constrained call avoiding boxing for value types 6294if (value.TryCopyTo(_destination.Slice(_pos))) 6330value.CopyTo(_destination.Slice(_pos)); 6339value.CopyTo(_destination.Slice(_pos)); 6365if (value.TryCopyTo(_destination.Slice(_pos))) 6454_destination.Slice(startingPos, charsWritten).CopyTo(_destination.Slice(startingPos + paddingNeeded));

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (1)

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Number.BigInteger.cs (1)

1201((Span<nuint>)_blocks).Slice(0, length).CopyTo(((Span<nuint>)_blocks).Slice(blocksToShift));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Number.DecimalIeee754.cs (1)

745return coefficient.DigitsCount > 1 && (coefficient.Digits.Slice(1).ContainsAnyExcept((byte)'0') || coefficient.HasNonZeroTail)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Number.DecimalIeee754.DiyFp128.cs (1)

372result = result.Slice(1);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (8)

1781Span<DigitPair> pairs = MemoryMarshal.Cast<char, DigitPair>(buffer.Slice(leadingDigits)); 1813UInt32ToDecChars((uint)(-value), buffer.Slice(sNegative.Length)); 2103UInt64ToDecChars((ulong)(-value), buffer.Slice(sNegative.Length)); 2301Span<DigitPair> pairs = MemoryMarshal.Cast<char, DigitPair>(buffer.Slice(leadingDigits)); 2505UInt128ToDecChars(absValue, buffer.Slice(sNegative.Length)); 2581Int64ToHexChars(buffer.Slice(upperLength), value.Lower, hexBase); 2636UInt64ToBinaryChars(buffer.Slice(upperLength), value.Lower); 2691UInt64ToDecChars(Int128DivMod1E19(ref value), buffer.Slice(index));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\BigIntegerCalculator.Shared.cs (5)

378source.Slice(start).CopyTo(dest.Slice(start)); 606nuint carry = MulAdd1(bits.Slice(i), left, right[i]); 619|| (CompareActual(left.Slice(left.Length - right.Length), right) < 0 && quotient.Length == left.Length - right.Length)); 676nuint carry = SubtractDivisor(left.Slice(n), right, digit); 682carry = AddDivisor(left.Slice(n), right);

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

526destination = destination.Slice(randomBytes.Length); 564destination = destination.Slice(i);

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

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

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncProfiler.cs (22)

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

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

195span.Slice(index, _decryptedLength - index).CopyTo(span.Slice(index + 1)); 240span.Slice(index + 1, _decryptedLength - (index + 1)).CopyTo(span.Slice(index));

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

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

404Ascii.FromUtf16(chars.Slice(idx), bytes.Slice(idx), out int charsConsumed); 415bytes = bytes.Slice(numElementsToConvert); 693Ascii.ToUtf16(bytes.Slice(idx), chars.Slice(idx), out int bytesConsumed); 703chars = chars.Slice(numElementsToConvert);

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

276chars = chars.Slice(charsWrittenJustNow);

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

205bytes = bytes.Slice(bytesWrittenJustNow);

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

501bytes: new Span<byte>(pOriginalBytes, originalByteCount).Slice(bytesWrittenSoFar), 533Span<byte> bytes = new Span<byte>(pOriginalBytes, originalByteCount).Slice(bytesWrittenSoFar); 538bytes = bytes.Slice(bytesWrittenJustNow); 557bytes = bytes.Slice(bytesWrittenJustNow); 641bytes = bytes.Slice(bytesWrittenThisIteration); 663bytes = bytes.Slice(bytesWrittenThisIteration); 1097chars: new Span<char>(pOriginalChars, originalCharCount).Slice(charsWrittenSoFar), 1135Span<char> chars = new Span<char>(pOriginalChars, originalCharCount).Slice(charsWrittenSoFar); 1144chars = chars.Slice(charsWrittenJustNow); 1160chars = chars.Slice(charsWrittenJustNow); 1245chars = chars.Slice(charsWrittenThisIteration); 1263chars = chars.Slice(charsWrittenThisIteration);

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

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

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

520decodedChars = decodedChars.Slice(charsConsumed);

src\runtime\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); 451if (((IUtf8SpanFormattable)value).TryFormat(_destination.Slice(_pos), out int bytesWritten, format: default, _provider)) 509if (((IUtf8SpanFormattable)value).TryFormat(_destination.Slice(_pos), out int bytesWritten, format, _provider)) 574if (Encoding.UTF8.TryGetBytes(value, _destination.Slice(_pos), out int bytesWritten)) 602if (utf8Value.TryCopyTo(_destination.Slice(_pos))) 801_destination.Slice(startingPos, bytesWritten).CopyTo(_destination.Slice(startingPos + paddingNeeded));

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

652chars = chars.Slice(charsWritten);

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

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

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

239destination = destination.Slice(1); 263destination = destination.Slice(valueCharsWritten);

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

System\Xml\UniqueId.cs (1)

293BinaryPrimitives.WriteInt64LittleEndian(destination.Slice(8), _idHigh);

System\Xml\XmlBinaryWriter.cs (10)

System\Xml\XmlConverter.cs (1)

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

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

System\DomainNameHelper.cs (1)

303while (!s_idnMapping.TryGetUnicode(ascii, dest.RawChars.Slice(dest.Length), out charsWritten))

System\IPv4AddressHelper.cs (2)

35numbers[i].TryFormat(stackSpace.Slice(totalChars), out charsWritten); 41numbers[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\UriExt.cs (2)

570vsb = new ValueStringBuilder(destination.Slice(indexOfFirstToUnescape)); 584vsb.AsSpan().CopyTo(destination.Slice(indexOfFirstToUnescape));

System\UriHelper.cs (5)

164vsb = new ValueStringBuilder(destination.Slice(indexOfFirstToEscape)); 178vsb.AsSpan().CopyTo(destination.Slice(indexOfFirstToEscape)); 755span.Slice(readOffset, segmentLength).CopyTo(span.Slice(writeOffset)); 766span.Slice(readOffset).CopyTo(span.Slice(writeOffset));

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

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.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\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder.AppendSpanFormattable.cs (1)

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

src\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder_1.cs (4)

167_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 187_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 188text.CopyTo(_chars.Slice(index)); 236text.CopyTo(_chars.Slice(pos));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\BigIntegerCalculator.Shared.cs (5)

378source.Slice(start).CopyTo(dest.Slice(start)); 606nuint carry = MulAdd1(bits.Slice(i), left, right[i]); 619|| (CompareActual(left.Slice(left.Length - right.Length), right) < 0 && quotient.Length == left.Length - right.Length)); 676nuint carry = SubtractDivisor(left.Slice(n), right, digit); 682carry = AddDivisor(left.Slice(n), right);

System\Number.BigInteger.cs (6)

399ReadOnlySpan<byte> fracDigitsSpan = number.Digits.Slice(intDigits.Length); 924BigIntegerToDecChars(Unsafe.BitCast<Span<char>, Span<Utf16Char>>(span.Slice(state.sNegative.Length)), state.base1E9Value, state.digits); 1083BigIntegerCalculator.Divide(bits.Slice(omittedLength), powOfTen, upper, lower.Slice(omittedLength)); 1104base1E9Buffer.Slice(lower1E9Length), 1406dst.Slice(shift).CopyTo(dst); 1407dst.Slice(dst.Length - shift).Clear();

System\Numerics\BigInteger.cs (10)

1697BinaryPrimitives.WriteUIntPtrBigEndian(destination.Slice(curByte), limb); 1701BinaryPrimitives.WriteUIntPtrLittleEndian(destination.Slice(curByte), limb); 3540zd.Slice(bits.Length).Clear(); 3726NumericsHelpers.DangerousMakeOnesComplement(zd.Slice(leadingZeroCount + 1)); 3849dest = dest.Slice(nint.Size); 3865dest = dest.Slice(nint.Size); 3891dest = dest.Slice(nint.Size); 3927dest = dest.Slice(nint.Size); 3960dest = dest.Slice(nint.Size); 5497NumericsHelpers.DangerousMakeOnesComplement(zd.Slice(negLeadingZeroCount + 1));

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

221Span<nuint> dst = bits.Slice(sigmaDigit); 223dst.Slice(src.Length).Clear(); 252a.Slice((t - 2) * n).CopyTo(z); 253z.Slice(a.Length - (t - 2) * n).Clear(); 255Span<nuint> quotientUpper = quotient.Slice((t - 2) * n); 262Debug.Assert(!q.Slice(quotientUpper.Length).ContainsAnyExcept(0u)); 270quotientUpper.Slice(n).Clear(); 276r.Slice(0, n).CopyTo(z.Slice(n)); 290Span<nuint> rt = r.Slice(sigmaDigit); 291remainder.Slice(rt.Length).Clear(); 336remainder.Slice(left.Length).Clear(); 353quotient.Slice(left.Length).Clear(); 359remainder.Slice(1).Clear(); 370quotient.Slice(quotientLength).Clear(); 375remainder.Slice(r1.Length).Clear(); 380Debug.Assert(!r1.Slice(remainder.Length).ContainsAnyExcept(0u)); 407BurnikelZieglerD3n2n(left.Slice(right.Length), left.Slice(halfN, halfN), right, quotient.Slice(halfN), r1); 429Span<nuint> r1 = remainder.Slice(n); 448b2.CopyTo(d.Slice(n));

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

65value = value.Slice(length);

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

259buffer.Slice(2).Clear(); 276buffer.Slice(1).Clear(); 460bits.Slice(maxLength).Clear();

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

29valueCopy.Slice(value.Length).Clear(); 33bits.Slice(result.Length).Clear(); 272valueCopy.Slice(value.Length).Clear(); 312valueCopy.Slice(value.Length).Clear(); 355bits.Slice(result.Length).Clear(); 379bits.Slice(result.Length).Clear(); 408bits.Slice(result.Length).Clear(); 497value.Slice(0, valueLength).CopyTo(shifted.Slice(k)); 505value.Slice(k).Clear(); 530bits.Slice(rModNLength).Clear(); 533originalBits.Slice(resultLength).Clear(); 644bits.Slice(resultLen).Clear(); 649originalBits.Slice(resultLen).Clear(); 734value.Slice(k).Clear();

System\Numerics\BigIntegerCalculator.ShiftRot.cs (10)

79Span<nuint> upper = bits.Slice(lowerLength); 81Span<nuint> lowerDst = bits.Slice(upperLength); 114Span<uint> upper = bits.Slice(lowerLength); 116Span<uint> lowerDst = bits.Slice(upperLength); 233Vector512<nuint> carries = Vector512.Create(remaining.Slice(1)) << back; 238remaining = remaining.Slice(Vector512<nuint>.Count); 244Vector256<nuint> carries = Vector256.Create(remaining.Slice(1)) << back; 249remaining = remaining.Slice(Vector256<nuint>.Count); 255Vector128<nuint> carries = Vector128.Create(remaining.Slice(1)) << back; 260remaining = remaining.Slice(Vector128<nuint>.Count);

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

114Span<nuint> bitsHigh = bits.Slice(n2); 139AddSelf(bits.Slice(n), core); 287Toom3Data q = Toom3Data.Build(right, n, pAndQAll.Slice(3 * pLength)); 320Span<nuint> z3 = bits.Slice(n * 3); 393AddSelf(bits.Slice(n), z1.TrimEnd((nuint)0)); 394AddSelf(bits.Slice(n * 2), z2.TrimEnd((nuint)0)); 439Span<nuint> bitsHigh = bits.Slice(n + n); 478AddSelf(bits.Slice(n), core.TrimEnd((nuint)0)); 498Span<nuint> bitsHigh = bits.Slice(n); 776AddSelf(bits.Slice(n), z1.TrimEnd((nuint)0)); 777AddSelf(bits.Slice(2 * n), z2.TrimEnd((nuint)0)); 781AddSelf(bits.Slice(3 * n), z3.TrimEnd((nuint)0));

System\Numerics\Complex.cs (5)

882? m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out int realChars, format, provider) 883: m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider)) 886destination = destination.Slice(1 + realChars); // + 1 for < 892? m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out int imaginaryChars, format, provider) 893: m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider))

System\Numerics\Complex.Generic.cs (5)

2088? m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out int realChars, format, provider) 2089: m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider)) 2092destination = destination.Slice(1 + realChars); // + 1 for < 2098? m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out int imaginaryChars, format, provider) 2099: m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider))

System\Numerics\NumericsHelpers.cs (4)

60d = d.Slice(i + 1); 84d = d.Slice(Vector512<nuint>.Count); 91d = d.Slice(Vector256<nuint>.Count); 98d = d.Slice(Vector128<nuint>.Count);

src\runtime\src\libraries\Common\src\Interop\Windows\BCrypt\Interop.BCryptImportKey.cs (1)

41key.CopyTo(blob.Slice(sizeof(BCRYPT_KEY_DATA_BLOB_HEADER)));

src\runtime\src\libraries\Common\src\System\Security\Cryptography\AsymmetricAlgorithmHelpers.Der.cs (1)

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

src\runtime\src\libraries\Common\src\System\Security\Cryptography\DSACng.SignVerify.cs (1)

140hash.CopyTo(stackBuf.Slice(zeroByteCount));

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

56span.CopyTo(destination.Slice(length - span.Length));

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

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

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

163CircularCopyUtf16BE(password, I.Slice(SLen)); 207destination = destination.Slice(hashBuf.Length); 259destination = destination.Slice(bytes.Length); 287destination = destination.Slice(count); 290destination = destination.Slice(nullTerminator.Length);

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

218Span<char> blobBodyChars = MemoryMarshal.Cast<byte, char>(blobBytes.Slice(index)); 224data.CopyTo(blobBytes.Slice(index)); 338Encoding.Unicode.GetBytes(parameterSet, buffer.Slice(blobHeaderSize)); 339key.CopyTo(buffer.Slice(blobHeaderSize + parameterSetMarshalLength));

src\runtime\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\runtime\src\libraries\Common\src\System\Security\Cryptography\X509Certificates\X509CertificateLoader.cs (1)

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

System\Security\Cryptography\Aes.cs (12)

641destination.Slice(written).Clear(); 707decrypt.Slice(8).CopyTo(destination); 726if (header != 0xA65959A6 || pad > 7 || destination.Slice(slen).ContainsAnyExcept((byte)0)) 777Span<byte> keyPart = buf.Slice(8); 805lease.Span.Slice(source.Length).Clear(); 828source.CopyTo(destination.Slice(8)); 833Span<byte> R = destination.Slice(8); 835for (uint i = 0; i < source.Length; i += 8, t++, R = R.Slice(8)) 837R.Slice(0, 8).CopyTo(B.Slice(8)); 871Span<byte> R = destination.Slice(rOffset); 877R.Slice(0, 8).CopyTo(B.Slice(8)); 881B.Slice(8).CopyTo(R);

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

254inputBuffer.Slice(0, whitespaceIndex).CopyTo(transformBuffer.Slice(index)); 266inputBuffer.CopyTo(transformBuffer.Slice(index)); 302transformBuffer.Slice(transformBuffer.Length - _inputIndex).CopyTo(_inputBuffer);

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

760ecParameters.Curve.G.X.CopyTo(basePointBytes.Slice(1)); 761ecParameters.Curve.G.Y.CopyTo(basePointBytes.Slice(1 + ecParameters.Curve.G.X.Length)); 788ecParameters.Q.X.CopyTo(publicKeyBytes.Slice(1)); 789ecParameters.Q.Y.CopyTo(publicKeyBytes.Slice(1 + ecParameters.Q.X!.Length));

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

581context.CopyTo(message.Slice(2)); 585message.Slice(2 + context.Length), 589hash.CopyTo(message.Slice(2 + context.Length + encodedOidLength));

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

61remainingOutput = remainingOutput.Slice(hashLength);

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

65BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), (ushort)value); 73BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), (uint)value); 81BinaryPrimitives.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\runtime\src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (1)

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

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

163CircularCopyUtf16BE(password, I.Slice(SLen)); 207destination = destination.Slice(hashBuf.Length); 259destination = destination.Slice(bytes.Length); 287destination = destination.Slice(count); 290destination = destination.Slice(nullTerminator.Length);

System\Security\Principal\SID.cs (2)

722((ulong)_identifierAuthority).TryFormat(result.Slice(length), out int written); 729((uint)values[index]).TryFormat(result.Slice(length), out written);

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.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)

58tempBuffer.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\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder.cs (5)

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

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

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

488bool success = rune.TryEncodeToUtf8(destination.Slice(written), out int bytesWritten); 534remaining.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)

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

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

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

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

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

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

320utf8Value.CopyTo(quotedValue.Slice(1)); 355JsonWriterHelper.EscapeString(utf8Value, escapedValue.Slice(1), firstByteToEscape, encoder: null, out int written);

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

159destination = destination.Slice(indexOfFirstByteToEscape); 189destination = destination.Slice(written); 236bool result = Utf8Formatter.TryFormat(value, destination.Slice(written), out int bytesWritten, format: s_hexStandardFormat); 283destination = destination.Slice(indexOfFirstByteToEscape); 313destination = destination.Slice(written); 363intChar.TryFormat(destination.Slice(written), out int charsWritten, HexFormatString);

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

732WriteIndentation(output.Slice(BytesPending), indent); 1166WriteIndentation(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)

170WriteIndentation(output.Slice(BytesPending), indent); 285escapedValue.CopyTo(output.Slice(BytesPending)); 320WriteIndentation(output.Slice(BytesPending), indent); 326escapedValue.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\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

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

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

453state.set.AsSpan(2).CopyTo(span.Slice(SetStartIndex)); 461state.set.AsSpan().CopyTo(span.Slice(SetStartIndex)); 465state.category.AsSpan().CopyTo(span.Slice(index));

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

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

src\runtime\src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (2)

88source.CopyTo(_span.Slice(_pos)); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length));

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

453state.set.AsSpan(2).CopyTo(span.Slice(SetStartIndex)); 461state.set.AsSpan().CopyTo(span.Slice(SetStartIndex)); 465state.category.AsSpan().CopyTo(span.Slice(index));

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

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

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

113_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 133_chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count)); 138.CopyTo(_chars.Slice(index)); 190.CopyTo(_chars.Slice(pos)); 217value.CopyTo(_chars.Slice(_pos));

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

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