AsMemory

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

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

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

Http2\Http2ConnectionTests.cs (1)

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

37return _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\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)

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

src\Shared\SizeLimitedStream.cs (1)

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

src\Shared\PooledArrayBufferWriter.cs (1)

37return _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)

74return 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)

74return 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)

679buffer.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\QueryStringEnumerable.cs (1)

103return buffer.AsMemory(0, unescapedLength);

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

679buffer.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)

263ws.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)

72await 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();

Utilities\InterceptableLocation.cs (1)

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

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

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

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

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

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)

597int 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)

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

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

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

323Memory<byte> buffer = rented.AsMemory(0, TarHelpers.RecordSize); // minimumLength means the array could've been larger 363await _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)

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

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

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

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

363await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, MetadataBufferLength), cancellationToken).ConfigureAwait(false); 369await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, CrcAndSizesBufferLength), cancellationToken).ConfigureAwait(false); 380await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, Zip64SizesBufferLength), cancellationToken).ConfigureAwait(false); 392await _archive.ArchiveStream.WriteAsync(writeBuffer.AsMemory(0, Zip64DataDescriptorCrcAndSizesBufferLength), cancellationToken).ConfigureAwait(false); 401return _archive.ArchiveStream.WriteAsync(dataDescriptor.AsMemory(0, bytesToWrite), cancellationToken);

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

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

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

48Memory<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)

370return 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)

170await 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\Mime\EightBitStream.cs (1)

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

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

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

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

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

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

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

2580Task<int> t = SendToAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask(); 2671Task<SocketReceiveMessageFromResult> t = ReceiveMessageFromAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask(); 2712Task<SocketReceiveFromResult> t = ReceiveFromAsync(buffer.AsMemory(offset, size), socketFlags, remoteEP).AsTask();

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

382ValueTask<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); 694await _stream!.WriteAsync(_bufBytes.AsMemory(0, _bufBytesUsed)).ConfigureAwait(false); 700await _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\MLKem.cs (1)

1632Memory<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\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); 485await AppendToBeSignedAsync(buffer, hasher, SigStructureContext.Signature, bodyProtected, buffer.AsMemory(start, signProtectedBytesWritten), associatedData, contentStream, cancellationToken).ConfigureAwait(false);

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

343await AppendToBeSignedAsync(buffer, hasher, 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)

92return Parse(utf8Bytes.AsMemory(0, length), readerOptions, utf8Bytes); 272utf8Bytes.AsMemory(0, actualByteCount), 632document = Parse(rented.AsMemory(0, length), state.Options, rented); 864lastRead = await stream.ReadAsync(rented.AsMemory(written, utf8BomLength - written), cancellationToken).ConfigureAwait(false);