AsMemory

251 references to AsMemory

Aspire.Dashboard (1)

Otlp\Model\OtlpInstrument.cs (1)

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

dotnet (4)

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

dotnet.Tests (6)

CommandTests\Test\NamedPipeClient.cs (6)

60await _messageBuffer.WriteAsync(bytes.AsMemory(0, sizeof(int)), cancellationToken).ConfigureAwait(false); 72await _messageBuffer.WriteAsync(bytes.AsMemory(0, sizeof(int)), cancellationToken).ConfigureAwait(false); 82await _messageBuffer.WriteAsync(_serializationBuffer.GetBuffer().AsMemory(0, (int)_serializationBuffer.Position), cancellationToken).ConfigureAwait(false); 93await _namedPipeClientStream.WriteAsync(_messageBuffer.GetBuffer().AsMemory(0, (int)_messageBuffer.Position), cancellationToken).ConfigureAwait(false); 113int currentReadBytes = await _namedPipeClientStream.ReadAsync(_readBuffer.AsMemory(currentReadIndex, _readBuffer.Length), cancellationToken).ConfigureAwait(false); 141await _messageBuffer.WriteAsync(_readBuffer.AsMemory(currentReadIndex, missingBytesToReadOfCurrentChunk), cancellationToken).ConfigureAwait(false);

http2cat (1)

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

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

HttpStress (1)

Program.cs (1)

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

IIS.Common.TestLib (1)

TestConnections.cs (1)

155return actual.AsMemory(0, offset);

IIS.FunctionalTests (1)

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

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

IIS.LongTests (1)

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

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

IIS.NewHandler.FunctionalTests (1)

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

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

IIS.NewShim.FunctionalTests (1)

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

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

IIS.ShadowCopy.Tests (1)

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

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

IISExpress.FunctionalTests (1)

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

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

InMemory.FunctionalTests (6)

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

Interop.FunctionalTests (3)

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

Microsoft.AspNetCore.Components (2)

src\Shared\PooledArrayBufferWriter.cs (1)

37return _rentedBuffer.AsMemory(0, _index);

src\Shared\QueryStringEnumerable.cs (1)

103return buffer.AsMemory(0, unescapedLength);

Microsoft.AspNetCore.Components.Endpoints (1)

FormMapping\HttpContextFormValueMapper.cs (1)

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

Microsoft.AspNetCore.Components.Server (5)

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

Microsoft.AspNetCore.Components.WebAssembly (1)

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

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

Microsoft.AspNetCore.Components.WebView (1)

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

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

Microsoft.AspNetCore.Diagnostics.Middleware (1)

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

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

Microsoft.AspNetCore.Http (3)

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

Microsoft.AspNetCore.Http.Connections (4)

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

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

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

Microsoft.AspNetCore.Http.Connections.Client (1)

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

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

Microsoft.AspNetCore.Http.Extensions (3)

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

Microsoft.AspNetCore.Http.Results (2)

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

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

Microsoft.AspNetCore.HttpLogging (1)

RequestBufferingStream.cs (1)

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

Microsoft.AspNetCore.Mvc.FunctionalTests (1)

src\Shared\SizeLimitedStream.cs (1)

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

Microsoft.AspNetCore.Mvc.ViewFeatures (1)

src\Shared\PooledArrayBufferWriter.cs (1)

37return _rentedBuffer.AsMemory(0, _index);

Microsoft.AspNetCore.OpenApi (3)

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

Microsoft.AspNetCore.OutputCaching (1)

Streams\OutputCacheStream.cs (1)

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

Microsoft.AspNetCore.RequestDecompression (1)

src\Shared\SizeLimitedStream.cs (1)

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

Microsoft.AspNetCore.ResponseCaching (1)

Streams\ResponseCachingStream.cs (1)

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

Microsoft.AspNetCore.ResponseCompression (1)

ResponseCompressionBody.cs (1)

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

Microsoft.AspNetCore.Routing.FunctionalTests (1)

src\Shared\SizeLimitedStream.cs (1)

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

Microsoft.AspNetCore.Server.HttpSys (1)

ResponseStream.cs (1)

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

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (1)

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

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

Microsoft.AspNetCore.Server.IIS (1)

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

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

Microsoft.AspNetCore.Server.Kestrel.Core (3)

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

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (2)

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

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

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (3)

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

Microsoft.AspNetCore.Shared.Tests (3)

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

Microsoft.AspNetCore.SignalR.Client.Core (1)

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

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

Microsoft.AspNetCore.SignalR.Client.Tests (3)

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

Microsoft.AspNetCore.SignalR.Common (3)

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

Microsoft.AspNetCore.SignalR.Common.Tests (2)

Internal\Protocol\Utf8BufferTextWriterTests.cs (2)

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

Microsoft.AspNetCore.SignalR.Protocols.MessagePack (3)

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

Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson (3)

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

Microsoft.AspNetCore.SignalR.Specification.Tests (3)

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

Microsoft.AspNetCore.SignalR.StackExchangeRedis (3)

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

Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests (1)

RedisEndToEnd.cs (1)

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

Microsoft.AspNetCore.SignalR.Tests (1)

HubConnectionHandlerTests.cs (1)

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

Microsoft.AspNetCore.TestHost (1)

ResponseBodyReaderStream.cs (1)

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

Microsoft.AspNetCore.TestHost.Tests (1)

WebSocketClientTests.cs (1)

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

Microsoft.AspNetCore.Watch.BrowserRefresh (3)

ResponseStreamWrapper.cs (1)

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

ScriptInjectingStream.cs (2)

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

Microsoft.AspNetCore.WebSockets.Tests (2)

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

Microsoft.AspNetCore.WebUtilities (17)

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

Microsoft.AspNetCore.WebUtilities.Tests (10)

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

Microsoft.Build.Tasks.Core (3)

CommunicationsUtilities.cs (1)

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

NodePipeBase.cs (2)

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

Microsoft.CodeAnalysis.CSharp (1)

Utilities\InterceptableLocation.cs (1)

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

Microsoft.DotNet.HotReload.Client.Tests (1)

ArrayBufferWriter.cs (1)

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

Microsoft.Extensions.Diagnostics.ResourceMonitoring (1)

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

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

Microsoft.Extensions.Http.Diagnostics (2)

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

Microsoft.Extensions.ServiceDiscovery.Dns (2)

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

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (12)

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

Microsoft.Extensions.ServiceDiscovery.Dns.Tests.Fuzzing (2)

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

Microsoft.ML.Tokenizers (4)

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

Shared (1)

BufferWriterPool\BufferWriter.cs (1)

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

Sockets.FunctionalTests (3)

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

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

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

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

857await 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 (12)

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)

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

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

System.Memory (1)

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

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

System.Memory.Data (1)

System\BinaryData.cs (1)

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

System.Net.Http (11)

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)

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

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

System.Net.HttpListener (1)

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

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

System.Net.Mail (10)

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

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

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

System.Net.Requests (1)

System\Net\RequestStream.cs (1)

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

System.Net.Security (2)

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

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

System.Net.Sockets (4)

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

System.Net.WebSockets (2)

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

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

System.Private.CoreLib (2)

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.Private.Xml (5)

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

System.Security.Cryptography (13)

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\X509CertificateLoader.Unix.cs (1)

524buf.AsMemory(0, written),

System.Security.Cryptography.Cose (3)

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

System.Security.Cryptography.Pkcs (1)

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

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

System.Text.Json (6)

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