AsMemory

Otlp\Model\OtlpInstrument.cs (1)

60var comparableAttributes = tempAttributes.AsMemory(0, copyCount);

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

Program.cs (1)

717await stream.WriteAsync(_buffer.AsMemory(i, 1));

TestConnections.cs (1)

155return actual.AsMemory(0, offset);

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

Http2\Http2ConnectionTests.cs (1)

1289var maxDataMinusPadding = _maxData.AsMemory(0, _maxData.Length - padLength - 1);

Http3\Http3StreamTests.cs (3)

2851readCount += await context.Request.Body.ReadAsync(buffer.AsMemory(readCount, 100 - readCount)); 2854await context.Response.Body.WriteAsync(buffer.AsMemory(0, 100)); 2882Assert.Equal(sourceData.AsMemory(0, 100).ToArray(), data.ToArray());

src\Servers\Kestrel\shared\test\StreamExtensions.cs (2)

70data.AddRange(buffer.AsMemory(0, read).ToArray()); 92data.AddRange(buffer.AsMemory(0, read).ToArray());

Http2\Http2RequestTests.cs (1)

311data.AddRange(buffer.AsMemory(0, readCount).ToArray());

src\Servers\Kestrel\shared\test\StreamExtensions.cs (2)

70data.AddRange(buffer.AsMemory(0, read).ToArray()); 92data.AddRange(buffer.AsMemory(0, read).ToArray());

src\Shared\PooledArrayBufferWriter.cs (1)

51return _rentedBuffer.AsMemory(0, _index);

src\Shared\QueryStringEnumerable.cs (1)

103return buffer.AsMemory(0, unescapedLength);

FormMapping\HttpContextFormValueMapper.cs (1)

135buffer.AsMemory(0, options.MaxKeyBufferSize),

Circuits\RemoteJSDataStream.cs (1)

185return await _pipeReaderStream.ReadAsync(buffer.AsMemory(offset, count), linkedCts.Token);

src\Shared\PooledArrayBufferWriter.cs (1)

51return _rentedBuffer.AsMemory(0, _index);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

src\Components\Shared\src\PullFromJSDataStream.cs (1)

77=> await ReadAsync(buffer.AsMemory(offset, count), cancellationToken);

src\Components\Shared\src\PullFromJSDataStream.cs (1)

77=> await ReadAsync(buffer.AsMemory(offset, count), cancellationToken);

src\Shared\PooledArrayBufferWriter.cs (1)

51return _rentedBuffer.AsMemory(0, _index);

src\Shared\PooledArrayBufferWriter.cs (1)

51return _rentedBuffer.AsMemory(0, _index);

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

45public ReadOnlyMemory<T> WrittenMemory => _buffer.AsMemory(0, WrittenCount);

Internal\ReferenceReadStream.cs (1)

102=> ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

src\Http\Shared\StreamCopyOperationInternal.cs (2)

59var read = await source.ReadAsync(buffer.AsMemory(0, readLength), cancel); 74await destination.WriteAsync(buffer.AsMemory(0, read), cancel);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

src\SignalR\common\Shared\PipeWriterStream.cs (1)

58return WriteCoreAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

src\SignalR\common\Shared\PipeWriterStream.cs (1)

58return WriteCoreAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

RequestDelegateFactory.cs (1)

125private static readonly MethodInfo AsMemoryMethod = new Func<char[]?, int, int, Memory<char>>(MemoryExtensions.AsMemory).Method;

src\Http\Shared\StreamCopyOperationInternal.cs (2)

59var read = await source.ReadAsync(buffer.AsMemory(0, readLength), cancel); 74await destination.WriteAsync(buffer.AsMemory(0, read), cancel);

src\Http\Shared\StreamCopyOperationInternal.cs (2)

59var read = await source.ReadAsync(buffer.AsMemory(0, readLength), cancel); 74await destination.WriteAsync(buffer.AsMemory(0, read), cancel);

RequestBufferingStream.cs (1)

47var res = await _innerStream.ReadAsync(buffer.AsMemory(offset, count), cancellationToken);

src\Shared\SizeLimitedStream.cs (1)

84return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

src\Shared\PooledArrayBufferWriter.cs (1)

51return _rentedBuffer.AsMemory(0, _index);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

Streams\OutputCacheStream.cs (1)

157await WriteAsync(buffer.AsMemory(offset, count), cancellationToken);

src\Shared\SizeLimitedStream.cs (1)

84return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

Streams\ResponseCachingStream.cs (1)

131await WriteAsync(buffer.AsMemory(offset, count), cancellationToken);

ResponseCompressionBody.cs (1)

178=> await WriteAsync(buffer.AsMemory(offset, count), cancellationToken);

src\Shared\SizeLimitedStream.cs (1)

84return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

ResponseStream.cs (1)

65=> await WriteAsync(buffer.AsMemory(offset, count), cancellationToken);

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

Middleware\Internal\LoggingStream.cs (1)

98int read = await _inner.ReadAsync(buffer.AsMemory(offset, count), cancellationToken);

src\Shared\runtime\Http3\QPack\QPackDecoder.cs (1)

685buffer.AsMemory(0, existingLength).CopyTo(newBuffer);

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

src\Servers\Kestrel\shared\test\StreamExtensions.cs (2)

70data.AddRange(buffer.AsMemory(0, read).ToArray()); 92data.AddRange(buffer.AsMemory(0, read).ToArray());

QuicConnectionContextTests.cs (1)

267data.AddRange(buffer.AsMemory(0, readCount).ToArray());

src\Servers\Kestrel\shared\test\StreamExtensions.cs (2)

70data.AddRange(buffer.AsMemory(0, read).ToArray()); 92data.AddRange(buffer.AsMemory(0, read).ToArray());

src\Shared\PooledArrayBufferWriter.cs (1)

51return _rentedBuffer.AsMemory(0, _index);

src\Shared\QueryStringEnumerable.cs (1)

103return buffer.AsMemory(0, unescapedLength);

src\Shared\runtime\Http3\QPack\QPackDecoder.cs (1)

685buffer.AsMemory(0, existingLength).CopyTo(newBuffer);

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

98return _output.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).GetAsTask();

src\SignalR\common\Shared\PipeWriterStream.cs (1)

58return WriteCoreAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

Internal\Protocol\Utf8BufferTextWriterTests.cs (2)

403segment.CopyTo(result.AsMemory(totalWritten, segment.Length)); 409CurrentSegment.Slice(0, Position).CopyTo(result.AsMemory(totalWritten, Position));

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

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

113return _currentSegment.AsMemory(_position, _currentSegment.Length - _position); 201await destination.WriteAsync(segment.Buffer.AsMemory(0, segment.Length), cancellationToken).ConfigureAwait(false); 211await destination.WriteAsync(_currentSegment.AsMemory(0, _position), cancellationToken).ConfigureAwait(false);

RedisEndToEnd.cs (1)

268ws.SetReceiveResult((res, buffer.AsMemory(0, res.Count)));

HubConnectionHandlerTests.cs (1)

520await client.Connection.Application.Output.WriteAsync(payload.AsMemory(0, payload.Length / 2));

ResponseBodyReaderStream.cs (1)

74return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

WebSocketClientTests.cs (1)

85await websocket.SendAsync(buffer.AsMemory(0, res.Count), System.Net.WebSockets.WebSocketMessageType.Binary, true, default);

WebSocketCompressionMiddlewareTests.cs (2)

130await webSocket.SendAsync(serverBuffer.AsMemory(0, result.Count), result.MessageType, result.EndOfMessage, default); 147await client.SendAsync(clientBuf.AsMemory(0, sendCount), WebSocketMessageType.Binary, true, default);

BufferedReadStream.cs (3)

222return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 232_buffer.AsMemory(_bufferOffset, toCopy).CopyTo(buffer); 329int read = await _inner.ReadAsync(_buffer.AsMemory(_bufferOffset + _bufferCount, _buffer.Length - _bufferCount - _bufferOffset), cancellationToken);

FileBufferingReadStream.cs (4)

329return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 366await _buffer.WriteAsync(rentedBuffer.AsMemory(0, copyRead), cancellationToken); 377await _buffer.WriteAsync(_rentedBuffer.AsMemory(0, (int)oldBuffer.Length), cancellationToken); 453await destination.WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken);

FileBufferingWriteStream.cs (1)

142await WriteAsync(buffer.AsMemory(offset, count), cancellationToken);

HttpRequestStreamReader.cs (2)

259_bytesRead = await _stream.ReadAsync(_byteBuffer.AsMemory(0, _byteBufferSize), cancellationToken); 490_bytesRead = await _stream.ReadAsync(_byteBuffer.AsMemory(0, _byteBufferSize)).ConfigureAwait(false);

HttpResponseStreamWriter.cs (1)

610await _stream.WriteAsync(_byteBuffer.AsMemory(0, count));

MultipartReaderStream.cs (1)

244=> ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

PagedByteBuffer.cs (4)

44=> Add(buffer.AsMemory(offset, count)); 55memory.Slice(0, copyLength).CopyTo(currentPage.AsMemory(_currentPageIndex, copyLength)); 92await writer.WriteAsync(page.AsMemory(0, length), cancellationToken); 109await stream.WriteAsync(page.AsMemory(0, length), cancellationToken);

src\Shared\QueryStringEnumerable.cs (1)

103return buffer.AsMemory(0, unescapedLength);

FileBufferingReadStreamTests.cs (9)

522Assert.Equal(data.AsMemory(0, 100).ToArray(), buffer); 540Assert.Equal(data.AsMemory(0, read).ToArray(), buffer); 559Assert.Equal(data.AsMemory(0, read).ToArray(), buffer); 579Assert.Equal(data.AsMemory(0, read1).ToArray(), buffer); 580Assert.Equal(data.AsMemory(0, read2).ToArray(), buffer2.AsMemory(0, read2).ToArray()); 599Assert.Equal(data.AsMemory(0, read1).ToArray(), buffer); 600Assert.Equal(data.AsMemory(0, read2).ToArray(), buffer2.AsMemory(0, read2).ToArray());

HttpResponseStreamWriterTest.cs (1)

827=> WriteAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

BackEnd\Client\MSBuildClientPacketPump.cs (1)

282ValueTask<int> bytesReadTask = localStream.ReadAsync(packetData.AsMemory(packetBytesRead, packetLength - packetBytesRead));

BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)

1015int bytesRead = await _pipeStream.ReadAsync(packetData.AsMemory(totalBytesRead, packetLength - totalBytesRead), CancellationToken.None).ConfigureAwait(false);

CommunicationsUtilities.cs (1)

928int bytesRead = await stream.ReadAsync(buffer.AsMemory(totalBytesRead, bytesToRead - totalBytesRead), CancellationToken.None);

Logging\BinaryLogger\Postprocessing\SubStream.cs (1)

75buffer.AsMemory(offset, count),

Logging\BinaryLogger\Postprocessing\TransparentReadStream.cs (1)

121buffer.AsMemory(offset, count),

CommunicationsUtilities.cs (1)

928int bytesRead = await stream.ReadAsync(buffer.AsMemory(totalBytesRead, bytesToRead - totalBytesRead), CancellationToken.None);

Utilities\InterceptableLocation.cs (1)

149var hash = bytes.AsMemory(start: hashIndex, length: hashSize);

ToolReduction\EmbeddingToolReductionStrategy.cs (1)

180var toolRankingInfoMemory = toolRankingInfoArray.AsMemory(start: 0, length: tools.Count);

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

45public ReadOnlyMemory<T> WrittenMemory => _buffer.AsMemory(0, WrittenCount);

Logging\Internal\HttpRequestBodyReader.cs (1)

90var read = await streamToReadFrom.ReadAsync(buffer.AsMemory(0, readLimit), cancellationToken).ConfigureAwait(false);

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

45public ReadOnlyMemory<T> WrittenMemory => _buffer.AsMemory(0, WrittenCount);

Resolver\DnsResolver.cs (2)

317bool result = DnsPrimitives.TryReadQName(segment.Array.AsMemory(messageOffset, segment.Offset + segment.Count - messageOffset), segment.Offset - messageOffset, out EncodedDomainName targetName, out int bytesRead) && bytesRead == record.Data.Length; 776await socket.SendAsync(buffer.AsMemory(0, length + 2), SocketFlags.None, cancellationToken).ConfigureAwait(false);

Resolver\DnsDataWriterTests.cs (3)

61DnsDataWriter writer = new DnsDataWriter(buffer.AsMemory(0, i)); 101DnsDataWriter writer = new DnsDataWriter(buffer.AsMemory(0, i)); 145Assert.True(DnsPrimitives.TryReadQName(nameBuffer.AsMemory(0, nameLength), 0, out EncodedDomainName encodedDomainName, out _));

Resolver\LoopbackDnsServer.cs (9)

60int bytesWritten = await ProcessRequestCore((IPEndPoint)result.RemoteEndPoint, new ArraySegment<byte>(buffer, 0, result.ReceivedBytes), action, buffer.AsMemory(0, 512)); 62await _dnsSocket.SendToAsync(buffer.AsMemory(0, bytesWritten), SocketFlags.None, result.RemoteEndPoint); 94int read = await tcpClient.ReceiveAsync(buffer.AsMemory(bytesRead, toRead), SocketFlags.None); 105await tcpClient.SendAsync(buffer.AsMemory(0, bytesWritten + 2), SocketFlags.None); 169!DnsPrimitives.TryReadQName(buffer.AsMemory(0, length), 0, out EncodedDomainName encodedName, out _)) 212int bytesWritten = Write(buffer.AsMemory(0, 512)); 249records.Add(new DnsResourceRecord(EncodeDomainName(name), QueryType.CNAME, QueryClass.Internet, ttl, buff.AsMemory(0, length))); 268records.Add(new DnsResourceRecord(EncodeDomainName(name), QueryType.SRV, QueryClass.Internet, ttl, buff.AsMemory(0, length))); 290records.Add(new DnsResourceRecord(EncodeDomainName(name), QueryType.SOA, QueryClass.Internet, ttl, buff.AsMemory(0, length)));

Fuzzers\EncodedDomainNameFuzzer.cs (1)

18if (!DnsPrimitives.TryReadQName(buffer.AsMemory(0, data.Length), i, out EncodedDomainName name, out _))

Fuzzers\WriteDomainNameRoundTripFuzzer.cs (1)

26if (!DnsPrimitives.TryReadQName(buffer.AsMemory(0, written), 0, out EncodedDomainName name, out int read))

Model\TiktokenTokenizer.cs (4)

331(int Id, int TokenIndex, int TokenLength)[] encodedTokens = BytePairEncoder.BytePairEncode(arrayPoolArray.AsMemory(0, encodedLength), _encoder, indexMappingSpan.Slice(0, encodedLength + 1)); 448(int Id, int TokenIndex, int TokenLength)[] encodedTokens = BytePairEncoder.BytePairEncode(arrayPoolArray.AsMemory(0, encodedLength), _encoder, indexMappingSpan.Slice(0, encodedLength + 1)); 613(int Id, int TokenIndex, int TokenLength)[] encodedTokens = BytePairEncoder.BytePairEncode(arrayPoolArray.AsMemory(0, encodedLength), _encoder, indexMappingSpan.Slice(0, encodedLength + 1)); 739(int Id, int TokenIndex, int TokenLength)[] encodedTokens = BytePairEncoder.BytePairEncode(arrayPoolArray.AsMemory(0, encodedLength), _encoder, indexMappingSpan.Slice(0, encodedLength + 1));

CommunicationsUtilities.cs (1)

928int bytesRead = await stream.ReadAsync(buffer.AsMemory(totalBytesRead, bytesToRead - totalBytesRead), CancellationToken.None);

BufferWriterPool\BufferWriter.cs (1)

45public ReadOnlyMemory<T> WrittenMemory => _buffer.AsMemory(0, WrittenCount);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (2)

70data.AddRange(buffer.AsMemory(0, read).ToArray()); 92data.AddRange(buffer.AsMemory(0, read).ToArray());

src\Servers\Kestrel\test\FunctionalTests\UnixDomainSocketsTests.cs (1)

108var bytesReceived = await socket.ReceiveAsync(buffer.AsMemory(read, buffer.Length - read), SocketFlags.None).DefaultTimeout();

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

47Memory<byte> buffer = rented.AsMemory(0, TarHelpers.RecordSize); // minimumLength means the array could've been larger 654Memory<byte> memory = buffer.AsMemory(0, (int)_size); 729Memory<byte> memory = buffer.AsMemory(0, (int)_size);

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

856await archiveStream.WriteAsync(buffer.AsMemory(0, paddingAfterData), cancellationToken).ConfigureAwait(false);

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

116Memory<byte> memory = buffer.AsMemory(0, currentLengthToRead);

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

338Memory<byte> buffer = rented.AsMemory(0, TarHelpers.RecordSize); // minimumLength means the array could've been larger 378await _archiveStream.WriteAsync(twoEmptyRecords.AsMemory(0, TwoRecordSize), cancellationToken: default).ConfigureAwait(false);

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

257return ReadAsyncInternal(buffer.AsMemory(offset, count), cancellationToken).AsTask();

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

169return CopyTo(output.AsMemory(offset, length)); 207SetInput(buffer.AsMemory(offset, length));

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

1035return WriteAsyncCore(buffer.AsMemory(offset, count), cancellationToken).AsTask();

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

179SetInput(inputBuffer.AsMemory(startIndex, count));

System\IO\Compression\ZipArchiveEntry.Async.cs (5)

434await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, MetadataBufferLength), cancellationToken).ConfigureAwait(false); 440await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, CrcAndSizesBufferLength), cancellationToken).ConfigureAwait(false); 451await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, Zip64SizesBufferLength), cancellationToken).ConfigureAwait(false); 463await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, Zip64DataDescriptorCrcAndSizesBufferLength), cancellationToken).ConfigureAwait(false); 472return _archive.ArchiveStream.WriteAsync(dataDescriptor.AsMemory(0, bytesToWrite), cancellationToken);

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

124Memory<byte> extraFieldBuffer = arrayPoolBuffer.AsMemory(0, extraFieldLength); 194Memory<byte> collatedHeader = arrayPoolBuffer.AsMemory(0, dynamicHeaderSize);

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

32Memory<byte> bufferMemory = buffer.AsMemory(0, BackwardsSeekingBufferSize);

src\libraries\Common\src\System\Buffers\ArrayBufferWriter.cs (1)

58public ReadOnlyMemory<T> WrittenMemory => _buffer.AsMemory(0, _index);

System\BinaryData.cs (1)

305return new BinaryData(memoryStream.GetBuffer().AsMemory(0, (int)memoryStream.Position), mediaType);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackDecoder.cs (1)

679buffer.AsMemory(0, existingLength).CopyTo(newBuffer);

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

380return stream.WriteAsync(_bufferedContent.GetSingleBuffer().AsMemory(0, (int)_bufferedContent.Length), cancellationToken);

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

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

162try { await _stream.WriteAsync(buffer.AsMemory(offset, count)).ConfigureAwait(false); }

System\Net\Base64Stream.cs (1)

169await BaseStream.WriteAsync(WriteState.Buffer.AsMemory(0, WriteState.Length), cancellationToken).ConfigureAwait(false);

System\Net\BufferedReadStream.cs (1)

59_storedBuffer.AsMemory(_storedOffset, read).CopyTo(buffer);

System\Net\DelegatedStream.cs (2)

144return ReadAsyncInternal(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 203return WriteAsyncInternal(buffer.AsMemory(offset, count), cancellationToken).AsTask();

System\Net\Mail\SmtpConnection.cs (1)

243await TIOAdapter.WriteAsync(_stream!, _bufferBuilder.GetBuffer().AsMemory(0, _bufferBuilder.Length), cancellationToken).ConfigureAwait(false);

System\Net\Mime\EightBitStream.cs (1)

81ValueTask task = BaseStream.WriteAsync(WriteState.Buffer.AsMemory(0, WriteState.Length), cancellationToken);

System\Net\Mime\MimePart.cs (2)

178while ((read = await TIOAdapter.ReadAsync(Stream, buffer.AsMemory(0, maxBufferSize), cancellationToken).ConfigureAwait(false)) > 0) 180await TIOAdapter.WriteAsync(outputStream, buffer.AsMemory(0, read), cancellationToken).ConfigureAwait(false);

System\Net\Mime\QEncodedStream.cs (1)

213await BaseStream.WriteAsync(WriteState.Buffer.AsMemory(0, WriteState.Length), cancellationToken).ConfigureAwait(false);

System\Net\Mime\QuotedPrintableStream.cs (1)

318await BaseStream.WriteAsync(WriteState.Buffer.AsMemory(0, WriteState.Length), cancellationToken).ConfigureAwait(false);

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

103certData = certDataRented.AsMemory(0, (int)certificateBuffer->Length); 110chainData = chainDataRented.AsMemory(0, (int)chainBuffer->Length);

System\Net\RequestStream.cs (1)

106return _internalStream.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

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

357_readBuffer.AsMemory(_readBufferOffset, copyBytes).CopyTo(buffer); 431_readBuffer.AsMemory(_readBufferOffset, copyBytes).CopyTo(buffer);

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

81Initialize(null, null, buffer, buffer.AsMemory(offset, count), offset, count, endOfPacket);

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

2587Task<int> t = SendToAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask(); 2678Task<SocketReceiveMessageFromResult> t = ReceiveMessageFromAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask(); 2719Task<SocketReceiveFromResult> t = ReceiveFromAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask();

System\Net\WebSockets\WebSocketStream.cs (2)

129return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 149return WriteAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();

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

383ValueTask<int> vt = ReadAtLeastAsyncCore(buffer.AsMemory(offset, count), count, throwOnEndOfStream: true, cancellationToken);

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

404int innerBytesReadJustNow = await _innerStream.ReadAsync(rentedBytes.AsMemory(0, DefaultReadByteBufferSize), cancellationToken).ConfigureAwait(false);

System\Xml\Core\XmlEncodedRawTextWriterAsync.cs (3)

652await _writer!.WriteAsync(_bufChars.AsMemory(1, _bufPos - 1)).ConfigureAwait(false); 691await _stream!.WriteAsync(_bufBytes.AsMemory(0, _bufBytesUsed)).ConfigureAwait(false); 697await _stream!.WriteAsync(_bufBytes.AsMemory(0, _bufBytesUsed)).ConfigureAwait(false);

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

1149charsRead = await _ps.textReader.ReadAsync(_ps.chars.AsMemory(_ps.charsUsed, _ps.chars.Length - _ps.charsUsed - 1)).ConfigureAwait(false);

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

559await _stream.WriteAsync(_bufBytes.AsMemory(1, _bufPos - 1)).ConfigureAwait(false);

src\libraries\Common\src\System\Security\Cryptography\MLDsaPkcs8.cs (2)

34Memory<byte> buffer = rented.AsMemory(0, seedSize); 43Memory<byte> buffer = rented.AsMemory(0, privateKeySize);

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

1669Memory<byte> encapsulationKey = encapsulationKeyBuffer.AsMemory(0, encapsulationKeySize);

src\libraries\Common\src\System\Security\Cryptography\MLKemPkcs8.cs (2)

34Memory<byte> buffer = rented.AsMemory(0, seedSize); 43Memory<byte> buffer = rented.AsMemory(0, decapsulationKeySize);

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

252bags = ReadBags(destination.AsMemory(0, written));

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

220return ReadAsyncInternal(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 295ValueTask<int> completedValueTask = ReadAsyncCore(buffer.AsMemory(offset, count), default(CancellationToken), useAsync: false); 459return WriteAsyncInternal(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 499WriteAsyncCore(buffer.AsMemory(offset, count), default, useAsync: false).AsTask().GetAwaiter().GetResult(); 730bytesRead = await ReadAsync(rentedBuffer.AsMemory(0, bufferSize), cancellationToken).ConfigureAwait(false); 731await destination.WriteAsync(rentedBuffer.AsMemory(0, bytesRead), cancellationToken).ConfigureAwait(false);

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

2032decryptedPkcs8 = KeyFormatHelper.DecryptPkcs8(password, base64Buffer.AsMemory(0, base64Written), out int bytesRead); 2122X509Certificate2? loaded = ExtractKeyFromECPrivateKeyInfo(certificate, base64Buffer.AsMemory(0, base64Written));

System\Security\Cryptography\X509Certificates\X509CertificateLoader.Unix.cs (1)

524buf.AsMemory(0, written),

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

408await WriteSignatureAsync(writer, signer, buffer, buffer.AsMemory(0, protectedMapBytesWritten), associatedData, content, cancellationToken).ConfigureAwait(false); 487await AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature, bodyProtected, buffer.AsMemory(start, signProtectedBytesWritten), associatedData, contentStream, cancellationToken).ConfigureAwait(false);

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

346await AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature1, buffer.AsMemory(0, protectedMapBytesWritten), ReadOnlyMemory<byte>.Empty, associatedData, content, cancellationToken).ConfigureAwait(false);

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

252bags = ReadBags(destination.AsMemory(0, written));

System\Text\Json\Document\JsonDocument.Parse.cs (4)

93utf8Bytes.AsMemory(0, length), 294utf8Bytes.AsMemory(0, actualByteCount), 661document = Parse(rented.AsMemory(0, length), state.Options, rented, allowDuplicateProperties: allowDuplicateProperties); 911lastRead = await stream.ReadAsync(rented.AsMemory(written, utf8BomLength - written), cancellationToken).ConfigureAwait(false);

System\Text\Json\Nodes\JsonValueOfJsonPrimitive.cs (1)

23ReadOnlyMemory<byte> utf8String = buffer.AsMemory(0, reader.CopyString(buffer));

System\Text\Json\Serialization\StreamReadBufferState.cs (1)

55public readonly ReadOnlySequence<byte> Bytes => new(_buffer.AsMemory(_offset, _count));