Length

src\Shared\CircularBuffer.cs (3)

104var overflowItem = data[data.Length - 1]; 106var shiftLength = data.Length - internalIndex - 1; 120data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CircularBuffer.cs (3)

104var overflowItem = data[data.Length - 1]; 106var shiftLength = data.Length - internalIndex - 1; 120data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CompareHelpers.cs (1)

30Debug.Assert(encodedByteCount == requestBytesSpan.Length, "Should match because span was previously trimmed to byte count value.");

Orchestrator\ApplicationOrchestrator.cs (1)

318return value[..^suffixSpan.Length];

src\Shared\CircularBuffer.cs (3)

104var overflowItem = data[data.Length - 1]; 106var shiftLength = data.Length - internalIndex - 1; 120data.Slice(internalIndex, data.Length - internalIndex - 1).CopyTo(data.Slice(internalIndex + 1));

src\Shared\CompareHelpers.cs (1)

30Debug.Assert(encodedByteCount == requestBytesSpan.Length, "Should match because span was previously trimmed to byte count value.");

src\Shared\PasswordGenerator.cs (1)

80Debug.Assert(destination.Length >= minValues);

src\Shared\PasswordGenerator.cs (1)

80Debug.Assert(destination.Length >= minValues);

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Shared\Http2cat\Http2Utilities.cs (2)

292var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 378var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\Http2cat\Http2Utilities.cs (2)

292var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 378var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\Http2cat\Http2Utilities.cs (2)

292var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 378var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\Http2cat\Http2Utilities.cs (2)

292var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 378var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\Http2cat\Http2Utilities.cs (2)

292var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 378var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

Http2\Http2TestBase.cs (2)

663var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 753var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

Http3\Http3StreamTests.cs (2)

2908for (var i = 0; i < chars.Length; i++) 2948for (var i = 0; i < chars.Length; i++)

ResponseTests.cs (6)

1568for (var i = 0; i < span.Length; i++) 1572httpContext.Response.BodyWriter.Advance(span.Length); 1649for (var i = 0; i < span.Length; i++) 1653httpContext.Response.BodyWriter.Advance(span.Length); 1658for (var i = 0; i < span.Length; i++) 1662httpContext.Response.BodyWriter.Advance(span.Length);

src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)

74frame.PayloadLength = headerData.Length;

src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (1)

154if (buffer.Length != 0)

Program.cs (2)

288destination.Advance(destinationSpan.Length); 298destination.Advance(destinationSpan.Length);

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

Internal\DefaultAntiforgeryTokenGenerator.cs (1)

199if (token.ClaimUid.Length != claimUidBytes.Length)

Internal\DefaultClaimUidExtractor.cs (1)

116Debug.Assert(destination.Length >= SHA256.HashSizeInBytes);

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

ParameterView.cs (3)

217if (oldDirectParameterFrames.Length == 0) 224if (newDirectParameterFrames.Length < oldDirectParameterFrames.Length)

PersistentState\PersistentStateValueProviderKeyResolver.cs (1)

112keyBuffer = keyBuffer[..(preKey.Length + currentBuffer.Length)];

src\Shared\UrlDecoder\UrlDecoder.cs (7)

20if (destination.Length < source.Length) 52if (sourceIndex == buffer.Length) 155if (sourceIndex == buffer.Length) 303if (scan == buffer.Length) 385return buffer.Length; 396if (sourceIndex == buffer.Length) 491if (sourceIndex == buffer.Length)

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

154for (var i = 0; i < componentIdsInDepthOrder.Length; i++)

Rendering\TypeNameHash.cs (1)

26written = typeNameBytes.Length;

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

src\Components\Shared\src\ExpressionFormatting\ReverseStringBuilder.cs (6)

27_nextEndIndex = _currentBuffer.Length; 33_nextEndIndex = _currentBuffer.Length; 36public readonly bool Empty => _nextEndIndex == _currentBuffer.Length; 59var sizeToRent = _currentBuffer.Length + Math.Max(MinimumRentedArraySize, remainingLength * 2); 63var newEndIndex = newBuffer.Length - _currentBuffer.Length + _nextEndIndex; 85startIndex = _currentBuffer.Length - remainingLength;

Columns\GridSort.cs (1)

181var nextPos = chars.Length;

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

249Debug.Assert(span.Length >= _bytesWritten);

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

162if (_span.Length >= source.Length) 180if (_span.Length < count) 234if (_span.Length == 0) 239var writable = Math.Min(bytesLeftToCopy, _span.Length);

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequenceReader.cs (6)

457if (firstSpan.Length >= destination.Length) 459firstSpan.Slice(0, destination.Length).CopyTo(destination); 468if (this.Remaining < destination.Length) 474Debug.Assert(firstSpan.Length < destination.Length, "firstSpan.Length < destination.Length"); 484int toCopy = Math.Min(nextSpan.Length, destination.Length - copied); 487if (copied >= destination.Length)

Circuits\RenderBatchWriterTest.cs (6)

39Assert.Equal(36, bytes.Length); // No other data 66Assert.Equal(48, bytes.Length); // No other data 93Assert.Equal(60, bytes.Length); // No other data 135Assert.Equal(60, bytes.Length); // No other data 169var diffsStartIndex = ReadInt(bytes, bytes.Length - 20); 233var referenceFramesStartIndex = ReadInt(bytes, bytes.Length - 16);

src\Components\Shared\src\ExpressionFormatting\ReverseStringBuilder.cs (6)

27_nextEndIndex = _currentBuffer.Length; 33_nextEndIndex = _currentBuffer.Length; 36public readonly bool Empty => _nextEndIndex == _currentBuffer.Length; 59var sizeToRent = _currentBuffer.Length + Math.Max(MinimumRentedArraySize, remainingLength * 2); 63var newEndIndex = newBuffer.Length - _currentBuffer.Length + _nextEndIndex; 85startIndex = _currentBuffer.Length - remainingLength;

Cng\CbcAuthenticatedEncryptor.cs (2)

155pbOutput: (buffer.Length > 0) ? pbBuffer : &dummy, 156cbOutput: (uint)buffer.Length,

Managed\AesGcmAuthenticatedEncryptor.cs (2)

114_keyDerivationKey.WriteSecretIntoBuffer(decryptedKdkUnsafe, decryptedKdk.Length); 253_keyDerivationKey.WriteSecretIntoBuffer(decryptedKdkUnsafe, decryptedKdk.Length);

Managed\ManagedAuthenticatedEncryptor.cs (2)

122_keyDerivationKey.WriteSecretIntoBuffer(decryptedKdkUnsafe, decryptedKdk.Length); 220_keyDerivationKey.WriteSecretIntoBuffer(decryptedKdkUnsafe, decryptedKdk.Length);

SP800_108\ManagedSP800_108_CTR_HMACSHA512.cs (10)

80var outputCount = operationSubkey.Length + validationSubkey.Length; 112prfInput[prfInput.Length - 4] = (byte)(outputSizeInBits >> 24); 113prfInput[prfInput.Length - 3] = (byte)(outputSizeInBits >> 16); 114prfInput[prfInput.Length - 2] = (byte)(outputSizeInBits >> 8); 115prfInput[prfInput.Length - 1] = (byte)(outputSizeInBits); 146CryptoUtil.Assert(prfOutputSizeInBytes == prfOutput.Length, "prfOutputSizeInBytes == prfOutput.Length"); 152var bytesToWrite = Math.Min(numBytesToCopyThisIteration, operationSubkey.Length - operationSubKeyIndex); 154if (operationSubKeyIndex < operationSubkey.Length) // meaning we need to write to operationSubKey 161if (operationSubKeyIndex == operationSubkey.Length && leftOverBytes != 0) // we have filled the operationSubKey. It's time for the validationSubKey

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

SequentialGenRandom.cs (1)

34for (var i = 0; i < target.Length; i++)

src\Shared\Dictionary\AdaptiveCapacityDictionary.cs (1)

561for (var i = 0; i < ArrayStorageSpan.Length; ++i)

Extensions\HttpResponseWritingExtensions.cs (1)

78if (encodedLength <= destination.Length)

src\Shared\UrlDecoder\UrlDecoder.cs (7)

20if (destination.Length < source.Length) 52if (sourceIndex == buffer.Length) 155if (sourceIndex == buffer.Length) 303if (scan == buffer.Length) 385return buffer.Length; 396if (sourceIndex == buffer.Length) 491if (sourceIndex == buffer.Length)

src\Shared\ValueStringBuilder\ValueListBuilder.cs (7)

33if ((uint)pos < (uint)span.Length) 47Debug.Assert(_pos == _span.Length); 78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

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

249Debug.Assert(span.Length >= _bytesWritten);

src\Shared\ValueStringBuilder\ValueListBuilder.cs (7)

33if ((uint)pos < (uint)span.Length) 47Debug.Assert(_pos == _span.Length); 78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\Shared\ValueStringBuilder\ValueStringBuilder.cs (16)

38Debug.Assert(value <= _chars.Length); 43public int Capacity => _chars.Length; 51if ((uint)capacity > (uint)_chars.Length) 137if (_pos > _chars.Length - count) 157if (_pos > (_chars.Length - count)) 172if ((uint)pos < (uint)_chars.Length) 192if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 206if (pos > _chars.Length - s.Length) 217if (_pos > _chars.Length - count) 223for (int i = 0; i < dst.Length; i++) 233if (pos > _chars.Length - length) 239for (int i = 0; i < dst.Length; i++) 249if (pos > _chars.Length - value.Length) 262if (origPos > _chars.Length - length) 290Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 293char[] poolArray = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_chars.Length * 2));

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

src\Shared\ValueStringBuilder\ValueListBuilder.cs (7)

33if ((uint)pos < (uint)span.Length) 47Debug.Assert(_pos == _span.Length); 78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\Shared\ValueStringBuilder\ValueStringBuilder.cs (16)

38Debug.Assert(value <= _chars.Length); 43public int Capacity => _chars.Length; 51if ((uint)capacity > (uint)_chars.Length) 137if (_pos > _chars.Length - count) 157if (_pos > (_chars.Length - count)) 172if ((uint)pos < (uint)_chars.Length) 192if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 206if (pos > _chars.Length - s.Length) 217if (_pos > _chars.Length - count) 223for (int i = 0; i < dst.Length; i++) 233if (pos > _chars.Length - length) 239for (int i = 0; i < dst.Length; i++) 249if (pos > _chars.Length - value.Length) 262if (origPos > _chars.Length - length) 290Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 293char[] poolArray = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_chars.Length * 2));

src\Identity\Extensions.Core\src\Base32.cs (7)

32for (int offset = 0; offset < bytes.Length;) 123switch (input.Length - offset) 132b1 = (offset < input.Length) ? input[offset++] : 0U; 133b2 = (offset < input.Length) ? input[offset++] : 0U; 134b3 = (offset < input.Length) ? input[offset++] : 0U; 135b4 = (offset < input.Length) ? input[offset++] : 0U; 136b5 = (offset < input.Length) ? input[offset++] : 0U;

src\Identity\Extensions.Core\src\Rfc6238AuthenticationService.cs (5)

54Debug.Assert(written == hash.Length); 60var offset = hash[hash.Length - 1] & 0xf; 61Debug.Assert(offset + 4 < hash.Length); 72var combined = new byte[checked(input.Length + modifierBytes.Length)]; 74Buffer.BlockCopy(modifierBytes, 0, combined, input.Length, modifierBytes.Length);

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

249Debug.Assert(span.Length >= _bytesWritten);

FormatterBinaryWriter.cs (2)

116length = span.Length; 200var toWrite = Math.Min(value.Length, available.Length);

RecyclableSequenceBuilder.cs (2)

92if (available.Length >= buffer.Length) 100var toWrite = Math.Min(buffer.Length, available.Length);

EndToEndBenchmarks.cs (1)

98bytes = Math.Min(bytes, span.Length);

Runtime\TagHelpers\TagHelperRunner.cs (2)

37for (var i = 0; i < tagHelpers.Length; i++) 42return Awaited(task, executionContext, i + 1, tagHelpers.Length);

Matching\DefaultEndpointSelector.cs (3)

26switch (candidateState.Length) 63for (var i = 0; i < candidateState.Length; i++) 112for (var i = 0; i < candidateState.Length; i++)

Matching\FastPathTokenizer.cs (2)

27while ((end = span.IndexOf('/')) >= 0 && count < segments.Length) 36if (length > 0 && count < segments.Length)

Matching\HttpMethodMatcherPolicy.cs (2)

399for (var i = 0; i < methods.Length; i++) 408for (var i = 0; i < methods.Length; i++)

Matching\ILEmitTrieFactory.cs (7)

128if (groups.Length < binarySearchThreshold) 132for (var i = 0; i < groups.Length; i++) 153var mid = groups.Length / 2; 348if (groups.Length < binarySearchThreshold) 368var mid = groups.Length / 2; 473if (disableBinarySearch || groups.Length < binarySearchThreshold) 500var mid = groups.Length / 2;

Matching\JumpTableMultipleEntryBenchmark.cs (2)

163for (var c = 0; c < buffer.Length; c++) 167if (char.IsDigit(buffer[c]) && c < buffer.Length / 2)

RequestProcessing\RequestContext.cs (1)

293outputSize: (uint)destination.Length,

RequestProcessing\Response.cs (3)

315_nativeResponse.Base.EntityChunkCount = checked((ushort)dataChunks.Length); 554if (unknownHeaders.Length == 0) 585if (knownHeaderInfo.Length == 0)

RequestProcessing\ResponseBody.cs (1)

265Debug.Assert(currentChunk == dataChunks.Length, "All chunks should be accounted for");

src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (4)

23if (raw[0] != '/' && !(raw.Length == 1 && raw[0] == '*')) 60while (scan < raw.Length && raw[scan] != '?') 75if (raw.Length < 7) 113if (raw.Length < 8)

src\Shared\HttpSys\RequestProcessing\RequestUriBuilder.cs (5)

23Debug.Assert(rawUrlBytes.Length != 0, "Length of the URL cannot be zero."); 26if (rawPath.Length == 0) 33if (rawPath.Length == 1 && rawPath[0] == (byte)'*') 59var end = rawPath.Length; 162if (reader == buffer.Length)

src\Shared\PathNormalizer\PathNormalizer.cs (4)

24while (src.Length > readPointer) 30return src.Length; 36writtenLength += src.Length - readPointer; 47var remainingLength = src.Length - readPointer;

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

Windows.Win32.PInvoke.HTTPAPI.dll.g.cs (2)

423 uint __result = PInvoke.HttpReceiveRequestEntityBody(RequestQueueHandleLocal, RequestId, Flags, (void* )EntityBufferLocal, (uint )EntityBuffer.Length, BytesReturnedLocal, Overlapped); 452 uint __result = PInvoke.HttpReceiveRequestEntityBody(RequestQueueHandleLocal, RequestId, Flags, (void* )EntityBufferLocal, (uint )EntityBuffer.Length, default(uint* ), Overlapped);

src\Shared\Http2cat\Http2Utilities.cs (2)

292var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength); 378var payload = buffer.Slice(extendedHeaderLength, buffer.Length - padLength - extendedHeaderLength);

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

Core\IISHttpContext.cs (2)

325if (rawUrlInBytes.Length == 0) 332if (rawUrlInBytes.Length > 0 && rawUrlInBytes[^1] == 0)

src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (4)

23if (raw[0] != '/' && !(raw.Length == 1 && raw[0] == '*')) 60while (scan < raw.Length && raw[scan] != '?') 75if (raw.Length < 7) 113if (raw.Length < 8)

src\Shared\HttpSys\RequestProcessing\RequestUriBuilder.cs (5)

23Debug.Assert(rawUrlBytes.Length != 0, "Length of the URL cannot be zero."); 26if (rawPath.Length == 0) 33if (rawPath.Length == 1 && rawPath[0] == (byte)'*') 59var end = rawPath.Length; 162if (reader == buffer.Length)

src\Shared\PathNormalizer\PathNormalizer.cs (4)

24while (src.Length > readPointer) 30return src.Length; 36writtenLength += src.Length - readPointer; 47var remainingLength = src.Length - readPointer;

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

Internal\Http\Http1Connection.cs (9)

400Debug.Assert(target.Length != 0, "Request target must be non-zero length"); 410else if (ch == ByteAsterisk && target.Length == 1) 448if (target.Length == 1) 465previousValue == null || previousValue.Length != target.Length || 496if (target.Length == targetPath.Length) 536var queryLength = query.Length; 584previousValue == null || previousValue.Length != target.Length || 642previousValue == null || previousValue.Length != target.Length || 674previousValue == null || previousValue.Length != query.Length ||

Internal\Http\HttpParser.cs (1)

225if (terminatorSize == -1 || !TryTakeSingleHeader(handler, headerSpan.Slice(0, headerSpan.Length - terminatorSize)))

Internal\Http\PathDecoder.cs (1)

38if (path.Length == pathLength && queryLength == 0)

Internal\Infrastructure\HttpUtilities.cs (1)

101Debug.Assert(written == destination.Length);

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

src\Shared\PathNormalizer\PathNormalizer.cs (4)

24while (src.Length > readPointer) 30return src.Length; 36writtenLength += src.Length - readPointer; 47var remainingLength = src.Length - readPointer;

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\runtime\Http3\Frames\Http3Frame.cs (1)

45if (buffer.Length != 0)

src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (1)

154if (buffer.Length != 0)

src\Shared\runtime\Http3\QPack\QPackEncoder.cs (8)

69if (destination.Length >= 2) 184if (buffer.Length != 0) 195if (buffer.Length >= encodedStringLength) 233if (buffer.Length > 0) 258if (buffer.Length >= valueLength) 303Debug.Assert(buffer.Length >= s.Length); 320if (buffer.Length != 0) 328if (buffer.Length >= s.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\UrlDecoder\UrlDecoder.cs (7)

20if (destination.Length < source.Length) 52if (sourceIndex == buffer.Length) 155if (sourceIndex == buffer.Length) 303if (scan == buffer.Length) 385return buffer.Length; 396if (sourceIndex == buffer.Length) 491if (sourceIndex == buffer.Length)

AsciiDecoding.cs (5)

41Assert.Equal(s.Length, asciiBytes.Length); 43for (var i = 0; i < asciiBytes.Length; i++) 103Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, span.Slice(0, span.Length - 1))); 107Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, span.Slice(1, span.Length - 1))); 140for (var i = 0; i < asciiBytes.Length; i++)

BufferWriterTests.cs (4)

152Assert.True(writer.Span.Length > 10); 162Assert.Equal(initialLength, writer.Span.Length); 177Assert.Equal(initialLength - 3, writer.Span.Length); 178Assert.Equal(Pipe.Writer.GetMemory().Length, writer.Span.Length);

Http2\Http2HPackEncoderTests.cs (4)

605headers.Cookie = new string('a', buffer.Length + 1); 620headers.Cookie = new string('a', buffer.Length + 1); 635headers.Cookie = new string('a', buffer.Length - 1); 651headers.Cookie = new string('a', buffer.Length - 1);

PipelineExtensionTests.cs (7)

79var spacer = new byte[writer.Span.Length - gapSize]; 82var bufferLength = writer.Span.Length; 84Assert.NotEqual(bufferLength, writer.Span.Length); 183var spacer = new byte[writer.Span.Length - gapSize]; 185Assert.Equal(gapSize, writer.Span.Length); 187var bufferLength = writer.Span.Length; 189Assert.NotEqual(bufferLength, writer.Span.Length);

src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)

74frame.PayloadLength = headerData.Length;

TestHelpers\AssertExtensions.cs (2)

13if (expected.Length != actual.Length) 15throw new XunitException($"Expected length to be {expected.Length} but was {actual.Length}");

Mocks\NullParser.cs (1)

40new TargetOffsetPathLength(4, startLine.Length - 4, false),

src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)

74frame.PayloadLength = headerData.Length;

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

Buffers\PooledArrayBufferWriterTests.cs (2)

82Assert.True(span.Length >= sizeHint && span.Length > 0);

Buffers\RefPooledArrayBufferWriterTests.cs (3)

21Assert.True(span.Length >= initialCapacity); 134Assert.True(span.Length >= sizeHint && span.Length > 0);

src\Shared\Buffers\RefPooledArrayBufferWriter.cs (8)

105if (_index + count > _buffer.Length) 107throw new InvalidOperationException($"Cannot advance past the end of the buffer. Current position: {_index}, Capacity: {_buffer.Length}, Requested advance: {count}."); 127var bufferSpace = _buffer.Length - _index; 131var rentedInitialSize = _buffer.Length + Math.Max(sizeHint, _buffer.Length); 144var availableSpace = _buffer.Length - _index; 151var growBy = Math.Max(sizeHint, _buffer.Length); 152var newSize = checked(_buffer.Length + growBy);

src\Shared\Dictionary\AdaptiveCapacityDictionary.cs (1)

561for (var i = 0; i < ArrayStorageSpan.Length; ++i)

src\Shared\HttpSys\RequestProcessing\RawUrlHelper.cs (4)

23if (raw[0] != '/' && !(raw.Length == 1 && raw[0] == '*')) 60while (scan < raw.Length && raw[scan] != '?') 75if (raw.Length < 7) 113if (raw.Length < 8)

src\Shared\HttpSys\RequestProcessing\RequestUriBuilder.cs (5)

23Debug.Assert(rawUrlBytes.Length != 0, "Length of the URL cannot be zero."); 26if (rawPath.Length == 0) 33if (rawPath.Length == 1 && rawPath[0] == (byte)'*') 59var end = rawPath.Length; 162if (reader == buffer.Length)

src\Shared\PathNormalizer\PathNormalizer.cs (4)

24while (src.Length > readPointer) 30return src.Length; 36writtenLength += src.Length - readPointer; 47var remainingLength = src.Length - readPointer;

src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (19)

src\Shared\runtime\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\Shared\runtime\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\Shared\runtime\Http3\Frames\Http3Frame.cs (1)

45if (buffer.Length != 0)

src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (1)

154if (buffer.Length != 0)

src\Shared\runtime\Http3\QPack\QPackEncoder.cs (8)

69if (destination.Length >= 2) 184if (buffer.Length != 0) 195if (buffer.Length >= encodedStringLength) 233if (buffer.Length > 0) 258if (buffer.Length >= valueLength) 303Debug.Assert(buffer.Length >= s.Length); 320if (buffer.Length != 0) 328if (buffer.Length >= s.Length)

src\Shared\ServerInfrastructure\BufferExtensions.cs (5)

120if (sourceLength <= dest.Length) 139if (number < 10 && buffer.Length >= 1) 144else if (number < 100 && buffer.Length >= 2) 153else if (number < 1000 && buffer.Length >= 3) 201if (sourceLength <= dest.Length)

src\Shared\ServerInfrastructure\BufferWriter.cs (4)

93if (_span.Length >= source.Length) 111if (_span.Length < count) 140if (_span.Length == 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\StringUtilities.cs (2)

34Debug.Assert(destination[0] == '\0' || written == destination.Length); 63Debug.Assert(written == destination.Length);

src\Shared\UrlDecoder\UrlDecoder.cs (7)

20if (destination.Length < source.Length) 52if (sourceIndex == buffer.Length) 155if (sourceIndex == buffer.Length) 303if (scan == buffer.Length) 385return buffer.Length; 396if (sourceIndex == buffer.Length) 491if (sourceIndex == buffer.Length)

Windows.Win32.PInvoke.HTTPAPI.dll.g.cs (18)

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

249Debug.Assert(span.Length >= _bytesWritten);

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

249Debug.Assert(span.Length >= _bytesWritten);

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

249Debug.Assert(span.Length >= _bytesWritten);

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

249Debug.Assert(span.Length >= _bytesWritten);

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

249Debug.Assert(span.Length >= _bytesWritten);

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

249Debug.Assert(span.Length >= _bytesWritten);

StaticAssetsInvoker.cs (1)

415for (var i = 0; i < states.Length; i++)

StaticAssetsIntegrationTests.cs (1)

611for (var i = 0; i < resources.Length; i++)

src\Shared\ValueStringBuilder\ValueListBuilder.cs (7)

33if ((uint)pos < (uint)span.Length) 47Debug.Assert(_pos == _span.Length); 78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\Shared\ValueStringBuilder\ValueStringBuilder.cs (16)

38Debug.Assert(value <= _chars.Length); 43public int Capacity => _chars.Length; 51if ((uint)capacity > (uint)_chars.Length) 137if (_pos > _chars.Length - count) 157if (_pos > (_chars.Length - count)) 172if ((uint)pos < (uint)_chars.Length) 192if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 206if (pos > _chars.Length - s.Length) 217if (_pos > _chars.Length - count) 223for (int i = 0; i < dst.Length; i++) 233if (pos > _chars.Length - length) 239for (int i = 0; i < dst.Length; i++) 249if (pos > _chars.Length - value.Length) 262if (origPos > _chars.Length - length) 290Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 293char[] poolArray = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_chars.Length * 2));

FileBufferingReadStream.cs (1)

312else if (buffer.Length > 0)

HttpRequestStreamReader.cs (1)

172var count = buffer.Length;

src\Shared\UrlDecoder\UrlDecoder.cs (7)

20if (destination.Length < source.Length) 52if (sourceIndex == buffer.Length) 155if (sourceIndex == buffer.Length) 303if (scan == buffer.Length) 385return buffer.Length; 396if (sourceIndex == buffer.Length) 491if (sourceIndex == buffer.Length)

CodeAnalysisEventSource.Common.cs (4)

56WriteEventCore(eventId: 4, data.Length, dataPtr); 90WriteEventCore(eventId: 6, data.Length, dataPtr); 146WriteEventCore(eventId: 17, data.Length, dataPtr); 174WriteEventCore(eventId: 18, data.Length, dataPtr);

CodeGen\PrivateImplementationDetails.cs (1)

529Debug.Assert(bytesWritten == hash.Length);

CommandLine\CommandLineParser.cs (2)

637if (lineBufferLength >= lineBuffer.Length) 639var temp = new char[lineBuffer.Length * 2];

Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

Text\SourceText.cs (1)

735while (buffer.Length > 0)

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (2)

1160Debug.Assert(bytesWritten == hash.Length); 1165Debug.Assert(bytesWritten == hash.Length);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

Protocol\Internal\Converters\VSInternalExtensionUtilities.cs (1)

85if (valueLength <= scratchChars.Length)

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Compilers\Core\Portable\CodeAnalysisEventSource.Common.cs (4)

56WriteEventCore(eventId: 4, data.Length, dataPtr); 90WriteEventCore(eventId: 6, data.Length, dataPtr); 146WriteEventCore(eventId: 17, data.Length, dataPtr); 174WriteEventCore(eventId: 18, data.Length, dataPtr);

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

Workspace\Solution\Checksum.cs (1)

88Contract.ThrowIfTrue(span.Length < HashSize);

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

ChecksumTests.cs (5)

58for (var i = 0; i < builder.Length; i++) 65for (var i = 1; i < builder.Length; i++) 87for (var i = 0; i < builder.Length; i++) 90for (var i = builder.Length - 10; i < builder.Length; i++)

DataFrame.cs (2)

428for (int i = 0; i < span.Length; i++) 448for (int i = 0; i < span.Length; i++)

PrimitiveColumnContainer.BinaryOperations.cs (2)

31for (var j = 0; j < leftSpan.Length; j++) 82for (var j = 0; j < rightSpan.Length; j++)

PrimitiveColumnContainer.cs (4)

186for (int i = 0; i < mutableBuffer.Length; i++) 204for (int i = 0; i < span.Length; i++) 247for (int i = 0; i < span.Length; i++) 295Debug.Assert(bitMapBufferSpan.Length >= bitMapBufferIndex);

PrimitiveDataFrameColumnComputations.cs (24)

Embeddings\BinaryEmbedding.cs (1)

101for (int i = 0; i < utf8.Length; i++)

TagSetTests.cs (1)

173for (int i = 0; i < chars.Length; i++)

Redaction\NullRedactor.cs (1)

28Throw.IfBufferTooSmall(destination.Length, source.Length, nameof(destination));

Redaction\Redactor.cs (1)

277if (len > destination.Length)

Redaction\TestSpanFormattable.cs (1)

27if (destination.Length < _value.Length)

HmacRedactor.cs (1)

104Throw.IfBufferTooSmall(destination.Length, length, nameof(destination));

FakeRedactor.cs (1)

79Throw.IfBufferTooSmall(destination.Length, str.Length, nameof(destination));

Chunkers\ValueStringBuilder.cs (14)

44Debug.Assert(value <= _chars.Length); 49public int Capacity => _chars.Length; 57if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

src\libraries\Common\src\System\Diagnostics\DiagnosticsHelper.cs (1)

127_maxIndex = bitMap.Length * sizeof(ulong) * 8;

Base32.cs (7)

32for (int offset = 0; offset < bytes.Length;) 123switch (input.Length - offset) 132b1 = (offset < input.Length) ? input[offset++] : 0U; 133b2 = (offset < input.Length) ? input[offset++] : 0U; 134b3 = (offset < input.Length) ? input[offset++] : 0U; 135b4 = (offset < input.Length) ? input[offset++] : 0U; 136b5 = (offset < input.Length) ? input[offset++] : 0U;

Rfc6238AuthenticationService.cs (5)

54Debug.Assert(written == hash.Length); 60var offset = hash[hash.Length - 1] & 0xf; 61Debug.Assert(offset + 4 < hash.Length); 72var combined = new byte[checked(input.Length + modifierBytes.Length)]; 74Buffer.BlockCopy(modifierBytes, 0, combined, input.Length, modifierBytes.Length);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

Resolver\DnsPrimitives.cs (7)

43if (buffer.Length < DnsMessageHeader.HeaderLength) 101destination.Length < length + 2) 115if (label.Length == 0) 130else if (label.Length > 63 || 139nameBuffer[0] = (byte)label.Length; 140written += label.Length + 1; 152if (label.Length != 0)

Logging\JustInTimeRedactor.cs (2)

129if (maxLenToRedact > workBuffer.Length) 153if (redactedLen > destination.Length)

Logging\JustInTimeRedactorTests.cs (1)

124if (s.Length > destination.Length)

Utilities\BigArray.cs (1)

389Contracts.Assert(0 <= length && length <= dst.Length);

Utilities\HashArray.cs (1)

237Contracts.Check(destination.Length >= _ct);

Utilities\Stream.cs (1)

703int numElementsToReadThisChunk = Math.Min(maxChunkSizeInElements, destination.Length);

Utilities\Utils.cs (4)

191Contracts.Assert(src.Count <= dst.Length); 463Contracts.Assert(0 <= lim && lim <= a.Length); 549for (int iv = 0; iv < rgv.Length; iv++) 550Swap(ref rgv[iv], ref rgv[iv + rand.Next(rgv.Length - iv)]);

Utilities\VBufferUtils.cs (3)

277for (int i = 0; i < editor.Values.Length; i++) 283for (int i = 0; i < editor.Values.Length; i++) 309int dstValuesCount = editor.Values.Length;

UnitTests\TestVBuffer.cs (4)

124for (int i = 0; i < editor.Values.Length; ++i) 561for (int i = 0; i < editor.Indices.Length; ++i) 1129for (int i = 0; i < bEditor.Values.Length; ++i) 1151GenericSpanSortHelper<int>.Sort(bEditor.Indices, 0, bEditor.Indices.Length);

AlignedArray.cs (2)

114Contracts.Assert(0 <= index && index <= dst.Length - count); 122Contracts.Assert(0 <= index && index <= dst.Length - count);

AvxIntrinsics.cs (10)

424float* pDstEnd = pdst + dst.Length; 468int length = dst.Length; 571Contracts.Assert(count <= dst.Length); 621float* pDstEnd = pdst + dst.Length; 666Contracts.Assert(count <= dst.Length); 721Contracts.Assert(count <= result.Length); 777Contracts.Assert(count <= dst.Length); 828Contracts.Assert(count <= dst.Length); 877Contracts.Assert(count <= dst.Length); 926Contracts.Assert(count <= dst.Length);

CpuMathUtils.cs (5)

54Contracts.Assert(count <= destination.Length); 73Contracts.Assert(count <= destination.Length); 95Contracts.Assert(count <= result.Length); 113Contracts.Assert(count <= destination.Length); 134Contracts.Assert(count <= destination.Length);

CpuMathUtils.netcoreapp.cs (8)

171if (destination.Length < MinInputSize || !Sse.IsSupported) 173for (int i = 0; i < destination.Length; i++) 205Contracts.Assert(count < destination.Length); 241Contracts.Assert(count < destination.Length); 536Contracts.Assert(count <= v.Length); 537Contracts.Assert(count <= w.Length); 578Contracts.Assert(count <= v.Length); 579Contracts.Assert(count <= w.Length);

SseIntrinsics.cs (10)

359float* pDstEnd = pdst + dst.Length; 392int length = dst.Length; 490Contracts.Assert(count <= dst.Length); 528float* pDstEnd = pdst + dst.Length; 560Contracts.Assert(count <= dst.Length); 602Contracts.Assert(count <= result.Length); 645Contracts.Assert(count <= dst.Length); 684Contracts.Assert(count <= dst.Length); 721Contracts.Assert(count <= dst.Length); 758Contracts.Assert(count <= dst.Length);

Deprecated\Vector\GenericSpanSortHelper.cs (9)

50Contracts.Assert(index >= 0 && length >= 0 && (keys.Length - index >= length), "Check the arguments in the caller!"); 93Contracts.Assert(length <= keys.Length); 94Contracts.Assert(length + left <= keys.Length); 95Contracts.Assert(length + left <= values.Length); 106Contracts.Assert(hi < keys.Length); 152Contracts.Assert(hi < keys.Length); 195Contracts.Assert(hi < keys.Length); 212Contracts.Assert(lo < keys.Length); 238Contracts.Assert(hi <= keys.Length);

Deprecated\Vector\VectorUtils.cs (1)

444Contracts.CheckParam(src.Length == dst.Length, nameof(dst), "Arrays must have the same dimensionality.");

Scorers\FeatureContributionCalculation.cs (1)

241var count = values.Length;

Transforms\ValueToKeyMappingTransformerImpl.cs (1)

660Contracts.Assert(0 <= nstr.Id && nstr.Id < editor.Values.Length);

VBuffer.cs (3)

270/// <param name="destination">The destination buffer. This <see cref="Span{T}.Length"/> must have least <see cref="Length"/>.</param> 279/// <param name="destination">The destination buffer. This <see cref="Span{T}.Length"/> must be at least <see cref="Length"/> 287Contracts.CheckParam(0 <= destinationIndex && destinationIndex <= destination.Length - Length,

VBufferEditor.cs (2)

136return new VBuffer<T>(_logicalLength, Values.Length, _values, _indices); 159Contracts.CheckParam(physicalValuesCount <= Values.Length, nameof(physicalValuesCount),

ImageLoader.cs (3)

342if (bytesRead != srcSpan.Length) 345Contract.Assert(srcSpan.Length == dstSpan.Length);

KMeansModelParameters.cs (1)

167Host.Assert(distances.Length >= _k);

Standard\LogisticRegression\LogisticRegression.cs (1)

214Contracts.Assert(editor.Values.Length >= BiasCount && (grad.IsDense || editor.Indices[BiasCount - 1] == BiasCount - 1));

Standard\LogisticRegression\MulticlassLogisticRegression.cs (2)

272Contracts.Assert(editor.Values.Length >= BiasCount && (grad.IsDense || editor.Indices[BiasCount - 1] == BiasCount - 1)); 1241Host.Assert(dst.Length == NumberOfClasses);

Standard\MulticlassClassification\PairwiseCouplingTrainer.cs (1)

385Contracts.Assert(output.Length >= _numClasses);

Standard\PoissonRegression\PoissonRegression.cs (1)

179Contracts.Assert(editor.Values.Length >= BiasCount && (grad.IsDense || editor.Indices[BiasCount - 1] == BiasCount - 1));

TestLogger.cs (1)

48if ((span.Length >= 2) && (span[count - 2] == '\r') && (span[count - 1] == '\n'))

Model\BertTokenizer.cs (16)

Model\BPETokenizer.cs (9)

934if (buffer.Length == 0) 964if (sSpan.Length > buffer.Length) 1017if (specialTokenSpan.Length > buffer.Length) 1046if (current.Length < span.Length) 1062if (current.Length == utf8BytesConsumed) // encoding is complete 1065if (completeCharsWritten > buffer.Length) 1083incompleteUtf8BytesInBuffer = current.Length - utf8BytesConsumed; 1217if (ContinuingSubwordPrefix.Length + s.Length <= buffer.Length) 1237if (s.Length + EndOfWordSuffix.Length <= buffer.Length)

Model\CodeGenTokenizer.cs (19)

1136if (destinationMaxSize > token.Length) 1200if (destinationMaxSize > token.Length) 1379if (BeginningOfSentenceToken!.Length > buffer.Length) 1402if (EndOfSentenceToken!.Length > buffer.Length) 1425if (UnknownToken!.Length > buffer.Length) 1452if (specialTokenSpan.Length > buffer.Length) 1472if (current.Length < span.Length) 1488if (current.Length == utf8BytesConsumed) // encoding is complete 1491if (completeCharsWritten > buffer.Length) 1509incompleteUtf8BytesInBuffer = current.Length - utf8BytesConsumed; 1600if (text.Length == 0) 1605if (text.Length == 1) 1613BpeSymbol[] symbols = ArrayPool<BpeSymbol>.Shared.Rent(text.Length); 1617for (int i = 0; i < text.Length; i++) 1621next: i == text.Length - 1 ? -1 : i + 1, 1627for (int i = 1; i < text.Length; i++) 1659List<EncodedToken> result = new List<EncodedToken>(text.Length); 1661for (int index = 0; (uint)index < (uint)text.Length; index = symbols[index].next) 1682int endIndex = index + length < mapping.Length ? mapping[index + length] : originalText.Length;

Model\EnglishRobertaTokenizer.cs (5)

808if (s.Length > buffer.Length) 917Debug.Assert(index + tokens[i].Value.Length <= indexMapping.Length); 950if (token.Length == 0) 957if (token.Length == 1) 964List<string> word = new(token.Length);

Model\SentencePieceBaseModel.cs (6)

601if (buffer.Length < specialToken!.Length) 629if (charCount > buffer.Length) 646if (buffer.Length < 1) 678if (tokenSpan.Length > buffer.Length) 705if (tokenSpan.Length > buffer.Length) 726if (buffer.Length < token.Length - delta)

Model\SentencePieceBpeModel.cs (4)

229if (len > utf8Bytes.Length) 529if (len > utf8Bytes.Length) 792if (len > utf8Bytes.Length) 1068if (len > utf8Bytes.Length)

Model\SentencePieceUnigramModel.cs (12)

Model\TiktokenTokenizer.cs (10)

328Debug.Assert(encodedLength < indexMappingSpan.Length); 445Debug.Assert(encodedLength < indexMappingSpan.Length); 610Debug.Assert(encodedLength < indexMappingSpan.Length); 736Debug.Assert(encodedLength < indexMappingSpan.Length); 819if ((uint)utf8ByteCount + (uint)tokenBytes.Length > (uint)utf8Bytes.Length) 841byte[] tmp = ArrayPool<byte>.Shared.Rent(Math.Max(utf8Bytes.Length * 2, requiredCapacity)); 893if (utf8BytesIncompleteCount + tokenBytes.Length > utf8Bytes.Length) 899if (Encoding.UTF8.GetMaxCharCount(utf8BytesIncompleteCount + tokenBytes.Length) > tempBuffer.Length) 917if (incompleteCharsWritten > buffer.Length) 950if (charsConsumed > buffer.Length)

Model\WordPieceTokenizer.cs (3)

755if (token.Length - ContinuingSubwordPrefix.Length > buffer.Length) 767if (token.Length + 1 > buffer.Length) 779if (token.Length > buffer.Length)

Normalizer\BertNormalizer.cs (2)

163if (index + chars.Length >= buffer.Length) 169index += chars.Length;

Normalizer\SentencePieceNormalizer.cs (8)

134if (span.Length < spanLength) 226Debug.Assert(bufferIndex < span.Length - 1); 259Debug.Assert(bufferIndex < span.Length); 403if (normalized.Length <= normalizedIndex + _spaceSymbol.Length) 415if (normalized.Length <= normalizedIndex + 1) 443int length = normalizedIndex - space.Length; 467if (normalized.Length <= normalizedIndex + _spaceSymbol.Length) 476if (normalized.Length <= normalizedIndex + 1)

Utils\BytePairEncoder.cs (9)

Utils\DoubleArrayTrie.cs (2)

747if (encodingLength > bytes.Length) 1086if (numResults < results.Length)

Utils\Helpers.cs (9)

32Debug.Assert(span.Length <= newSize); 70Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 71Debug.Assert(indexMapping.Length >= destination.Length); 124Debug.Assert(destination.Length >= 4); 162Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 163Debug.Assert(indexMapping.Length >= destination.Length); 237Debug.Assert(utf16Chars.Length >= GetUtf16LengthFromUtf8Bytes(utf8Bytes));

Utils\OrdinalUtf8StringComparer.cs (2)

61if (requiredLength1 > buffer1.Length) 67if (requiredLength2 > buffer2.Length)

Utils\ValueStringBuilder.cs (16)

41Debug.Assert(value <= _chars.Length); 46public int Capacity => _chars.Length; 54if ((uint)capacity > (uint)_chars.Length) 231if (_pos > _chars.Length - count) 251if (_pos > (_chars.Length - count)) 271if ((uint)pos < (uint)chars.Length) 291if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 305if (pos > _chars.Length - s.Length) 320if (_pos > _chars.Length - count) 326for (int i = 0; i < dst.Length; i++) 336if (pos > _chars.Length - length) 342for (int i = 0; i < dst.Length; i++) 352if (pos > _chars.Length - value.Length) 365if (origPos > _chars.Length - length) 395Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 401Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

BertTokenizerTests.cs (4)

401Assert.Equal(ids1Span.Length, written); 424Assert.Equal(ids1Span.Length, written); 441Assert.Equal(ids1Span.Length, written); 594Assert.Equal(ids1Span.Length, written);

LlamaTests.cs (3)

904if (sp.Length > 0 && sp[sp.Length - 1] == ' ') 906sp = sp.Slice(0, sp.Length - 1);

src\Microsoft.ML.Tokenizers\Utils\DoubleArrayTrie.cs (2)

747if (encodingLength > bytes.Length) 1086if (numResults < results.Length)

src\Microsoft.ML.Tokenizers\Utils\Helpers.cs (9)

32Debug.Assert(span.Length <= newSize); 70Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 71Debug.Assert(indexMapping.Length >= destination.Length); 124Debug.Assert(destination.Length >= 4); 162Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 163Debug.Assert(indexMapping.Length >= destination.Length); 237Debug.Assert(utf16Chars.Length >= GetUtf16LengthFromUtf8Bytes(utf8Bytes));

src\Microsoft.ML.Tokenizers\Utils\OrdinalUtf8StringComparer.cs (2)

61if (requiredLength1 > buffer1.Length) 67if (requiredLength2 > buffer2.Length)

TokenizerTests.cs (1)

86if (pos >= destination.Length)

Dracula\CMCountTable.cs (1)

147Contracts.Assert(counts.Length == LabelCardinality);

Dracula\DictCountTable.cs (1)

118Contracts.Check(counts.Length == LabelCardinality);

Dracula\Featurizer.cs (4)

140_host.Assert(features.Length == NumFeatures); 173_host.Assert(_labelBinCount == counts.Length); 194_host.Assert(counts.Length == _labelBinCount); 195_host.Assert(logOdds.Length == _logOddsCount);

HeaderUtilities.cs (2)

629var spanLength = span.Length; 699span[span.Length - 1] = span[0] = '\"';

src\Microsoft.Private.Windows.Polyfills\System\DecimalExtensions.cs (1)

19if (destination.Length <= 3)

src\Microsoft.Private.Windows.Polyfills\System\IO\BinaryReaderExtensions.cs (2)

26byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 29int numRead = reader.Read(sharedBuffer, 0, buffer.Length);

src\Microsoft.Private.Windows.Polyfills\System\IO\StreamExtensions.cs (4)

31byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 34int numRead = stream.Read(sharedBuffer, 0, buffer.Length); 35if ((uint)numRead > (uint)buffer.Length) 85while (totalRead < buffer.Length)

src\Microsoft.Private.Windows.Polyfills\System\StringExtensions.cs (1)

20if (destination.Length < stringValue.Length)

src\Microsoft.Private.Windows.Polyfills\System\Text\EncodingExtensions.cs (1)

26return encoding.GetBytes(sourcePointer, source.Length, destinationPointer, destination.Length);

System\BufferScope.cs (3)

59if (initialBuffer.Length >= minimumLength) 83if (_span!.Length >= capacity) 111public readonly int Length => _span.Length;

System\IO\BinaryReaderExtensions.cs (1)

124if (reader.Read(arrayData) != arrayData.Length)

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

294uint charactersCopied = PInvokeCore.DragQueryFile(hdrop, i, buffer, (uint)fileName.Length);

System\SpanHelpers.cs (2)

17if (source.Length >= destination.Length) 19source = source[..(destination.Length - 1)];

System\SpanWriter.cs (11)

16readonly get => Span.Length - _unwritten.Length; 20public readonly int Length => Span.Length; 46if (_unwritten.Length >= values.Length) 63if (_unwritten.Length >= count) 82public void Rewind(int count) => _unwritten = Span[(Span.Length - _unwritten.Length - count)..]; 92Debug.Assert((uint)count <= (uint)_unwritten.Length); 93UncheckedSlice(ref _unwritten, count, _unwritten.Length - count); 99Debug.Assert((uint)start <= (uint)span.Length && (uint)length <= (uint)(span.Length - start));

System\Text\ValueStringBuilder.cs (15)

52Debug.Assert(value <= _chars.Length); 57public readonly int Capacity => _chars.Length; 65if ((uint)capacity > (uint)_chars.Length) 155if (_pos > _chars.Length - count) 175if (_pos > (_chars.Length - count)) 190if ((uint)pos < (uint)_chars.Length) 216if (s.Length == 1 && (uint)pos < (uint)_chars.Length) 231if (pos > _chars.Length - s.Length) 260if (_pos > _chars.Length - count) 266for (int i = 0; i < dst.Length; i++) 277if (pos > _chars.Length - length) 283for (int i = 0; i < dst.Length; i++) 294if (pos > _chars.Length - value.Length) 322Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 330Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

Windows.Win32.IDispatch.g.cs (2)

101 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 102 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IDispatchEx.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IEnumFORMATETC.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumSTATDATA.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumSTATSTG.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumString.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IPictureDisp.g.cs (2)

84 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 85 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITypeInfo.g.cs (2)

218 if (rgszNames.Length != pMemId.Length) throw new ArgumentException(); 219 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(rgszNamesLocal, (uint )pMemId.Length, pMemIdLocal);

Windows.Win32.PInvokeCore.GDI32.dll.g.cs (2)

442 uint __result = PInvokeCore.GetEnhMetaFileBits(hEMF, (uint )lpData.Length, lpDataLocal); 493 uint __result = PInvokeCore.GetPaletteEntries(hpal, iStart, (uint )pPalEntries.Length, pPalEntriesLocal);

Windows.Win32.System_Com_IEnumFORMATETC_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Com_IEnumSTATDATA_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Com_IEnumString_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Com_ITypeInfo_Extensions.g.cs (2)

90 if (rgszNames.Length != pMemId.Length) throw new ArgumentException(); 91 winmdroot.Foundation.HRESULT __result = @this.GetIDsOfNames(rgszNamesLocal, (uint )pMemId.Length, pMemIdLocal);

Windows.Win32.System_Com_StructuredStorage_IEnumSTATSTG_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows\Win32\Graphics\Gdi\ArgbBuffer.cs (2)

29public ArgbBuffer(Span<Color> colors) : this(colors.Length) 31for (int i = 0; i < colors.Length; i++)

Windows\Win32\PInvokeCore.GetPaletteEntries.cs (1)

13return GetPaletteEntries(hpal, 0, (uint)entries.Length, entry);

System\ISpanFormattableTests.cs (1)

17if (formatted.Length > destination.Length)

System\Windows\Input\TextCompositionManager.cs (2)

407ptrMultiByte, multiByte.Length, ptrOutputChars, outputChars.Length); 857Debug.Assert(destination.Length == 2, "Invalid buffer length");

System\Windows\Media\ColorTransform.cs (6)

101for (int i = 0; i < dstValue.Length; i++) 132if (srcValue.Length < 3 || srcValue.Length > 8) 137if (srcValue.Length <= 4) 141for (int i = 0; i < srcValue.Length; i++) 163for (int i = 0; i < srcValue.Length; i++)

System\Windows\Media\Imaging\WriteableBitmap.Tests.cs (6)

101smallRect.Length, tileSize * channels, 0, 0); 105smallRect.Length, tileSize * channels, width - tileSize, 0); 109smallRect.Length, tileSize * channels, (width - tileSize) / 2, (height - tileSize) / 2); 113smallRect.Length, tileSize * channels, 0, height - tileSize); 117smallRect.Length, tileSize * channels, width - tileSize, height - tileSize); 166bigRect.Length * channels, width * channels, 0, 0);

MS\Internal\PtsHost\ListMarkerSourceInfo.cs (2)

191result[result.Length - 1] = NumberSuffix; 192for (int i = result.Length - 2; i >= 0; --i)

System\Windows\Documents\FixedSOMTextRun.cs (1)

156for (int i = 0; i < destination.Length; i++)

Serialization\XpsFontSubsetter.cs (1)

683for (int i = 0; i < guidByteArray.Length; i++)

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

ServerSentEvents\Helpers.cs (2)

53Debug.Assert(value.Length <= buffer.Length); 67Debug.Assert(maxByteCount <= buffer.Length);

src\libraries\Common\src\System\Collections\Generic\BitHelper.cs (1)

30if (bitArrayIndex < (uint)span.Length)

System\Collections\Frozen\FrozenDictionary.cs (1)

384if (destination.Length < Count)

System\Collections\Frozen\FrozenHashTable.cs (7)

61if ((long)numBuckets + hashCodes.Length > Array.MaxLength) 69int[] arrayPoolBuckets = ArrayPool<int>.Shared.Rent(numBuckets + hashCodes.Length); 71Span<int> nexts = arrayPoolBuckets.AsSpan(numBuckets, hashCodes.Length); 78for (int index = 0; index < hashCodes.Length; index++) 81int bucketNum = (int)HashHelpers.FastMod((uint)hashCode, (uint)bucketStarts.Length, fastModMultiplier); 94var hashtableHashcodes = new int[hashCodes.Length]; 95var hashtableBuckets = new Bucket[bucketStarts.Length];

System\Collections\Frozen\Int32\Int32FrozenDictionary.cs (1)

40for (int srcIndex = 0; srcIndex < hashCodes.Length; srcIndex++)

System\Collections\Frozen\ItemsFrozenSet.cs (1)

35for (int srcIndex = 0; srcIndex < hashCodes.Length; srcIndex++)

System\Collections\Frozen\KeysAndValuesFrozenDictionary.cs (1)

37for (int srcIndex = 0; srcIndex < hashCodes.Length; srcIndex++)

System\Collections\Frozen\String\OrdinalStringFrozenDictionary.cs (1)

52for (int srcIndex = 0; srcIndex < hashCodes.Length; srcIndex++)

System\Collections\Frozen\String\OrdinalStringFrozenSet.cs (1)

43for (int srcIndex = 0; srcIndex < hashCodes.Length; srcIndex++)

System\Collections\Immutable\ImmutableArray_1.Builder.cs (1)

1020Requires.Range(this.Count <= destination.Length, nameof(destination));

System\Collections\Immutable\ImmutableArray_1.cs (1)

916Requires.Range(self.Length <= destination.Length, nameof(destination));

System\Collections\Specialized\BitVector32.cs (2)

166dst[dst.Length - 1] = '}'; 170for (int i = 0; i < dst.Length; i++)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\ConsolePal.Unix.cs (4)

521Debug.Assert(readBytesPos > 0 && readBytesPos <= readBytes.Length); 578if (dstPos == dst.Length) 580var tmpReadBytes = new byte[dst.Length * 2]; 613Debug.Assert(foundByteDstPos < foundByteDst.Length, "Should only be called when there's room for at least one byte.");

System\IO\CachedConsoleStream.cs (1)

65if (lastNewLine + 1 < charBuffer.Length)

System\IO\StdInReader.cs (1)

77if (spaceRemaining < chars.Length)

System\Data\SQLTypes\SQLBytes.cs (1)

326int count = Math.Min(buffer.Length, (int)(Length - offset));

System\Data\SQLTypes\SQLDecimal.cs (7)

1172ArgumentOutOfRangeException.ThrowIfLessThan(destination.Length, 4, nameof(destination)); 1866Debug.Assert(rgulData.Length == s_cNumeMax, "rgulData.Length == x_cNumeMax", "Invalid array length"); 1940Debug.Assert(rglData.Length == 4, "rglData.Length == 4", $"Wrong array length: {rglData.Length}"); 2472Debug.Assert(rgulD.Length >= ciulS, "rgulD.Length >= ciulS", "Invalid array length"); 2544Debug.Assert(rgulU.Length == s_cNumeMax); 2613Debug.Assert(rgulD.Length == s_cNumeMax);

src\libraries\Common\src\System\Diagnostics\DiagnosticsHelper.cs (1)

127_maxIndex = bitMap.Length * sizeof(ulong) * 8;

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Diagnostics\Activity.cs (5)

2020Debug.Assert(outBytes.Length == 16 || outBytes.Length == 8); 2025if (outBytes.Length == 16) 2037Debug.Assert(outBytes.Length * 2 == charData.Length); 2038for (int i = 0; i < outBytes.Length; i++)

System\Diagnostics\Metrics\AggregatorStore.cs (1)

502KeyValuePair<string, string>[] labels = new KeyValuePair<string, string>[indexedNames.Length];

System\Diagnostics\Metrics\TagList.netcore.cs (1)

143if (tags.Length < _tagsCount)

System\Diagnostics\FileVersionInfo.Unix.cs (5)

207if (parts.Length <= 4 && parts.Length > 0) 210if (!endedEarly && parts.Length > 1) 213if (!endedEarly && parts.Length > 2) 216if (!endedEarly && parts.Length > 3)

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetGroupList.cs (2)

23int ngroups = groups.Length; 33else if (rv == -1 && ngroups > groups.Length)

src\libraries\Common\src\Interop\Unix\System.Native\Interop.IsMemberOfGroup.cs (2)

30rv = Interop.Sys.GetGroups(groups.Length, pGroups); 41groups = new uint[groups.Length * 2];

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (3)

43int resultLength = ReadLink(path, ref MemoryMarshal.GetReference(spanBuffer), spanBuffer.Length); 51else if (resultLength < spanBuffer.Length) 71arrayBuffer = ArrayPool<byte>.Shared.Rent(spanBuffer.Length * 2);

src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

41if ((long)MaxUtf8BytesPerChar * managed.Length >= buffer.Length) 45if (exactByteCount > buffer.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Diagnostics\Process.Linux.cs (3)

283if (bytesRead == buffer.Length) 285uint newLength = (uint)buffer.Length * 2; 297Debug.Assert(bytesRead < buffer.Length);

System\Diagnostics\XmlWriterTraceListener.cs (1)

411Debug.Assert(charsWritten == span.Length);

System\DirectoryServices\Protocols\common\DirectoryControl.cs (7)

171ThrowUnless(bytesConsumed == asnSpan.Length); 194ThrowUnless(bytesConsumed == asnSpan.Length); 209ThrowUnless(bytesConsumed == asnSpan.Length); 221ThrowUnless(asnSpan.Length == bytesConsumed); 234ThrowUnless(bytesConsumed == asnSpan.Length); 246if (asnSpan.Length <= AttributeNameStackAllocationThreshold) 275ThrowUnless(bytesConsumed == asnSpan.Length);

System\Drawing\Drawing2D\GraphicsPath.cs (2)

974PInvokeGdiPlus.GdipGetPathTypes(_nativePath, t, destination.Length).ThrowIfFailed(); 1019PInvokeGdiPlus.GdipGetPathPoints(_nativePath, (GdiPlus.PointF*)p, destination.Length).ThrowIfFailed();

System\Drawing\Drawing2D\GraphicsPathIterator.cs (8)

162if (points.Length != types.Length 163|| points.Length < Count) 168if (points.Length == 0) 182points.Length).ThrowIfFailed(); 211if ((points.Length != types.Length) 215|| count > points.Length

System\Drawing\Drawing2D\Matrix.cs (1)

147Debug.Assert(elements.Length >= 6);

System\Drawing\FontFamily.cs (1)

238Debug.Assert(span.Length == (int)PInvokeCore.LF_FACESIZE);

System\Drawing\Imaging\EncoderParameters.cs (2)

43EncoderParameters parameters = new(nativeParameters.Length); 44for (int i = 0; i < nativeParameters.Length; i++)

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

57Return(_skipClear ? 0 : Span.Length); 114if (currentBuffer.Length >= length)

System\Formats\Asn1\Asn1Tag.cs (3)

301/// <see langword="false"/> if <paramref name="destination"/>.<see cref="Span{T}.Length"/> < 308if (destination.Length < spaceRequired) 360/// <paramref name="destination"/>.<see cref="Span{T}.Length"/> < <see cref="CalculateEncodedSize"/>.

System\Formats\Asn1\AsnDecoder.BitString.cs (2)

189if (value.Length > destination.Length) 609if (dest.Length < contentLength)

System\Formats\Asn1\AsnDecoder.NamedBitList.cs (1)

395for (int byteIdx = 0; byteIdx < value.Length; byteIdx++)

System\Formats\Asn1\AsnDecoder.OctetString.cs (5)

86if (contents.Length > destination.Length) 464if (dest.Length < contentLength) 506if (tmpSpace.Length > 0 && tooBig > tmpSpace.Length) 512if (tooBig > tmpSpace.Length)

System\Formats\Asn1\AsnDecoder.Oid.cs (2)

199Debug.Assert(writeSpan.Length >= SemanticByteCount); 212int bytesWritten = tmpBytes.Length - writeSpan.Length;

System\Formats\Asn1\AsnDecoder.Text.cs (1)

352if (contents.Length > destination.Length)

System\Formats\Asn1\AsnWriter.cs (1)

144if (destination.Length < _offset)

System\Formats\Asn1\AsnWriter.GeneralizedTime.cs (2)

103int totalLength = IntegerPortionLength + 1 + fraction.Length; 138_offset += fraction.Length;

System\Formats\Asn1\AsnWriter.Oid.cs (1)

190Debug.Assert(dest.Length > 0);

System\Formats\Cbor\Reader\CborReader.String.cs (4)

80if (length > destination.Length) 241if (charLength > destination.Length) 355if (concatenatedBufferSize > destination.Length) 424if (concatenatedStringSize > destination.Length)

System\Formats\Cbor\Writer\CborWriter.cs (2)

193if (encoding.Length > destination.Length) 211if (encoding.Length > destination.Length)

System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (1)

134int sliceSize = Math.Min(valuesToRead.Length, MaxChunkLength);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

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

49int origCount = destination.Length; 50int count = destination.Length;

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

113destination = destination[..LimitByRemaining(destination.Length)];

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

895if (span.Length < length) 974int i = destination.Length - 3; 975int j = converted.Length - 2; // Skip the null terminator in 'converted' 997Debug.Assert(destination.Length > 1); 1000int numToCopy = Math.Min(bytesToWrite.Length, destination.Length); 1011Debug.Assert(destination.Length > 1); 1017int numToCopy = Math.Min(bytesToWrite.Length, destination.Length - 1); 1019int copyPos = destination.Length - 1 - bytesToWrite.Length; 1071Debug.Assert(destination.Length == 8, "8 byte field expected."); 1096Debug.Assert(destination.Length == 12, "12 byte field expected."); 1125int i = digits.Length - 1;

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

105int initialLength = buffer.Length; 113if (buffer.Length == 0) 140return initialLength - buffer.Length;

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

115bytes = bytes.Slice(0, (int)Math.Min(bytes.Length, _uncompressedSize - _currentInflatedCount));

System\IO\Compression\DeflateManaged\OutputWindow.cs (6)

125if (output.Length > _bytesUsed) 133copy_end = (_end - _bytesUsed + output.Length) & WindowMask; // copy length of bytes 136int copied = output.Length; 138int tailLen = output.Length - copy_end; 146_window.AsSpan(copy_end - output.Length, output.Length).CopyTo(output);

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

72if (destination.Length == 0) 77return InflateVerified(bufPtr, destination.Length);

System\IO\Compression\ZipBlocks.cs (7)

440int bytesRead = stream.ReadAtLeast(blockContents, blockContents.Length, throwOnEndOfStream: false); 519int bytesRead = stream.ReadAtLeast(blockContents, blockContents.Length, throwOnEndOfStream: false); 633Debug.Assert(blockBytes.Length == FieldLengths.FilenameLength + FieldLengths.ExtraFieldLength); 665int bytesRead = stream.ReadAtLeast(blockBytes, blockBytes.Length, throwOnEndOfStream: false); 670bytesRead = stream.ReadAtLeast(blockBytes, blockBytes.Length, throwOnEndOfStream: false); 822Debug.Assert(bytesToRead == collatedHeader[remainingBufferLength..].Length); 962int bytesRead = stream.ReadAtLeast(blockContents, blockContents.Length, throwOnEndOfStream: false);

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

351int origCount = destination.Length; 352int count = destination.Length; 791if (buffer.Length > 0)

System\IO\Compression\ZipHelper.cs (9)

119if (maxBytesToRead - totalBytesRead + overlap < bufferSpan.Length) 127outOfBytes = bytesRead < bufferSpan.Length; 128if (bytesRead < bufferSpan.Length) 134Debug.Assert(bufferPointer < bufferSpan.Length); 169if (stream.Position >= buffer.Length) 171Debug.Assert(overlap <= buffer.Length); 172stream.Seek(-(buffer.Length - overlap), SeekOrigin.Current); 173bytesRead = stream.ReadAtLeast(buffer, buffer.Length, throwOnEndOfStream: true); 174stream.Seek(-buffer.Length, SeekOrigin.Current);

System\IO\Compression\Zstandard\ZstandardDecoder.cs (3)

161size = (nuint)destination.Length, 256destPtr, (nuint)destination.Length, 301dctx, destPtr, (nuint)destination.Length,

System\IO\Compression\Zstandard\ZstandardDictionary.cs (1)

109Debug.Assert(lengthsAsNuint.Length == sampleLengths.Length);

System\IO\Compression\Zstandard\ZstandardEncoder.cs (2)

253size = (nuint)destination.Length, 376nuint result = Interop.Zstd.ZSTD_compress2(ctx, outBytes, (nuint)destination.Length, inBytes, (nuint)source.Length);

System\IO\Compression\Zstandard\ZstandardStream.Decompress.cs (2)

74(lastResult == OperationStatus.DestinationTooSmall && destination.IsEmpty && _buffer.ActiveLength == 0), $"{nameof(lastResult)} == {lastResult}, {nameof(destination.Length)} == {destination.Length}");

System\IO\Compression\dec\BrotliDecoder.cs (6)

64nuint availableOutput = (nuint)destination.Length; 83Debug.Assert(availableOutput <= (nuint)destination.Length); 86bytesWritten += destination.Length - (int)availableOutput; 97destination = destination.Slice(destination.Length - (int)availableOutput); 119nuint availableOutput = (nuint)destination.Length; 122Debug.Assert(success ? availableOutput <= (nuint)destination.Length : availableOutput == 0);

System\IO\Compression\dec\BrotliStream.Decompress.cs (2)

245(lastResult == OperationStatus.DestinationTooSmall && destination.IsEmpty && _bufferCount == 0), $"{nameof(lastResult)} == {lastResult}, {nameof(destination.Length)} == {destination.Length}");

System\IO\Compression\enc\BrotliEncoder.cs (7)

149nuint availableOutput = (nuint)destination.Length; 167Debug.Assert(availableOutput <= (nuint)destination.Length); 170bytesWritten += destination.Length - (int)availableOutput; 173if ((int)availableOutput == destination.Length && Interop.Brotli.BrotliEncoderHasMoreOutput(_state) == Interop.BOOL.FALSE && availableInput == 0) 179destination = destination.Slice(destination.Length - (int)availableOutput); 217nuint availableOutput = (nuint)destination.Length; 220Debug.Assert(success ? availableOutput <= (nuint)destination.Length : availableOutput == 0);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\IO\Hashing\Adler32.cs (2)

144if (destination.Length < Size) 166if (destination.Length < Size)

System\IO\Hashing\Crc32.cs (2)

230if (destination.Length < Size) 276if (destination.Length < Size)

System\IO\Hashing\Crc64.cs (2)

239if (destination.Length < Size) 285if (destination.Length < Size)

System\IO\Hashing\NonCryptographicHashAlgorithm.cs (5)

163if (destination.Length < HashLengthInBytes) 188if (destination.Length < HashLengthInBytes) 225if (destination.Length < HashLengthInBytes) 250if (destination.Length < HashLengthInBytes) 284Debug.Assert(destination.Length == HashLengthInBytes);

System\IO\Hashing\XxHash128.cs (1)

104if (destination.Length >= sizeof(ulong) * 2)

System\IO\Hashing\XxHash3.cs (1)

104if (destination.Length >= sizeof(long))

System\IO\Hashing\XxHash32.cs (2)

214if (destination.Length < HashSize) 237if (destination.Length < HashSize)

System\IO\Hashing\XxHash64.cs (2)

214if (destination.Length < HashSize) 237if (destination.Length < HashSize)

System\IO\Hashing\XxHashShared.cs (2)

324Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 327state.BufferedCount = (uint)remaining.Length;

System\IO\Packaging\InterleavedZipPackagePartStream.cs (2)

93if (buffer.Length == 0) 129while (totalBytesRead < buffer.Length)

System\IO\Pipelines\Pipe.cs (1)

1104int writable = Math.Min(destination.Length, source.Length);

System\IO\Pipelines\PipeReaderStream.cs (1)

126int actual = (int)Math.Min(bufferLength, buffer.Length);

System\IO\Pipes\PipeStream.Unix.cs (1)

261if (buffer.Length == 0)

System\IO\Ports\SerialStream.Unix.cs (1)

784int numBytes = Interop.Serial.Read(_handle, bufPtr, buff.Length);

System\Linq\OrderedEnumerable.SpeedOpt.cs (1)

48for (int i = 0; i < destination.Length; i++)

System\Linq\Range.cs (2)

83ref T end = ref Unsafe.Add(ref pos, destination.Length); 87destination.Length >= Vector<T>.Count)

System\Linq\SegmentedArrayBuilder.cs (6)

107if ((uint)countInCurrentSegment < (uint)currentSegment.Length) 144int availableSpaceInCurrentSpan = _currentSegment.Length - _countInCurrentSegment; 162bool currentSegmentIsScratchBufferWithRemainingSpace = _segmentsCount == 0 && _countInCurrentSegment < _currentSegment.Length; 169int remainingSpaceInCurrentSegment = _currentSegment.Length - _countInCurrentSegment; 219if ((uint)countInCurrentSegment < (uint)currentSegment.Length) 342int currentSegmentLength = _currentSegment.Length;

System\Linq\Select.SpeedOpt.cs (6)

166for (int i = 0; i < destination.Length; i++) 309for (int i = 0; i < results.Length; i++, start++) 422for (int i = 0; i < destination.Length; i++) 540for (int i = 0; i < results.Length; i++) 815Debug.Assert(index == results.Length, "All list elements were not initialized."); 983for (int i = 0; i < destination.Length; i++, sourceIndex++)

System\Linq\SingleLinkedNode.cs (1)

119int index = span.Length;

System\Linq\SkipTake.SpeedOpt.cs (2)

153sourceSpan.Slice(sourceIndex, destination.Length).CopyTo(destination); 159for (int i = 0; i < destination.Length; i++, sourceIndex++)

System\Linq\SingleLinkedNode.cs (1)

119int index = span.Length;

System\Buffers\BuffersExtensions.cs (4)

68if (span.Length > destination.Length) 80if (sequence.Length > destination.Length) 121if (value.Length <= destination.Length) 137int writeSize = Math.Min(destination.Length, input.Length);

System\Buffers\SequenceReader.cs (6)

417if (firstSpan.Length >= destination.Length) 419firstSpan.Slice(0, destination.Length).CopyTo(destination); 430if (Remaining < destination.Length) 434Debug.Assert(firstSpan.Length < destination.Length); 444int toCopy = Math.Min(nextSpan.Length, destination.Length - copied); 447if (copied >= destination.Length)

System\Text\EncodingExtensions.cs (4)

116int originalBytesLength = bytes.Length; 130return originalBytesLength - bytes.Length; // total number of bytes we wrote 307int originalCharsLength = chars.Length; 321return originalCharsLength - chars.Length; // total number of chars we wrote

src\libraries\Common\src\System\IO\ReadOnlyMemoryStream.cs (5)

108if (remaining <= 0 || buffer.Length == 0) 112else if (remaining <= buffer.Length) 120_content.Span.Slice(_position, buffer.Length).CopyTo(buffer); 121_position += buffer.Length; 122return buffer.Length;

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\IO\ReadOnlyMemoryStream.cs (5)

108if (remaining <= 0 || buffer.Length == 0) 112else if (remaining <= buffer.Length) 120_content.Span.Slice(_position, buffer.Length).CopyTo(buffer); 121_position += buffer.Length; 122return buffer.Length;

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HPackEncoder.cs (19)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\Huffman.cs (5)

680Debug.Assert(dst.Length > 0); 712if (j == dst.Length) 714Array.Resize(ref dstArray, dst.Length * 2); 779if (j == dst.Length) 781Array.Resize(ref dstArray, dst.Length * 2);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\IntegerEncoder.cs (3)

28if (destination.Length == 0) 47if (1 == destination.Length) 60if (i >= destination.Length)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\Frames\Http3Frame.cs (1)

45if (buffer.Length != 0)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\Helpers\VariableLengthIntegerHelper.cs (1)

154if (buffer.Length != 0)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackEncoder.cs (8)

69if (destination.Length >= 2) 184if (buffer.Length != 0) 195if (buffer.Length >= encodedStringLength) 233if (buffer.Length > 0) 258if (buffer.Length >= valueLength) 303Debug.Assert(buffer.Length >= s.Length); 320if (buffer.Length != 0) 328if (buffer.Length >= s.Length)

src\libraries\Common\src\System\Net\MultiArrayBuffer.cs (1)

387if (destination.Length < _length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

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

1010Debug.Assert(remainingInCurrentBuffer.Length < buffer.Length); 1011buffer.Slice(0, remainingInCurrentBuffer.Length).CopyTo(remainingInCurrentBuffer); 1012buffer = buffer.Slice(remainingInCurrentBuffer.Length); 1052Debug.Assert(destination.Length >= _totalLength); 1065Debug.Assert(destination.Length >= buffer.Length); 1073Debug.Assert(_lastBufferOffset <= destination.Length);

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

482if (buffer.Length == 0)

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (10)

37if (buffer.Length == 0) 64buffer.Length >= _connection.ReadBufferSize && 72Debug.Assert(buffer.Length != 0); 73int bytesRead = _connection.Read(buffer.Slice(0, (int)Math.Min((ulong)buffer.Length, _chunkBytesRemaining))); 86if (buffer.Length == 0) 101if (buffer.Length == 0) 296Debug.Assert(buffer.Length > 0); 298while (buffer.Length > 0) 300if (ReadChunkFromConnectionBuffer(buffer.Length, cancellationRegistration) is not ReadOnlyMemory<byte> bytesRead || bytesRead.Length == 0) 305Debug.Assert(bytesRead.Length <= buffer.Length);

System\Net\Http\SocketsHttpHandler\ConnectionCloseReadStream.cs (1)

28if (bytesRead == 0 && buffer.Length != 0)

System\Net\Http\SocketsHttpHandler\ContentLengthReadStream.cs (2)

32if ((ulong)buffer.Length > _contentBytesRemaining) 38if (bytesRead <= 0 && buffer.Length != 0)

System\Net\Http\SocketsHttpHandler\DecompressionHandler.cs (1)

388if (buffer.Length != 0)

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (2)

1694Debug.Assert(span.Length == 0); 1946Debug.Assert(destination.Length >= Size);

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (2)

1116int bytesRead = Math.Min(buffer.Length, activeBuffer.Length); 1153else if (buffer.Length != 0)

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (4)

1220int copyLen = (int)Math.Min(buffer.Length, Math.Min(_responseDataPayloadRemaining, _recvBuffer.ActiveLength)); 1240int copyLen = (int)Math.Min(buffer.Length, _responseDataPayloadRemaining); 1243if (bytesRead == 0 && buffer.Length != 0) 1257while (buffer.Length != 0);

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (21)

1041int length = (uint)carriageReturnIndex < (uint)buffer.Length && buffer[carriageReturnIndex] == '\r' 1050if (_allowedReadLineBytes <= buffer.Length) 1065if (line.Length < MinStatusLineLength || line[8] != ' ') 1101if (line.Length == MinStatusLineLength) 1137int bytesScanned = finished ? bytesConsumed : buffer.Length; 1152int originalBufferLength = buffer.Length; 1159return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); 1166return (finished: true, bytesConsumed: originalBufferLength - buffer.Length + colIdx + 1); 1173if ((uint)valueStartIdx >= (uint)buffer.Length) 1175return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); 1185if ((uint)lfIdx >= (uint)valueIterator.Length) 1187return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); 1191int crOrLfIdx = (uint)crIdx < (uint)valueIterator.Length && valueIterator[crIdx] == '\r' 1196if ((uint)spIdx >= (uint)valueIterator.Length) 1198return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); 1208ReadOnlySpan<byte> headerValue = buffer.Slice(valueStartIdx, buffer.Length - valueIterator.Length + crOrLfIdx - valueStartIdx); 1212buffer = buffer.Slice(buffer.Length - valueIterator.Length + spIdx); 1749int toCopy = Math.Min(available.Length, buffer.Length); 1810if (destination.Length == 0)

System\Net\Http\SocketsHttpHandler\RawConnectionStream.cs (1)

34if (bytesRead == 0 && buffer.Length != 0)

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

System\Net\HttpListener.cs (1)

206toLowerLength = destination.Length;

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Net\Base64Stream.cs (1)

87byte* end = start + buffer.Length;

System\Net\BufferedReadStream.cs (2)

36int read = Math.Min(buffer.Length, _storedLength - _storedOffset); 39if (read == buffer.Length || !_readMore)

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

150if (unwrappedChallenge.Length != 4 || (unwrappedChallenge[0] & 1) != 1)

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

236if (buffer.Length == 0 || _currentReader != caller || _readState == ReadState.Done)

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

71byte* end = start + buffer.Length; 84if (buffer.Length == 1)

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

100byte* end = start + buffer.Length; 113if (buffer.Length == 1)

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (7)

81err = Interop.Sys.SetAddressFamily(rawAddress, buffer.Length, (int)family); 106err = Interop.Sys.SetPort(rawAddress, buffer.Length, port); 132err = Interop.Sys.GetIPv6Address(rawAddress, buffer.Length, ipAddress, address.Length, &localScope); 144err = Interop.Sys.SetIPv4Address(rawAddress, buffer.Length, address); 161SetIPv6Address(buffer, rawInput, address.Length, scope); 170err = Interop.Sys.SetIPv6Address(rawAddress, buffer.Length, address, addressLength, scope); 181buffer[0] = (byte)Math.Min(buffer.Length, 255);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

System\Net\NetworkInformation\UnicastIPAddressInformation.cs (1)

80Debug.Assert(prefixLength <= (addressBytes.Length * 8));

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (7)

81err = Interop.Sys.SetAddressFamily(rawAddress, buffer.Length, (int)family); 106err = Interop.Sys.SetPort(rawAddress, buffer.Length, port); 132err = Interop.Sys.GetIPv6Address(rawAddress, buffer.Length, ipAddress, address.Length, &localScope); 144err = Interop.Sys.SetIPv4Address(rawAddress, buffer.Length, address); 161SetIPv6Address(buffer, rawInput, address.Length, scope); 170err = Interop.Sys.SetIPv6Address(rawAddress, buffer.Length, address, addressLength, scope); 181buffer[0] = (byte)Math.Min(buffer.Length, 255);

src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

41if ((long)MaxUtf8BytesPerChar * managed.Length >= buffer.Length) 45if (exactByteCount > buffer.Length)

System\Net\NetworkInformation\Ping.RawSocket.cs (1)

311header.SocketAddressLen = socketAddress.Length;

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

41for (int i = 0; i < numbers.Length; ++i)

src\libraries\Common\src\System\Net\NetworkInformation\InterfaceInfoPal.Unix.cs (1)

62buffer[buffer.Length - 1] = 0;

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (7)

81err = Interop.Sys.SetAddressFamily(rawAddress, buffer.Length, (int)family); 106err = Interop.Sys.SetPort(rawAddress, buffer.Length, port); 132err = Interop.Sys.GetIPv6Address(rawAddress, buffer.Length, ipAddress, address.Length, &localScope); 144err = Interop.Sys.SetIPv4Address(rawAddress, buffer.Length, address); 161SetIPv6Address(buffer, rawInput, address.Length, scope); 170err = Interop.Sys.SetIPv6Address(rawAddress, buffer.Length, address, addressLength, scope); 181buffer[0] = (byte)Math.Min(buffer.Length, 255);

System\Net\IPAddress.cs (5)

326if (destination.Length < IPAddressParserStatics.IPv6AddressBytes) 337if (destination.Length < IPAddressParserStatics.IPv4AddressBytes) 504if (destination.Length >= IPAddressParser.MaxIPv4StringLength) 512if (destination.Length >= IPAddressParser.MaxIPv6StringLength) 520Debug.Assert(tmpDestination.Length >= IPAddressParser.MaxIPv4StringLength);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs (2)

29return BioGets(b, pBuf, buf.Length); 38internal static int BioRead(SafeBioHandle b, Span<byte> data) => BioRead(b, data, data.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

41for (int i = 0; i < numbers.Length; ++i)

src\libraries\Common\src\System\Net\MultiArrayBuffer.cs (1)

387if (destination.Length < _length)

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (7)

81err = Interop.Sys.SetAddressFamily(rawAddress, buffer.Length, (int)family); 106err = Interop.Sys.SetPort(rawAddress, buffer.Length, port); 132err = Interop.Sys.GetIPv6Address(rawAddress, buffer.Length, ipAddress, address.Length, &localScope); 144err = Interop.Sys.SetIPv4Address(rawAddress, buffer.Length, address); 161SetIPv6Address(buffer, rawInput, address.Length, scope); 170err = Interop.Sys.SetIPv6Address(rawAddress, buffer.Length, address, addressLength, scope); 181buffer[0] = (byte)Math.Min(buffer.Length, 255);

src\libraries\Common\src\System\Net\StreamBuffer.cs (1)

205int bytesRead = Math.Min(buffer.Length, _buffer.ActiveMemory.Length);

System\Net\Quic\Internal\ReceiveBuffers.cs (4)

56if (totalLength < quicBuffer.Length) 61_buffer.Commit(quicBuffer.Length); 62totalCopied += quicBuffer.Length; 63totalLength -= quicBuffer.Length;

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

206if (chainData.Length > 0)

System\Net\Quic\QuicStream.Stream.cs (2)

118byte[] rentedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 126int readLength = ReadAsync(new Memory<byte>(rentedBuffer, 0, buffer.Length), cts?.Token ?? default).AsTask().GetAwaiter().GetResult();

System\Net\HttpWebResponse.cs (1)

403int readBytes = innerStream.Read(buffer.Slice(0, (int)Math.Min(buffer.Length, _maxRemainingLength)));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs (2)

29return BioGets(b, pBuf, buf.Length); 38internal static int BioRead(SafeBioHandle b, Span<byte> data) => BioRead(b, data, data.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (4)

263Ssl.SslCtxSetCaching(sslCtx, 1, cacheSize, contextId.Length, contextId, null, null); 799int retVal = Ssl.SslRead(context, ref MemoryMarshal.GetReference(buffer), buffer.Length, out errorCode); 897while (clientList.Length > 0) 1013Debug.Assert(buffer.Length >= count);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs (5)

93int algorithmCount = algorithms.Length; 96if (res != 0 || algorithmCount > algorithms.Length) 267Debug.Assert(GetAlpnProtocolListSerializedLength(applicationProtocols) == buffer.Length, 291return SslSetAlpnProtos(ssl, pBuffer, serializedProtocols.Length); 307return SslAddClientCAs(ssl, pHandles, x509handles.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

41for (int i = 0; i < numbers.Length; ++i)

src\libraries\Common\src\System\Net\Security\MD4.cs (3)

65Debug.Assert(destination.Length == 128 >> 3); 175for (int i = 0, j = 0; j < output.Length; i++, j += 4) 183for (int i = 0, j = 0; i < output.Length; i++, j += 4)

src\libraries\Common\src\System\Net\Security\RC4.cs (1)

78Debug.Assert(input.Length == output.Length);

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

57Return(_skipClear ? 0 : Span.Length); 114if (currentBuffer.Length >= length)

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (6)

365Debug.Assert(asBytes.Length == sizeof(NegotiateMessage)); 455Debug.Assert(clientChallenge.Length == ChallengeLength); 478SetField(ref field, blob.Length, payloadOffset); 480payloadOffset += blob.Length; 865unwrappedLength = input.Length - SignatureLength; 872if (input.Length < SignatureLength)

System\Net\Security\SslStream.cs (1)

786PoolingPointerMemoryManager memoryManager = RentPointerMemoryManager(ref _readPointerMemoryManager, ptr, buffer.Length);

System\Net\Security\SslStream.Protocol.cs (1)

185Debug.Assert(ret && written == certHash.Length);

System\Net\ServerSentEvents\Helpers.cs (3)

18Debug.Assert(MaxDecimalDigits <= buffer.Length); 36Debug.Assert(value.Length <= buffer.Length); 50Debug.Assert(buffer.Length >= maxByteCount);

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (7)

81err = Interop.Sys.SetAddressFamily(rawAddress, buffer.Length, (int)family); 106err = Interop.Sys.SetPort(rawAddress, buffer.Length, port); 132err = Interop.Sys.GetIPv6Address(rawAddress, buffer.Length, ipAddress, address.Length, &localScope); 144err = Interop.Sys.SetIPv4Address(rawAddress, buffer.Length, address); 161SetIPv6Address(buffer, rawInput, address.Length, scope); 170err = Interop.Sys.SetIPv6Address(rawAddress, buffer.Length, address, addressLength, scope); 181buffer[0] = (byte)Math.Min(buffer.Length, 255);

System\Net\Sockets\SafeSocketHandle.Unix.OptionTracking.cs (2)

34Debug.Assert(values.Length == TrackableOptionCount); 64for (int i = 0; i < values.Length; i++)

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

142int bufferLength = buffer.Length; 151Debug.Assert(bufferLength <= buffer.Length); 185bufferLength = buffer.Length; 310int size = buffer.Length; 358int size = buffer.Length; 2298int realOptionLength = optionValue.Length;

System\Net\Sockets\SocketAsyncContext.Unix.cs (2)

1689Length = buffer.Length, 1909Length = buffer.Length,

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

113received = Interop.Sys.Read(handle, b, buffer.Length); 131buffer.Length, 155Count = (UIntPtr)buffer.Length 158Debug.Assert(socketAddress.Length != 0 || sockAddr == null); 162SocketAddressLen = socketAddress.Length, 414int sockAddrLen = socketAddress.Length; 498Count = (UIntPtr)buffer.Length 501Debug.Assert(socketAddress.Length != 0 || rawSocketAddress == null); 505SocketAddressLen = socketAddress.Length, 531socketAddressLen = socketAddress.Length; 580SocketAddressLen = socketAddress.Length, 603socketAddressLen = socketAddress.Length; 685if (data.Length > 0) 688err = Interop.Sys.Connectx(socket, rawSocketAddress, socketAddress.Length, data, data.Length, tfo ? 1 : 0, &sentBytes); 785else if (buffer.Length == 0) 853else if (buffer.Length == 0) 1686Debug.Assert((uint)optionLength <= optionValue.Length); 1851Interop.Error err = Interop.Sys.Select(readFDs, readFDs.Length, writeFDs, writeFDs.Length, errorFDs, errorFDs.Length, microseconds, maxFd, out triggered); 1894Debug.Assert(buffer.Length == socketList.Count);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

System\Net\WebSockets\Compression\WebSocketDeflater.cs (7)

95Debug.Assert(written == output.Length); 133_stream.AvailOut = (uint)output.Length; 141written = output.Length - (int)_stream.AvailOut; 149|| written == output.Length; 157Debug.Assert(output.Length > 0); 165_stream.AvailOut = (uint)output.Length; 188return output.Length - (int)_stream.AvailOut;

System\Net\WebSockets\Compression\WebSocketInflater.cs (7)

130if (_available > 0 && output.Length > 0) 171if (output.Length == written) 181if (output.Length > written) 188if (written < output.Length || IsFinished(_stream, out _remainingByte)) 230Debug.Assert(destination.Length > 0); 236stream.AvailOut = (uint)destination.Length; 242return destination.Length - (int)stream.AvailOut;

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

912int limit = (int)Math.Min(header.Compressed ? _inflater!.Span.Length : payloadBuffer.Length, header.PayloadLength); 1667byte* toMaskEnd = toMaskBeg + toMask.Length;

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBinaryOperator.cs (2)

66if (x.Length > destination.Length) 1400if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBooleanUnaryOperator.cs (1)

187if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IStatefulUnaryOperator.cs (1)

34if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.ITernaryOperator.cs (3)

51if (x.Length > destination.Length) 1528if (x.Length > destination.Length) 3016if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryInputBinaryOutput.cs (6)

51if (x.Length > destination1.Length) 56if (x.Length > destination2.Length) 183if (x.Length > destination1.Length) 188if (x.Length > destination2.Length) 367if (x.Length > destination1.Length) 372if (x.Length > destination2.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToFourOperator.cs (1)

35if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToTwoOperator.cs (1)

35if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOperator.cs (1)

70if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryTwoToOneOperator.cs (1)

35if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\ReadOnlyTensorSpan_1.cs (1)

461if (_shape.FlattenedLength <= destination.Length)

System\Numerics\Tensors\netcore\Tensor.cs (7)

394for (int i = 0; i < span.Length; i++) 431for (int i = 0; i < span.Length; i++) 1631span.Slice(0, ospan.Length).CopyTo(ospan); 1685if (ospan.Length >= span.Length) 1691span.Slice(0, ospan.Length).CopyTo(ospan); 1770for (int i = 0; i < srcIndexes.Length; i++) 1892for (int i = 0; i < sliceDims.Length; i++)

System\Numerics\Tensors\netcore\TensorOperation.cs (34)

System\Numerics\Tensors\netcore\TensorPrimitives.ConvertHelpers.cs (1)

19if (source.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsCanonical.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsComplexNumber.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsFinite.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsImaginaryNumber.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsInteger.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsNaN.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsNegative.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.IsRealNumber.cs (1)

23if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.SoftMax.cs (1)

32if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorShape.cs (7)

409Debug.Assert(indexes.Length >= Rank); 410Debug.Assert(indexes.Length == destinationShape.Rank); 446if (indexes.Length != Rank) 474Debug.Assert(indexes.Length >= Rank); 475Debug.Assert(indexes.Length == destinationShape.Rank); 511if (indexes.Length != Rank) 811if (intermediateLengths.Length != 0)

System\Numerics\Tensors\netcore\TensorSpan_1.cs (2)

77_shape = TensorShape.Create(ref reference, span.Length, pinned: false); 89_shape = TensorShape.Create(ref reference, span.Length, lengths, strides, pinned: false);

System\Numerics\Tensors\TensorPrimitives.Helpers.cs (2)

30Debug.Assert(destination1.Length >= inputLength); 31Debug.Assert(destination1.Length >= inputLength);

System\Numerics\Tensors\TensorPrimitives.Single.cs (1)

852if (x.Length > destination.Length)

src\libraries\Common\src\Interop\Unix\System.Native\Interop.IsMemberOfGroup.cs (2)

30rv = Interop.Sys.GetGroups(groups.Length, pGroups); 41groups = new uint[groups.Length * 2];

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (3)

43int resultLength = ReadLink(path, ref MemoryMarshal.GetReference(spanBuffer), spanBuffer.Length); 51else if (resultLength < spanBuffer.Length) 71arrayBuffer = ArrayPool<byte>.Shared.Rent(spanBuffer.Length * 2);

src\libraries\Common\src\System\Collections\Generic\BitHelper.cs (1)

30if (bitArrayIndex < (uint)span.Length)

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\Common\src\System\HexConverter.cs (7)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 305Debug.Assert(source.Length <= (destination.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Number.Formatting.Common.cs (2)

502if (thousandsSepCtr >= thousandsSepPos.Length) 504var newThousandsSepPos = new int[thousandsSepPos.Length * 2];

src\libraries\Common\src\System\Number.NumberBuffer.cs (3)

69for (numDigits = 0; numDigits < Digits.Length; numDigits++) 82Debug.Assert(numDigits < Digits.Length, "Null terminator not found in Number"); 97for (int i = 0; i < Digits.Length; i++)

src\libraries\Common\src\System\Number.Parsing.Common.cs (1)

95int maxDigCount = number.Digits.Length - 1;

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (2)

256if (parts.Length is < 2 or > 4) 262for (int i = 0; i < parts.Length; i++)

src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

41if ((long)MaxUtf8BytesPerChar * managed.Length >= buffer.Length) 45if (exactByteCount > buffer.Length)

src\libraries\Common\src\System\Sha1ForNonSecretPurposes.cs (4)

29Debug.Assert(destination.Length == 20); 58while (tail.Length > 0) 68for (int i = 80; i < w.Length; i++) 139Debug.Assert(output.Length == 20);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

src\libraries\System.Private.CoreLib\src\System\Array.cs (2)

1565if (foundCount >= span.Length) 1567values = new T[Math.Min((uint)span.Length * 2, (uint)array.Length)];

src\libraries\System.Private.CoreLib\src\System\BitConverter.cs (14)

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReverseEndianness.cs (2)

289if (destination.Length < source.Length) 381if (destination.Length < source.Length)

src\libraries\System.Private.CoreLib\src\System\Buffers\MemoryManager.cs (1)

16public virtual Memory<T> Memory => new Memory<T>(this, GetSpan().Length);

src\libraries\System.Private.CoreLib\src\System\Buffers\StandardFormat.cs (2)

160Debug.Assert(destination.Length == FormatStringLength); 164if (symbol != default && destination.Length == FormatStringLength)

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

207Debug.Assert(buffer.Length == charsWritten, $"The source length: {source.Length}, chars written: {charsWritten}");

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (9)

38int destLength = bytes.Length; 347uint bufferLength = (uint)buffer.Length; 351if (decoder.IsInvalidLength(buffer.Length)) 489for (; encodedIdx < source.Length && (uint)bufferIdx < (uint)buffer.Length; ++encodedIdx) 594for (; encodedIdx < source.Length && (uint)bufferIdx < (uint)buffer.Length; ++encodedIdx) 718int BlockSize = Math.Min(source.Length - (int)sourceIndex, 4); 726while (sourceIndex < (uint)source.Length) 730while (bufferIdx < BlockSize && sourceIndex < (uint)source.Length) 758Debug.Assert(source.Length == sourceIndex);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (2)

35int destLength = destination.Length; 595if (buffer.Length < encodedLength)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs (1)

162Debug.Assert(buffer.Length == charsWritten, $"The source length: {source.Length}, bytes written: {charsWritten}");

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs (1)

61int maxDigitCount = digits.Length - 1;

src\libraries\System.Private.CoreLib\src\System\Byte.cs (2)

371if (destination.Length >= sizeof(byte)) 389if (destination.Length >= sizeof(byte))

src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (1)

445for (i = 0; i < thisRemaining.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (66)

125if (keys.Length > 1) 127IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 140int partitionSize = keys.Length; 181Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold); 184int hi = keys.Length - 1; 222int n = keys.Length; 260for (int i = 0; i < keys.Length - 1; i++) 289if (keys.Length > 1) 299if (nanLeft == keys.Length) 306IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1)); 416int partitionSize = keys.Length; 460Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold); 464ref T lastRef = ref Unsafe.Add(ref zeroRef, keys.Length - 1); 465ref T middleRef = ref Unsafe.Add(ref zeroRef, (keys.Length - 1) >> 1); 471ref T nextToLastRef = ref Unsafe.Add(ref zeroRef, keys.Length - 2); 511int n = keys.Length; 547for (int i = 0; i < keys.Length - 1; i++) 636Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 637Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 669Debug.Assert(keys.Length == values.Length); 671if (keys.Length > 1) 673IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 680Debug.Assert(values.Length == keys.Length); 684int partitionSize = keys.Length; 725Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold); 728int hi = keys.Length - 1; 766int n = keys.Length; 810for (int i = 0; i < keys.Length - 1; i++) 840if (keys.Length > 1) 850if (nanLeft == keys.Length) 858IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1)); 910Debug.Assert(values.Length == keys.Length); 913int partitionSize = keys.Length; 954Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold); 956int hi = keys.Length - 1; 1001int n = keys.Length; 1041for (int i = 0; i < keys.Length - 1; i++) 1117for (int i = 0; i < keys.Length; i++) 1127if ((uint)i < (uint)values.Length) // check to see if we have values 1194if (keys.Length > 1) 1196IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 1209int partitionSize = keys.Length; 1249Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold); 1252int hi = keys.Length - 1; 1290int n = keys.Length; 1328for (int i = 0; i < keys.Length - 1; i++) 1388Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 1389Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 1407Debug.Assert(keys.Length == values.Length); 1409if (keys.Length > 1) 1411IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 1418Debug.Assert(values.Length == keys.Length); 1422int partitionSize = keys.Length; 1462Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold); 1465int hi = keys.Length - 1; 1502int n = keys.Length; 1546for (int i = 0; i < keys.Length - 1; i++)

src\libraries\System.Private.CoreLib\src\System\Convert.cs (15)

2301int i = chars.Length; 2366Debug.Assert(buffer.Length == charsWritten, $"Expected {buffer.Length} == {charsWritten}"); 2432if (charLengthRequired > chars.Length) 2455Debug.Assert(destination.Length >= ToBase64_CalculateAndValidateOutputLength(source.Length, insertLineBreaks: true)); 2671if (destination.Length < quotient) 2673source = source.Slice(0, destination.Length * 2); 2674quotient = destination.Length; 2727if (destination.Length < quotient) 2729utf8Source = utf8Source.Slice(0, destination.Length * 2); 2730quotient = destination.Length; 2820else if ((source.Length > (int.MaxValue / 2)) || (destination.Length < (source.Length * 2))) 2843else if ((source.Length > (int.MaxValue / 2)) || (utf8Destination.Length < (source.Length * 2))) 2915else if ((source.Length > (int.MaxValue / 2)) || (destination.Length < (source.Length * 2))) 2938else if ((source.Length > (int.MaxValue / 2)) || (utf8Destination.Length < (source.Length * 2)))

src\libraries\System.Private.CoreLib\src\System\DateOnly.cs (2)

817Debug.Assert(charsWritten == destination.Length); 823Debug.Assert(charsWritten == destination.Length);

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (6)

593if (destination.Length <= 3) 614if (destination.Length <= 3) 1148if (destination.Length >= sizeof(sbyte)) 1162if (destination.Length >= sizeof(sbyte)) 1176if (destination.Length >= (sizeof(uint) + sizeof(ulong))) 1205if (destination.Length >= (sizeof(ulong) + sizeof(uint)))

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipe.cs (1)

134return Enable(outputFilePath, format, circularBufferSizeInMB, providersNativePointer, (uint)providersNative.Length);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventProvider.cs (3)

525if (refObjIndex >= dataRefObj.Length) 527Span<object?> newDataRefObj = new object?[dataRefObj.Length * 2]; 531Span<int> newRefObjPosition = new int[refObjPosition.Length * 2];

src\libraries\System.Private.CoreLib\src\System\Enum.cs (2)

1556if (sizeof(TStorage) * 2 <= destination.Length) 1993if (length <= destination.Length)

src\libraries\System.Private.CoreLib\src\System\Environment.Variables.Windows.cs (2)

37uint length = Interop.Kernel32.GetEnvironmentVariable(variable, ref MemoryMarshal.GetReference(span), (uint)span.Length); 38return length > 0 && length <= span.Length ?

src\libraries\System.Private.CoreLib\src\System\Exception.cs (1)

175Debug.Assert(resultSpan.Length == 0);

src\libraries\System.Private.CoreLib\src\System\Globalization\CalendarData.Icu.cs (2)

132return Interop.Globalization.GetCalendarInfo(locale, id, type, bufferPtr, buffer.Length); 223Debug.Assert(index + 3 < modifiedPattern.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Icu.cs (7)

778actualSortKeyLength = Interop.Globalization.GetSortKey(_sortHandle, pSource, source.Length, pDest, destination.Length, options); 784if ((uint)actualSortKeyLength > (uint)destination.Length) 786if (actualSortKeyLength > destination.Length) 891sortKeyLength = Interop.Globalization.GetSortKey(_sortHandle, pSource, source.Length, pSortKey, sortKey.Length, options); 895if (sortKeyLength > sortKey.Length) // slow path for big strings 914sortKeyLength = Interop.Globalization.GetSortKey(_sortHandle, pSource, source.Length, pSortKey, sortKey.Length, options); 920if (sortKeyLength == 0 || sortKeyLength > sortKey.Length) // internal error (0) or a bug (2nd call failed) in ucol_getSortKey

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Invariant.cs (3)

46Debug.Assert(sortKey.Length >= source.Length * sizeof(char)); 58Debug.Assert(sortKey.Length >= source.Length * sizeof(char)); 93if ((uint)destination.Length < (uint)source.Length * sizeof(char))

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Nls.cs (2)

452pSortKey, destination.Length, 474Debug.Assert(actualSortKeyLength <= destination.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (1)

88if (buffer.Length - bufferIndex >= length + 1)

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (9)

1318if (destination.Length < 16) 1346if (destination.Length < 8) 1373if (destination.Length < 10) 1400if (destination.Length < 16) 1465if (destination.Length < charsRequired) 1524if (destination.Length < FormatSLength) 1559if (destination.Length < FormatuLength) 1600if (destination.Length < FormatRLength) 1671if (destination.Length < bytesRequired)

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.cs (3)

283if (unicode.Length <= destination.Length) 310if (result.Length <= destination.Length) 692if (strUnicode.Length <= destination.Length)

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.Icu.cs (6)

60int actualLength = Interop.Globalization.ToAscii(flags, unicode, unicode.Length, destination, destination.Length); 62if (actualLength <= destination.Length) 104int realLen = Interop.Globalization.ToUnicode(flags, ascii, ascii.Length, output, output.Length); 110else if (realLen <= output.Length) 131int actualLength = Interop.Globalization.ToUnicode(flags, ascii, ascii.Length, destination, destination.Length); 133if (actualLength <= destination.Length)

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.Nls.cs (8)

46int length = Interop.Normaliz.IdnToAscii(flags, unicode, unicode.Length, output, output.Length); 51Debug.Assert(length == output.Length); 69if (length > destination.Length) 76int actualLength = Interop.Normaliz.IdnToAscii(flags, unicode, unicode.Length, destination, destination.Length); 120int length = Interop.Normaliz.IdnToUnicode(flags, ascii, ascii.Length, output, output.Length); 125Debug.Assert(length == output.Length); 143if (length > destination.Length) 150int actualLength = Interop.Normaliz.IdnToUnicode(flags, ascii, ascii.Length, destination, destination.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\InvariantModeCasing.cs (2)

114Debug.Assert(source.Length <= destination.Length); 140Debug.Assert(source.Length <= destination.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Icu.cs (4)

78realLen = Interop.Globalization.NormalizeString(normalizationForm, pInput, strInput.Length, pDest, buffer.Length); 87if (realLen <= buffer.Length) 149realLen = Interop.Globalization.NormalizeString(normalizationForm, pInput, source.Length, pDest, destination.Length); 158if (realLen <= destination.Length)

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Nls.cs (3)

65realLength = Interop.Normaliz.NormalizeString(normalizationForm, pInput, strInput.Length, pDest, buffer.Length); 80Debug.Assert(realLength > buffer.Length, "Buffer overflow should have iLength > cBuffer.Length"); 136realLength = Interop.Normaliz.NormalizeString(normalizationForm, pInput, source.Length, pDest, destination.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.cs (1)

692if (destination.Length < source.Length)

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (3)

210Debug.Assert(destination.Length >= source.Length); 217Debug.Assert(destination.Length >= source.Length); 268pDestination + charsConsumed, destination.Length - charsConsumed, toUpper);

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanFormat.cs (1)

226if (destination.Length < requiredOutputLength)

src\libraries\System.Private.CoreLib\src\System\Guid.cs (4)

1036if (destination.Length < 16) 1055if (destination.Length < 16) 1330if ((byte)flags > destination.Length) 1454if (dest.Length < 68)

src\libraries\System.Private.CoreLib\src\System\Half.cs (2)

1364if (destination.Length >= sizeof(sbyte)) 1378if (destination.Length >= sizeof(sbyte))

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (3)

326int numBytes = buffer.Length; 474Debug.Assert(buffer.Length != 1, "length of 1 should use ReadByte."); 480return Unsafe.As<MemoryStream>(_stream).InternalReadSpan(buffer.Length);

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

196if (maxByteCount > buffer.Length)

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (3)

448int readbytes = Math.Min(_readLen - _readPos, destination.Length); 536if (bytesFromBuffer == destination.Length) 558if (destination.Length >= _bufferSize)

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

56return Encoding.UTF8.GetString(path.Slice(0, path.Length - 1)); // trim off the trailing '\0'

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEntry.Unix.cs (2)

86Debug.Assert(Directory.Length + FileName.Length < _pathBuffer.Length, 87$"directory ({Directory.Length} chars) & name ({Directory.Length} chars) too long for buffer ({_pathBuffer.Length} chars)");

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemName.cs (3)

253if (currentMatch >= currentMatches.Length - 2) 255int newSize = currentMatches.Length * 2; 383int previousLength = priorMatches.Length;

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (5)

1517if (bytesRead == buffer.Length) 1519uint newLength = (uint)buffer.Length * 2; 1522newLength = (uint)Math.Max(Array.MaxLength, buffer.Length + 1); 1535Debug.Assert(bytesRead < buffer.Length); 1596fileOffset += toStore.Length;

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

358int n = Math.Min(_length - _position, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (5)

592if (destination.Length < pathToUse.Length) 604if (destination.Length < charsNeeded) 636if (destination.Length < charsNeeded) 781Debug.Assert(fourth.Length == destination.Length); 800Debug.Assert(chars.Length == 12, $"Unexpected {nameof(chars)}.Length");

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

121return Encoding.UTF8.GetString(path.Slice(0, path.Length - 1)); // trim off the trailing '\0'

src\libraries\System.Private.CoreLib\src\System\IO\RandomAccess.Unix.cs (5)

35result = Interop.Sys.ReadFromNonblocking(handle, bufPtr, buffer.Length); 40result = Interop.Sys.PRead(handle, bufPtr, buffer.Length, fileOffset); 50result = Interop.Sys.Read(handle, bufPtr, buffer.Length); 203bytesWritten = Interop.Sys.PWriteV(handle, pinnedVectors, left.Length, fileOffset); 213bytesWritten = Interop.Sys.WriteV(handle, pinnedVectors, left.Length);

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

178if (!_strategy.CanSeek || (destination.Length >= _bufferSize)) 207if (n > destination.Length) 209n = destination.Length; 231if (n < destination.Length && !isBlocked)

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

784byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 787int numRead = Read(sharedBuffer, 0, buffer.Length); 788if ((uint)numRead > (uint)buffer.Length) 820_ = ReadAtLeastCore(buffer, buffer.Length, throwOnEndOfStream: true); 882ValidateReadAtLeastArguments(buffer.Length, minimumBytes); 890Debug.Assert(minimumBytes <= buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (5)

376int count = buffer.Length; 457} while (i > 0 && n < buffer.Length); 695readToUserBuffer = userBuffer.Length >= _maxCharsPerBuffer; 748readToUserBuffer = userBuffer.Length >= _maxCharsPerBuffer; 784_isBlocked &= charsRead < userBuffer.Length;

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

133if (n > buffer.Length) 135n = buffer.Length;

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

98char[] array = ArrayPool<char>.Shared.Rent(buffer.Length); 102int numRead = Read(array, 0, buffer.Length); 103if ((uint)numRead > (uint)buffer.Length) 148char[] array = ArrayPool<char>.Shared.Rent(buffer.Length); 152int numRead = ReadBlock(array, 0, buffer.Length); 153if ((uint)numRead > (uint)buffer.Length)

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

376long n = Math.Min(len - pos, buffer.Length);

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

318lengthOfUnderlyingSpan = memoryManagerSpan.Length;

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (37)

3717if (span.Length > 1) 3719SpanHelpers.Reverse(ref MemoryMarshal.GetReference(span), (nuint)span.Length); 4179/// no larger element, the bitwise complement of <see cref="Span{T}.Length"/>. 4201/// no larger element, the bitwise complement of <see cref="Span{T}.Length"/>. 4226/// no larger element, the bitwise complement of <see cref="Span{T}.Length"/>. 4346if (span.Length > 1) 4373if (span.Length > 1) 4419if (keys.Length != items.Length) 4422if (keys.Length > 1) 4454if (keys.Length != items.Length) 4457if (keys.Length > 1) 4473uint length = (uint)span.Length; 4551(uint)span.Length); 4563(uint)span.Length); 4574(uint)span.Length); 4585(uint)span.Length); 4593for (int i = 0; i < span.Length; i++) 4608for (int i = 0; i < span.Length; i++) 4638if (length > (uint)destination.Length) 4649(nuint)byteOffset > (nuint)(-((nint)destination.Length * sizeof(T))))) 4722if (length > (uint)destination.Length) 4733(nuint)byteOffset > (nuint)(-((nint)destination.Length * sizeof(T))))) 4828if (source.Length > destination.Length) 4878if (source.Length > destination.Length) 5201if (separators.IsEmpty && destination.Length > source.Length) 5242if (separators.IsEmpty && destination.Length > source.Length) 5289if (destination.Length == 1) 5333Span<Range> destinationMinusOne = destination.Slice(0, destination.Length - 1); 5334while (separatorIndex < separatorList.Length && (rangeCount < destinationMinusOne.Length || !keepEmptyEntries)) 5357if ((uint)rangeCount >= (uint)destinationMinusOne.Length) 5376if ((uint)rangeCount < (uint)destination.Length) 6091_success = shouldAppend = destination.Length >= literalLength; 6107_success = shouldAppend = destination.Length >= literalLength; 6326if (alignment <= _destination.Length - _pos) 6446if (paddingNeeded <= _destination.Length - _pos)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.cs (4)

205if (destination.Length < source.Length) 229if (destination.Length < source.Length) 257if (destination.Length < source.Length) 281if (destination.Length < source.Length)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Trim.cs (3)

790if (span.Length == 0 || 801for (; start < span.Length; start++) 809int end = span.Length - 1;

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (1)

349Span<byte> utf8Bytes = MemoryMarshal.AsBytes(dest).Slice(dest.Length * 2 - state.byteCount);

src\libraries\System.Private.CoreLib\src\System\Number.Dragon4.cs (3)

61Debug.Assert(buffer.Length > 0); 244int cutoffExponent = digitExponent - buffer.Length; 482Debug.Assert(outputLen <= buffer.Length);

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (14)

src\libraries\System.Private.CoreLib\src\System\Numerics\BFloat16.cs (4)

1021if (destination.Length >= sizeof(sbyte)) 1035if (destination.Length >= sizeof(sbyte)) 1049if (destination.Length >= sizeof(byte)) 1063if (destination.Length >= sizeof(byte))

src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Argb.T.cs (1)

84if (destination.Length < 4)

src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Rgba.T.cs (1)

84if (destination.Length < 4)

src\libraries\System.Private.CoreLib\src\System\Numerics\INumberBase.cs (1)

490int destinationMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Destination.Length);

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector_1.cs (4)

671if (destination.Length < Vector<byte>.Count) 685if (destination.Length < Count) 792if (destination.Length < Vector<byte>.Count) 807if (destination.Length < Count)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector2.cs (2)

1014if (destination.Length < ElementCount) 1028if (destination.Length < ElementCount)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector3.cs (2)

1024if (destination.Length < ElementCount) 1038if (destination.Length < ElementCount)

src\libraries\System.Private.CoreLib\src\System\Random.CompatImpl.cs (2)

244for (int i = 0; i < buffer.Length; i++) 332for (int i = 0; i < buffer.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Random.cs (12)

226if (destination.Length < randomBytes.Length) 228randomBytes = randomBytes.Slice(0, destination.Length); 233for (int i = 0; i < randomBytes.Length; i++) 238destination = destination.Slice(randomBytes.Length); 254if (destination.Length * 2 < randomBytes.Length) 256randomBytes = randomBytes.Slice(0, destination.Length * 2); 264if ((uint)i >= (uint)destination.Length) 284for (int i = 0; i < destination.Length; i++) 366for (int i = 0; i < values.Length - 1; i++) 368int j = Next(i, values.Length);

src\libraries\System.Private.CoreLib\src\System\Random.Xoshiro256StarStarImpl.cs (3)

140while (buffer.Length >= sizeof(ulong)) 160Debug.Assert(buffer.Length < sizeof(ulong)); 161for (int i = 0; i < buffer.Length; i++)

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

240lengthOfUnderlyingSpan = memoryManagerSpan.Length;

src\libraries\System.Private.CoreLib\src\System\ReadOnlySpan.cs (2)

315if ((uint)_length <= (uint)destination.Length) 336if ((uint)_length <= (uint)destination.Length)

src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyNameHelpers.StrongName.cs (1)

27publicKeyToken[i] = hash[hash.Length - 1 - i];

src\libraries\System.Private.CoreLib\src\System\Reflection\ConstructorInvoker.cs (2)

204int argLen = arguments.Length; 391for (int i = 0; i < dest.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodInvoker.cs (2)

241int argLen = arguments.Length; 444for (int i = 0; i < dest.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (1)

607for (int i = 0; i < bits.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\DefaultInterpolatedStringHandler.cs (4)

595if (_chars.Length - _pos < additionalChars) 629Debug.Assert(additionalChars > _chars.Length - _pos); 640GrowCore((uint)_chars.Length + 1); 652uint newCapacity = Math.Max(requiredMinCapacity, Math.Min((uint)_chars.Length * 2, string.MaxLength));

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

56/// <see cref="BitArray.Length"/>. The returned span's <see cref="Span{Byte}.Length"/> will be the smallest number

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ComWrappers.cs (3)

886for (int i = 0; i < dispatches.Length; i++) 890for (int j = 0; j < dispatchVtables.Length; j++) 892int index = i * dispatchVtables.Length + j;

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\AnsiStringMarshaller.cs (2)

83if ((long)Marshal.SystemMaxDBCSCharSize * managed.Length >= buffer.Length) 87if (exactByteCount > buffer.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ArrayMarshaller.cs (1)

156if (array.Length <= buffer.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\BStrStringMarshaller.cs (1)

83if (manualBstrNeeds > buffer.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\PointerArrayMarshaller.cs (1)

157if (array.Length <= buffer.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ReadOnlySpanMarshaller.cs (1)

122if (managed.Length <= buffer.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\SpanMarshaller.cs (6)

45numElements = managed.Length; 156if (managed.Length <= buffer.Length) 158_span = buffer[0..managed.Length]; 162int bufferSize = checked(managed.Length * sizeof(TUnmanagedElement)); 164_span = new Span<TUnmanagedElement>(_allocatedMemory, managed.Length);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\Utf8StringMarshaller.cs (2)

87if ((long)MaxUtf8BytesPerChar * managed.Length >= buffer.Length) 91if (exactByteCount > buffer.Length)

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

38checked(span.Length * sizeof(T))); 93internal static unsafe ref T GetNonNullPinnableReference<T>(Span<T> span) => ref (span.Length != 0) ? ref Unsafe.AsRef(in span._reference) : ref Unsafe.AsRef<T>((void*)1); 127uint fromLength = (uint)span.Length; 516if (destination.Length < sizeof(T)) 535if (destination.Length < sizeof(T)) 559if (span.Length < sizeof(T))

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NFloat.cs (4)

1043if (destination.Length >= sizeof(NativeExponentType)) 1067if (destination.Length >= sizeof(NativeExponentType)) 1091if (destination.Length >= sizeof(NativeSignificandType)) 1115if (destination.Length >= sizeof(NativeSignificandType))

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\SafeBuffer.cs (2)

239SpaceCheck(ptr, checked((nuint)(alignedSizeofT * buffer.Length))); 247for (int i = 0; i < buffer.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\ISimdVector_2.cs (2)

204if (destination.Length < TSelf.ElementCount) 794if (destination.Length < TSelf.ElementCount)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (2)

802if (destination.Length < Vector128<T>.Count) 4170if (destination.Length < Vector128<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (2)

809if (destination.Length < Vector256<T>.Count) 4119if (destination.Length < Vector256<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (2)

719if (destination.Length < Vector512<T>.Count) 4089if (destination.Length < Vector512<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (2)

759if (destination.Length < Vector64<T>.Count) 4057if (destination.Length < Vector64<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Versioning\FrameworkName.cs (1)

140for (int i = 1; i < components.Length; i++)

src\libraries\System.Private.CoreLib\src\System\SByte.cs (2)

429if (destination.Length >= sizeof(sbyte)) 443if (destination.Length >= sizeof(sbyte))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\RabinKarp.cs (1)

175Debug.Assert(charsWritten == upperCase.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\TeddyBucketizer.cs (1)

122for (int i = 0; i < bucketIndexes.Length; i++)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (2)

64Debug.Assert(i == normalizedValues.Length); 109Debug.Assert(newCount <= values.Length - unreachableValues.Count);

src\libraries\System.Private.CoreLib\src\System\Security\SecureString.cs (1)

363byteLength = (span.Length + 1) * sizeof(char);

src\libraries\System.Private.CoreLib\src\System\Single.cs (2)

722if (destination.Length >= sizeof(sbyte)) 736if (destination.Length >= sizeof(sbyte))

src\libraries\System.Private.CoreLib\src\System\Span.cs (4)

250if (index < _span.Length) 333if ((uint)_length <= (uint)destination.Length) 354if ((uint)_length <= (uint)destination.Length) 446var destination = new T[Length];

src\libraries\System.Private.CoreLib\src\System\String.cs (2)

449if ((uint)Length <= (uint)destination.Length) 466if ((uint)Length <= (uint)destination.Length)

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (1)

1440Debug.Assert(this.Length - thisIdx == dstSpan.Length - dstIdx);

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.CaseConversion.cs (5)

171if (source.Length <= destination.Length) 178numElementsToConvert = (uint)destination.Length; 199nuint numElementsActuallyConverted = ChangeCase<T, T, TCasing>(pBuffer, pBuffer, (nuint)buffer.Length); 200Debug.Assert(numElementsActuallyConverted <= (nuint)buffer.Length); 203return elementsWritten == buffer.Length ? OperationStatus.Done : OperationStatus.InvalidData;

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Transcoding.cs (4)

25if (source.Length <= destination.Length) 32numElementsToConvert = (uint)destination.Length; 60if (source.Length <= destination.Length) 67numElementsToConvert = (uint)destination.Length;

src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (8)

326return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length); 336int written = GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length, throwForDestinationOverflow: false); 400int numElementsToConvert = Math.Min(chars.Length, bytes.Length); 430return originalBytesLength - bytes.Length; // total number of bytes written 623return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length); 633int written = GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length, throwForDestinationOverflow: false); 694int numElementsToConvert = Math.Min(bytes.Length, chars.Length); 724return originalCharsLength - chars.Length; // total number of chars written

src\libraries\System.Private.CoreLib\src\System\Text\Decoder.cs (2)

204return GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length, flush); 311Convert(bytesPtr, bytes.Length, charsPtr, chars.Length, flush, out bytesUsed, out charsUsed, out completed);

src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (2)

272int originalCharCount = chars.Length; 290charsWritten = originalCharCount - chars.Length;

src\libraries\System.Private.CoreLib\src\System\Text\DecoderNLS.cs (3)

355Debug.Assert(combinedBufferBytesConsumed == combinedBuffer.Length, "We should be asked to persist the entire combined buffer."); 386if ((uint)total >= (uint)dest.Length) 398if ((uint)total >= (uint)dest.Length)

src\libraries\System.Private.CoreLib\src\System\Text\Encoder.cs (2)

201return GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length, flush); 310Convert(charsPtr, chars.Length, bytesPtr, bytes.Length, flush, out charsUsed, out bytesUsed, out completed);

src\libraries\System.Private.CoreLib\src\System\Text\EncoderFallback.cs (3)

195int originalBytesLength = bytes.Length; 218bytesWritten = originalBytesLength - bytes.Length; 239bytesWritten = originalBytesLength - bytes.Length;

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (4)

734return GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length); 746if (required <= bytes.Length) 885return GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length); 897if (required <= chars.Length)

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (11)

550ThrowBytesOverflow(encoder, nothingEncoded: bytes.Length == originalByteCount); // might not throw if we wrote at least one byte 561bytesLength: bytes.Length, 581return originalByteCount - bytes.Length; // total number of bytes written up until now 664bytesLength: bytes.Length, 693ThrowBytesOverflow(encoder, nothingEncoded: bytes.Length == originalBytesLength); 712return originalBytesLength - bytes.Length; 1172charsLength: chars.Length, 1185return originalCharCount - chars.Length; // total number of chars written 1272charsLength: chars.Length, 1298ThrowCharsOverflow(decoder, nothingDecoded: chars.Length == originalCharsLength); 1315return originalCharsLength - chars.Length; // total number of chars written

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.cs (5)

238return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length); 248int written = GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length, throwForDestinationOverflow: false); 538return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length); 545if (bytes.Length <= chars.Length) 550charsWritten = GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length);

src\libraries\System.Private.CoreLib\src\System\Text\Rune.cs (5)

299Debug.Assert(buffer.Length >= MaxUtf16CharsPerRune); 1103else if (destination.Length > 1) 1150if (destination.Length > 1) 1161if (destination.Length > 2) 1173if (destination.Length > 3)

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (3)

1758if ((uint)charsWritten > (uint)RemainingCurrentChunk.Length) 3024if ((uint)charsWritten > (uint)destination.Length) 3095if ((uint)charsWritten > (uint)destination.Length)

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

353int bytesToReturn = Math.Min(_readBufferCount, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (11)

66outputBytesRemaining: destination.Length, 95if (destination.Length <= 2) 157outputCharsRemaining: destination.Length, 252outputCharsRemaining: destination.Length, 289if (destination.Length < bytesConsumedJustNow) 374_success = shouldAppend = destination.Length >= literalLength; // UTF8 encoding never produces fewer bytes than input characters 390_success = shouldAppend = destination.Length >= literalLength; // UTF8 encoding never produces fewer bytes than input characters 408ref MemoryMarshal.GetReference(dest), dest.Length); 689GrowAndAppendFormatted(ref this, value, utf16.Length, out charsWritten, format); 736GrowAndAppendFormatted(ref this, value, utf16.Length, out charsWritten, format); 793if (paddingNeeded <= _destination.Length - _pos)

src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (5)

372return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length); 382int written = GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length, throwForDestinationOverflow: false); 571return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length); 581int written = GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length, throwForDestinationOverflow: false); 671return originalCharsLength - chars.Length; // total number of chars written

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (2)

3599for (int i = 0; i < continuations.Length; i++) 3653for (int i = 0; i < continuations.Length; i++)

src\libraries\System.Private.CoreLib\src\System\TimeOnly.cs (2)

988Debug.Assert(charsWritten == destination.Length); 994Debug.Assert(charsWritten == destination.Length);

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Cache.cs (2)

225if (encountered < offsets.Length) 234if (offsets.Length >= 2 && offsets[0] > offsets[1])

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.FullGlobalizationData.Unix.cs (2)

118return Interop.Globalization.GetTimeZoneDisplayName(locale, id, type, bufferPtr, buffer.Length); 138return Interop.Globalization.GetTimeZoneDisplayName(locale, id, type, bufferPtr, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\UInt128.cs (16)

1094Debug.Assert(left.Length >= right.Length); 1166Span<uint> bits = rawBits.Slice(0, left.Length - right.Length + 1); 1168Debug.Assert(left.Length >= 1); 1169Debug.Assert(right.Length >= 1); 1170Debug.Assert(left.Length >= right.Length); 1178uint divLo = right.Length > 1 ? right[^2] : 0; 1187uint divNx = right.Length > 2 ? right[^3] : 0; 1195for (int i = left.Length; i >= right.Length; i--) 1197int n = i - right.Length; 1198uint t = ((uint)(i) < (uint)(left.Length)) ? left[i] : 0; 1245if ((uint)(n) < (uint)(bits.Length)) 1250if ((uint)(i) < (uint)(left.Length)) 1264Debug.Assert(left.Length >= right.Length);

src\System\RuntimeHandles.cs (2)

191Span<IntPtr> outHandles = inHandles.Length <= stackScratch.Length ? 563int countLocal = buffer.Length;

src\System\RuntimeType.CoreCLR.cs (3)

358Filter filter = new Filter(pUtf8Name, utf8Name.Length, listType); 863Debug.Assert(count > result.Length); 1305(!declaringType.IsActualInterface && !isInterface && usedSlots.Length >= numVirtuals));

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

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

202int count = buffer.Length;

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

64if (slicedBuffer.Length < buffer.Length)

System\Xml\EncodingStreamWrapper.cs (1)

616int count = buffer.Length;

System\Xml\XmlBufferReader.cs (4)

493if (dst.Length > 0) 495GetBuffer(dst.Length, out _offset) 496.AsSpan(_offset, dst.Length) 499Advance(dst.Length);

System\Xml\XmlConverter.cs (2)

1099return chars.Length; 1140Debug.Assert(count == chars.Length);

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

41for (int i = 0; i < numbers.Length; ++i)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Uri.cs (2)

4352while ((uint)i < (uint)chars.Length) 4354if (chars[i] == '%' && (uint)(i + 2) < (uint)chars.Length)

System\UriExt.cs (2)

551if (destination.Length < indexOfFirstToUnescape) 580if (destination.Length >= newLength)

System\UriHelper.cs (11)

19Debug.Assert(charsWritten == buffer.Length); 136if (destination.Length < charsToEscape.Length) 172if (destination.Length >= newLength) 612Debug.Assert(buffer.Length == destIndex); 639for (int i = span.Length - 1; i >= 0; i--) 675|| (lastSlash == 0 && i + dotCount + 1 == span.Length)) // "/..." 725if (lastSlash == dotCount || (lastSlash == 0 && dotCount == span.Length)) 735return span.Length; 748Debug.Assert(start >= readOffset && length > 0 && start + length <= span.Length); 762if (readOffset != span.Length) 767writeOffset += span.Length - readOffset;

System\ValueStringBuilderExtensions.cs (2)

15if ((uint)(pos + 1) < (uint)chars.Length && (uint)pos < (uint)chars.Length)

System\BufferScope.cs (3)

59if (initialBuffer.Length >= minimumLength) 83if (_span!.Length >= capacity) 111public readonly int Length => _span.Length;

System\IO\BinaryReaderExtensions.cs (1)

124if (reader.Read(arrayData) != arrayData.Length)

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

294uint charactersCopied = PInvokeCore.DragQueryFile(hdrop, i, buffer, (uint)fileName.Length);

System\SpanHelpers.cs (2)

17if (source.Length >= destination.Length) 19source = source[..(destination.Length - 1)];

System\SpanWriter.cs (11)

16readonly get => Span.Length - _unwritten.Length; 20public readonly int Length => Span.Length; 46if (_unwritten.Length >= values.Length) 63if (_unwritten.Length >= count) 82public void Rewind(int count) => _unwritten = Span[(Span.Length - _unwritten.Length - count)..]; 92Debug.Assert((uint)count <= (uint)_unwritten.Length); 93UncheckedSlice(ref _unwritten, count, _unwritten.Length - count); 99Debug.Assert((uint)start <= (uint)span.Length && (uint)length <= (uint)(span.Length - start));

System\Text\ValueStringBuilder.cs (15)

52Debug.Assert(value <= _chars.Length); 57public readonly int Capacity => _chars.Length; 65if ((uint)capacity > (uint)_chars.Length) 155if (_pos > _chars.Length - count) 175if (_pos > (_chars.Length - count)) 190if ((uint)pos < (uint)_chars.Length) 216if (s.Length == 1 && (uint)pos < (uint)_chars.Length) 231if (pos > _chars.Length - s.Length) 260if (_pos > _chars.Length - count) 266for (int i = 0; i < dst.Length; i++) 277if (pos > _chars.Length - length) 283for (int i = 0; i < dst.Length; i++) 294if (pos > _chars.Length - value.Length) 322Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 330Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

Windows.Win32.IDispatch.g.cs (2)

101 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 102 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IDispatchEx.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IEnumFORMATETC.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumSTATDATA.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumSTATSTG.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumString.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IPictureDisp.g.cs (2)

84 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 85 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITypeInfo.g.cs (2)

358 if (rgszNames.Length != pMemId.Length) throw new ArgumentException(); 359 winmdroot.Foundation.HRESULT __result = this.GetIDsOfNames(rgszNamesLocal, (uint )pMemId.Length, pMemIdLocal);

Windows.Win32.PInvokeCore.GDI32.dll.g.cs (2)

458 uint __result = PInvokeCore.GetEnhMetaFileBits(hEMF, (uint )lpData.Length, lpDataLocal); 509 uint __result = PInvokeCore.GetPaletteEntries(hpal, iStart, (uint )pPalEntries.Length, pPalEntriesLocal);

Windows.Win32.System_Com_IEnumFORMATETC_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Com_IEnumSTATDATA_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Com_IEnumString_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Com_ITypeInfo_Extensions.g.cs (2)

90 if (rgszNames.Length != pMemId.Length) throw new ArgumentException(); 91 winmdroot.Foundation.HRESULT __result = @this.GetIDsOfNames(rgszNamesLocal, (uint )pMemId.Length, pMemIdLocal);

Windows.Win32.System_Com_StructuredStorage_IEnumSTATSTG_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows\Win32\Graphics\Gdi\ArgbBuffer.cs (2)

29public ArgbBuffer(Span<Color> colors) : this(colors.Length) 31for (int i = 0; i < colors.Length; i++)

Windows\Win32\PInvokeCore.GetPaletteEntries.cs (1)

13return GetPaletteEntries(hpal, 0, (uint)entries.Length, entry);

Windows\Win32\System\Com\ComInterfaceTable.cs (8)

25Count = entries.Length 43Count = entries.Length 63Count = entries.Length 85Count = entries.Length 109Count = entries.Length 135Count = entries.Length 169Count = entries.Length 239Count = entries.Length

Windows\Win32\System\Variant\VARIANT.cs (21)

Windows.Win32.PInvokeGdiPlus.gdiplus.dll.g.cs (5)

4544 winmdroot.Graphics.GdiPlus.Status __result = PInvokeGdiPlus.GdipGetPathTypes(pathLocal, typesLocal, types.Length); 5020 winmdroot.Graphics.GdiPlus.Status __result = PInvokeGdiPlus.GdipGetRegionData(regionLocal, bufferLocal, (uint )buffer.Length, sizeFilled); 6095 if (points.Length != types.Length) throw new ArgumentException(); 6096 winmdroot.Graphics.GdiPlus.Status __result = PInvokeGdiPlus.GdipPathIterEnumerate(iteratorLocal, resultCountLocal, pointsLocal, typesLocal, types.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Xml\Base64Decoder.cs (2)

125if ((uint)iByte >= (uint)bytes.Length) 159if (iByte == bytes.Length)

System\Xml\BinaryXml\XmlBinaryReader.cs (1)

2333int cch = dstChars.Length;

System\Xml\BinHexDecoder.cs (1)

146if ((uint)iByte >= (uint)bytes.Length)

System\Xml\Schema\XsdDateTime.cs (1)

568return destination.Length >= vsb.Length;

System\Xml\Schema\XsdDuration.cs (1)

444return destination.Length >= vsb.Length;

System\Xml\XmlConvert.cs (1)

1650if (destination.Length < 1) return false;

System\Xml\Xsl\Runtime\XslNumber.cs (1)

343for (int newPos = result.Length - 1; newPos >= 0; newPos--)

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (2)

256if (parts.Length is < 2 or > 4) 262for (int i = 0; i < parts.Length; i++)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Reflection\Internal\Utilities\StreamExtensions.cs (1)

52=> stream.ReadAtLeast(buffer, buffer.Length, throwOnEndOfStream: false);

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\Common\src\System\Number.Formatting.Common.cs (2)

502if (thousandsSepCtr >= thousandsSepPos.Length) 504var newThousandsSepPos = new int[thousandsSepPos.Length * 2];

src\libraries\Common\src\System\Number.NumberBuffer.cs (3)

69for (numDigits = 0; numDigits < Digits.Length; numDigits++) 82Debug.Assert(numDigits < Digits.Length, "Null terminator not found in Number"); 97for (int i = 0; i < Digits.Length; i++)

src\libraries\Common\src\System\Number.Parsing.Common.cs (1)

95int maxDigCount = number.Digits.Length - 1;

src\libraries\Common\src\System\Text\ValueStringBuilder_1.cs (13)

45Debug.Assert(value <= _chars.Length); 50public readonly int Capacity => _chars.Length; 58if ((uint)capacity > (uint)_chars.Length) 161if (_pos > _chars.Length - count) 181if (_pos > (_chars.Length - count)) 197if ((uint)pos < (uint)chars.Length) 217if (text.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 231if (pos > _chars.Length - text.Length) 242if (_pos > _chars.Length - count) 248for (int i = 0; i < dst.Length; i++) 259if (origPos > _chars.Length - length) 287Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 295Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Number.BigInteger.cs (19)

449Debug.Assert(bits.Trim((nuint)0).Length == 0); 550for (int i = 0; i < bits.Length; i++) 559for (int i = 0; i < bits.Length; i++) 590int cur = bits.Length - 1; 677long tmpCharCount = charsInHighByte + ((long)(bytes.Length - 1) << 3); 696if (charsIncludeDigits > destination.Length) 727for (int i = bytes.Length - 2; i >= 0; i--) 854if (destination.Length < strLength) 894BigIntegerToDecChars((Utf16Char*)ptr + span.Length, state.base1E9Value, state.digits); 1324Debug.Assert(pow1E9.Length >= 1); 1326if (pow1E9.Length <= LeadingPowers1E9.Length) 1340if (pow1E9.Length - toExclusive < (src.Length << 1)) 1356dst.Slice(dst.Length - shift).Clear(); 1362Debug.Assert(toExclusive == pow1E9.Length || pow1E9[toExclusive] == 0); 1433Span<nuint> powersOfTen = BigInteger.RentedBuffer.Create(bits.Length, out BigInteger.RentedBuffer powersOfTenBuffer); 1495for (int i = 0; i < bits2.Length; i++) 1504for (int i = 0; i < bits2.Length; i++) 1553Debug.Assert(destination.Length * TParser.DigitsPerBlock == input.Length); 1555for (int i = 0; i < destination.Length; i++)

System\Numerics\BigInteger.cs (15)

258Debug.Assert(bits.Length == 4 && (bits[3] & DecimalScaleFactorMask) == 0); 582if ((value.Length > 0) && ((nint)value[^1] < 0)) 603if (value.Length > MaxLength) 608if (value.Length == 0) 613else if (value.Length == 1) 1534if (destination.Length != 0) 1631if (destination.Length < length) 1729Debug.Assert(_bits is null || _sign == 0 ? buffer.Length == 2 : buffer.Length >= _bits.Length + 1); 1744NumericsHelpers.DangerousMakeTwosComplement(buffer.Slice(0, buffer.Length - 1)); // Mutates limbs 2717Debug.Assert((uint)leastSignificant < (uint)zd.Length); 3288Debug.Assert((uint)leadingZeroCount < (uint)zd.Length); 3401if (destination.Length >= byteCount) 3479if (destination.Length >= byteCount) 5059if ((uint)negLeadingZeroCount < (uint)zd.Length) // is equivalent to negLeadingZeroCount >= 0 && negLeadingZeroCount < zd.Length

System\Numerics\BigIntegerCalculator.AddSub.cs (8)

27Debug.Assert(bits.Length == left.Length + 1); 36Debug.Assert(bits.Length == left.Length + 1); 55Debug.Assert(left.Length >= right.Length); 70for (; carry != 0 && i < left.Length; i++) 84Debug.Assert(bits.Length == left.Length); 94Debug.Assert(bits.Length == left.Length); 111Debug.Assert(left.Length >= right.Length); 126for (; borrow != 0 && i < left.Length; i++)

System\Numerics\BigIntegerCalculator.Bitwise.cs (1)

57for (int i = 0; i < result.Length; i++)

System\Numerics\BigIntegerCalculator.DivRem.cs (63)

System\Numerics\BigIntegerCalculator.FastReducer.cs (11)

26Debug.Assert(r.Length == modulus.Length * 2 + 1); 27Debug.Assert(mu.Length == r.Length - modulus.Length + 1); 28Debug.Assert(q1.Length == modulus.Length * 2 + 2); 29Debug.Assert(q2.Length == modulus.Length * 2 + 2); 47Debug.Assert(value.Length <= _modulus.Length * 2); 50if (value.Length < _modulus.Length) 52return value.Length; 75Debug.Assert(bits.Length + k >= left.Length + right.Length); 102if (left.Length > k) 129return left.Length;

System\Numerics\BigIntegerCalculator.GcdInv.cs (19)

93Debug.Assert(result.Length == left.Length); 107Debug.Assert(left.Length >= 2); 108Debug.Assert(right.Length >= 2); 109Debug.Assert(left.Length >= right.Length); 120while (right.Length > (nint.Size == 4 ? 2 : 1)) 219if (right.Length > 0) 231if (right.Length > 1) 254Debug.Assert(buffer.Length >= 2); 256if (buffer.Length > 2) 271Debug.Assert(buffer.Length >= 1); 273if (buffer.Length > 1) 390Debug.Assert(x.Length >= 1); 391Debug.Assert(y.Length >= 1); 392Debug.Assert(x.Length >= y.Length); 398int length = y.Length; 455Debug.Assert(bits.Length >= maxLength); 457if (bits.Length > maxLength)

System\Numerics\BigIntegerCalculator.PowMod.cs (25)

23Debug.Assert(bits.Length == PowBound(power, value.Length)); 25Span<nuint> temp = BigInteger.RentedBuffer.Create(bits.Length, out BigInteger.RentedBuffer tempBuffer); 27Span<nuint> valueCopy = BigInteger.RentedBuffer.Create(bits.Length, out BigInteger.RentedBuffer valueCopyBuffer); 33bits.Slice(result.Length).Clear(); 41Debug.Assert(value.Length >= valueLength); 42Debug.Assert(temp.Length == result.Length); 43Debug.Assert(value.Length == temp.Length); 69Debug.Assert(leftLength <= left.Length); 86Debug.Assert(valueLength <= value.Length); 87Debug.Assert(temp.Length >= valueLength + valueLength); 261Debug.Assert(bits.Length == modulus.Length + modulus.Length); 266int size = Math.Max(value.Length, bits.Length); 283Span<nuint> temp = BigInteger.RentedBuffer.Create(bits.Length, out BigInteger.RentedBuffer tempBuffer); 301Debug.Assert(bits.Length == modulus.Length + modulus.Length); 306int size = Math.Max(value.Length, bits.Length); 323Span<nuint> temp = BigInteger.RentedBuffer.Create(bits.Length, out BigInteger.RentedBuffer tempBuffer); 355bits.Slice(result.Length).Clear(); 379bits.Slice(result.Length).Clear(); 394size = r.Length - modulus.Length + 1; 408bits.Slice(result.Length).Clear(); 483Debug.Assert(bits.Length >= modulus.Length * 2); 499if (shifted.Length >= modulus.Length) 679Debug.Assert(value.Length >= 2 * k);

System\Numerics\BigIntegerCalculator.ShiftRot.cs (14)

28RotateRight(bits, digitShift % bits.Length, smallShift); 37RotateLeft(bits, digitShift % bits.Length, smallShift); 43Debug.Assert(bits.Length > 0); 53SwapUpperAndLower(bits, bits.Length - digitShift); 58Debug.Assert(bits.Length > 0); 74Debug.Assert(lowerLength < bits.Length); 76int upperLength = bits.Length - lowerLength; 119int offset = bits.Length; 167for (int i = 0; i < bits.Length; i++) 195while (Vector512.IsHardwareAccelerated && bits.Length - offset >= Vector512<nuint>.Count + 1) 206while (Vector256.IsHardwareAccelerated && bits.Length - offset >= Vector256<nuint>.Count + 1) 217while (Vector128.IsHardwareAccelerated && bits.Length - offset >= Vector128<nuint>.Count + 1) 229for (int i = bits.Length - 1; i >= offset; i--) 239for (int i = bits.Length - 1; i >= 0; i--)

System\Numerics\BigIntegerCalculator.SquMul.cs (29)

System\Numerics\BigIntegerCalculator.Utils.cs (5)

87if (bits.Length >= modulus.Length) 94return bits.Length; 220Debug.Assert(result.Length >= left.Length); 271Debug.Assert(result.Length >= left.Length); 326Debug.Assert(result.Length >= right.Length);

System\Numerics\Complex.cs (3)

2274if (destination.Length >= 6) 2284if (destination.Length >= 4) 2291if ((uint)(2 + imaginaryChars) < (uint)destination.Length)

System\Numerics\NumericsHelpers.cs (5)

119if ((uint)i >= (uint)d.Length) 149while (Vector512.IsHardwareAccelerated && d.Length - offset >= Vector512<nuint>.Count) 156while (Vector256.IsHardwareAccelerated && d.Length - offset >= Vector256<nuint>.Count) 163while (Vector128.IsHardwareAccelerated && d.Length - offset >= Vector128<nuint>.Count) 170for (; offset < d.Length; offset++)

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (3)

43int resultLength = ReadLink(path, ref MemoryMarshal.GetReference(spanBuffer), spanBuffer.Length); 51else if (resultLength < spanBuffer.Length) 71arrayBuffer = ArrayPool<byte>.Shared.Rent(spanBuffer.Length * 2);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs (2)

29return BioGets(b, pBuf, buf.Length); 38internal static int BioRead(SafeBioHandle b, Span<byte> data) => BioRead(b, data, data.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Cipher.cs (3)

154if (!EvpCipherGetGcmTag(ctx, ref MemoryMarshal.GetReference(tag), tag.Length)) 169if (!EvpCipherGetAeadTag(ctx, ref MemoryMarshal.GetReference(tag), tag.Length)) 214if (!EvpCipherGetCcmTag(ctx, ref MemoryMarshal.GetReference(tag), tag.Length))

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.cs (5)

84destination.Length); 89return EvpDigestFinalXOF(ctx, destination, (uint)destination.Length); 94return EvpDigestCurrentXOF(ctx, destination, (uint)destination.Length); 99return EvpDigestXOFOneShot(type, source, source.Length, destination, (uint)destination.Length); 104int ret = EvpDigestSqueeze(ctx, destination, (uint)destination.Length, out bool haveFeature);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Kdf.cs (4)

83destination.Length); 108destination.Length); 133destination.Length); 161destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Kem.cs (3)

154int ret = CryptoNative_EvpKemDecapsulate(key, GetExtraHandle(key), ciphertext, ciphertext.Length, sharedSecret, sharedSecret.Length); 184int ret = CryptoNative_EvpKemEncapsulate(key, GetExtraHandle(key), ciphertext, ciphertext.Length, sharedSecret, sharedSecret.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Mac.cs (3)

78destination.Length, 90int ret = CryptoNative_EvpMacFinal(ctx, mac, mac.Length); 102int ret = CryptoNative_EvpMacCurrent(ctx, mac, mac.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.Ecdh.cs (1)

34(uint)destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.EcDsa.cs (1)

34destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.ExportKeyContents.cs (1)

21int ret = action(key, destination, destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.MLDsa.cs (3)

94destination, destination.Length); 149destination, destination.Length); 204destination, destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.Rsa.cs (3)

74destination.Length); 111destination.Length); 152destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.SlhDsa.cs (2)

93destination, destination.Length); 148destination, destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Hmac.cs (1)

39int size = destination.Length;

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

41if ((long)MaxUtf8BytesPerChar * managed.Length >= buffer.Length) 45if (exactByteCount > buffer.Length)

src\libraries\Common\src\System\Security\Cryptography\AsymmetricAlgorithmHelpers.Der.cs (5)

64Debug.Assert(destination.Length >= encodedSize); 87if (signatureField.Length > response.Length) 89if (signatureField.Length != response.Length + 1 || 94Debug.Fail($"A signature field was longer ({signatureField.Length}) than expected ({response.Length})"); 103int writeOffset = response.Length - signatureField.Length;

src\libraries\Common\src\System\Security\Cryptography\CompositeMLDsa.cs (8)

216if (destination.Length < Algorithm.MaxSignatureSizeInBytes) 1386if (destination.Length < minimumPossiblePkcs8Key) 1540if (destination.Length < Algorithm.MinPublicKeySizeInBytes) 1577if (destination.Length < Algorithm.MinPublicKeySizeInBytes) 1595if (localBytesWritten > destination.Length) 1665if (destination.Length < Algorithm.MinPrivateKeySizeInBytes) 1702if (destination.Length < Algorithm.MinPrivateKeySizeInBytes) 1725if (localBytesWritten > destination.Length)

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

285return mldsaSig.Length + tradBytesWritten;

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

277if (destination.Length < 1 + 2 * fieldWidth)

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

57Return(_skipClear ? 0 : Span.Length); 114if (currentBuffer.Length >= length)

src\libraries\Common\src\System\Security\Cryptography\DSAOpenSsl.cs (4)

236if (destination.Length < p1363SignatureSize) 251if (destination.Length >= maxSignatureSize) 255else if (maxSignatureSize > signDestination.Length) 287if (signatureLength > destination.Length)

src\libraries\Common\src\System\Security\Cryptography\ECDiffieHellmanDerivation.cs (3)

223int len = Math.Min(p.Length, retSpan.Length); 228if (retSpan.Length == 0)

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

119if (destination.Length < encodedSize)

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

282if (destination.Length != expectedLength)

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

33int length = destination.Length; 55destination.Slice(0, destination.Length - span.Length).Clear();

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

787if (destination.Length < minimumPossiblePkcs8MLDsaKey)

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

35written = buffer.Length; 44written = buffer.Length;

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

111if (ciphertext.Length != Algorithm.CiphertextSizeInBytes) 118if (sharedSecret.Length != Algorithm.SharedSecretSizeInBytes) 208if (sharedSecret.Length != Algorithm.SharedSecretSizeInBytes) 291if (destination.Length != Algorithm.PrivateSeedSizeInBytes) 522if (destination.Length != Algorithm.DecapsulationKeySizeInBytes) 576if (destination.Length != Algorithm.EncapsulationKeySizeInBytes) 709if (destination.Length < MinimumPossiblePkcs8MLKemKey)

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

35written = buffer.Length; 44written = buffer.Length;

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (10)

103Debug.Assert(destination.Length >= encryptedData.Length); 213if (byteCount > buf.Length) 229Debug.Assert(written == buf.Length); 498if (byteCount > buf.Length) 514Debug.Assert(written == buf.Length); 531CryptoPool.Return(rented, buf.Length); 967byte[] rentedDestination = CryptoPool.Rent(destination.Length); 1013CryptoPool.Return(rentedDestination, destination.Length); 1048if (!hasher.TryGetHashAndReset(t, out tLength) || tLength != t.Length) 1056t.Slice(0, dk.Length).CopyTo(dk);

src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Builder.cs (3)

212if (!mac.TryGetHashAndReset(macSpan, out int bytesWritten) || bytesWritten != macSpan.Length) 214Debug.Fail($"TryGetHashAndReset wrote {bytesWritten} of {macSpan.Length} bytes"); 356if (destination.Length < _sealedData.Length)

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (20)

183if (!hash.TryGetHashAndReset(hashBuf, out int bytesWritten) || bytesWritten != hashBuf.Length) 185Debug.Fail($"Hash output wrote {bytesWritten} bytes when {hashBuf.Length} was expected"); 200if (hashBuf.Length >= destination.Length) 202hashBuf.Slice(0, destination.Length).CopyTo(destination); 207destination = destination.Slice(hashBuf.Length); 216for (int j = (I.Length / vBytes) - 1; j >= 0; j--) 238Debug.Assert(into.Length == addend.Length); 242for (int i = into.Length - 1; i >= 0; i--) 254while (destination.Length > 0) 256if (destination.Length >= bytes.Length) 263bytes.Slice(0, destination.Length).CopyTo(destination); 273Debug.Assert(destination.Length % 2 == 0); 275while (destination.Length > 0) 277if (destination.Length >= fullCopyLen) 288Span<byte> nullTerminator = destination.Slice(0, Math.Min(2, destination.Length)); 290destination = destination.Slice(nullTerminator.Length); 294ReadOnlySpan<char> trimmed = password.Slice(0, destination.Length / 2); 298if (count != destination.Length) 300Debug.Fail($"Partial copy wrote {count} bytes of {destination.Length} expected");

src\libraries\Common\src\System\Security\Cryptography\RSAOpenSsl.cs (7)

123if (destination.Length < keySizeBytes) 129if (keySizeBytes > tmp.Length) 138if (destination.Length < written) 183if (destination.Length < rsaSize) 185Debug.Fail($"Caller is responsible for temporary decryption buffer creation destination. destination.Length: {destination.Length}, needed: {rsaSize}"); 250if (destination.Length < rsaSize) 740if (destination.Length < bytesRequired)

src\libraries\Common\src\System\Security\Cryptography\RsaPaddingProcessor.cs (22)

src\libraries\Common\src\System\Security\Cryptography\SlhDsa.cs (5)

134if (destination.Length != signatureSizeInBytes) 318if (destination.Length != Algorithm.SignatureSizeInBytes) 622if (destination.Length < MinimumPossiblePkcs8SlhDsaKey) 1079if (destination.Length != publicKeySizeInBytes) 1130if (destination.Length != privateKeySizeInBytes)

src\libraries\Common\src\System\Security\Cryptography\SP800108HmacCounterKdf.cs (4)

275CheckPrfOutputLength(destination.Length, nameof(destination)); 355CheckPrfOutputLength(destination.Length, nameof(destination)); 431CheckPrfOutputLength(destination.Length, nameof(destination)); 482CheckPrfOutputLength(destination.Length, nameof(destination));

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

18_buffer = (uint)maxLength <= stackBuffer.Length ?

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

1265if (!mac.TryGetHashAndReset(macKey, out int bytesWritten) || bytesWritten != macKey.Length) 1267Debug.Fail($"TryGetHashAndReset wrote {bytesWritten} of {macKey.Length} bytes");

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Security\Cryptography\Aes.cs (7)

136if (destination.Length != requiredLength) 204/// <paramref name="destination"/> has a <see cref="Span{T}.Length"/> that is 262if (destination.Length < minOutput) 268if (destination.Length > maxOutput) 294if (written > destination.Length) 411Debug.Assert(destination.Length == GetKeyWrapPaddedLength(source.Length)); 454Debug.Assert(destination.Length == GetKeyWrapPaddedLength(source.Length));

System\Security\Cryptography\AesCcm.OpenSsl.cs (5)

47Interop.Crypto.EvpCipherSetCcmTagLength(ctx, tag.Length); 77if (ciphertextBytesWritten != ciphertext.Length) 79Debug.Fail($"CCM encrypt wrote {ciphertextBytesWritten} of {ciphertext.Length} bytes."); 134if (plaintextBytesWritten != plaintext.Length) 136Debug.Fail($"CCM decrypt wrote {plaintextBytesWritten} of {plaintext.Length} bytes.");

System\Security\Cryptography\AesGcm.OpenSsl.cs (4)

69if (ciphertextBytesWritten != ciphertext.Length) 71Debug.Fail($"GCM encrypt wrote {ciphertextBytesWritten} of {ciphertext.Length} bytes."); 117if (plaintextBytesWritten != plaintext.Length) 119Debug.Fail($"GCM decrypt wrote {plaintextBytesWritten} of {plaintext.Length} bytes.");

System\Security\Cryptography\AesImplementation.OpenSsl.cs (2)

45Debug.Assert(written == destination.Length); 105if (written > destination.Length)

System\Security\Cryptography\AsnFormatter.cs (1)

41Debug.Assert(j == hexOrder.Length);

System\Security\Cryptography\Base64Transforms.cs (10)

System\Security\Cryptography\ChaCha20Poly1305.OpenSsl.cs (4)

66if (ciphertextBytesWritten != ciphertext.Length) 68Debug.Fail($"ChaCha20Poly1305 encrypt wrote {ciphertextBytesWritten} of {ciphertext.Length} bytes."); 114if (plaintextBytesWritten != plaintext.Length) 116Debug.Fail($"ChaCha20Poly1305 decrypt wrote {plaintextBytesWritten} of {plaintext.Length} bytes.");

System\Security\Cryptography\CryptographicOperations.cs (4)

190if (destination.Length < hashSizeInBytes) 267CheckDestinationSize(hashSizeInBytes, destination.Length); 505if (destination.Length < hashSizeInBytes) 617CheckDestinationSize(hashSizeInBytes, destination.Length);

System\Security\Cryptography\DSA.cs (1)

883Debug.Assert(tmp.Length == HashBufferStackSize);

System\Security\Cryptography\ECDsa.cs (4)

147if (maxSignatureSize > signature.Length) 429if (maxSignatureSize > signature.Length) 1018if (hash.Length <= destination.Length) 1203Debug.Assert(tmp.Length == HashBufferStackSize);

System\Security\Cryptography\HashAlgorithm.cs (2)

57if (destination.Length < HashSizeValue / 8) 265if (destination.Length >= hashSizeInBytes)

System\Security\Cryptography\HashProvider.cs (1)

52if (destination.Length < HashSizeInBytes)

System\Security\Cryptography\HashProviderDispenser.Unix.cs (3)

45if (hashSize <= 0 || destination.Length < hashSize) 63if (hashSize <= 0 || destination.Length < hashSize) 70uint length = (uint)destination.Length;

System\Security\Cryptography\HashStatic.cs (2)

53if (destination.Length < THash.HashSizeInBytes) 69if (destination.Length < THash.HashSizeInBytes)

System\Security\Cryptography\Helpers.cs (1)

346return ref buffer.Length != 0 ? ref MemoryMarshal.GetReference(buffer) : ref Unsafe.AsRef<byte>((void*)1);

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

55if (prk.Length < hashLength) 60if (prk.Length > hashLength) 122if (output.Length == 0) 130if (output.Length > maxOkmLength) 179if (output.Length == 0) 184if (output.Length > maxOkmLength)

System\Security\Cryptography\HKDFManagedImplementation.cs (7)

15Debug.Assert(written == prk.Length, $"Bytes written is {written} bytes which does not match output length ({prk.Length} bytes)"); 58if (remainingOutput.Length >= hashLength) 66if (remainingOutput.Length > 0) 71lastChunk.Slice(0, remainingOutput.Length).CopyTo(remainingOutput); 97Debug.Assert(written == output.Length, $"Bytes written is {written} bytes which does not match output length ({output.Length} bytes)");

System\Security\Cryptography\HMACStatic.cs (2)

73if (destination.Length < THMAC.HashSizeInBytes) 89if (destination.Length < THMAC.HashSizeInBytes)

System\Security\Cryptography\IncrementalHash.cs (8)

146/// <paramref name="destination"/> has a <see cref="Span{T}.Length"/> value less 153if (destination.Length < HashLengthInBytes) 163if (destination.Length < HashLengthInBytes) 175Debug.Assert(destination.Length >= HashLengthInBytes); 218/// <paramref name="destination"/> has a <see cref="Span{T}.Length"/> value less 225if (destination.Length < HashLengthInBytes) 253if (destination.Length < HashLengthInBytes) 265Debug.Assert(destination.Length >= HashLengthInBytes);

System\Security\Cryptography\Kmac128.cs (2)

137Debug.Assert(written == destination.Length); 177Debug.Assert(written == destination.Length);

System\Security\Cryptography\Kmac256.cs (2)

137Debug.Assert(written == destination.Length); 177Debug.Assert(written == destination.Length);

System\Security\Cryptography\KmacXof128.cs (2)

137Debug.Assert(written == destination.Length); 177Debug.Assert(written == destination.Length);

System\Security\Cryptography\KmacXof256.cs (2)

137Debug.Assert(written == destination.Length); 177Debug.Assert(written == destination.Length);

System\Security\Cryptography\LiteHash.OpenSsl.cs (2)

69return destination.Length; 75return destination.Length;

System\Security\Cryptography\LiteHash.Unix.cs (8)

71return destination.Length; 159Debug.Assert(destination.Length >= _hashSizeInBytes); 161uint length = (uint)destination.Length; 175uint length = (uint)destination.Length; 245Debug.Assert(destination.Length >= _hashSizeInBytes); 247int length = destination.Length; 255Debug.Assert(destination.Length >= _hashSizeInBytes); 257int length = destination.Length;

System\Security\Cryptography\LiteHashProvider.Xof.cs (2)

17Debug.Assert(written == destination.Length); 39Debug.Assert(written == destination.Length);

System\Security\Cryptography\OpenSslCipher.cs (1)

52Debug.Assert(input.Length <= output.Length);

System\Security\Cryptography\PemEncoding.cs (4)

235Debug.Assert(destination.Length >= size); 465if (destination.Length < encodedSize) 528if (destination.Length < encodedSize) 719if (charsWritten != destination.Length)

System\Security\Cryptography\RandomNumberGenerator.cs (22)

59byte[] array = ArrayPool<byte>.Shared.Rent(data.Length); 62GetBytes(array, 0, data.Length); 63new ReadOnlySpan<byte>(array, 0, data.Length).CopyTo(data); 67Array.Clear(array, 0, data.Length); 82byte[] array = ArrayPool<byte>.Shared.Rent(data.Length); 89new ReadOnlySpan<byte>(array, 0, data.Length).CopyTo(data); 93Array.Clear(array, 0, data.Length); 291int n = values.Length; 318int needed = (destination.Length + 1) >>> 1; 323if (destination.Length % 2 != 0) 335needed = destination.Length / 2; 344destination = destination.Slice(remainingRandom.Length * 2); 373if (destination.Length < randomBytes.Length) 375randomBytes = randomBytes.Slice(0, destination.Length); 380for (int i = 0; i < randomBytes.Length; i++) 385destination = destination.Slice(randomBytes.Length); 401if (destination.Length * 2 < randomBytes.Length) 403randomBytes = randomBytes.Slice(0, destination.Length * 2); 411if ((uint)i >= (uint)destination.Length) 431for (int i = 0; i < destination.Length; i++)

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

21if (data.Length > 0) 23fixed (byte* ptr = data) GetBytes(ptr, data.Length); 42if (data.Length > 0) 44fixed (byte* ptr = data) GetBytes(ptr, data.Length); 62while (data.Length > 0) 97data = data.Slice(data.Length - zerosFound);

System\Security\Cryptography\Rfc2898DeriveBytes.cs (1)

186int cb = destination.Length;

System\Security\Cryptography\RSA.cs (4)

106if (destination.Length >= result.Length) 121if (destination.Length >= result.Length) 330if (destination.Length >= result.Length) 345if (destination.Length >= result.Length)

System\Security\Cryptography\SP800108HmacCounterKdfImplementationManaged.cs (7)

28if (destination.Length == 0) 33Debug.Assert(destination.Length <= 0x1FFFFFFF); 49BinaryPrimitives.WriteUInt32BigEndian(lBuffer, (uint)destination.Length * 8U); 60if (destination.Length >= hash.HashLengthInBytes) 68Debug.Assert(hmacBufferWritten > destination.Length); 69hmacBuffer.Slice(0, destination.Length).CopyTo(destination); 87if (destination.Length == 0)

System\Security\Cryptography\SP800108HmacCounterKdfImplementationOpenSsl.cs (1)

102if (destination.Length == 0)

System\Security\Cryptography\SymmetricAlgorithm.cs (1)

776|| (uint)written > decryptBuffer.Length)

System\Security\Cryptography\SymmetricPadding.cs (5)

48if (destination.Length < count) 63if (destination.Length < ansiSize) 80if (destination.Length < isoSize) 97if (destination.Length < pkcsSize) 118if (destination.Length < zeroSize)

System\Security\Cryptography\UniversalCryptoDecryptor.cs (1)

114if (decryptedBytes.Length > 0)

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

38if (output.Length >= input.Length) 69if (!depaddingRequired || input.Length - cipher.BlockSizeInBytes > output.Length) 93if (output.Length < depaddedLength) 144if (output.Length - writtenToOutput < depaddedLength) 185if (unpaddedLength > output.Length) 212if (output.Length < ciphertextLength)

System\Security\Cryptography\X509Certificates\OpenSslCrlCache.cs (1)

384if (SHA256.HashData(utf16Url, hash) != hash.Length)

System\Security\Cryptography\X509Certificates\OpenSslX509ChainProcessor.cs (1)

283if (chainSize <= tempChain.Length)

System\Security\Cryptography\X509Certificates\X500NameEncoder.cs (1)

562Debug.Assert(destination.Length >= chars.Length);

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

1068Span<byte> pk2 = publicKeysBuffer.Slice(pk1.Length, publicKey.Algorithm.PublicKeySizeInBytes);

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

568charsWritten != destination.Length) 616if (buffer.Length < certSize)

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

207return mldsaSignature.Length;

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

350if (expectedSize > destination.Length) 583if (destination.Length < GetEncodedLength())

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

281if (expectedSize > destination.Length) 1009if (destination.Length < GetEncodedLength())

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

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

57Return(_skipClear ? 0 : Span.Length); 114if (currentBuffer.Length >= length)

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (10)

103Debug.Assert(destination.Length >= encryptedData.Length); 213if (byteCount > buf.Length) 229Debug.Assert(written == buf.Length); 498if (byteCount > buf.Length) 514Debug.Assert(written == buf.Length); 531CryptoPool.Return(rented, buf.Length); 967byte[] rentedDestination = CryptoPool.Rent(destination.Length); 1013CryptoPool.Return(rentedDestination, destination.Length); 1048if (!hasher.TryGetHashAndReset(t, out tLength) || tLength != t.Length) 1056t.Slice(0, dk.Length).CopyTo(dk);

src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Builder.cs (3)

212if (!mac.TryGetHashAndReset(macSpan, out int bytesWritten) || bytesWritten != macSpan.Length) 214Debug.Fail($"TryGetHashAndReset wrote {bytesWritten} of {macSpan.Length} bytes"); 356if (destination.Length < _sealedData.Length)

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (20)

183if (!hash.TryGetHashAndReset(hashBuf, out int bytesWritten) || bytesWritten != hashBuf.Length) 185Debug.Fail($"Hash output wrote {bytesWritten} bytes when {hashBuf.Length} was expected"); 200if (hashBuf.Length >= destination.Length) 202hashBuf.Slice(0, destination.Length).CopyTo(destination); 207destination = destination.Slice(hashBuf.Length); 216for (int j = (I.Length / vBytes) - 1; j >= 0; j--) 238Debug.Assert(into.Length == addend.Length); 242for (int i = into.Length - 1; i >= 0; i--) 254while (destination.Length > 0) 256if (destination.Length >= bytes.Length) 263bytes.Slice(0, destination.Length).CopyTo(destination); 273Debug.Assert(destination.Length % 2 == 0); 275while (destination.Length > 0) 277if (destination.Length >= fullCopyLen) 288Span<byte> nullTerminator = destination.Slice(0, Math.Min(2, destination.Length)); 290destination = destination.Slice(nullTerminator.Length); 294ReadOnlySpan<char> trimmed = password.Slice(0, destination.Length / 2); 298if (count != destination.Length) 300Debug.Fail($"Partial copy wrote {count} bytes of {destination.Length} expected");

System\Security\Cryptography\Pkcs\CmsHash.cs (2)

47if (destination.Length < OutputSizeBytes) 77if (destination.Length < OutputSizeBytes)

System\Security\Cryptography\Pkcs\CmsSignature.cs (3)

173int fieldSize = ieeeSignature.Length / 2; 176fieldSize * 2 == ieeeSignature.Length, 177$"ieeeSignature.Length ({ieeeSignature.Length}) must be even");

System\Security\Cryptography\Pkcs\Rfc3161TimestampRequest.cs (1)

153if (destination.Length < _encodedBytes.Length)

System\Security\Cryptography\Pkcs\Rfc3161TimestampToken.cs (3)

191$"TryGetHashAndReset did not fit in {stackSpan.Length} for hash {hashAlgorithmId.Value}"); 489written != thumbprint.Length || 527$"TryGetCertHash did not fit in {thumbprint.Length} for hash {certId2.Value.HashAlgorithm.Algorithm}");

System\Security\Cryptography\Pkcs\Rfc3161TimestampTokenInfo.cs (1)

215if (destination.Length < _encodedBytes.Length)

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (1)

46int length = FormatMessage(flags, moduleHandle, unchecked((uint)errorCode), 0, bufferPtr, stackBuffer.Length, IntPtr.Zero);

System\Security\Cryptography\ProtectedData.cs (1)

388if (outputBlob.cbData > outputSpan.Length)

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

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

242byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 243Memory<byte> memBuffer = new Memory<byte>(sharedBuffer, 0, buffer.Length);

System\Text\BaseCodePageEncoding.netcoreapp.cs (1)

18Debug.Assert(bytesRead == codePageIndex.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (2)

70Debug.Assert(definedCharsBitmapAsLittleEndian.Length == thisAllowedCharactersBitmap.Length * sizeof(uint)); 87for (int i = 0; i < thisAllowedCharactersBitmap.Length; i++)

System\Text\Encodings\Web\DefaultHtmlEncoder.cs (8)

109if ((uint)destination.Length <= (uint)idxOfSemicolon) { goto OutOfSpaceInner; } 118for (int i = destination.Length - 1; (uint)destination.Length > (uint)i; i--) 125return destination.Length + 4; 184if ((uint)destination.Length <= (uint)idxOfSemicolon) { goto OutOfSpaceInner; } 195for (int i = destination.Length - 1; (uint)destination.Length > (uint)i; i--) 202return destination.Length + 4;

System\Text\Encodings\Web\DefaultJavaScriptEncoder.cs (6)

117if ((uint)destination.Length <= 1) { goto OutOfSpace; } 135if ((uint)destination.Length <= 5) { goto OutOfSpaceInner; } 146if ((uint)destination.Length <= 11) { goto OutOfSpaceInner; } 168if ((uint)destination.Length <= 1) { goto OutOfSpace; } 186if ((uint)destination.Length <= 5) { goto OutOfSpaceInner; } 197if ((uint)destination.Length <= 11) { goto OutOfSpaceInner; }

System\Text\Encodings\Web\DefaultUrlEncoder.cs (8)

System\Text\Encodings\Web\OptimizedInboxTextEncoder.cs (3)

153if ((uint)destination.Length <= (uint)dstIdx) 173if ((uint)destination.Length <= (uint)dstIdxTemp) 290if ((uint)destination.Length <= (uint)dstIdxTemp)

System\Text\Encodings\Web\TextEncoder.cs (15)

46return TryEncodeUnicodeScalar((int)unicodeScalar, pBuffer, buffer.Length, out charsWritten); 76if ((uint)utf8Destination.Length > (uint)dstIdx) 168if (charsWrittenJustNow == 0 || (uint)charsWrittenJustNow > (uint)destBuffer.Length) 175stringBuilder.Length -= destBuffer.Length - charsWrittenJustNow; 293if (utf8Destination.Length < utf8Source.Length) 295sourceSearchSpace = utf8Source.Slice(0, utf8Destination.Length); 330int originalUtf8DestinationLength = utf8Destination.Length; 355if ((uint)dstIdxTemp >= (uint)utf8Destination.Length) 383bytesWritten = originalUtf8DestinationLength - utf8Destination.Length; 423if (destination.Length < source.Length) 425sourceSearchSpace = source.Slice(0, destination.Length); 455int originalDestinationLength = destination.Length; 499charsWritten = originalDestinationLength - destination.Length; 527if (charsWrittenJustNow == 0 || (uint)charsWrittenJustNow > (uint)scratchBuffer.Length) 580if (destination.Length < source.Length)

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

src\libraries\System.Text.Json\Common\JsonCamelCaseNamingPolicy.cs (2)

30for (int i = 0; i < chars.Length; i++) 37bool hasNext = (i + 1 < chars.Length);

src\libraries\System.Text.Json\Common\JsonHelpers.cs (4)

78Span<(TKey, int)> keys = span.Length <= StackallocThreshold 79? (stackalloc (TKey, int)[StackallocThreshold]).Slice(0, span.Length) 80: new (TKey, int)[span.Length]; 82for (int i = 0; i < keys.Length; i++)

src\libraries\System.Text.Json\Common\JsonSeparatorNamingPolicy.cs (2)

177if (charsWritten == destination.Length) 187int newSize = checked(destination.Length * 2);

System\Text\Json\Document\JsonDocument.TryGetProperty.cs (1)

187Span<byte> utf8Unescaped = remaining <= utf8UnescapedStack.Length ?

System\Text\Json\JsonEncodedText.cs (1)

91Debug.Assert(expectedByteCount == utf8Bytes.Length);

System\Text\Json\Reader\JsonReaderHelper.cs (3)

190if (JsonHelpers.IsValidUnescapedDateTimeOffsetParseLength(sourceUnescaped.Length) 238if (JsonHelpers.IsValidUnescapedDateTimeOffsetParseLength(sourceUnescaped.Length) 287if (utf8Unescaped.Length == JsonConstants.MaximumFormatGuidLength

System\Text\Json\Reader\JsonReaderHelper.Unescaping.cs (4)

358Debug.Assert(destination.Length >= source.Length); 371Debug.Assert(destination.Length >= source.Length); 408if (written == destination.Length) 513if ((uint)(written + nextUnescapedSegmentLength) >= (uint)destination.Length)

System\Text\Json\Reader\Utf8JsonReader.MultiSegment.cs (1)

588int amountToWrite = Math.Min(span.Length, readSoFar.Length - written);

System\Text\Json\Writer\JsonWriterHelper.cs (2)

16Debug.Assert(buffer.Length >= indent); 322quotedValue[quotedValue.Length - 1] = JsonConstants.Quote;

System\Text\Json\Writer\JsonWriterHelper.Date.cs (6)

51Debug.Assert(buffer.Length == maxDateTimeLength || 52buffer.Length == maxDateTimeLength + 1 || 53buffer.Length == JsonConstants.MaximumFormatDateTimeOffsetLength); 77bytesWritten = buffer.Length; 83if (buffer.Length == maxDateTimeLength) 88else if (buffer.Length == JsonConstants.MaximumFormatDateTimeOffsetLength)

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.StringSegment.cs (4)

408if (combinedBuffer.Length is 3) 416Debug.Assert(combinedBuffer.Length is 1 or 2); 543if ((uint)total >= (uint)dest.Length) 554if ((uint)total >= (uint)dest.Length)

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\System.Text.Json\Common\JsonCamelCaseNamingPolicy.cs (2)

30for (int i = 0; i < chars.Length; i++) 37bool hasNext = (i + 1 < chars.Length);

src\libraries\System.Text.Json\Common\JsonHelpers.cs (4)

78Span<(TKey, int)> keys = span.Length <= StackallocThreshold 79? (stackalloc (TKey, int)[StackallocThreshold]).Slice(0, span.Length) 80: new (TKey, int)[span.Length]; 82for (int i = 0; i < keys.Length; i++)

src\libraries\System.Text.Json\Common\JsonSeparatorNamingPolicy.cs (2)

177if (charsWritten == destination.Length) 187int newSize = checked(destination.Length * 2);

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Text\RegularExpressions\Regex.Replace.cs (2)

224for (int i = 0; i < span.Length; i++) 231for (int i = 0; i < span.Length; i++)

System\Text\RegularExpressions\RegexCharClass.cs (9)

545numCategories == categories.Length) 560numCategories == categories.Length) 585if (numCategories == categories.Length) 606if (numCategories == categories.Length) 729if (++evaluated > chars.Length) 1029Debug.Assert(twoChars.Length >= 2); 1589span[SetLengthIndex] = (char)(span.Length - SetStartIndex); 1600Debug.Assert(i == span.Length); 1982Span<char> invertedGroup = group.Length <= scratch.Length ? scratch.Slice(0, group.Length) : new char[group.Length];

System\Text\RegularExpressions\RegexCompiler.cs (1)

5532switch (setChars.Length)

System\Text\RegularExpressions\RegexReplacement.cs (2)

265int length = ((span.Length / 2) - 1) * replacement.Length; 266for (int i = 1; i < span.Length; i += 2) // the count of each pair is the second item

System\Text\RegularExpressions\Symbolic\RegexNodeConverter.cs (3)

428Debug.Assert(cat >= 0 && cat < categoryCodes.Length, $"Expected {cat} to be in range [0, {categoryCodes.Length})."); 507for (int i = 0; i < catCodes.Length; i++)

RegexGenerator.Emitter.cs (1)

5108indexOfExpr = setChars.Length switch

src\libraries\Common\src\System\Collections\Generic\ValueListBuilder.cs (12)

32Debug.Assert(value <= _span.Length); 53if ((uint)pos < (uint)span.Length) 69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 113if ((uint)(pos + length) <= (uint)span.Length) 137Debug.Assert(_pos == _span.Length); 209Debug.Assert(_pos > _span.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 215int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _pos + additionalCapacityBeyondPos); 225nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\EncodingPolyfills.cs (3)

39return encoding.GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length); 48return encoding.GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length); 64if (charCount > chars.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (9)

545numCategories == categories.Length) 560numCategories == categories.Length) 585if (numCategories == categories.Length) 606if (numCategories == categories.Length) 729if (++evaluated > chars.Length) 1029Debug.Assert(twoChars.Length >= 2); 1609span[SetLengthIndex] = (char)(span.Length - SetStartIndex); 1621Debug.Assert(i == span.Length); 1982Span<char> invertedGroup = group.Length <= scratch.Length ? scratch.Slice(0, group.Length) : new char[group.Length];

src\libraries\Common\src\System\HexConverter.cs (6)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 204Debug.Assert(destination.Length >= (source.Length * 2)); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 464while (j < destination.Length) 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 499while (j < destination.Length)

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (14)

40Debug.Assert(value <= _chars.Length); 45public int Capacity => _chars.Length; 53if ((uint)capacity > (uint)_chars.Length) 107if (_pos > _chars.Length - count) 127if (_pos > (_chars.Length - count)) 147if ((uint)pos < (uint)chars.Length) 167if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 181if (pos > _chars.Length - s.Length) 196if (_pos > _chars.Length - count) 202for (int i = 0; i < dst.Length; i++) 212if (pos > _chars.Length - value.Length) 225if (origPos > _chars.Length - length) 253Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed."); 261Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

System\Web\Util\HttpEncoder.cs (2)

684for (int i = idxOfFirstSurrogate; (uint)i < (uint)chars.Length; i++) 688if ((uint)(i + 1) >= (uint)chars.Length || !char.IsLowSurrogate(chars[i + 1]))

System\Windows\Forms\ActiveX\AxHost.VBFormat.cs (2)

53if (format.Length >= buffer.Length) 56format = format[..(buffer.Length - 1)];

System\Windows\Forms\ActiveX\DataStreamFromComStream.cs (1)

78_comStream->Read(ch, (uint)buffer.Length, &bytesRead);

System\Windows\Forms\Control.cs (1)

2271length = PInvoke.GetClassName(lastParentHandle, lpClassName, buffer.Length);

System\Windows\Forms\Controls\ComboBox\ComboBox.AutoCompleteDropDownFinder.cs (1)

42int length = PInvoke.GetClassName(hwnd, (PWSTR)b, buffer.Length);

System\Windows\Forms\Controls\Labels\LinkUtilities.cs (1)

44int nMax = Math.Min(rgb.Length, rgbsCount);

System\Windows\Forms\Controls\MonthCalendar\MonthCalendar.cs (1)

1102for (int i = 0; i < boldDates.Length; ++i, ++startMonth)

System\Windows\Forms\Controls\MonthCalendar\MonthCalendar.MonthCalendarAccessibleObject.cs (1)

299cchName = (UIntPtr)name.Length - 1

System\Windows\Forms\Dialogs\CommonDialogs\ColorDialog.cs (1)

87MemoryMarshal.Cast<int, COLORREF>(value)[..Math.Min(customColors.Length, value.Length)].CopyTo(customColors);

System\Windows\Forms\Printing\PageSetupDialog.cs (1)

293buffer.Length);

System\Windows\Forms\SendKeys\SendKeys.cs (1)

311if (keystate.Length < 256)

System\Windows\Forms\VisualStyles\VisualStyleInformation.cs (3)

45PInvoke.GetCurrentThemeName(pFilename, filename.Length, null, 0, null, 0); 67PInvoke.GetCurrentThemeName(null, 0, pColorScheme, colorScheme.Length, null, 0); 89PInvoke.GetCurrentThemeName(null, 0, null, 0, pSize, size.Length);

System\Windows\Forms\VisualStyles\VisualStyleRenderer.cs (2)

520_lastHResult = PInvoke.GetThemeFilename(HTHEME, Part, State, (THEME_PROPERTY_SYMBOL_ID)prop, pFilename, filename.Length); 649_lastHResult = PInvoke.GetThemeString(HTHEME, Part, State, (int)prop, pString, aString.Length);

System\ComponentModel\Design\ByteViewer.cs (2)

185Debug.Assert(charsBuffer.Length >= lineBuffer.Length); 207Debug.Assert(charsBuffer.Length >= lineBuffer.Length * 3 + 1);

System\Windows\Forms\Design\DesignerUtils.cs (1)

664for (int i = 0; i < alphaValues.Length; i++)

System\ComponentModel\TypeConverterHelper.cs (2)

35if (tokensCount != output.Length) 52for (int i = 0; i < output.Length; i++)

Windows.Win32.IAccessible.g.cs (2)

90 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 91 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IEnumConnections.g.cs (1)

62 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgcd.Length, rgcdLocal, pcFetchedLocal);

Windows.Win32.IEnumOLEVERB.g.cs (1)

60 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.IEnumVARIANT.g.cs (1)

61 winmdroot.Foundation.HRESULT __result = this.Next((uint )rgVar.Length, rgVarLocal, pCeltFetchedLocal);

Windows.Win32.IFontDisp.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLCurrentStyle.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLDataTransfer.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLDocument.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLDocument2.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLDocument3.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLDocument4.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLDOMNode.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLElement.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLElement2.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLElement3.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLElementCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLEventObj.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLFiltersCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLFormElement.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLFrameBase.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLFramesCollection2.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLImageElementFactory.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLImgElement.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLLocation.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLMimeTypesCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLOpsProfile.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLOptionElement.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLOptionElementFactory.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLPluginsCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLRect.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLRectCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLRenderStyle.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLRuleStyle.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLScreen.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLSelectionObject.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLStyle.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLStyleSheet.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLStyleSheetRule.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLStyleSheetRulesCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLStyleSheetsCollection.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLWindow2.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLWindow3.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IHTMLWindow4.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IOmHistory.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IOmNavigator.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITextDocument.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITextFont.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITextPara.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITextRange.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITextSelection.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.ITextStoryRanges.g.cs (2)

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 84 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IWebBrowser.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IWebBrowser2.g.cs (2)

94 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 95 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.IWebBrowserApp.g.cs (2)

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException(); 83 this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);

Windows.Win32.PInvoke.GDI32.dll.g.cs (1)

359 uint __result = PInvoke.GetSystemPaletteEntries(hdc, iStart, (uint )pPalEntries.Length, pPalEntriesLocal);

Windows.Win32.PInvoke.USER32.dll.g.cs (1)

1482 if (lpKeyState.Length < 256) throw new ArgumentException();

Windows.Win32.System_Com_IEnumConnections_Extensions.g.cs (1)

30 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgcd.Length, rgcdLocal, pcFetchedLocal);

Windows.Win32.System_Ole_IEnumOLEVERB_Extensions.g.cs (1)

28 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgelt.Length, rgeltLocal, pceltFetched);

Windows.Win32.System_Ole_IEnumVARIANT_Extensions.g.cs (1)

30 winmdroot.Foundation.HRESULT __result = @this.Next((uint )rgVar.Length, rgVarLocal, pCeltFetchedLocal);

Windows\Win32\PInvoke.GetThemeDocumentationProperty.cs (1)

13GetThemeDocumentationProperty(pszThemeName, pszPropertyName, pBuffer, buffer.Length);

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

29encoded.Length.Should().Be(expectedLength);

System\Windows\Forms\ListBoxTests.cs (7)

2661Assert.Equal(1, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0])); 2667Assert.Equal(2, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0])); 2673Assert.Equal(0, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0])); 3178Assert.Equal(1, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0])); 3185Assert.Equal(1, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0])); 3191Assert.Equal(2, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0])); 3197Assert.Equal(0, (int)PInvokeCore.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));

System\Windows\Forms\RichTextBoxTests.cs (1)

11023length = PInvoke.GetClassName(hWnd, lpClassName, buffer.Length);

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;

src\Compilers\Core\Portable\Hashing\NonCryptographicHashAlgorithm.cs (5)

208if (destination.Length < HashLengthInBytes) 233if (destination.Length < HashLengthInBytes) 270if (destination.Length < HashLengthInBytes) 295if (destination.Length < HashLengthInBytes) 329Debug.Assert(destination.Length == HashLengthInBytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

108if (destination.Length >= sizeof(ulong) * 2)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (2)

333Debug.Assert(remaining.Length <= InternalBufferLengthBytes); 336state.BufferedCount = (uint)remaining.Length;

src\Dependencies\Collections\Internal\ArraySortHelper.cs (6)

694Debug.Assert(0 <= i && i < keys.Length && i < values.Length); 695Debug.Assert(0 <= j && j < keys.Length && j < values.Length); 727Debug.Assert(keys.Length == values.Length); 738Debug.Assert(values.Length == keys.Length); 978Debug.Assert(values.Length == keys.Length); 1252if ((uint)i < (uint)values.Length) // check to see if we have values

src\Dependencies\Collections\Internal\BitHelper.cs (2)

40if (bitArrayIndex < (uint)span.Length) 55bitArrayIndex < (uint)span.Length &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (3)

175Debug.Assert(tempBuffer.Length != 0); // We only bound-check after writing a character to the tempBuffer. 184if (charsWritten == tempBuffer.Length) 200int destLength = bytes.Length;