Array

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBinaryWriter.cs (2)

1038_captureText = XmlConverter.Base64Encoding.GetString(arraySegment.Array, arraySegment.Offset, arraySegment.Count); 1109writer.WriteBase64Text(null, 0, arraySegment.Array, arraySegment.Offset, arraySegment.Count);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlUTF8TextReader.cs (1)

576BufferReader.SetBuffer(seg.Array, seg.Offset, seg.Count, null, null);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\BinaryMessageEncoder.cs (5)

259return XmlDictionaryReader.CreateBinaryReader(buffer.Array, buffer.Offset, buffer.Count, 384byte[] buffer = messageData.Array; 444byte[] buffer = messageData.Array; 556message = _messagePatterns.TryCreateMessage(buffer.Array, buffer.Offset, buffer.Count, bufferManager, messageData); 700XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(messageData.Array, messageData.Offset, messageData.Count, XD.Dictionary, XmlDictionaryReaderQuotas.Max, _readerSessionForLogging);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\BufferedMessageData.cs (1)

72_bufferManager.ReturnBuffer(_buffer.Array);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\Connection.cs (1)

769ValidateBufferBounds(buffer.Array, buffer.Offset, buffer.Count);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\FramingChannels.cs (4)

84this.Connection.Write(messageData.Array, messageData.Offset, messageData.Count, !allowOutputBatching, 101return this.Connection.BeginWrite(messageData.Array, messageData.Offset, messageData.Count, 248await connection.WriteAsync(preamble.Array, preamble.Offset, preamble.Count, true, timeoutHelper.RemainingTime()); 287connection.Write(preamble.Array, preamble.Offset, preamble.Count, true, timeoutHelper.RemainingTime());

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\FramingEncoders.cs (2)

228byte[] buffer = messageFrame.Array; 313byte[] buffer = messageFrame.Array;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageHelper.cs (1)

207byte[] buffer = messageBuffer.Array;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageBuffer.cs (1)

188stream.Write(buffer.Array, buffer.Offset, buffer.Count);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageContent.cs (4)

218_stream = new MemoryStream(_buffer.Array, _buffer.Offset, _buffer.Count, false, true); 235await stream.WriteAsync(_buffer.Array, _buffer.Offset, _buffer.Count); 258if (_buffer.Array != null) 260var byteArray = _buffer.Array;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageEncoderCompressionHandler.cs (6)

19MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count); 24bufferedOutStream.Write(buffer.Array, 0, buffer.Offset); 54bufferManager.ReturnBuffer(buffer.Array); 63bufferedOutStream.Write(buffer.Array, 0, buffer.Offset); 69ds.Write(buffer.Array, buffer.Offset, buffer.Count); 74bufferManager.ReturnBuffer(buffer.Array);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TextMessageEncoder.cs (2)

509XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateTextReader(messageData.Array, messageData.Offset, messageData.Count, XmlDictionaryReaderQuotas.Max); 717return XmlDictionaryReader.CreateTextReader(buffer.Array, buffer.Offset, buffer.Count, this.Quotas);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TransportDuplexSessionChannel.cs (1)

546buffer = messageData.Array;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\WebSocketTransportDuplexSessionChannel.cs (5)

308BufferManager.ReturnBuffer(messageData.Array); 1250Buffer.BlockCopy(_initialReadBuffer.Array, _initialReadBuffer.Offset, buffer, offset, bytesToCopy); 1251_initialReadBuffer = new ArraySegment<byte>(_initialReadBuffer.Array, _initialReadBuffer.Offset + bytesToCopy, _initialReadBuffer.Count - bytesToCopy); 1272_webSocket.ReceiveAsync(new ArraySegment<byte>(_initialReadBuffer.Array), cancelToken); 1294_bufferManager.ReturnBuffer(_initialReadBuffer.Array);

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (1)

211XmlDictionaryReader bufferReader = XmlDictionaryReader.CreateTextReader(memoryBuffer.Array, 0, (int)memoryStream.Length, XmlDictionaryReaderQuotas.Max);

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\RequestSecurityToken.cs (2)

495if (_cachedWriteBuffer.Array == null) 515writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(_cachedWriteBuffer.Array, 0, _cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\RequestSecurityTokenResponse.cs (2)

506if (_cachedWriteBuffer.Array == null) 525writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(_cachedWriteBuffer.Array, 0, _cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);

CustomTextMessageEncoder.cs (3)

63Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length); 64bufferManager.ReturnBuffer(buffer.Array); 95Array.Copy(messageBuffer.Array, 0, totalBytes, messageOffset, messageLength);

TextTests.4.1.0.cs (1)

117Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes");

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

VTableExportPEBuilder.cs (8)

217bytes.Array![bytes.Offset + relativeOffset + 0] = (byte)(_sdataRva & 0xFF); 218bytes.Array[bytes.Offset + relativeOffset + 1] = (byte)((_sdataRva >> 8) & 0xFF); 219bytes.Array[bytes.Offset + relativeOffset + 2] = (byte)((_sdataRva >> 16) & 0xFF); 220bytes.Array[bytes.Offset + relativeOffset + 3] = (byte)((_sdataRva >> 24) & 0xFF); 223bytes.Array[bytes.Offset + relativeOffset + 4] = (byte)(_sdataSize & 0xFF); 224bytes.Array[bytes.Offset + relativeOffset + 5] = (byte)((_sdataSize >> 8) & 0xFF); 225bytes.Array[bytes.Offset + relativeOffset + 6] = (byte)((_sdataSize >> 16) & 0xFF); 226bytes.Array[bytes.Offset + relativeOffset + 7] = (byte)((_sdataSize >> 24) & 0xFF);

Compiler\DependencyAnalysis\ReadyToRun\NibbleWriter.cs (1)

157Array.Copy(blobSegment.Array, blobSegment.Offset, output, startOffset, blob.Length);

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

115if (_segment.Array != null) 117return ref _segment.Array[_segment.Offset + _buffered];

ArraySegmentExtensions.cs (4)

13if (arraySegment.Offset == 0 && arraySegment.Count == arraySegment.Array!.Length) 15return arraySegment.Array; 19Buffer.BlockCopy(arraySegment.Array!, arraySegment.Offset, retVal, 0, retVal.Length); 27_ = new ArraySegment<T>(arraySegment.Array!, arraySegment.Offset, arraySegment.Count);

Cng\CbcAuthenticatedEncryptor.cs (1)

457fixed (byte* pbPlaintextArray = plaintext.Array)

Secret.cs (2)

121fixed (byte* pbPlaintextArray = plaintext.Array) 247fixed (byte* pbBufferArray = buffer.Array)

WebSockets\WebSocketAdapter.cs (4)

99if (buffer.Array == null || buffer.Count == 0) 107(buffer.Array[buffer.Offset] << 8) 108| buffer.Array[buffer.Offset + 1]; 109string description = Encoding.UTF8.GetString(buffer.Array, buffer.Offset + 2, buffer.Count - 2);

RequestProcessing\ResponseBody.cs (1)

274handle = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned);

RequestProcessing\ResponseStreamAsyncResult.cs (5)

80_dataChunks[currentChunk].Anonymous.FromMemory.pBuffer = (void*)Marshal.UnsafeAddrOfPinnedArrayElement(chunkHeaderBuffer.Array!, chunkHeaderBuffer.Offset); 84_dataChunks[currentChunk].Anonymous.FromMemory.pBuffer = (void*)Marshal.UnsafeAddrOfPinnedArrayElement(data.Array!, data.Offset); 124objectsToPin[0] = chunkHeaderBuffer.Array!; 152_dataChunks[0].Anonymous.FromMemory.pBuffer = (void*)Marshal.UnsafeAddrOfPinnedArrayElement(chunkHeaderBuffer.Array!, chunkHeaderBuffer.Offset); 159objectsToPin[pinIndex] = segment.Array!;

Npm\NodeScriptRunner.cs (3)

109Debug.Assert(chunk.Array != null); 112chunk.Array, '\n', chunk.Offset, chunk.Count) >= 0; 115Console.Write(chunk.Array, chunk.Offset, chunk.Count);

TestWebSocket.cs (7)

143Array.Copy(receiveMessage.Buffer.Array!, receiveMessage.Buffer.Offset, buffer.Array!, buffer.Offset, count); 146receiveMessage.Buffer = new ArraySegment<byte>(receiveMessage.Buffer.Array!, receiveMessage.Buffer.Offset + count, receiveMessage.Buffer.Count - count); 196if (buffer.Array == null) 200if (buffer.Offset < 0 || buffer.Offset > buffer.Array.Length) 204if (buffer.Count < 0 || buffer.Count > buffer.Array.Length - buffer.Offset) 291Array.Copy(message.Buffer.Array!, message.Buffer.Offset, array, 0, message.Buffer.Count);

MultipartReaderStream.cs (1)

353if (matchBytes[matchCount] != segment1.Array![matchOffset + matchCount])

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

EmbeddedText.cs (5)

179if (bytes.Array == null) 188SourceText.CalculateChecksum(bytes.Array, bytes.Offset, bytes.Count, checksumAlgorithm), 266RoslynDebug.Assert(bytes.Array != null); 273builder.WriteBytes(bytes.Array, bytes.Offset, bytes.Count); 285deflater.Write(bytes.Array, bytes.Offset, bytes.Count);

EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

InternalUtilities\IncrementalHashExtensions.cs (2)

32RoslynDebug.AssertNotNull(segment.Array); 33hash.AppendData(segment.Array, segment.Offset, segment.Count);

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

Parser\SlidingTextWindow.cs (5)

123s_windowPool.Free(_characterWindow.Array!); 140this.Text.CopyTo(position, _characterWindow.Array!, 0, amountToRead); 142_characterWindow = new(_characterWindow.Array!, 0, amountToRead); 336return _characterWindow.Array![position - _characterWindowStartPositionInText]; 426var array = _characterWindow.Array!;

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

PrimitiveDataFrameColumn.Sort.cs (1)

69value = arraySegment.Array[index + arraySegment.Offset];

src\RpmHeader.cs (2)

57builder.AppendLine($"\t\t{BitConverter.ToString(((ArraySegment<byte>)entry.Value).Array!, ((ArraySegment<byte>)entry.Value).Offset, ((ArraySegment<byte>)entry.Value).Count)}"); 258storeStream.Write(binary.Array!, binary.Offset, binary.Count);

BlockingMemoryStream.cs (4)

39if (_remaining.Array is not null) 44Buffer.BlockCopy(_remaining.Array, _remaining.Offset, buffer, offset, count); 49Buffer.BlockCopy(_remaining.Array, _remaining.Offset, buffer, offset, count); 50_remaining = new ArraySegment<byte>(_remaining.Array, _remaining.Offset + count, _remaining.Count - count);

ChatCompletion\ChatResponseExtensions.cs (1)

340ms.Write(segment.Array!, segment.Offset, segment.Count);

Contents\DataContent.cs (2)

247await fileStream.WriteAsync(array.Array, array.Offset, array.Count, cancellationToken).ConfigureAwait(false); 296Convert.ToBase64String(segment.Array!, segment.Offset, segment.Count) :

Files\HostedFileClientExtensions.cs (1)

42new(arraySegment.Array!, arraySegment.Offset, arraySegment.Count) :

parent\parent\parent\eng\MSBuild\parent\parent\src\LegacySupport\FilePolyfills\FilePolyfills.cs (2)

63segment.Count == segment.Array!.Length) 65byteArray = segment.Array;

SpeechToText\SpeechToTextClientExtensions.cs (2)

51new MemoryStream(array.Array!, array.Offset, array.Count) : 73new MemoryStream(array.Array!, array.Offset, array.Count) :

Embeddings\EmbeddingTests.cs (1)

36Assert.Same(floats, array.Array);

parent\parent\parent\eng\MSBuild\parent\parent\src\LegacySupport\FilePolyfills\FilePolyfills.cs (2)

63segment.Count == segment.Array!.Length) 65byteArray = segment.Array;

OpenAIImageGenerator.cs (1)

62new MemoryStream(array.Array!, array.Offset, array.Count) :

Internal\DefaultHybridCache.StampedeStateT.cs (1)

236result = new(payload.Array!, payload.Offset, payload.Count, result.ReturnToPool);

Internal\HybridCachePayload.cs (2)

187ReadOnlySpan<byte> bytes = new(source.Array!, source.Offset, source.Count); 300payload = new(source.Array!, start, payloadLength);

DistributedCacheTests.cs (4)

337Assert.NotNull(segment.Array); 339Assert.Equal(size, segment.Array.Length); 345Assert.NotNull(segment.Array); 347Assert.NotEqual(size, segment.Array.Length);

DatabaseOperations.cs (1)

328read = (int)source.GetBytes(ordinal, dataIndex, segment.Array, segment.Offset, segment.Count);

SqlParameterCollectionExtensions.cs (5)

27if (value.Array is null) // null array (not really anticipating this, but...) 38if (value.Offset == 0 & value.Count == value.Array!.Length) // right-sized array 46value.Array); 51return parameters.AddWithValue(Columns.Names.CacheItemValue, SqlDbType.VarBinary, value.Array); 57p.Value = value.Array;

DependencyContextJsonReader.cs (1)

35ArrayPool<byte>.Shared.Return(buffer.Array!);

BlobAppendReferenceWrapper.cs (1)

37Content = new ByteArrayContent(data.Array, data.Offset, data.Count)

EventSourceLogger.cs (1)

293? Encoding.UTF8.GetString(buffer.Array!, buffer.Offset, buffer.Count)

Resolver\DnsDataReader.cs (2)

125if (_returnToPool && MessageBuffer.Array != null) 127ArrayPool<byte>.Shared.Return(MessageBuffer.Array);

Resolver\DnsResolver.cs (3)

294Debug.Assert(segment.Array == messageBytes.Array, "record data backed by different array than the original message"); 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;

Resolver\DnsResponse.cs (2)

32if (RawMessageBytes.Array != null) 34ArrayPool<byte>.Shared.Return(RawMessageBytes.Array);

Utilities\HybridMemoryStream.cs (1)

176_overflowStream.Write(buffer.Array, buffer.Offset, buffer.Count);

DataLoadSave\Binary\BinaryLoader.cs (2)

1817_stream.ReadBlock(buffer.Array, buffer.Offset, buffer.Count); 1895stream.ReadBlock(buf.Array, buf.Offset, buf.Count);

DataLoadSave\Binary\BinarySaver.cs (4)

233stream.Write(buffer.Array, buffer.Offset, buffer.Count); 377compressStream.Write(buffer.Array, buffer.Offset, buffer.Count); 390stream.Write(buffer.Array, buffer.Offset, buffer.Count); 430stream.Write(buffer.Array, buffer.Offset, buffer.Count);

DataLoadSave\Binary\Codecs.cs (1)

895Stream.Write(buffer.Array, buffer.Offset, buffer.Count);

SentencepieceModel.cs (1)

302return ModelProto.Parse(segment.Array!, start, end);

System\Value.cs (2)

551byte[]? array = segment.Array; 570char[]? array = segment.Array;

HashObjectWriter.cs (1)

265_hashFunc.Update(bytes.Array!, bytes.Offset, bytes.Count);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (2)

163if (TryGetBytesFromStream(data, out ArraySegment<byte> bytes) && bytes.Offset == 0 && bytes.Array is object) 165return SourceText.From(bytes.Array,

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

74Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 169Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count); 239index = Array.IndexOf(segment.Array!, value, segment.Offset, segment.Count);

System\Diagnostics\Process.Multiplexing.cs (6)

396ArrayPool<byte>.Shared.Return(standardOutput.Array!); 397ArrayPool<byte>.Shared.Return(standardError.Array!); 432ArrayPool<byte>.Shared.Return(standardOutput.Array!); 433ArrayPool<byte>.Shared.Return(standardError.Array!); 456ArrayPool<byte>.Shared.Return(outputTask.Result.Array!); 461ArrayPool<byte>.Shared.Return(errorTask.Result.Array!);

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

17Debug.Assert(arraySegment.Array != null); 20Return(arraySegment.Array, clearSize == ClearAll ? arraySegment.Count : clearSize);

System\Formats\Nrbf\Utils\TypeNameHelpers.cs (1)

134ArrayPool<char>.Shared.Return(assemblyQualifiedName.Array!);

System\Buffers\ReadOnlySequence.cs (1)

155T[]? array = segment.Array;

src\runtime\src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (4)

99if (arraySegment.Array == null) 101throw new ArgumentNullException(parameterName + "." + nameof(arraySegment.Array)); 103if (arraySegment.Offset < 0 || arraySegment.Offset > arraySegment.Array.Length) 107if (arraySegment.Count < 0 || arraySegment.Count > (arraySegment.Array.Length - arraySegment.Offset))

System\Net\HttpWebRequest.cs (1)

1274_sendRequestTask = SendRequest(async, new ByteArrayContent(buffer.Array!, buffer.Offset, buffer.Count));

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

17Debug.Assert(arraySegment.Array != null); 20Return(arraySegment.Array, clearSize == ClearAll ? arraySegment.Count : clearSize);

System\Net\Security\SslStreamCertificateContext.Linux.cs (1)

355ArrayPool<char>.Shared.Return(rentedChars.Array!);

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

19ArgumentNullException.ThrowIfNull(segment.Array, nameof(segment)); 22if (segment.Offset < 0 || segment.Count < 0 || segment.Count > (segment.Array.Length - segment.Offset))

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

801ArgumentNullException.ThrowIfNull(buffer.Array, nameof(buffer.Array)); 802if ((uint)buffer.Offset > (uint)buffer.Array.Length) 806if ((uint)buffer.Count > (uint)(buffer.Array.Length - buffer.Offset))

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

125return arraySegment.Array;

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

311handles[i] = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned); 425handles[i] = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned); 564handles[i] = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned);

src\runtime\src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (4)

99if (arraySegment.Array == null) 101throw new ArgumentNullException(parameterName + "." + nameof(arraySegment.Array)); 103if (arraySegment.Offset < 0 || arraySegment.Offset > arraySegment.Array.Length) 107if (arraySegment.Count < 0 || arraySegment.Count > (arraySegment.Array.Length - arraySegment.Offset))

src\runtime\src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (4)

99if (arraySegment.Array == null) 101throw new ArgumentNullException(parameterName + "." + nameof(arraySegment.Array)); 103if (arraySegment.Offset < 0 || arraySegment.Offset > arraySegment.Array.Length) 107if (arraySegment.Count < 0 || arraySegment.Count > (arraySegment.Array.Length - arraySegment.Offset))

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

290Debug.Assert(arraySegment.Array != null); 293Debug.Assert(arraySegment.Offset + arraySegment.Count <= arraySegment.Array.Length); 295_array = arraySegment.Array;

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

411Read(destinationArray.Array!, destinationArray.Offset, destinationArray.Count) : 695Write(sourceArray.Array!, sourceArray.Offset, sourceArray.Count);

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

184n = arraySegment.Array != null 185? _strategy.Read(arraySegment.Array, arraySegment.Offset, arraySegment.Count) 235int moreBytesRead = arraySegment.Array != null 236? _strategy.Read(arraySegment.Array, arraySegment.Offset + n, arraySegment.Count - n) 511if (arraySegment.Array != null) 531if (arraySegment.Array != null) 533_strategy.Write(arraySegment.Array, arraySegment.Offset, arraySegment.Count);

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

313return new ValueTask<int>(ReadAsync(array.Array!, array.Offset, array.Count, cancellationToken)); 737return new ValueTask(WriteAsync(array.Array!, array.Offset, array.Count, cancellationToken));

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

276ReadAsync(array.Array!, array.Offset, array.Count) : 306ReadBlockAsync(array.Array!, array.Offset, array.Count) :

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

675WriteAsync(array.Array!, array.Offset, array.Count) : 770WriteLineAsync(array.Array!, array.Offset, array.Count) :

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

469Read(destinationArray.Array!, destinationArray.Offset, destinationArray.Count) : 736Write(sourceArray.Array!, sourceArray.Offset, sourceArray.Count);

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

181public static implicit operator Memory<T>(ArraySegment<T> segment) => new Memory<T>(segment.Array, segment.Offset, segment.Count);

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

3756return new Span<T>(segment.Array, segment.Offset, segment.Count); 3776return new Span<T>(segment.Array, segment.Offset + start, segment.Count - start); 3812return new Span<T>(segment.Array, segment.Offset + start, length); 3824return new Span<T>(segment.Array, segment.Offset + start, length); 3900public static Memory<T> AsMemory<T>(this ArraySegment<T> segment) => new Memory<T>(segment.Array, segment.Offset, segment.Count); 3918return new Memory<T>(segment.Array, segment.Offset + start, segment.Count - start); 3940return new Memory<T>(segment.Array, segment.Offset + start, length);

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

116public static implicit operator ReadOnlyMemory<T>(ArraySegment<T> segment) => new ReadOnlyMemory<T>(segment.Array, segment.Offset, segment.Count);

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

212=> new ReadOnlySpan<T>(segment.Array, segment.Offset, segment.Count);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\MemoryMarshal.cs (1)

342segment = new ArraySegment<T>(tempArraySegment.Array!, tempArraySegment.Offset + index, length);

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

217new Span<T>(segment.Array, segment.Offset, segment.Count);

System\Runtime\Serialization\Json\XmlJsonReader.cs (1)

792BufferReader.SetBuffer(seg.Array!, seg.Offset, seg.Count, null, null);

System\Runtime\Serialization\MemoryStreamAdapter.cs (2)

98if (innerBuffer.Count == innerBuffer.Array!.Length) 100adapter.Buffer = innerBuffer.Array;

System\Xml\XmlBinaryWriter.cs (2)

1067_captureText = DataContractSerializer.Base64Encoding.GetString(arraySegment.Array!, arraySegment.Offset, arraySegment.Count); 1137writer.WriteBase64Text(null, 0, arraySegment.Array!, arraySegment.Offset, arraySegment.Count);

System\Xml\XmlUTF8TextReader.cs (1)

568BufferReader.SetBuffer(seg.Array!, seg.Offset, seg.Count, null, null);

System\Value.cs (2)

551byte[]? array = segment.Array; 570char[]? array = segment.Array;

System\Runtime\InteropServices\JavaScript\Marshaling\JSMarshalerArgument.Byte.cs (3)

138if (value.Array == null) 145slot.GCHandle = ctx.GetJSOwnedObjectGCHandle(value.Array, GCHandleType.Pinned); 146var refPtr = (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(value.Array));

System\Runtime\InteropServices\JavaScript\Marshaling\JSMarshalerArgument.Double.cs (3)

144if (value.Array == null) 151slot.GCHandle = ctx.GetJSOwnedObjectGCHandle(value.Array, GCHandleType.Pinned); 152var refPtr = (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(value.Array));

System\Runtime\InteropServices\JavaScript\Marshaling\JSMarshalerArgument.Int32.cs (3)

138if (value.Array == null) 145slot.GCHandle = ctx.GetJSOwnedObjectGCHandle(value.Array, GCHandleType.Pinned); 146var refPtr = (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(value.Array));

System\Runtime\InteropServices\JavaScript\Marshaling\JSMarshalerArgument.Single.cs (3)

144if (value.Array == null) 151slot.GCHandle = ctx.GetJSOwnedObjectGCHandle(value.Array, GCHandleType.Pinned); 152var refPtr = (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(value.Array));

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

17Debug.Assert(arraySegment.Array != null); 20Return(arraySegment.Array, clearSize == ClearAll ? arraySegment.Count : clearSize);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\X509Certificates\X509CertificateLoader.Pkcs12.cs (2)

1137if (decrypted.Array is null) 1172Debug.Assert(decrypted.Array is not null);

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

382numOutputBytes = _transform.TransformBlock(tempInputBuffer, 0, numWholeReadBlocksInBytes, bufferArray.Array!, bufferArray.Offset); 654Debug.Assert(segment.Array is not null); 655return transform.TransformBlock(segment.Array, segment.Offset, inputBuffer.Length, outputBuffer, outputOffset);

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

17Debug.Assert(arraySegment.Array != null); 20Return(arraySegment.Array, clearSize == ClearAll ? arraySegment.Count : clearSize);

System\ServiceModel\Channels\ConnectionUtilities.cs (1)

10ValidateBufferBounds(buffer.Array, buffer.Offset, buffer.Count);

System\ServiceModel\Channels\HttpResponseMessageHelper.cs (1)

212byte[] buffer = messageBuffer.Array;

System\ServiceModel\Channels\MessageContent.cs (4)

238_stream = new MemoryStream(_buffer.Array, _buffer.Offset, _buffer.Count, false, true); 258await stream.WriteAsync(_buffer.Array, _buffer.Offset, _buffer.Count); 286if (_buffer.Array != null) 288var byteArray = _buffer.Array;

System\ServiceModel\Channels\TransportDuplexSessionChannel.cs (1)

489buffer = messageData.Array;

System\ServiceModel\Channels\WebSocketTransportDuplexSessionChannel.cs (5)

287BufferManager.ReturnBuffer(messageData.Array); 1222Buffer.BlockCopy(_initialReadBuffer.Array, _initialReadBuffer.Offset, buffer, offset, bytesToCopy); 1223_initialReadBuffer = new ArraySegment<byte>(_initialReadBuffer.Array, _initialReadBuffer.Offset + bytesToCopy, _initialReadBuffer.Count - bytesToCopy); 1244_webSocket.ReceiveAsync(new ArraySegment<byte>(_initialReadBuffer.Array), cancelToken); 1266_bufferManager.ReturnBuffer(_initialReadBuffer.Array);

System\ServiceModel\Channels\FramingChannels.cs (1)

62BufferManager.ReturnBuffer(messageData.Array);

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

233byte[] buffer = messageFrame.Array; 318byte[] buffer = messageFrame.Array;

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

535return new ValueTask<int>(ReadAsync(array.Array!, array.Offset, array.Count, cancellationToken)); 593envelopeStartBytes.CopyTo(new Memory<byte>(messageData.Array, messageData.Offset - envelopeStartBytes.Length, envelopeStartBytes.Length)); 594await connection.WriteAsync(new Memory<byte>(messageData.Array, messageData.Offset - envelopeStartBytes.Length,

System\ServiceModel\Channels\TransportDuplexSessionChannel.cs (1)

435buffer = messageData.Array;

System\ServiceModel\Channels\BinaryMessageEncoder.cs (6)

238((IXmlBinaryReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count, 246xmlReader = XmlDictionaryReader.CreateBinaryReader(buffer.Array, buffer.Offset, buffer.Count, 374byte[] buffer = messageData.Array; 434byte[] buffer = messageData.Array; 546message = _messagePatterns.TryCreateMessage(buffer.Array, buffer.Offset, buffer.Count, bufferManager, messageData); 690XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(messageData.Array, messageData.Offset, messageData.Count, XD.Dictionary, XmlDictionaryReaderQuotas.Max, _readerSessionForLogging);

System\ServiceModel\Channels\BufferedMessageData.cs (1)

65BufferManager.ReturnBuffer(Buffer.Array);

System\ServiceModel\Channels\MessageBuffer.cs (1)

210stream.Write(buffer.Array, buffer.Offset, buffer.Count);

System\ServiceModel\Channels\MessageEncoderCompressionHandler.cs (6)

19MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count); 24bufferedOutStream.Write(buffer.Array, 0, buffer.Offset); 54bufferManager.ReturnBuffer(buffer.Array); 63bufferedOutStream.Write(buffer.Array, 0, buffer.Offset); 69ds.Write(buffer.Array, buffer.Offset, buffer.Count); 74bufferManager.ReturnBuffer(buffer.Array);

System\ServiceModel\Channels\MtomMessageEncoder.cs (5)

501XmlDictionaryReader xmlDictionaryReader = XmlMtomReader.Create(messageData.Array, messageData.Offset, messageData.Count, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, XmlDictionaryReaderQuotas.Max, int.MaxValue, null); 619((IXmlMtomReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count, MtomMessageEncoderFactory.GetSupportedEncodings(), _contentType, Quotas, _messageEncoder.MaxBufferSize, _onClose); 623xmlReader = XmlMtomReader.Create(buffer.Array, buffer.Offset, buffer.Count, MtomMessageEncoderFactory.GetSupportedEncodings(), _contentType, Quotas, _messageEncoder.MaxBufferSize, _onClose); 634((IXmlTextReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count, TextMessageEncoderFactory.GetEncodingFromContentType(_contentType, _messageEncoder._factory.ContentEncodingMap), Quotas, _onClose); 638xmlReader = XmlDictionaryReader.CreateTextReader(buffer.Array, buffer.Offset, buffer.Count, TextMessageEncoderFactory.GetEncodingFromContentType(_contentType, _messageEncoder._factory.ContentEncodingMap), Quotas, _onClose);

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

540XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateTextReader(messageData.Array, messageData.Offset, messageData.Count, XmlDictionaryReaderQuotas.Max); 755return XmlDictionaryReader.CreateTextReader(buffer.Array, buffer.Offset, buffer.Count, Quotas);

System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (1)

238XmlDictionaryReader bufferReader = XmlDictionaryReader.CreateTextReader(memoryBuffer.Array, 0, (int)memoryStream.Length, XmlDictionaryReaderQuotas.Max);

System\ServiceModel\Security\RequestSecurityToken.cs (2)

434if (_cachedWriteBuffer.Array == null) 454writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(_cachedWriteBuffer.Array, 0, _cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);

System\ServiceModel\Security\RequestSecurityTokenResponse.cs (2)

575if (_cachedWriteBuffer.Array == null) 594writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(_cachedWriteBuffer.Array, 0, _cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);

System\Text\Json\Document\JsonDocument.cs (2)

835if (rented.Array is not null) 838ArrayPool<byte>.Shared.Return(rented.Array);

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

127Debug.Assert(drained.Array is not null); 133drained.Array, 140ArrayPool<byte>.Shared.Return(drained.Array); 160Debug.Assert(drained.Array is not null); 163Buffer.BlockCopy(drained.Array, 0, owned, 0, drained.Count); 167ArrayPool<byte>.Shared.Return(drained.Array); 224Debug.Assert(drained.Array is not null); 230drained.Array, 237ArrayPool<byte>.Shared.Return(drained.Array); 248Debug.Assert(drained.Array is not null); 251Buffer.BlockCopy(drained.Array, 0, owned, 0, drained.Count); 255ArrayPool<byte>.Shared.Return(drained.Array);