AsMemory

Otlp\Model\OtlpInstrument.cs (1)

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

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

311await buffer.WriteAsync(bytes.AsMemory(0, bytesRead), cancellationToken);

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

103Memory<byte> remainingBytesToProcess = _readBuffer.AsMemory(0, currentReadBytes); 189await _messageBuffer.WriteAsync(bytes.AsMemory(0, sizeof(int)), cancellationToken); 192await _messageBuffer.WriteAsync(_serializationBuffer.GetBuffer().AsMemory(0, (int)_serializationBuffer.Position), cancellationToken); 197await _namedPipeServerStream.WriteAsync(_messageBuffer.GetBuffer().AsMemory(0, (int)_messageBuffer.Position), cancellationToken);

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

64sectionWriter.EmitData(_fileTableWriter.GetBuffer().AsMemory(0, (int)_fileTableWriter.Length)); 67sectionWriter.EmitData(_stringTableWriter.GetBuffer().AsMemory(0, (int)_stringTableWriter.Length));

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

63AppendData(_padding.AsMemory(0, paddingLength));

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

63AppendData(_padding.AsMemory(0, paddingLength));

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

51return _rentedBuffer.AsMemory(0, _index);

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

106return buffer.AsMemory(0, unescapedLength);

FormMapping\HttpContextFormValueMapper.cs (1)

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

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

106return buffer.AsMemory(0, unescapedLength);

Circuits\RemoteJSDataStream.cs (1)

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

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

51return _rentedBuffer.AsMemory(0, _index);

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

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

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

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

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

51return _rentedBuffer.AsMemory(0, _index);

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

51return _rentedBuffer.AsMemory(0, _index);

parent\parent\parent\eng\MSBuild\parent\parent\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\aspnetcore\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\aspnetcore\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\aspnetcore\src\SignalR\common\Shared\PipeWriterStream.cs (1)

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

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

106return buffer.AsMemory(0, unescapedLength);

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

51return _rentedBuffer.AsMemory(0, _index);

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

PooledArrayBufferWriter`1.cs (1)

44return _rentedBuffer.AsMemory(0, _index);

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

ResponseStream.cs (1)

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

src\aspnetcore\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\aspnetcore\src\Shared\runtime\Http3\QPack\QPackDecoder.cs (1)

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

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

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

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

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

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

ResponseBodyReaderStream.cs (1)

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

src\sdk\src\Dotnet.Watch\Web.Middleware\ResponseStreamWrapper.cs (1)

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

src\sdk\src\Dotnet.Watch\Web.Middleware\ScriptInjectingStream.cs (2)

79ScriptInjectionPerformed = await TryInjectScriptAsync(buffer.AsMemory(offset, count), cancellationToken); 83await _baseStream.WriteAsync(buffer.AsMemory(offset, count), cancellationToken);

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)

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

106return buffer.AsMemory(0, unescapedLength);

BackEnd\Client\MSBuildClientPacketPump.cs (1)

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

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

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

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

75buffer.AsMemory(offset, count),

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

121buffer.AsMemory(offset, count),

src\msbuild\src\Shared\NodePipeBase.cs (2)

149await NodeStream.WriteAsync(buffer.AsMemory(i, lengthToWrite), cancellationToken).ConfigureAwait(false); 233int bytesRead = await NodeStream.ReadAsync(buffer.AsMemory(totalBytesRead, bytesToRead - totalBytesRead), cancellationToken).ConfigureAwait(false);

Utilities\InterceptableLocation.cs (1)

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

Language\TagHelperCollection.FixedSizeBuilder.cs (1)

103var length => new SingleSegmentCollection(_items.AsMemory(0, length))

Files\HostedFileDownloadStream.cs (1)

108memoryStream.GetBuffer().AsMemory(0, (int)memoryStream.Length),

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\BufferWriterPool\BufferWriter.cs (1)

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

Logging\Internal\HttpResponseBodyReader.cs (2)

200_ = sb.Append(Encoding.UTF8.GetString(buffer.AsMemory(0, read).ToArray())); 222FlushResult result = await writer.WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken).ConfigureAwait(false);

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\BufferWriterPool\BufferWriter.cs (1)

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

Resolver\DnsResolver.cs (2)

298bool 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; 792await 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));

BufferWriterPool\BufferWriter.cs (1)

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

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

177ValueTask<int> vt = ReadCoreAsync<SyncReadWriteAdapter>(rented.AsMemory(0, toRead), CancellationToken.None); 306int bytesRead = await ReadFromPackedDataCoreAsync<TAdapter>(buffer.AsMemory(0, toRead), _packedStartOffsets[i] + written, cancellationToken).ConfigureAwait(false); 311await TAdapter.WriteAsync(destination, buffer.AsMemory(0, bytesRead), cancellationToken).ConfigureAwait(false); 467int newBytes = await TAdapter.ReadAtLeastAsync(rawStream, bytes.AsMemory(availableStart, TarHelpers.RecordSize), TarHelpers.RecordSize, throwOnEndOfStream: false, cancellationToken).ConfigureAwait(false);

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

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

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

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

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

69await TAdapter.ReadExactlyAsync(archiveStream, buffer.AsMemory(0, currentLengthToRead), cancellationToken).ConfigureAwait(false); 92Memory<byte> memory = buffer.AsMemory(0, currentLengthToRead);

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

345Memory<byte> buffer = rented.AsMemory(0, TarHelpers.RecordSize); // minimumLength means the array could've been larger 380await TAdapter.WriteAsync(_archiveStream, twoEmptyRecords.AsMemory(0, TwoRecordSize), CancellationToken.None).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)

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

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

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

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

357await _baseStream.WriteAsync(authCode.AsMemory(0, MacSizeInBytes), cancellationToken).ConfigureAwait(false); 435return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 523return WriteAsyncCore(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 543await _baseStream.WriteAsync(workBuffer.AsMemory(0, bytesToProcess), cancellationToken).ConfigureAwait(false);

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

992await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, MetadataBufferLength), cancellationToken).ConfigureAwait(false); 998await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, CrcAndSizesBufferLength), cancellationToken).ConfigureAwait(false); 1009await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, Zip64SizesBufferLength), cancellationToken).ConfigureAwait(false); 1021await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, Zip64DataDescriptorCrcAndSizesBufferLength), cancellationToken).ConfigureAwait(false); 1030return _archive.ArchiveStream.WriteAsync(dataDescriptor.AsMemory(0, bytesToWrite), cancellationToken);

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

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

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

391return ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 417return WriteAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); 447await _base.WriteAsync(workBuffer.AsMemory(0, chunkSize), cancellationToken).ConfigureAwait(false);

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

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

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

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

src\runtime\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\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackDecoder.cs (1)

685buffer.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\Http\WinHttpResponseStream.cs (1)

156await destination.WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken).ConfigureAwait(false);

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

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

System\Net\Base64Stream.cs (1)

164await 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)

82ValueTask 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\DnsResolverPal.Managed.cs (4)

402ReadOnlyMemory<byte> query = queryBytes.AsMemory(0, queryLength); 705await SendExactAsync(socket, buffer.AsMemory(0, 2), timeoutCts.Token).ConfigureAwait(false); 708await ReceiveExactAsync(socket, buffer.AsMemory(0, 2), timeoutCts.Token).ConfigureAwait(false); 717await ReceiveExactAsync(socket, buffer.AsMemory(0, responseLength), timeoutCts.Token).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)

354_readBuffer.AsMemory(_readBufferOffset, copyBytes).CopyTo(buffer); 436_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)

2589Task<int> t = SendToAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask(); 2680Task<SocketReceiveMessageFromResult> t = ReceiveMessageFromAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask(); 2721Task<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\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (1)

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

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

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

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

263bags = 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 (1)

2116X509Certificate2? loaded = ExtractKeyFromECPrivateKeyInfo(certificate, base64Buffer.AsMemory(0, base64Written));

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

263bags = 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); 909lastRead = 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));

System\Media\SoundPlayer.cs (2)

503int readBytes = await _stream.ReadAsync(_streamData.AsMemory(_currentPos, BlockSize), cancellationToken).ConfigureAwait(false); 515readBytes = await _stream.ReadAsync(_streamData.AsMemory(_currentPos, BlockSize), cancellationToken).ConfigureAwait(false);