Span

BrowserLogsCdpConnectionTests.cs (1)

609readableBuffer.Slice(0, count).CopyTo(buffer.Span);

Dcp\GatedReadStream.cs (1)

70content.Span.Slice(_offset, count).CopyTo(buffer.Span);

Commands\Test\MTP\IPC\NamedPipeServer.cs (1)

109remainingBytesToReadOfWholeMessage = BitConverter.ToInt32(remainingBytesToProcess.Span);

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

FormMapping\FormDataReader.cs (8)

123!key.Span[..prefix.Length].Equals(prefix.Span, StringComparison.OrdinalIgnoreCase)) 200if (_currentPrefixBuffer.Length == keyLength || _currentPrefixBuffer.Span[^(keyLength + 1)] != '.') 230separator.CopyTo(_prefixBuffer.Span[_currentPrefixBuffer.Length..]); 234key.CopyTo(_prefixBuffer[startingPoint..].Span); 259var index = _currentPrefixBuffer.Span.LastIndexOfAny(".["); 264if (_currentPrefixBuffer.Span[index] == '.') 266return _currentPrefixBuffer.Span[(index + 1)..].ToString(); 271return _currentPrefixBuffer.Span[(index + 1)..^1].ToString();

BlazorPack\SequenceOfT.cs (2)

325internal Span<T> RemainingSpan => this.AvailableMemory.Span.Slice(this.End); 443this.AvailableMemory.Span.Slice(startIndex, length).Clear();

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

66_span = memory.Span; 221_span = memory.Span;

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

106_memory.Span[_memoryUsed] = (byte)value; 150return _memory.Span.Slice(_memoryUsed, _memory.Length - _memoryUsed);

src\aspnetcore\src\Components\Endpoints\src\FormMapping\FormDataReader.cs (8)

123!key.Span[..prefix.Length].Equals(prefix.Span, StringComparison.OrdinalIgnoreCase)) 200if (_currentPrefixBuffer.Length == keyLength || _currentPrefixBuffer.Span[^(keyLength + 1)] != '.') 230separator.CopyTo(_prefixBuffer.Span[_currentPrefixBuffer.Length..]); 234key.CopyTo(_prefixBuffer[startingPoint..].Span); 259var index = _currentPrefixBuffer.Span.LastIndexOfAny(".["); 264if (_currentPrefixBuffer.Span[index] == '.') 266return _currentPrefixBuffer.Span[(index + 1)..].ToString(); 271return _currentPrefixBuffer.Span[(index + 1)..^1].ToString();

BufferingStream.cs (1)

127return _tailMemory.Span;

RequestBufferingStream.cs (2)

40WriteToBuffer(destination.Slice(0, res).Span); 97if (span.Slice(0, innerCount).TryCopyTo(_tailMemory.Span))

ResponseBufferingStream.cs (1)

135if (slice.TryCopyTo(_tailMemory.Span))

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

106_memory.Span[_memoryUsed] = (byte)value; 150return _memory.Span.Slice(_memoryUsed, _memory.Length - _memoryUsed);

RecyclableSequenceBuilder.cs (1)

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

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\MemoryBuilder`1.cs (6)

71return ref _memory.Span[index]; 86memory.Span[index] = item; 103memory.Span[index] = source[0]; 118_memory.Span[index] = item; 130source.CopyTo(_memory.Span[_length..]); 162_memory.Span.CopyTo(newArray);

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\MemoryBuilderExtensions.cs (3)

43return builder.AsMemory().Span[0].ToString(); 49foreach (var chunk in chunks.Span) 56foreach (var chunk in chunks.Span)

Utilities\CleanableWeakCache`2.cs (1)

277foreach (var key in deadKeys.AsMemory().Span)

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticMemoryPool.cs (2)

173fixed (byte* inUseMemoryPtr = memory.Span) 174fixed (byte* beginPooledMemoryPtr = block.Memory.Span)

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticPoolBlock.cs (1)

116return _memory.Span;

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (11)

Core\IISHttpContext.IO.cs (1)

38readableBuffer.CopyTo(memory.Span);

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticMemoryPool.cs (2)

173fixed (byte* inUseMemoryPtr = memory.Span) 174fixed (byte* beginPooledMemoryPtr = block.Memory.Span)

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticPoolBlock.cs (1)

116return _memory.Span;

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (11)

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

138readableBuffer.CopyTo(destination.Span);

Internal\Http\Http1OutputProducer.cs (7)

225return GetFakeMemory(sizeHint).Span; 229return LeasedMemory(sizeHint).Span; 233return GetChunkedMemory(sizeHint).Span; 237return _pipeWriter.GetMemory(sizeHint).Span; 401CommitChunkInternal(ref writer, segment.Span); 405writer.Write(segment.Span); 803public ReadOnlySpan<byte> Span => Buffer.Span.Slice(0, Length);

Internal\Http\HttpRequestStream.cs (1)

138slice.CopyTo(destination.Span);

Internal\Http2\Http2Connection.cs (1)

1910bufferSlice.CopyTo(outputBuffer.Span);

Internal\Http2\Http2OutputProducer.cs (1)

486return GetFakeMemory(sizeHint).Span;

Internal\Http3\Http3OutputProducer.cs (1)

219return GetFakeMemory(sizeHint).Span;

Internal\Infrastructure\PipeWriterHelpers\ConcurrentPipeWriter.cs (1)

87return _tailMemory.Span;

Middleware\Internal\LoggingStream.cs (1)

111Log("ReadAsync", destination.Span.Slice(0, read));

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticMemoryPool.cs (2)

173fixed (byte* inUseMemoryPtr = memory.Span) 174fixed (byte* beginPooledMemoryPtr = block.Memory.Span)

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticPoolBlock.cs (1)

116return _memory.Span;

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

138readableBuffer.CopyTo(destination.Span);

ConnectionIoState.cs (2)

244var status = TlsRead(buffer.Span, out var read); 291var status = TlsRead(_readBuffer.Span, out var read);

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticMemoryPool.cs (2)

173fixed (byte* inUseMemoryPtr = memory.Span) 174fixed (byte* beginPooledMemoryPtr = block.Memory.Span)

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticPoolBlock.cs (1)

116return _memory.Span;

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticMemoryPool.cs (2)

173fixed (byte* inUseMemoryPtr = memory.Span) 174fixed (byte* beginPooledMemoryPtr = block.Memory.Span)

src\aspnetcore\src\Shared\Buffers.MemoryPool\DiagnosticPoolBlock.cs (1)

116return _memory.Span;

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

106_memory.Span[_memoryUsed] = (byte)value; 150return _memory.Span.Slice(_memoryUsed, _memory.Length - _memoryUsed);

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

106_memory.Span[_memoryUsed] = (byte)value; 150return _memory.Span.Slice(_memoryUsed, _memory.Length - _memoryUsed);

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

106_memory.Span[_memoryUsed] = (byte)value; 150return _memory.Span.Slice(_memoryUsed, _memory.Length - _memoryUsed);

ResponseBodyReaderStream.cs (1)

104readableBuffer.CopyTo(buffer.Span);

MultipartReaderStream.cs (3)

274var readAmount = _innerStream.Read(slice.Span); 297read = _innerStream.Read(slice.Span); 308read = _innerStream.Read(buffer.Span[..Math.Min(buffer.Length, bufferedData.Count)]);

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

29memory.Span.Clear();

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

CSharp\RequiredAttributeParser.cs (3)

148return ParseResult.Failed(name, nameComparison, value, valueComparison, _diagnostics.AsMemory().Span); 165return ParseResult.Failed(name, nameComparison, value, valueComparison, _diagnostics.AsMemory().Span); 173return ParseResult.Failed(name, nameComparison, value, valueComparison, _diagnostics.AsMemory().Span);

Language\TagHelperBinder.cs (2)

91foreach (var (builderIndex, tagHelper) in toAdd.AsMemory().Span) 96foreach (var tagHelper in catchAllToAdd.AsMemory().Span)

Language\TagHelperCollection_Factories.cs (2)

148return Create(builder.AsMemory().Span); 294return Merge(builder.AsMemory().Span);

Language\TagHelperCollection.SegmentBuilder.cs (1)

99var segments = _builder.AsMemory().Span;

Language\TagHelperDiscoveryService.cs (1)

70return TagHelperCollection.Merge(collections.AsMemory().Span);

SourceGenerators\RazorSourceGenerator.cs (1)

367return TagHelperCollection.Merge(collections.AsMemory().Span);

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

DataFrameBuffer.cs (2)

32get => (MemoryMarshal.Cast<byte, T>(Buffer.Span)).Slice(0, Length); 38get => MemoryMarshal.Cast<byte, T>(Buffer.Span);

DatabaseOperations.cs (1)

341if (new ReadOnlySpan<byte>(lease, 0, read).TryCopyTo(memory.Span))

Resolver\DnsDataWriter.cs (6)

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

Resolver\DnsResolver.cs (1)

922int len = memory.Span[0];

Resolver\DnsPrimitivesTests.cs (9)

106data.Span[^2] = 0xc0; 118data.Span[^2] = 0xc0; 131data.Span[4] = 0xc0; 141data.Span[4] = 0xc0; 151data.Span[13] = 0xc0; 152data.Span[14] = 0x00; // -> com 153data.Span[24] = 0xc0; 154data.Span[25] = 13; // -> -> com 163data.Span[0] = 0x40;

Fuzzers\DnsResponseFuzzer.cs (1)

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

OnnxTransform.cs (1)

721tensor.Buffer.Span.CopyTo(editor.Values);

Normalizer\SentencePieceNormalizer.cs (2)

439ReadOnlySpan<byte> normalizedByte = normalizedPrefix.Length == 0 ? input.Slice(0, p) : normalizedPrefix.Span; 470ReadOnlySpan<byte> sp = normalizedPrefix.Length == 0 ? input.Slice(0, p) : normalizedPrefix.Span;

src\roslyn\src\Dependencies\Collections\Segmented\SegmentedArray.cs (1)

29memory.Span.Clear();

src\runtime\src\libraries\Common\src\System\ReadWriteAdapter.cs (3)

61new ValueTask<int>(stream.Read(buffer.Span)); 64new ValueTask<int>(stream.ReadAtLeast(buffer.Span, minimumBytes, throwOnEndOfStream)); 68stream.ReadExactly(buffer.Span);

System\Formats\Tar\GnuSparseStream.cs (1)

232buffer.Slice(totalFilled, zeroCount).Span.Clear();

System\Formats\Tar\TarHeader.Read.cs (3)

32TarHeader? header = TryReadAttributes(initialFormat, buffer.Span, archiveStream); 668ReadExtendedAttributesFromBuffer(memory.Span, _name); 720ReadGnuLongPathDataFromBuffer(memory.Span);

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

59WriteFieldsToBuffer(format, buffer.Span); 149WriteFieldsToBuffer(format, buffer.Span); 308buffer.Span.Clear(); 315buffer.Span.Clear(); 327buffer.Span.Clear(); // Reset it to reuse it 384buffer.Span.Clear(); // Reset it to reuse it 393buffer.Span.Clear(); // Reset it to reuse it

System\Formats\Tar\TarWriter.cs (1)

346buffer.Span.Clear(); // Rented arrays aren't clean

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

173int bytesRead = _inflater.Inflate(buffer.Span); 228bytesRead = _inflater.Inflate(buffer.Span);

System\IO\Compression\DeflateManaged\InputBuffer.cs (6)

46_bitBuffer |= (uint)_buffer.Span[0] << _bitsInBuffer; 57_bitBuffer |= (uint)_buffer.Span[0] << _bitsInBuffer; 79Span<byte> span = _buffer.Span; 87_bitBuffer |= (uint)_buffer.Span[0] << _bitsInBuffer; 96_bitBuffer |= (uint)_buffer.Span[0] << _bitsInBuffer; 137output.Span[0] = (byte)_bitBuffer;

System\IO\Compression\DeflateZLib\DeflateStream.cs (1)

469bytesRead = _inflater.Inflate(buffer.Span);

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

460ProcessBlock(buffer.Span.Slice(0, bytesRead));

System\IO\Compression\ZipBlocks.Async.cs (2)

152List<ZipGenericExtraField> list = GetExtraFieldPostReadWork(extraFieldBuffer.Span, out byte[] trailingData); 226dynamicHeader = collatedHeader.Span;

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

404Span<byte> span = buffer.Span;

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

609ProcessBytesRead(buffer.Span.Slice(0, bytesRead));

System\IO\Compression\ZipHelper.Async.cs (1)

59bufferPointer = bufferMemory.Span.LastIndexOf(signatureToFind.Span);

System\IO\Compression\Zstandard\ZstandardStream.Compress.cs (2)

187lastResult = _encoder.Flush(output.Span, out bytesWritten); 191lastResult = _encoder.Compress(buffer.Span, output.Span, out bytesConsumed, out bytesWritten, isFinalBlock);

System\IO\Compression\Zstandard\ZstandardStream.Decompress.cs (1)

334while (!TryDecompress(buffer.Span, out bytesWritten, out lastResult))

System\IO\Compression\dec\BrotliStream.Decompress.cs (1)

164while (!TryDecompress(buffer.Span, out bytesWritten, out lastResult))

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

123internal OperationStatus Flush(Memory<byte> destination, out int bytesWritten) => Flush(destination.Span, out bytesWritten); 131internal OperationStatus Compress(ReadOnlyMemory<byte> source, Memory<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) => Compress(source.Span, destination.Span, out bytesConsumed, out bytesWritten, isFinalBlock);

System\IO\Pipelines\Pipe.cs (3)

165return _writingHeadMemory.Span; 1211Span<byte> destination = _writingHeadMemory.Span; 1236destination = _writingHeadMemory.Span;

System\IO\Pipelines\PipeReaderStream.cs (1)

108return HandleReadResult(result, buffer.Span);

System\IO\Pipelines\StreamPipeWriter.cs (1)

116return _tailMemory.Span;

System\IO\Ports\SerialStream.Unix.cs (1)

780Span<byte> buff = readRequest.Buffer.Span;

System\Buffers\ReadOnlySequence.Helpers.cs (2)

229return ((MemoryManager<T>)startObject).Memory.Span.Slice(startIndex, endIndex - startIndex); 694return ((MemoryManager<T>)startObject).Memory.Span.Slice(startIndex, endIndex - startIndex);

System\Buffers\ReadOnlySequenceStream.cs (1)

127int n = Read(buffer.Span);

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

396block.Span.CopyTo(destination); 415source.CopyTo(block.Span); 419source.Slice(0, block.Length).CopyTo(block.Span);

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

143int bytesRead = ReadChunksFromConnectionBuffer(buffer.Span, cancellationRegistration: default); 226int bytesCopied = ReadChunksFromConnectionBuffer(buffer.Span, ctr);

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

408buffer.Span[0] = _firstByte;

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

1319FrameHeader.WriteTo(writeBuffer.Span, 0, FrameType.Settings, FrameFlags.Ack, streamId: 0); 1342Span<byte> span = writeBuffer.Span; 1357Span<byte> span = writeBuffer.Span; 1723Span<byte> span = writeBuffer.Span; 1801FrameHeader.WriteTo(writeBuffer.Span, s.current.Length, FrameType.Data, FrameFlags.None, s.streamId); 1821FrameHeader.WriteTo(writeBuffer.Span, 0, FrameType.Data, FrameFlags.EndStream, s.streamId); 1834Span<byte> span = writeBuffer.Span;

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

1164(bool wait, int bytesRead) = TryReadFromBuffer(buffer.Span); 1169(wait, bytesRead) = TryReadFromBuffer(buffer.Span);

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

1290_recvBuffer.ActiveSpan.Slice(0, copyLen).CopyTo(buffer.Span);

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

1807return new ValueTask<int>(ReadFromBuffer(destination.Span)); 1882return ReadFromBuffer(destination.Span);

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

350stream.Write(buffer.Span); 359: stream.ReadAtLeast(buffer.Span, buffer.Length, throwOnEndOfStream: false);

src\runtime\src\libraries\Common\src\System\ReadWriteAdapter.cs (3)

61new ValueTask<int>(stream.Read(buffer.Span)); 64new ValueTask<int>(stream.ReadAtLeast(buffer.Span, minimumBytes, throwOnEndOfStream)); 68stream.ReadExactly(buffer.Span);

System\Net\Base64Stream.cs (1)

206read = DecodeBytes(buffer.Span.Slice(0, read));

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

144public bool Equals(SocketAddress? comparand) => comparand != null && Buffer.Span.SequenceEqual(comparand.Buffer.Span);

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

11public static IPAddress GetIPAddress(this SocketAddress socketAddress) => IPEndPointExtensions.GetIPAddress(socketAddress.Buffer.Span); 15return (int)SocketAddressPal.GetPort(socketAddress.Buffer.Span); 27return ipe.Equals(socketAddress.Buffer.Span);

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

396block.Span.CopyTo(destination); 415source.CopyTo(block.Span); 419source.Slice(0, block.Length).CopyTo(block.Span);

src\runtime\src\libraries\Common\src\System\Net\StreamBuffer.cs (2)

242(bool wait, int bytesRead) = TryReadFromBuffer(buffer.Span); 247(wait, bytesRead) = TryReadFromBuffer(buffer.Span);

System\Net\Quic\Internal\ReceiveBuffers.cs (1)

78activeBuffer.Slice(0, copied).CopyTo(buffer.Span);

System\Net\Quic\QuicConnection.SslConnectionOptions.cs (5)

104certificateBuffer->Span.CopyTo(certData.Span); 111chainBuffer->Span.CopyTo(chainData.Span); 132certificate = X509CertificateLoader.LoadCertificate(certData.Span); 135result = _connection._sslConnectionOptions.ValidateCertificate(certificate, certData.Span, chainData.Span);

src\runtime\src\libraries\Common\src\System\ReadWriteAdapter.cs (3)

61new ValueTask<int>(stream.Read(buffer.Span)); 64new ValueTask<int>(stream.ReadAtLeast(buffer.Span, minimumBytes, throwOnEndOfStream)); 68stream.ReadExactly(buffer.Span);

System\Net\Security\SslStream.IO.cs (2)

943Span<byte> destination = _handshakeWaiter == null ? buffer.Span : default; 1097_buffer.DecryptedReadOnlySpanSliced(copyBytes).CopyTo(buffer.Span);

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

11public static IPAddress GetIPAddress(this SocketAddress socketAddress) => IPEndPointExtensions.GetIPAddress(socketAddress.Buffer.Span); 15return (int)SocketAddressPal.GetPort(socketAddress.Buffer.Span); 27return ipe.Equals(socketAddress.Buffer.Span);

System\Net\Sockets\NetEventSource.Sockets.cs (1)

58DumpBuffer(thisOrContextObject, buffer.Span.Slice(offset, count), memberName);

System\Net\Sockets\Socket.cs (4)

334buffer.Slice(0, size).CopyTo(socketAddress.Buffer.Span); 380buffer.Slice(0, size).CopyTo(socketAddress.Buffer.Span); 816socketAddress.Buffer.Span.Slice(0, socketAddress.Size)); 3284ipep.Serialize(e._socketAddress.Buffer.Span);

System\Net\Sockets\SocketAsyncContext.Unix.cs (27)

System\Net\Sockets\SocketAsyncEventArgs.Unix.cs (1)

347new ReadOnlySpan<byte>(_acceptBuffer, 0, _acceptAddressBufferCount).CopyTo(remoteSocketAddress.Buffer.Span);

System\Net\Sockets\SocketPal.Unix.cs (9)

631fixed (byte* rawSocketAddress = socketAddress.Span) 683fixed (byte* rawSocketAddress = socketAddress.Span) 910SysReceiveMessageFrom(socket, flags, buffer, socketAddress.Span, out receivedSocketAddressLength, isIPv4, isIPv6, out receivedFlags, out ipPacketInformation, out errno) : 911SysReceiveMessageFrom(socket, flags, buffers, socketAddress.Span, out receivedSocketAddressLength, isIPv4, isIPv6, out receivedFlags, out ipPacketInformation, out errno); 919SocketAddressPal.Clear(socketAddress.Span); 1245TryCompleteSendTo(handle, buffer, ref offset, ref count, socketFlags, socketAddress.Span, ref bytesTransferred, out errorCode); 1258TryCompleteSendTo(handle, buffer, socketFlags, socketAddress.Span, ref bytesTransferred, out errorCode); 1363bool completed = TryCompleteReceiveFrom(handle, new Span<byte>(buffer, offset, count), socketFlags, socketAddress.Span, out socketAddressLen, out bytesTransferred, out socketFlags, out errorCode); 1375bool completed = TryCompleteReceiveFrom(handle, buffer, socketFlags, socketAddress.Span, out socketAddressLen, out bytesTransferred, out socketFlags, out errorCode);

System\Net\Sockets\UnixDomainSocketEndPoint.cs (1)

115public override EndPoint Create(SocketAddress socketAddress) => new UnixDomainSocketEndPoint(socketAddress.Buffer.Span.Slice(0, socketAddress.Size));

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

836long payloadLength = _receiveBuffer.Span[_receiveBufferOffset + 1] & 0x7F; 926_receiveBuffer.Span.Slice(_receiveBufferOffset, receiveBufferBytesToCopy).CopyTo( 927header.Compressed ? _inflater!.Span : payloadBuffer.Span); 956payloadBuffer.Span.Slice(0, totalBytesReceived), header.Mask, _receivedMaskOffsetOffset); 971header.Processed = _inflater!.Inflate(payloadBuffer.Span, out totalBytesReceived) && header.PayloadLength == 0; 981!TryValidateUtf8(payloadBuffer.Span.Slice(0, totalBytesReceived), header.EndOfMessage, _utf8TextState)) 1099ApplyMask(_receiveBuffer.Span.Slice(_receiveBufferOffset, (int)header.PayloadLength), header.Mask, 0); 1102closeStatus = (WebSocketCloseStatus)BinaryPrimitives.ReadUInt16BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset)); 1112closeStatusDescription = s_textEncoding.GetString(_receiveBuffer.Span.Slice(_receiveBufferOffset + 2, (int)header.PayloadLength - 2)); 1203ApplyMask(_receiveBuffer.Span.Slice(_receiveBufferOffset, (int)header.PayloadLength), header.Mask, 0); 1222long pongPayload = BinaryPrimitives.ReadInt64BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset, (int)header.PayloadLength)); 1317Span<byte> receiveBufferSpan = _receiveBuffer.Span; 1613_receiveBuffer.Span.Slice(_receiveBufferOffset, _receiveBufferCount).CopyTo(_receiveBuffer.Span);

System\Net\WebSockets\WebSocket.cs (1)

47new Span<byte>(array, 0, r.Count).CopyTo(buffer.Span);

src\runtime\src\libraries\System.Private.CoreLib\src\Microsoft\Win32\SafeHandles\SafeFileHandle.ThreadPoolValueTaskSource.cs (1)

99result = RandomAccess.ReadAtOffset(_fileHandle, writableSingleSegment.Span, _fileOffset);

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

646bytesFromBuffer = ReadFromBuffer(buffer.Span); 687int bytesFromBuffer = ReadFromBuffer(buffer.Span); 718bytesFromBuffer = ReadFromBuffer(buffer.Span);

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

412Read(buffer.Span));

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

151return new ValueTask<int>(Read(buffer.Span));

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

330_buffer.AsSpan(_readPos, buffer.Length).CopyTo(buffer.Span); 374new Span<byte>(_buffer!, _readPos, n).CopyTo(destination.Span); 412_buffer.AsSpan(_readPos, bytesFromBuffer).CopyTo(buffer.Span); 449_buffer.AsSpan(0, bytesFromBuffer).CopyTo(buffer.Span);

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

324new ReadOnlySpan<byte>(localBuffer, 0, result).CopyTo(localDestination.Span);

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

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\StringReader.cs (2)

303new ValueTask<int>(ReadBlock(buffer.Span)); 321new ValueTask<int>(Read(buffer.Span));

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

272return new ValueTask<int>(Read(buffer.Span));

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\TextReader.cs (3)

280return t.Item1.Read(t.Item2.Span); 287return t.Item1.Read(t.Item2.Span); 310return t.Item1.ReadBlock(t.Item2.Span);

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

470Read(buffer.Span));

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

90ReadOnlySpan<byte> span = _memory.Span; 122_memory.Span.Slice(_position, bytesToRead).CopyTo(buffer); 153return new ValueTask<int>(Read(buffer.Span)); 192destination.Write(_memory.Span.Slice(_position, _length - _position)); 229_memory.Span.Slice(_length, _position - _length).Clear(); 232_memory.Span[_position++] = value; 265_memory.Span.Slice(_length, _position - _length).Clear(); 268buffer.CopyTo(_memory.Span.Slice(_position)); 329_memory.Span.Slice(_length, newLength - _length).Clear();

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

212return (_object is string str) ? str.Substring(_index, _length) : Span.ToString(); 362public void CopyTo(Memory<T> destination) => Span.CopyTo(destination.Span); 372public bool TryCopyTo(Memory<T> destination) => Span.TryCopyTo(destination.Span); 440public T[] ToArray() => Span.ToArray();

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

3972source.CopyTo(destination.Span);

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

18ReadOnlySpan<T> span = memory.Span; 30=> memory.Slice(ClampStart(memory.Span, trimElement)); 38=> memory.Slice(0, ClampEnd(memory.Span, 0, trimElement)); 206ReadOnlySpan<T> span = memory.Span; 231return memory.Slice(ClampStart(memory.Span, trimElements)); 253return memory.Slice(0, ClampEnd(memory.Span, 0, trimElements)); 519ReadOnlySpan<char> span = memory.Span; 530=> memory.Slice(ClampStart(memory.Span)); 537=> memory.Slice(0, ClampEnd(memory.Span, 0));

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

284public void CopyTo(Memory<T> destination) => Span.CopyTo(destination.Span); 294public bool TryCopyTo(Memory<T> destination) => Span.TryCopyTo(destination.Span);

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

433_readBuffer.AsSpan(_readBufferOffset, bytesToReturn).CopyTo(buffer.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\KeyFormatHelper.Encrypted.cs (2)

164decryptedMemory.Span, 184CryptographicOperations.ZeroMemory(decryptedMemory.Span);

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

1643ExportEncapsulationKeyCore(encapsulationKey.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs8PrivateKeyInfo.cs (2)

188Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span)); 219Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span));

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

319new ReadOnlySpan<byte>(_outputBuffer, 0, bytesToCopy).CopyTo(buffer.Span); 392tempOutputBuffer.AsSpan(0, numOutputBytes).CopyTo(buffer.Span);

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

160return hash.Finalize(destination.Span);

System\Security\Cryptography\LiteHashProvider.Xof.cs (1)

145hash.Finalize(destination.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\KeyFormatHelper.Encrypted.cs (2)

164decryptedMemory.Span, 184CryptographicOperations.ZeroMemory(decryptedMemory.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs8PrivateKeyInfo.cs (2)

188Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span)); 219Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span));

System\ServiceModel\Channels\Connection.cs (2)

207buffer.CopyTo(memBuffer.Span); 248memBuffer.Slice(0, bytesRead).Span.CopyTo(buffer);

System\ServiceModel\Channels\FramingEncoders.cs (8)

19var span = bytes.Span; 59EncodedBytes.Span[0] = (byte)recordType; 62Encoding.UTF8.GetBytes(value, EncodedBytes.Slice(offset).Span); 75return (EncodedBytes.Span[0] << 16) | 76(EncodedBytes.Span[EncodedBytes.Length / 2] << 8) | 77EncodedBytes.Span[EncodedBytes.Length - 1]; 110if (EncodedBytes.Span[i] != otherBytes.Span[i])

System\ServiceModel\Channels\SingletonConnectionReader.cs (3)

546new ReadOnlySpan<byte>(localBuffer, 0, result).CopyTo(localDestination.Span); 651_encodedSize.Span[0] = 0x01; 652_encodedSize.Span[1] = value;

System\Text\Json\Serialization\Converters\Collection\MemoryConverter.cs (1)

49return ReadOnlyMemoryConverter<T>.OnWriteResume(writer, value.Span, options, ref state);

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

20writer.WriteBase64StringValue(value.Span);

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

643Span<byte> output = _memory.Span; 722Span<byte> output = _memory.Span; 1081Span<byte> output = _memory.Span; 1162Span<byte> output = _memory.Span;

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

221Span<byte> output = _memory.Span; 256Span<byte> output = _memory.Span; 295Span<byte> output = _memory.Span; 345Span<byte> output = _memory.Span;

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

226Span<byte> output = _memory.Span; 259Span<byte> output = _memory.Span; 297Span<byte> output = _memory.Span; 345Span<byte> output = _memory.Span;

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

225Span<byte> output = _memory.Span; 258Span<byte> output = _memory.Span; 296Span<byte> output = _memory.Span; 344Span<byte> output = _memory.Span;

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

225Span<byte> output = _memory.Span; 255Span<byte> output = _memory.Span; 290Span<byte> output = _memory.Span; 335Span<byte> output = _memory.Span;

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

229Span<byte> output = _memory.Span; 259Span<byte> output = _memory.Span; 294Span<byte> output = _memory.Span; 339Span<byte> output = _memory.Span;

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

229Span<byte> output = _memory.Span; 259Span<byte> output = _memory.Span; 294Span<byte> output = _memory.Span; 339Span<byte> output = _memory.Span;

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

225Span<byte> output = _memory.Span; 259Span<byte> output = _memory.Span; 298Span<byte> output = _memory.Span; 347Span<byte> output = _memory.Span;

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

87Span<byte> output = _memory.Span; 118Span<byte> output = _memory.Span; 160Span<byte> output = _memory.Span; 191Span<byte> output = _memory.Span;

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

345Span<byte> output = _memory.Span; 375Span<byte> output = _memory.Span; 408Span<byte> output = _memory.Span; 438Span<byte> output = _memory.Span; 483Span<byte> output = _memory.Span;

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

298Span<byte> output = _memory.Span; 328Span<byte> output = _memory.Span; 363Span<byte> output = _memory.Span; 408Span<byte> output = _memory.Span;

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

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

307Span<byte> output = _memory.Span; 337Span<byte> output = _memory.Span; 372Span<byte> output = _memory.Span; 417Span<byte> output = _memory.Span;

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

74Span<byte> output = _memory.Span; 114Span<byte> output = _memory.Span;

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

91Span<byte> output = _memory.Span; 125Span<byte> output = _memory.Span; 204Span<byte> output = _memory.Span; 231Span<byte> output = _memory.Span;

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

51Span<byte> output = _memory.Span; 79Span<byte> output = _memory.Span;

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

52Span<byte> output = _memory.Span; 80Span<byte> output = _memory.Span;

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

51Span<byte> output = _memory.Span; 75Span<byte> output = _memory.Span;

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

55Span<byte> output = _memory.Span; 79Span<byte> output = _memory.Span;

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

55Span<byte> output = _memory.Span; 79Span<byte> output = _memory.Span;

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

56Span<byte> output = _memory.Span; 81Span<byte> output = _memory.Span;

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

51Span<byte> output = _memory.Span; 80Span<byte> output = _memory.Span;

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

75Span<byte> output = _memory.Span; 99Span<byte> output = _memory.Span;

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

180Span<byte> output = _memory.Span; 268Span<byte> output = _memory.Span;

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

64Span<byte> output = _memory.Span; 88Span<byte> output = _memory.Span;

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

129Span<byte> output = _memory.Span; 157Span<byte> output = _memory.Span; 277Span<byte> output = _memory.Span; 307Span<byte> output = _memory.Span;

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

175Span<byte> output = _memory.Span; 341Span<byte> output = _memory.Span; 454Span<byte> output = _memory.Span; 485Span<byte> output = _memory.Span; 514Span<byte> output = _memory.Span; 531_memory.Span[BytesPending++] = JsonConstants.Quote;

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

66Span<byte> output = _memory.Span; 90Span<byte> output = _memory.Span;