Length

ConsoleLogs\AnsiParser.cs (7)

84for (var i = 0; i < span.Length; i++) 273if (span.Length <= 2 || (span[0] != EscapeChar || span[1] != '[')) 337if (span.Length <= 2 || (span[0] != EscapeChar || span[1] != ']')) 388if (span.Length <= 5 || (span[0] != EscapeChar || span[1] != ']')) 401if (urlEndEscapePosition < 0 || span.Length < urlEndEscapePosition + 1 || span[urlEndEscapePosition + 1] != '\\') 409while (linkEndEscapePosition != -1 && span.Length > (linkEndEscapePosition + 2) && span[linkEndEscapePosition + 1] != ']') 415if (linkEndEscapePosition < 0 || span.Length < linkEndEscapePosition + 2 || span[linkEndEscapePosition + 2] != '8')

Extensions\StringExtensions.cs (1)

46if (s.Length == 0)

Otlp\Model\OtlpHelpers.cs (1)

81for (var pos = 0; pos < data.Length; pos++)

src\Shared\ConsoleLogs\TimestampParser.cs (1)

22if (match.Index + match.Length >= span.Length)

src\Shared\ConsoleLogs\TimestampParser.cs (1)

22if (match.Index + match.Length >= span.Length)

VolumeNameGenerator.cs (1)

44for (var i = 0; i < nameSpan.Length; i++)

EnvVarEscaper.cs (14)

35if (input.Length > MaxInputLength) 68for (var i = firstUnescaped; i < input.Length;) 85for (var i = 0; i < input.Length; i++) 101if (input.Length == 1) 123while (varLength < remaining.Length && (char.IsLetterOrDigit(remaining[varLength]) || remaining[varLength] == '_' || remaining[varLength] == '-')) 168for (var i = 0; i < remaining.Length; i++) 171if (remaining[i] == '$' && i + 1 < remaining.Length && remaining[i + 1] == '{') 194return input.Length; 206if (content.Length > MaxContentLength) 212var stripped = new char[Math.Min(content.Length, MaxContentLength)]; 271if (content.Length > MaxContentLength) 299for (var i = 0; i < content.Length - 1; i++) 301if (content[i] == '$' && i + 1 < content.Length && content[i + 1] == '{') 316else if (depth == 0 && content[i] == ':' && i + 1 < content.Length && content[i + 1] == '-')

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

RuntimeSource\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

Linker\TypeReferenceExtensions.cs (4)

392if (type.Name.Length + 1 > name.Length) 395if (!name.Slice(name.Length - type.Name.Length).Equals(type.Name.AsSpan(), StringComparison.Ordinal)) 398if (name[name.Length - type.Name.Length - 1] != '.') 401return name.Slice(0, name.Length - type.Name.Length - 1).Equals(type.Namespace, StringComparison.Ordinal);

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

CompilationExtensions.cs (2)

150switch (span.Length) 158var builder = ImmutableArray.CreateBuilder<T>(span.Length);

INamedTypeSymbolExtensions.cs (1)

19while (roSpan.Length > 0)

ResponseTests.cs (1)

3435encoder.Convert(source, writer.GetSpan(), flush: source.Length == 0, out var charsUsed, out var bytesUsed, out completed);

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (1)

623if (span.Length > 0)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Shared\Debugger\DebuggerHelpers.cs (2)

30if (values.Length == 0) 42for (var i = 0; i < values.Length; i++)

NavigationManagerExtensions.cs (2)

116_builder = new(uriWithoutQueryStringAndHash.Length + additionalCapacity); 761newQueryStringBuilder = new(uriWithoutQueryStringAndHash, query.Length + hash.Length);

PersistentStateValueProvider.cs (1)

211GrowBuffer(ref pool, ref keyBuffer, keySpan.Length * 4 + preKey.Length);

src\Components\Shared\src\ArrayBuilder.cs (2)

87var requiredCapacity = _itemsInUse + source.Length; 101_itemsInUse += source.Length;

src\Http\Routing\src\Constraints\FileNameRouteConstraint.cs (2)

124if (value.Length == 0) 143for (var i = dotIndex + 1; i < value.Length; i++)

src\Http\Routing\src\Patterns\RoutePatternMatcher.cs (4)

342var lastIndex = requestSegment.Length; 404if (part is RoutePatternLiteralPart literal && ((indexOfLiteral + literal.Content.Length) != requestSegment.Length)) 408else if (part is RoutePatternSeparatorPart separator && ((indexOfLiteral + separator.Content.Length) != requestSegment.Length)) 464if (parameterValueSpan.Length == 0)

src\Shared\QueryStringEnumerable.cs (1)

99var buffer = new char[source.Length];

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

20if (destination.Length < source.Length) 29return DecodeInPlace(destination.Slice(0, source.Length), isFormEncoding); 363return DecodeInPlace(destination.Slice(0, source.Length)); 591if ((uint)tempIdx >= (uint)buffer.Length) 603return (uint)c >= (uint)CharToHexLookup.Length ? -1 : CharToHexLookup[c];

FormMapping\FormDataReader.cs (5)

175if (CurrentPrefix.Span.Length == 0) 203var keyLength = key.Length; 235Debug.Assert(_prefixBuffer.Length >= (_currentPrefixBuffer.Length + separator.Length)); 239var startingPoint = _currentPrefixBuffer.Length + separator.Length; 240_currentPrefixBuffer = _prefixBuffer.Slice(0, startingPoint + key.Length);

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

40var startIndex = _nextEndIndex - span.Length; 65newEndIndex -= span.Length;

src\Components\Shared\src\ArrayBuilder.cs (2)

87var requiredCapacity = _itemsInUse + source.Length; 101_itemsInUse += source.Length;

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

162if (_span.Length >= source.Length) 165Advance(source.Length); 231int bytesLeftToCopy = source.Length;

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\MessagePackReader.cs (3)

736if (this.reader.CurrentSpanIndex + length <= this.reader.CurrentSpan.Length) 771if (unreadSpan.Length >= byteLength) 1109int bytesRead = Math.Min(remainingByteLength, this.reader.UnreadSpan.Length);

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

744int length = (int)src.Length; 856var length = utf8stringBytes.Length; 946ref byte buffer = ref this.WriteString_PrepareSpan(value.Length, out int bufferSize, out int useOffset); 950int byteCount = StringEncoding.UTF8.GetBytes(pValue, value.Length, pBuffer + useOffset, bufferSize);

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

69this.nextPosition = sequence.GetPosition(first.Length); 71this.moreData = first.Length > 0; 216if (this.CurrentSpanIndex >= this.CurrentSpan.Length) 337if ((count & TooBigOrNegative) == 0 && this.CurrentSpan.Length - this.CurrentSpanIndex > (int)count) 347else if (this.CurrentSpan.Length - this.CurrentSpanIndex == (int)count) 369if (this.usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length) 387Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length, "this.CurrentSpanIndex < this.CurrentSpan.Length"); 417int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex; 457if (firstSpan.Length >= destination.Length) 474Debug.Assert(firstSpan.Length < destination.Length, "firstSpan.Length < destination.Length"); 476int copied = firstSpan.Length; 484int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);

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

35if (span.Length < sizeof(T)) 72Debug.Assert(reader.UnreadSpan.Length < sizeof(T), "reader.UnreadSpan.Length < sizeof(T)");

Routing\NavLink.cs (4)

191if (currentUriAbsolute.Length == hrefAbsolute.Length - 1) 201if (hrefAbsolute[hrefAbsolute.Length - 1] == '/' && 202currentUriAbsolute.SequenceEqual(hrefAbsolute.Slice(0, hrefAbsolute.Length - 1), CaseInsensitiveComparer))

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

40var startIndex = _nextEndIndex - span.Length; 65newEndIndex -= span.Length;

src\Components\Shared\src\ArrayBuilder.cs (2)

87var requiredCapacity = _itemsInUse + source.Length; 101_itemsInUse += source.Length;

ResponseCookiesWrapper.cs (1)

142var nonSuppressedValues = new List<KeyValuePair<string, string>>(keyValuePairs.Length);

src\Shared\Debugger\DebuggerHelpers.cs (2)

30if (values.Length == 0) 42for (var i = 0; i < values.Length; i++)

CryptoUtil.cs (2)

98Assert(bufA.Length == bufB.Length, "countA == countB");

SP800_108\ManagedSP800_108_CTR_HMACSHA512.cs (6)

69var prfInputLength = checked(sizeof(uint) /* [i]_2 */ + label.Length + 1 /* 0x00 */ + (contextHeader.Length + contextData.Length) + sizeof(uint) /* [K]_2 */); 92contextHeader.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1)); 93contextData.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1 + contextHeader.Length));

Latency\AcceptanceTests.cs (1)

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

Internal\ResponseCookies.cs (1)

91var cookies = new string[keyValuePairs.Length];

src\Shared\HttpRuleParser.cs (1)

65return (firstNonTokenCharIdx == -1) ? subspan.Length : firstNonTokenCharIdx;

src\Shared\Debugger\DebuggerHelpers.cs (2)

30if (values.Length == 0) 42for (var i = 0; i < values.Length; i++)

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

20if (destination.Length < source.Length) 29return DecodeInPlace(destination.Slice(0, source.Length), isFormEncoding); 363return DecodeInPlace(destination.Slice(0, source.Length)); 591if ((uint)tempIdx >= (uint)buffer.Length) 603return (uint)c >= (uint)CharToHexLookup.Length ? -1 : CharToHexLookup[c];

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

169while (buffer.Length > 0)

src\Components\Endpoints\src\FormMapping\FormDataReader.cs (5)

175if (CurrentPrefix.Span.Length == 0) 203var keyLength = key.Length; 235Debug.Assert(_prefixBuffer.Length >= (_currentPrefixBuffer.Length + separator.Length)); 239var startingPoint = _currentPrefixBuffer.Length + separator.Length; 240_currentPrefixBuffer = _prefixBuffer.Slice(0, startingPoint + key.Length);

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

249if (pos > _chars.Length - value.Length) 251Grow(value.Length); 255_pos += value.Length;

UriHelper.cs (3)

219text.CopyTo(buffer.Slice(index, text.Length)); 220return index + text.Length; 234if (uriParts.path.Length > 0 && pathBaseSpan.Length > 0 && pathBaseSpan[^1] == '/')

src\Shared\ResultsHelpers\SharedUrlHelper.cs (1)

81for (var i = 0; i < readOnlySpan.Length; i++)

RequestBufferingStream.cs (2)

84if (span.Length == 0) 94var innerCount = Math.Min(remaining, span.Length);

ResponseBufferingStream.cs (1)

85var innerCount = Math.Min(remaining, span.Length);

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

249if (pos > _chars.Length - value.Length) 251Grow(value.Length); 255_pos += value.Length;

ForwardedHeadersMiddleware.cs (1)

455if ((uint)hostEndIdx >= (uint)host.Length || // No ']'. The uint cast is there to eliminate the

Passkeys\BufferSourceJsonConverter.cs (5)

47Span<byte> byteSpan = utf8Unescaped.Length <= StackallocByteThreshold ? 49(pooledArray = ArrayPool<byte>.Shared.Rent(utf8Unescaped.Length)); 63Debug.Assert(bytesConsumed == utf8Unescaped.Length); 79var encodedLength = Base64Url.GetEncodedLength(bytes.Length); 86Debug.Assert(bytesConsumed == bytes.Length);

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

78if (trimmedInput.Length == 0) 83var output = new byte[trimmedInput.Length * 5 / 8];

Routing\UrlHelperBase.cs (1)

363for (var i = 0; i < readOnlySpan.Length; i++)

src\Shared\HttpRuleParser.cs (1)

65return (firstNonTokenCharIdx == -1) ? subspan.Length : firstNonTokenCharIdx;

src\Shared\ResultsHelpers\SharedUrlHelper.cs (1)

81for (var i = 0; i < readOnlySpan.Length; i++)

Rendering\TagBuilder.cs (1)

183while (remainingName.Length > 0)

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

169while (buffer.Length > 0)

FormatterBinaryWriter.cs (3)

182else if ((offset + value.Length) <= length) 185offset += value.Length; 200var toWrite = Math.Min(value.Length, available.Length);

OutputCacheEntryFormatter.cs (1)

174writer.Write7BitEncodedInt(span.Length);

RecyclableSequenceBuilder.cs (3)

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

Streams\OutputCacheStream.cs (1)

145if (_segmentWriteStream.Length + buffer.Length > _maxBufferSize)

EndToEndBenchmarks.cs (2)

83var bytes = Math.Min(rand.Next(4, 1024), value.Length); 96var bytes = Math.Min(rand.Next(4, 1024), value.Length);

src\Shared\SegmentWriteStream.cs (1)

143var bytesWritten = Math.Min(buffer.Length, _segmentSize - (int)_bufferStream.Length);

Constraints\FileNameRouteConstraint.cs (2)

124if (value.Length == 0) 143for (var i = dotIndex + 1; i < value.Length; i++)

Matching\DfaMatcher.cs (3)

218for (var i = 0; i < segments.Length; i++) 244if ((uint)segmentIndex < (uint)segments.Length) 266if ((uint)segmentIndex < (uint)segments.Length)

Matching\FastPathTokenizer.cs (1)

35var length = span.Length;

Matching\HostMatcherPolicy.cs (2)

105if (host.Length == 0 || MemoryExtensions.Equals(host, WildcardHost, StringComparison.OrdinalIgnoreCase)) 131else if (port.Length > 0 && (!int.TryParse(port, out var parsed) || parsed != requestPort))

Matching\SingleEntryAsciiJumpTable.cs (3)

47Debug.Assert(a.Length == b.Length && b.Length == length);

Patterns\RoutePatternMatcher.cs (4)

342var lastIndex = requestSegment.Length; 404if (part is RoutePatternLiteralPart literal && ((indexOfLiteral + literal.Content.Length) != requestSegment.Length)) 408else if (part is RoutePatternSeparatorPart separator && ((indexOfLiteral + separator.Content.Length) != requestSegment.Length)) 464if (parameterValueSpan.Length == 0)

src\Shared\Debugger\DebuggerHelpers.cs (2)

30if (values.Length == 0) 42for (var i = 0; i < values.Length; i++)

src\Shared\HttpRuleParser.cs (1)

65return (firstNonTokenCharIdx == -1) ? subspan.Length : firstNonTokenCharIdx;

RequestProcessing\ResponseBody.cs (1)

296chunk.Anonymous.FromMemory.BufferLength = (uint)bytes.Length;

RequestProcessing\ResponseStreamAsyncResult.cs (1)

175chunk.Anonymous.FromMemory.BufferLength = (uint)bytes.Length;

src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (1)

197if (index < timestamps.Length && timestamps[index] > 0)

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (2)

281for (int i = 0; i < HeaderKeys.Length; i++) 295for (int i = 0; i < HeaderKeys.Length; i++)

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

HttpsTests.cs (1)

274Assert.True(requestTimingFeature.Timestamps.Length > (int)HttpSysRequestTimingType.Http3HeaderDecodeEnd);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (1)

197if (index < timestamps.Length && timestamps[index] > 0)

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (2)

281for (int i = 0; i < HeaderKeys.Length; i++) 295for (int i = 0; i < HeaderKeys.Length; i++)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

Internal\Http\DateHeaderValueManager.cs (2)

47var dateBytes = new byte[DatePreambleBytes.Length + dateValue.Length]; 49Encoding.ASCII.GetBytes(dateValue, dateBytes.AsSpan(DatePreambleBytes.Length));

Internal\Http\Http1OutputProducer.cs (4)

308if (_advancedBytesForChunk > 0 || buffer.Length > 0) 326if (buffer.Length > 0) 328writer.WriteBeginChunkBytes(buffer.Length); 589if (buffer.Length > 0)

Internal\Http\HttpHeaders.cs (17)

Internal\Http\HttpHeaders.Generated.cs (4)

7522switch (name.Length) 7891if (previousValue.Length == value.Length && 8107if (previousValue.Length == value.Length && 8310if (previousValue.Length == value.Length &&

Internal\Http\HttpParser.cs (20)

75if (next == 0 || requestLine.Length == 0) 78reader.Rewind(requestLine.Length + 1); 79var readResult = reader.TryReadExact(requestLine.Length + 1, out var requestLineSequence); 98if ((uint)offset >= (uint)requestLine.Length) 139for (; (uint)offset < (uint)requestLine.Length; offset++) 153while ((uint)offset < (uint)requestLine.Length 163if ((uint)offset + 9 != (uint)requestLine.Length || requestLine[offset + 8] != ByteCR) 168if (_disableHttp1LineFeedTerminators || (uint)offset + 8 != (uint)requestLine.Length) 204if (span.Length >= 2 && span[0] == ByteCR && span[1] == ByteLF) 224if ((uint)span.Length > (uint)(crIndex + 1) && span[crIndex + 1] == ByteLF) 233span = span.Slice(0, span.Length - 1); 253var stopIndex = Math.Min(crIndex + 2, span.Length); 284if (span.Length == 0) 321var array = new byte[span.Length + (lineFeedOnly ? 1 : 2)]; 470if ((uint)nameEnd >= (uint)headerLine.Length) 493if ((uint)valueStart < (uint)headerLine.Length) 502if ((uint)valueStart < (uint)headerLine.Length) 510for (; valueStart < headerLine.Length; valueStart++) 524var valueEnd = headerLine.Length - 1; 574return (requestLine.Length >= MinTlsRequestSize && requestLine[0] == SslRecordTypeHandshake);

Internal\Http\HttpRequestHeaders.cs (1)

103consumed != value.Length)

Internal\Http2\Http2Connection.cs (9)

564if (readableBuffer.Length >= ClientPreface.Length) 641if (requestLine.Length > 10 && requestLine[requestLine.Length - 1] == (byte)'\r') 643httpVersion = HttpUtilities.GetKnownVersion(requestLine.Slice(requestLine.Length - 9, 8)); 663Debug.Assert(buffer.Length >= ClientPreface.Length, "Not enough content to match preface."); 665var preface = buffer.Slice(0, ClientPreface.Length); 1579_totalParsedHeaderSize += name.Length + value.Length; 1670for (var i = 0; i < name.Length; i++)

Internal\Http2\Http2FrameWriter.cs (4)

509_outgoingFrame.PayloadLength = ContinueBytes.Length; 610while (dataToFrame.Length > 0) 619var currentSize = Math.Min(dataToFrame.Length, _maxFrameSize); 621if (endOfHeaders && dataToFrame.Length == currentSize)

Internal\Http2\Http2OutputProducer.cs (4)

398if (_completeScheduled || data.Length == 0) 407EnqueueDataWrite(data.Length); 534if (_completeScheduled || data.Length == 0) 543EnqueueDataWrite(data.Length);

Internal\Http2\Http2Stream.cs (4)

434Span<byte> pathBuffer = pathSegment.Length <= MaxPathBufferStackAllocSize 437? stackalloc byte[MaxPathBufferStackAllocSize].Slice(0, pathSegment.Length) 440: new byte[pathSegment.Length]; 442for (var i = 0; i < pathSegment.Length; i++)

Internal\Http3\Http3FrameWriter.cs (1)

272_outgoingFrame.RemainingLength = ContinueBytes.Length;

Internal\Http3\Http3OutputProducer.cs (2)

339if (_streamCompleted || data.Length == 0) 364if (_streamCompleted || data.Length == 0)

Internal\Http3\Http3Stream.cs (7)

298_totalParsedHeaderSize += name.Length + value.Length; 380for (var i = 0; i < name.Length; i++) 1196Span<byte> pathBuffer = pathSegment.Length <= MaxPathBufferStackAllocSize 1199? stackalloc byte[MaxPathBufferStackAllocSize].Slice(0, pathSegment.Length) 1202: new byte[pathSegment.Length]; 1204for (var i = 0; i < pathSegment.Length; i++)

Internal\Http3\QPack\DecoderStreamReader.cs (1)

58for (var i = 0; i < span.Length; i++)

Internal\Http3\QPack\EncoderStreamReader.cs (1)

105for (var i = 0; i < span.Length; i++)

Internal\Http3\QPackHeaderWriter.cs (2)

126buffer[2] = (byte)statusBytes.Length; 129return 3 + statusBytes.Length;

Internal\Infrastructure\HttpUtilities.cs (10)

78Debug.Assert(bytes.Length == 8, "Mask must be exactly 8 bytes long."); 92var str = string.Create(span.Length, span, static (destination, source) => 181for (var i = 0; i < Math.Min(span.Length, maxChars); i++) 187if (span.Length > maxChars) 217if (sizeof(uint) <= span.Length) 224else if (sizeof(ulong) <= span.Length) 281Debug.Assert(WordListForPerfectHashOfMethods.Length == (MaxHashValue + 1) && methodsLookup.Length == (MaxHashValue + 1)); 287&& index < (uint)methodsLookup.Length) 332return (uint)str.Length + associatedValues[c]; 383if (span.Length > sizeof(ulong) && span[sizeof(ulong)] == (byte)'\r')

Middleware\Internal\LoggingStream.cs (5)

160builder.Append(buffer.Length); 163if (buffer.Length > 0) 174for (int i = 0; i < buffer.Length; i++) 193if (i != buffer.Length - 1) 208var numBytesInLastLine = buffer.Length % 16;

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

42if (buffer.Length != 0)

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

239while (currentIndex < data.Length); 287int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 342if (currentIndex < data.Length) 373int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 426if (currentIndex < data.Length) 534if (currentIndex < data.Length) 563if (currentIndex < data.Length) 689for (; currentIndex < data.Length; currentIndex++)

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

222if (values.Length == 1) 227if (values.Length == 0) 237int valueLength = separator.Length * (values.Length - 1); 266for (int i = 1; i < values.Length; i++) 281for (int i = 1; i < values.Length; i++)

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

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

20if (destination.Length < source.Length) 29return DecodeInPlace(destination.Slice(0, source.Length), isFormEncoding); 363return DecodeInPlace(destination.Slice(0, source.Length)); 591if ((uint)tempIdx >= (uint)buffer.Length) 603return (uint)c >= (uint)CharToHexLookup.Length ? -1 : CharToHexLookup[c];

src\Shared\test\Shared.Tests\runtime\Http3\QPackDecoderTest.cs (1)

374if (name.Length == 0)

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (1)

623if (span.Length > 0)

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

runtime\Http3\QPackDecoderTest.cs (1)

374if (name.Length == 0)

src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (1)

197if (index < timestamps.Length && timestamps[index] > 0)

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (2)

281for (int i = 0; i < HeaderKeys.Length; i++) 295for (int i = 0; i < HeaderKeys.Length; i++)

src\Shared\QueryStringEnumerable.cs (1)

99var buffer = new char[source.Length];

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

60int entryLength = HeaderField.GetLength(name.Length, value.Length);

src\Shared\runtime\Http2\Hpack\HeaderField.cs (1)

20Debug.Assert(name.Length > 0);

src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (7)

188while (currentIndex < data.Length); 215if (currentIndex < data.Length) 287if (currentIndex < data.Length) 313if (currentIndex < data.Length) 425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 640for (; currentIndex < data.Length; currentIndex++)

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

424if (IntegerEncoder.Encode(value.Length, 7, destination, out int integerLength)) 429if (value.Length <= destination.Length) 434bytesWritten = integerLength + value.Length; 517if (values.Length == 0) 521else if (values.Length == 1) 530int valueLength = checked((values.Length - 1) * separator.Length); 561for (int i = 1; i < values.Length; i++) 576for (int i = 1; i < values.Length; i++)

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

692while (i < src.Length)

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

42if (buffer.Length != 0)

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

239while (currentIndex < data.Length); 287int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 342if (currentIndex < data.Length) 373int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 426if (currentIndex < data.Length) 534if (currentIndex < data.Length) 563if (currentIndex < data.Length) 689for (; currentIndex < data.Length; currentIndex++)

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

222if (values.Length == 1) 227if (values.Length == 0) 237int valueLength = separator.Length * (values.Length - 1); 266for (int i = 1; i < values.Length; i++) 281for (int i = 1; i < values.Length; i++)

src\Shared\SegmentWriteStream.cs (1)

143var bytesWritten = Math.Min(buffer.Length, _segmentSize - (int)_bufferStream.Length);

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

93if (_span.Length >= source.Length) 96Advance(source.Length); 138while (source.Length > 0) 145var writable = Math.Min(source.Length, _span.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

229Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length"); 230var settingsCount = data.Length / SettingSize;

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

26var resultString = string.Create(span.Length, span, static (destination, source) => 56return string.Create(span.Length, span, static (destination, source) =>

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

20if (destination.Length < source.Length) 29return DecodeInPlace(destination.Slice(0, source.Length), isFormEncoding); 363return DecodeInPlace(destination.Slice(0, source.Length)); 591if ((uint)tempIdx >= (uint)buffer.Length) 603return (uint)c >= (uint)CharToHexLookup.Length ? -1 : CharToHexLookup[c];

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

169while (buffer.Length > 0)

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

169while (buffer.Length > 0)

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

169while (buffer.Length > 0)

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

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

237totalWritten += segment.Span.Length; 266totalWritten += segment.Span.Length; 319_position += span.Length; 320_bytesWritten += span.Length;

HandshakeHelpers.cs (3)

97if (value.Length == 0) 222if (value.Length == 0) 230if (value[0] == '"' && value.EndsWith("\"".AsSpan()) && value.Length > 1)

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

249if (pos > _chars.Length - value.Length) 251Grow(value.Length); 255_pos += value.Length;

FormPipeReader.cs (14)

164while (span.Length > 0) 175span = span.Slice(keyValuePair.Length + andDelimiter.Length); 176consumed += keyValuePair.Length + andDelimiter.Length; 185if ((uint)span.Length > (uint)KeyLengthLimit + (uint)ValueLengthLimit) 194consumed += keyValuePair.Length; 202if (keyValuePair.Length > KeyLengthLimit) 214if (key.Length > KeyLengthLimit) 219value = keyValuePair.Slice(equals + equalsDelimiter.Length); 220if (value.Length > ValueLengthLimit) 269Debug.Assert(segmentConsumed == keyValuePair.FirstSpan.Length); 388if (readOnlySpan.Length == 0) 398var span = MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(readOnlySpan), readOnlySpan.Length);

HttpResponseStreamWriter.cs (2)

145var remaining = value.Length; 660var remaining = Math.Min(_charBufferSize - _charBufferCount, value.Length);

MultipartBoundary.cs (1)

20FinalBoundaryLength = BoundaryBytes.Length + 2; // Include the final '--' terminator.

MultipartReaderStream.cs (6)

194var length = _boundary.BoundaryBytes.Length; 211var length = _boundary.BoundaryBytes.Length; 275var length = _boundary.BoundaryBytes.Length; 297var length = _boundary.BoundaryBytes.Length; 335matchOffset = Math.Max(segment1.Offset, segment1.Offset + segment1.Count - matchBytes.Length); 343for (matchCount = 0; matchCount < matchBytes.Length && matchCount < countLimit; matchCount++)

src\Shared\QueryStringEnumerable.cs (1)

99var buffer = new char[source.Length];

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

20if (destination.Length < source.Length) 29return DecodeInPlace(destination.Slice(0, source.Length), isFormEncoding); 363return DecodeInPlace(destination.Slice(0, source.Length)); 591if ((uint)tempIdx >= (uint)buffer.Length) 603return (uint)c >= (uint)CharToHexLookup.Length ? -1 : CharToHexLookup[c];

src\Compilers\Core\Portable\InternalUtilities\CommandLineUtilities.cs (6)

67while (i < commandLine.Length) 69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 74if (i == commandLine.Length) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0))) 99} while (i < commandLine.Length && commandLine[i] == '\\'); 102if (i >= commandLine.Length || commandLine[i] != '"')

src\Compilers\Core\Portable\InternalUtilities\CommandLineUtilities.cs (6)

67while (i < commandLine.Length) 69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 74if (i == commandLine.Length) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0))) 99} while (i < commandLine.Length && commandLine[i] == '\\'); 102if (i >= commandLine.Length || commandLine[i] != '"')

CaseInsensitiveComparison.cs (7)

127int len = Math.Min(str1.Length, str2.Length); 138return str1.Length - str2.Length; 176if (str1.Length != str2.Length) 181for (int i = 0; i < str1.Length; i++)

CodeGen\PrivateImplementationDetails.cs (1)

590char[] c = new char[hash.Length * 2];

CommandLine\CommandLineParser.cs (7)

104if (optionName.Length != value.Length) 141arg.Length > 0 && (arg[0] == '/' || arg[0] == '-'); 956while (i < arg.Length) 981Debug.Assert(i < arg.Length); 984while (i < arg.Length && arg[i] == '\\') 990if (i < arg.Length && arg[i] == '"') 1090for (int i = 0; i < span.Length; i++)

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (6)

172if (algorithmId != default(Guid) && checksum.Length > 0) 180documentWriter.SetCheckSum(algorithmId, (uint)checksum.Length, bytes); 198documentWriter.SetSource((uint)source.Length, bytes); 489if (yieldOffsets.Length != resumeOffsets.Length) 496int count = yieldOffsets.Length;

FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

Hashing\XxHash128.cs (1)

135uint length = (uint)source.Length;

Hashing\XxHashShared.cs (12)

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

InternalUtilities\CommandLineUtilities.cs (6)

67while (i < commandLine.Length) 69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 74if (i == commandLine.Length) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0))) 99} while (i < commandLine.Length && commandLine[i] == '\\'); 102if (i >= commandLine.Length || commandLine[i] != '"')

InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

MemoryExtensions.cs (4)

15for (int i = startIndex; i < span.Length; i++) 28for (int i = 0; i < span.Length; i++) 96if (span.Length > 1 && span[0] == '"' && span[span.Length - 1] == '"')

MetadataReader\MetadataHelpers.cs (2)

502int emittedTypeNameLength = emittedTypeName.Length; 535if (aritySpan is { Length: >= 1 and <= 5 } and not ['0', ..])

Operations\ControlFlowGraphBuilder.cs (1)

7818ArrayBuilder<IOperation> statementsBuilder = ArrayBuilder<IOperation>.GetInstance(statements.Length);

PEWriter\MetadataWriter.cs (1)

464_pseudoSymbolTokenToTokenMap = new EntityHandle[referencesInIL.Length];

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

StrongName\CryptoBlobParser.cs (3)

162var w = new BlobWriter(3 * sizeof(uint) + s_offsetToKeyData + pubKeyData.Length); 165w.WriteUInt32((uint)(s_offsetToKeyData + pubKeyData.Length)); 182w.WriteBytes(bytes, pubKeyData.Length);

Symbols\CommonGeneratedNameParser.cs (1)

32for (int i = metadataNameSuffix.Length - 1; i >= -1; i--)

Syntax\SeparatedSyntaxList.cs (4)

22if (nodes.Length == 0) 25if (nodes.Length == 1) 28var builder = new CodeAnalysis.Syntax.SeparatedSyntaxListBuilder<TNode>(nodes.Length); 34for (int i = 1, n = nodes.Length; i < n; i++)

Syntax\SyntaxList`1.cs (4)

23if (nodes.Length == 0) 30switch (nodes.Length) 37var copy = new ArrayElement<GreenNode>[nodes.Length]; 38for (int i = 0, n = nodes.Length; i < n; i++)

Syntax\SyntaxNodeOrTokenList.cs (4)

71if (nodesAndTokens.Length == 0) 82switch (nodesAndTokens.Length) 93var copy = new ArrayElement<GreenNode>[nodesAndTokens.Length]; 94for (int i = 0, n = nodesAndTokens.Length; i < n; i++)

Syntax\SyntaxTokenList.cs (4)

67if (tokens.Length == 0) 75switch (tokens.Length) 84var copy = new ArrayElement<GreenNode>[tokens.Length]; 85for (int i = 0, n = tokens.Length; i < n; i++)

Syntax\SyntaxTriviaList.cs (4)

73if (trivias.Length == 0) 81switch (trivias.Length) 90var copy = new ArrayElement<GreenNode>[trivias.Length]; 91for (int i = 0, n = trivias.Length; i < n; i++)

Syntax\SyntaxTriviaListBuilder.cs (1)

88this.Add(items, 0, items.Length);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Analyzers\Core\Analyzers\DiagnosticCustomTags.cs (2)

64Debug.Assert(customTags.Length == tags.Length); 66for (var i = 0; i < tags.Length; i++)

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (2)

359_formatArguments = new string[formatArguments.Length]; 360for (var i = 0; i < formatArguments.Length; i++)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

CommandLine\CSharpCommandLineParser.cs (2)

1767while (index < valueSpan.Length) 1777if (nextIndex < valueSpan.Length)

CSharpParseOptions.cs (1)

216while (currentIndex < @namespace.Length && @namespace.IndexOf('.', currentIndex) is not -1 and var dotIndex)

Lowering\ExtensionMethodBodyRewriter.cs (1)

59Debug.Assert(symbol.Parameters.Length == rewrittenParameters.Length);

Parser\LanguageParser_InterpolatedString.cs (10)

154if (text.Length == 0) 177while (currentIndex < text.Length) 195var isBlankLine = (currentIndex == text.Length && isLast) || (currentIndex < text.Length && SyntaxFacts.IsNewLine(text[currentIndex])); 222currentIndex = Math.Min(currentIndex, lineStartPosition + indentationWhitespace.Length); 299for (int i = 0, n = Math.Min(currentLineWhitespace.Length, indentationLineWhitespace.Length); i < n; i++) 326while (currentIndex < text.Length && SyntaxFacts.IsWhitespace(text[currentIndex])) 334while (currentIndex < text.Length) 343currentIndex += SlidingTextWindow.GetNewLineWidth(ch, currentIndex + 1 < text.Length ? text[currentIndex + 1] : '\0');

Parser\QuickScanner.cs (1)

204var charPropLength = CharProperties.Length;

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (3)

560if (parameterTypes.Length > 0) 562var paramsBuilder = ArrayBuilder<FunctionPointerParameterSymbol>.GetInstance(parameterTypes.Length); 564for (int i = 0; i < parameterTypes.Length; i++)

Symbols\MemberSignatureComparer.cs (3)

768Debug.Assert(params1.Length == params2.Length); 770var numParams = params1.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (1)

302for (var i = 0; i < names.Length; i++)

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (1)

326for (var i = regexes.Length - 2; i >= 0; i--)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (1)

302for (var i = 0; i < names.Length; i++)

Shared\Extensions\IProjectionBufferFactoryServiceExtensions.cs (1)

245if (exposedLineSpans.Length > 0)

EmbeddedLanguages\StackFrame\StackFrameSyntaxFactory.cs (2)

69var separatedList = parameters.Length == 0 80for (var i = 1; i < parameters.Length; i++)

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (7)

127int len = Math.Min(str1.Length, str2.Length); 138return str1.Length - str2.Length; 176if (str1.Length != str2.Length) 181for (int i = 0; i < str1.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

Common\GlyphExtensions.cs (1)

21using var _ = ArrayBuilder<Glyph>.GetInstance(tags.Length, out var builder);

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Analyzer.cs (3)

103while (current < operations.Length && 115if (operations.Length == 0) 129if (current < operations.Length)

EmbeddedLanguages\RegularExpressions\RegexCharClass.cs (1)

207if ((uint)chDiv8 < (uint)asciiLookup.Length)

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (4)

176while (span.Length > 0) 180if (span.Length == 0) 197end = span.Length; 227source = source.Slice(index + separator.Length);

src\Analyzers\Core\Analyzers\DiagnosticCustomTags.cs (2)

64Debug.Assert(customTags.Length == tags.Length); 66for (var i = 0; i < tags.Length; i++)

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (2)

359_formatArguments = new string[formatArguments.Length]; 360for (var i = 0; i < formatArguments.Length; i++)

EditAndContinue\SourceMarkers.cs (2)

177for (var i = 0; i < span.Length; i++) 190for (var i = span.Length - 1; i >= 0; i--)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

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

82var valueLength = reader.HasValueSequence ? reader.ValueSequence.Length : reader.ValueSpan.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

Assert\AssertEx.cs (6)

368if (expected.Length != actual.Length) 371for (int i = 0; i < expected.Length; i++) 794var expectedString = join(itemSeparator, expected[..Math.Min(expected.Length, maxDisplayedExpectedEntries)], itemInspector); 807if (expected.Length > maxDisplayedExpectedEntries) 817if (TryGenerateExpectedSourceFileAndGetDiffLink(actualString, expected.Length, expectedValueSourcePath, expectedValueSourceLine, out var link))

TestHelpers.cs (2)

157if (input.Length % 2 != 0) 162var bytes = new byte[input.Length >> 1];

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

FindSymbols\FindReferences\Finders\AbstractReferenceFinder_GlobalSuppressions.cs (2)

133if (expectedDocCommentId.Length < docCommentId.Length) 137if (docCommentId.Span[expectedDocCommentId.Length] != '.')

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

Workspace\Solution\Checksum.cs (1)

54if (checksum.Length < HashSize)

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (7)

127int len = Math.Min(str1.Length, str2.Length); 138return str1.Length - str2.Length; 176if (str1.Length != str2.Length) 181for (int i = 0; i < str1.Length; i++)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\CommandLineUtilities.cs (6)

67while (i < commandLine.Length) 69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 74if (i == commandLine.Length) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0))) 99} while (i < commandLine.Length && commandLine[i] == '\\'); 102if (i >= commandLine.Length || commandLine[i] != '"')

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

XxHash128Tests.cs (3)

111ReadOnlySpan<byte> slice = input.Slice(0, rand.Next(0, input.Length) + 1); 113input = input.Slice(slice.Length); 114processed += slice.Length;

Microsoft\CSharp\RuntimeBinder\Semantics\ExpressionBinder.cs (1)

1635Debug.Assert(ek >= ExpressionKind.FirstOp && (ek - ExpressionKind.FirstOp) < (int)EK2NAME.Length);

Computations\Arithmetic.net8.cs (40)

DataFrameColumns\ArrowStringDataFrameColumn.cs (3)

212mutableDataBuffer.IncreaseSize(value.Length); 214mutableOffsetsBuffer.Append(mutableOffsetsBuffer[mutableOffsetsBuffer.Length - 1] + value.Length); 262return Encoding.UTF8.GetString(data, bytes.Length);

DataFrameColumns\StringDataFrameColumn.cs (2)

351for (int i = 0; i < span.Length; i++) 373for (int i = 0; i < span.Length; i++)

DataFrameColumns\VBufferDataFrameColumn.cs (2)

237for (int i = 0; i < span.Length; i++) 259for (int i = 0; i < span.Length; i++)

DateTimeComputation.cs (4)

39for (int i = 0; i < readOnlySpan.Length; i++) 111for (int i = 0; i < readOnlySpan.Length; i++) 203for (int i = 0; i < readOnlySpan.Length; i++) 261for (int i = 0; i < readOnlySpan.Length; i++)

PrimitiveColumnContainer.BinaryOperations.cs (5)

129if (availableInRetSpan < leftSpan.Length) 144index += leftSpan.Length; 171if (availableInRetSpan < leftSpan.Length) 186index += leftSpan.Length; 194for (var i = 0; i < left.Length; i++)

PrimitiveColumnContainer.cs (11)

575for (int i = 0; i < span.Length; i++) 594for (int i = 0; i < span.Length; i++) 613for (int i = 0; i < span.Length; i++) 632for (int i = 0; i < span.Length; i++) 651for (int i = 0; i < span.Length; i++) 670for (int i = 0; i < span.Length; i++) 689for (int i = 0; i < span.Length; i++) 708for (int i = 0; i < span.Length; i++) 727for (int i = 0; i < span.Length; i++) 746for (int i = 0; i < span.Length; i++) 765for (int i = 0; i < span.Length; i++)

PrimitiveDataFrameColumn.cs (2)

370for (int i = 0; i < span.Length; i++) 625for (int i = 0; i < readOnlySpan.Length; i++)

PrimitiveDataFrameColumnComputations.cs (98)

Utils\BitUtility.cs (1)

151Debug.Assert(span.Length >= endByteIndex);

VBufferColumnTests.cs (4)

32Assert.Equal(5, vBufferColumn[0].GetValues().Length); 45Assert.Equal(5, vBufferColumn[0].GetValues().Length); 64Assert.Equal(5, values.Length); 66for (int i = 0; i < values.Length; i++)

Signing.cs (3)

263var w = new BlobWriter(3 * sizeof(uint) + Constants.OffsetToKeyData + pubKeyData.Length); 266w.WriteUInt32((uint)(Constants.OffsetToKeyData + pubKeyData.Length)); 283w.WriteBytes(bytes, pubKeyData.Length);

Helpers.cs (8)

24for (int idx = pos; idx < value.Length; idx++) 45pos = value.Length; 64while ((word = GetNextWord(value, ref pos)).Length != 0) 66for (var i = 0; i < word.Length; i++) 94while ((word = GetNextWord(value, ref pos)).Length != 0) 96for (var i = 0; i < word.Length; i++) 123while ((word = GetNextWord(value, ref pos)).Length != 0) 129for (var i = 0; i < word.Length; i++)

ChatCompletion\DistributedCachingChatClient.cs (2)

145int length = FixedValuesCount + additionalValues.Length + clientValues.Length; 154clientValues.CopyTo(arr, FixedValuesCount + additionalValues.Length);

ChatCompletion\FunctionInvokingChatClient.cs (2)

757var contents = new List<AIContent>(results.Length); 758for (int i = 0; i < results.Length; i++)

Embeddings\DistributedCachingEmbeddingGenerator.cs (2)

116int length = FixedValuesCount + clientValues.Length + values.Length; 123clientValues.CopyTo(arr, FixedValuesCount + values.Length);

Contents\DataUriParser.cs (2)

152if (value!.Length % 4 != 0) 158var index = value.Length - 1;

Embeddings\BinaryEmbedding.cs (3)

64int length = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length; 69BitArray result = new(utf8.Length); 71for (int i = 0; i < utf8.Length; i++)

src\Shared\JsonSchemaExporter\JsonSchemaExporter.cs (1)

561for (int i = 0; i < path.Length; i++)

Utilities\AIJsonUtilities.cs (1)

149var chars = new char[hashData.Length * 2];

AzureAIInferenceEmbeddingGenerator.cs (4)

128if (base64.Length < 2 || base64[0] != (byte)'"' || base64[base64.Length - 1] != (byte)'"') 133base64 = base64.Slice(1, base64.Length - 2); 136byte[] bytes = ArrayPool<byte>.Shared.Rent(Base64.GetMaxDecodedFromUtf8Length(base64.Length));

Common\NGramExtensions.cs (6)

35ReadOnlySpan<T> next = input.Slice(0, Math.Min(n, input.Length)); 37while (next.Length == n) 42next = input.Slice(0, Math.Min(n, input.Length)); 65maxN = input.Length; // Update to use Length instead of Count() 74for (int i = 0; i <= input.Length - minN; i++) 76for (int s = minN; s <= maxN && s <= input.Length - i; s++)

Utilities\JsonOutputFixer.cs (1)

27if (trimmed.Length > markerLength && trimmed.Slice(0, markerLength).SequenceEqual(JsonMarker.AsSpan()))

QuantizationEmbeddingGenerator.cs (3)

50var result = new BitArray(vector.Length); 51for (int i = 0; i < vector.Length; i++) 82var result = new Half[vector.Length];

src\Shared\ServerSentEvents\Helpers.cs (6)

52Span<byte> buffer = writer.GetSpan(value.Length); 53Debug.Assert(value.Length <= buffer.Length); 55writer.Advance(value.Length); 65int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length); 75bytesWritten = Encoding.UTF8.GetBytes(chars, value.Length, bytes, maxByteCount); 122Encoding.UTF8.GetString(ptr, bytes.Length);

src\Shared\ServerSentEvents\SseFormatter.cs (1)

156if (data[i++] == '\r' && i < data.Length && data[i] == '\n')

src\Shared\ServerSentEvents\SseParser_1.cs (7)

125while (FillLineBuffer() != 0 && _lineLength < Utf8Bom.Length); 205while (await FillLineBufferAsync(cancellationToken).ConfigureAwait(false) != 0 && _lineLength < Utf8Bom.Length) ; 392ReadOnlySpan<byte> remainder = _lineBuffer.AsSpan(_newlineIndex + newlineLength, _lineLength - line.Length - newlineLength); 394(remainder[0] is LF || (remainder[0] is CR && remainder.Length > 1))) 396advance = line.Length + newlineLength + (remainder.StartsWith(CRLF) ? 2 : 1); 420_dataLength += fieldValue.Length; 462advance = line.Length + GetNewLineLength();

Internal\HybridCachePayload.cs (3)

193if (bytes.Length < 19) // minimum needed for empty payload and zero tags 298if (bytes.Length != payloadLength + 2 343|| buffer.Length < (length = (int)u64Length)) // note buffer is now past the prefix via "ref"

Redaction\NullRedactor.cs (3)

20public override int GetRedactedLength(ReadOnlySpan<char> input) => input.Length; 28Throw.IfBufferTooSmall(destination.Length, source.Length, nameof(destination)); 31return source.Length;

Redaction\Redactor.cs (1)

251var fmt = format.Length > 0 ? format.ToString() : string.Empty;

Redaction\RedactorTest.cs (2)

331public override int GetRedactedLength(ReadOnlySpan<char> input) => input.Length; 336return source.Length;

FakePlaintextRedactor.cs (2)

10public override int GetRedactedLength(ReadOnlySpan<char> input) => input.Length; 15return source.Length;

DependencyContextJsonReader.cs (6)

66long expectedLength = Math.Max(utf8Bom.Length, stream.Length - stream.Position) + 1; 81Debug.Assert(rented.Length >= utf8Bom.Length); 86utf8Bom.Length - written); 89} while (lastRead > 0 && written < utf8Bom.Length); 92if (written == utf8Bom.Length && 93utf8Bom.SequenceEqual(rented.AsSpan(0, utf8Bom.Length)))

Linux\LinuxUtilizationParserCgroupV1.cs (12)

137stat = stat.Slice(StartingTokens.Length, stat.Length - StartingTokens.Length); 224ReadOnlySpan<char> inactiveMemorySlice = memoryFile.Slice(index + TotalInactiveFile.Length, memoryFile.Length - index - TotalInactiveFile.Length); 274ReadOnlySpan<char> totalMemory = firstLine.Slice(MemTotal.Length, firstLine.Length - MemTotal.Length); 283if (next == -1 || totalMemory.Length - next < 2) 288ReadOnlySpan<char> unit = totalMemory.Slice(totalMemory.Length - 2, 2); 383while (numberStart < buffer.Length && char.IsWhiteSpace(buffer[numberStart])) 388if (numberStart == buffer.Length || !char.IsDigit(buffer[numberStart])) 397while (numberEnd < buffer.Length && char.IsDigit(buffer[numberEnd])) 405return numberEnd < buffer.Length ? numberEnd : -1; 415if (quotaBuffer.IsEmpty || (quotaBuffer.Length == 2 && quotaBuffer[0] == '-' && quotaBuffer[1] == '1')) 433if (periodBuffer.IsEmpty || (periodBuffer.Length == 2 && periodBuffer[0] == '-' && periodBuffer[1] == '1')) 471if (cpuPodWeightBuffer.IsEmpty || (cpuPodWeightBuffer.Length == 2 && cpuPodWeightBuffer[0] == '-' && cpuPodWeightBuffer[1] == '1'))

Linux\LinuxUtilizationParserCgroupV2.cs (14)

128if (colonIndex == -1 || colonIndex + 1 >= fileContent.Length) 181stat = stat.Slice(StartingTokens.Length, stat.Length - StartingTokens.Length); 373ReadOnlySpan<char> inactiveMemorySlice = memoryFile.Slice(index + InactiveFile.Length, memoryFile.Length - index - InactiveFile.Length); 419ReadOnlySpan<char> totalMemory = firstLine.Slice(MemTotal.Length, firstLine.Length - MemTotal.Length); 428if (next == -1 || totalMemory.Length - next < 2) 433ReadOnlySpan<char> unit = totalMemory.Slice(totalMemory.Length - 2, 2); 573while (numberStart < buffer.Length && char.IsWhiteSpace(buffer[numberStart])) 578if (numberStart == buffer.Length || !char.IsDigit(buffer[numberStart])) 587while (numberEnd < buffer.Length && char.IsDigit(buffer[numberEnd])) 595return numberEnd < buffer.Length ? numberEnd : -1; 633if (quotaBuffer.IsEmpty || (quotaBuffer.Length == 2 && quotaBuffer[0] == '-' && quotaBuffer[1] == '1')) 654ReadOnlySpan<char> cpuPeriodSlice = quotaBuffer.Slice(index + quotaString.Length, quotaBuffer.Length - index - quotaString.Length); 695else if (content.Length >= 2 && content[0] == '-' && content[1] == '1') 766if (cpuPodWeightBuffer.IsEmpty || (cpuPodWeightBuffer.Length == 2 && cpuPodWeightBuffer[0] == '-' && cpuPodWeightBuffer[1] == '1'))

Http\DownstreamDependencyMetadataManager.cs (8)

112if (routeSpan.Length > 1 && routeSpan[routeSpan.Length - 1] == '/') 114routeSpan = routeSpan.Slice(0, routeSpan.Length - 1); 125else if (routeSpan.Length != route.Length) 366if (requestRouteAsSpan.Length > 1) 368if (requestRouteAsSpan[requestRouteAsSpan.Length - 1] == '/') 370requestRouteAsSpan = requestRouteAsSpan.Slice(0, requestRouteAsSpan.Length - 1); 381var requestPathEndIndex = requestRouteAsSpan.Length;

Latency\Internal\HttpClientLatencyLogEnricher.cs (2)

70for (int i = 0; i < latencyData.Checkpoints.Length; i++) 77for (int i = 0; i < latencyData.Checkpoints.Length; i++)

Base32.cs (2)

78if (trimmedInput.Length == 0) 83var output = new byte[trimmedInput.Length * 5 / 8];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

AnsiParser.cs (3)

56for (int i = 0; i < span.Length; i++) 58if (span[i] == EscapeChar && span.Length >= i + 4 && span[i + 1] == '[') 78else if (span.Length >= i + 5 && span[i + 4] == 'm')

JsonConsoleFormatter.cs (1)

106var logMessageBuffer = ArrayPool<char>.Shared.Rent(Encoding.UTF8.GetMaxCharCount(messageBytes.Length));

LoggerMessageGenerator.Emitter.cs (1)

634=> variableOrTemplateName.Length > 0 && variableOrTemplateName[0] == '@';

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

StringSegment.cs (2)

596for (i = 0; i < span.Length; i++) 616for (i = span.Length - 1; i >= 0; i--)

Resolver\DnsDataWriter.cs (2)

112if (_buffer.Length - _position < value.Length) 118_position += value.Length;

Resolver\DnsPrimitives.cs (1)

19if (buffer.Length < DnsMessageHeader.HeaderLength)

Fuzzers\DnsResponseFuzzer.cs (1)

37_length = data.Length;

Fuzzers\EncodedDomainNameFuzzer.cs (3)

10byte[] buffer = ArrayPool<byte>.Shared.Rent(data.Length); 16for (int i = 0; i < data.Length; i++) 18if (!DnsPrimitives.TryReadQName(buffer.AsMemory(0, data.Length), i, out EncodedDomainName name, out _))

Fuzzers\WriteDomainNameRoundTripFuzzer.cs (1)

16byte[] buffer = ArrayPool<byte>.Shared.Rent(data.Length * 2);

Http\HttpRouteFormatter.cs (2)

75if (startIndex >= httpPathAsSpan.Length) 93length = httpPathAsSpan.Slice(startIndex).Length;

Http\HttpRouteParser.cs (2)

68if (startIndex < httpPathAsSpan.Length) 77length = httpPathAsSpan.Slice(startIndex).Length;

Latency\Internal\LatencyConsoleExporter.cs (12)

55latencyData.Checkpoints.Length, 56latencyData.Tags.Length, 57latencyData.Measures.Length); 60if (_outputCheckpoints && latencyData.Checkpoints.Length > 0) 63for (int i = 0; i < latencyData.Checkpoints.Length; i++) 69for (int i = 0; i < latencyData.Checkpoints.Length; i++) 76if (_outputTags && latencyData.Tags.Length > 0) 79for (int i = 0; i < latencyData.Tags.Length; i++) 85for (int i = 0; i < latencyData.Tags.Length; i++) 92if (_outputMeasures && latencyData.Measures.Length > 0) 95for (int i = 0; i < latencyData.Measures.Length; i++) 101for (int i = 0; i < latencyData.Measures.Length; i++)

Logging\JustInTimeRedactor.cs (3)

114inputAsSpan = f.ToString(format.Length > 0 ? format.ToString() : string.Empty, formatProvider).AsSpan(); 128int maxLenToRedact = inputAsSpan.Length + DiscriminatorSeparator.Length + _discriminator.Length + MaxDayOfYearLength; 136charsInWorkBuffer = inputAsSpan.Length;

Latency\LatencyDataTests.cs (9)

15Assert.True(ld.Checkpoints.Length == 0); 16Assert.True(ld.Measures.Length == 0); 17Assert.True(ld.Tags.Length == 0); 31Assert.True(ld.Checkpoints.Length == num); 32Assert.True(ld.Measures.Length == num); 33Assert.True(ld.Tags.Length == num); 50Assert.True(ld.Checkpoints.Length == numCheckpoints); 51Assert.True(ld.Measures.Length == numMeasures); 52Assert.True(ld.Tags.Length == numTags);

Latency\NoopLatencyContextTests.cs (3)

73Assert.True(latencyData.Checkpoints.Length == 0); 74Assert.True(latencyData.Measures.Length == 0); 75Assert.True(latencyData.Tags.Length == 0);

Latency\Internal\LatencyContextProviderTests.cs (6)

60Assert.True(lc.LatencyData.Checkpoints.Length == 1); 61Assert.True(lc.LatencyData.Measures.Length == 1); 62Assert.True(lc.LatencyData.Tags.Length == 1); 91Assert.True(lc.LatencyData.Checkpoints.Length == 1); 92Assert.True(lc.LatencyData.Measures.Length == 1); 93Assert.True(lc.LatencyData.Tags.Length == 1);

Latency\Internal\TagCollectionTests.cs (1)

104for (int i = 0; i < tags.Length; i++)

src\Generators\Shared\RoslynExtensions.cs (2)

109switch (span.Length) 122var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\Generators\Shared\RoslynExtensions.cs (2)

109switch (span.Length) 122var builder = ImmutableArray.CreateBuilder<T>(span.Length);

ComInterfaceGenerator.cs (2)

865var literals = new CollectionElementSyntax[bytes.Length]; 867for (int i = 0; i < bytes.Length; i++)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\Components\Shared\src\ArrayBuilder.cs (2)

87var requiredCapacity = _itemsInUse + source.Length; 101_itemsInUse += source.Length;

Debugger\DebuggerDisplayHelpers.cs (1)

37 var size = values.Length;

Types\Shared\WebUtils.shared.cs (2)

61 var chars = new char[span.Length]; 63 for (int i = 0; i < span.Length; i++)

Color.cs (14)

353 if (colorAsHex.Length == 6 || colorAsHex.Length == 3) 359 else if (colorAsHex.Length == 4) 375 else if (colorAsHex.Length == 8) 403 if (colorAsHex.Length == 6) 410 else if (colorAsHex.Length == 3) 423 else if (colorAsHex.Length == 4) 439 else if (colorAsHex.Length == 8) 758 Span<char> loweredValue = value.Length <= 128 ? stackalloc char[value.Length] : new char[value.Length]; 761 Debug.Assert(charsWritten == value.Length); 1000 if (!elem.IsEmpty && elem[elem.Length - 1] == '%' && acceptPercent) 1003 elem = elem.Slice(0, elem.Length - 1);

Data\AnnotationUtils.cs (1)

400for (int i = 0; i < catIndicesValues.Length; i += 2)

Data\ReadOnlyMemoryUtils.cs (3)

221for (j = min; j < span.Length; j++) 231Contracts.Assert(j == span.Length); 252sb.Append(valueChars, span.Length);

Utilities\ArrayUtils.cs (1)

51Debug.Assert(0 <= min && min <= lim && lim <= input.Length);

Utilities\BigArray.cs (6)

329LongLimToMajorMaxMinorLim(_length + src.Length, out maMax, out miLim); 337Contracts.Assert(miLim - miMin == src.Length); 343Contracts.Assert((BlockSize - miMin) + miLim == src.Length); 366Contracts.Assert(srcSoFar < src.Length); 369Contracts.Assert(src.Length - srcSoFar == miLim); 375_length += src.Length;

Utilities\DoubleParser.cs (30)

113if (ich >= span.Length) 127if (span.Length - ich == 1) 143if (!DoubleParser.TryParse(span.Slice(ich, span.Length - ich), out value, out ichEnd, flags)) 150while (ichEnd < span.Length) 165if (ich >= span.Length) 179if (span.Length - ich == 1) 195if (!DoubleParser.TryParse(span.Slice(ich, span.Length - ich), out value, out ichEnd, flags)) 202while (ichEnd < span.Length) 494if (ich < span.Length) 505if (ich + 3 <= span.Length && span[ich + 1] == 'a' && span[ich + 2] == 'N') 514if (ich + 8 <= span.Length && span[ich + 1] == 'n' && span[ich + 2] == 'f' && span[ich + 3] == 'i' && span[ich + 4] == 'n' && span[ich + 5] == 'i' && span[ich + 6] == 't' && span[ich + 7] == 'y') 523if (ich + 2 <= span.Length && span[ich + 1] == InfinitySymbol) 530if (ich + 9 <= span.Length && span[ich + 1] == 'I' && span[ich + 2] == 'n' && span[ich + 3] == 'f' && span[ich + 4] == 'i' && span[ich + 5] == 'n' && span[ich + 6] == 'i' && span[ich + 7] == 't' && span[ich + 8] == 'y') 551Contracts.Assert(0 <= ich && ich <= span.Length); 562if (ich >= span.Length) 579if (++i >= span.Length) 585if (++i >= span.Length) 616Contracts.Assert(i < span.Length); 626if (++i >= span.Length) 632Contracts.Assert(i < span.Length); 638Contracts.Assert(i < span.Length); 644if (++i >= span.Length) 651Contracts.Assert(i < span.Length); 664Contracts.Assert(i < span.Length); 679if (++i >= span.Length) 686Contracts.Assert(i < span.Length); 690if (++i >= span.Length) 695if (++i >= span.Length) 711Contracts.Assert(i < span.Length); 718if (++i >= span.Length)

Utilities\FloatUtils.cs (2)

447for (int i = 0; i < values.Length; i++) 460for (int i = 0; i < values.Length; i++)

Utilities\Hashing.cs (2)

126for (int ich = 0; ich < span.Length; ich++) 192for (int ich = 0; ich < span.Length; ich++)

Utilities\LineParser.cs (3)

27for (int i = 0; i <= valuesToParse.Length; i++) 29if (i == valuesToParse.Length || valuesToParse[i] == ' ' || valuesToParse[i] == '\t') 61for (int i = 0; i < valuesToParse.Length; i++)

Utilities\MathUtils.cs (7)

150for (int i = a.Length - 1; i >= 0; i--) 179for (int i = a.Length - 1; i >= 0; i--) 207for (int i = 0; i < inputs.Length; i++) 219if (inputs.Length == 1) 225for (int i = 0; i < inputs.Length; i++) 739Contracts.Assert(aIdx >= 0 && aIdx <= a.Length - len); 740Contracts.Assert(bIdx >= 0 && bIdx <= b.Length - len);

Utilities\Stream.cs (19)

Utilities\Utils.cs (5)

678if (values.Length < 1) 684for (int i = 1; i < values.Length; i++) 700Contracts.Check(values.Length >= len); 1272for (int i = 0; i < source.Length; i++) 1284for (int i = 0; i < source.Length; i++)

Utilities\VBufferUtils.cs (104)

UnitTests\TestEntryPoints.cs (5)

4505Assert.Equal(5, treeValues.GetValues().Length); 4507Assert.Equal(5, leafIndicators.GetValues().Length); 4551Assert.Equal(150, feat.GetValues().Length); 5411for (int i = 0; i < slotNameValues.Length; i++) 6113for (int i = 0; i < avgValues.Length; i++)

UnitTests\TestVBuffer.cs (34)

AlignedArray.cs (5)

128Contracts.Assert(src.Length <= _size); 134Contracts.Assert(0 <= start && start <= _size - src.Length); 144Contracts.Assert(rgposSrc.Length <= valuesSrc.Length); 145Contracts.Assert(0 <= iposMin && iposMin <= iposLim && iposLim <= rgposSrc.Length);

AvxIntrinsics.cs (25)

CpuMathUtils.cs (9)

53Contracts.Assert(count <= source.Length); 72Contracts.Assert(count <= source.Length); 93Contracts.Assert(count <= source.Length); 94Contracts.Assert(count <= destination.Length); 112Contracts.Assert(count <= source.Length); 132Contracts.Assert(count <= left.Length); 133Contracts.Assert(count <= right.Length); 191Contracts.Assert(left.Length >= count); 192Contracts.Assert(right.Length >= count);

CpuMathUtils.netcoreapp.cs (21)

SseIntrinsics.cs (25)

Commands\ShowSchemaCommand.cs (1)

280itw.Write(": Length={0}, Count={0}", value.Length, value.GetValues().Length);

Data\BufferBuilder.cs (1)

398int count = values.Length;

Data\Conversion.cs (10)

771private bool HasNA(in VBuffer<R4> src) { var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (R4.IsNaN(srcValues[i])) return true; } return false; } 772private bool HasNA(in VBuffer<R8> src) { var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (R8.IsNaN(srcValues[i])) return true; } return false; } 795private bool HasZero(in VBuffer<U1> src) { if (!src.IsDense) return true; var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (srcValues[i] == 0) return true; } return false; } 796private bool HasZero(in VBuffer<U2> src) { if (!src.IsDense) return true; var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (srcValues[i] == 0) return true; } return false; } 797private bool HasZero(in VBuffer<U4> src) { if (!src.IsDense) return true; var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (srcValues[i] == 0) return true; } return false; } 798private bool HasZero(in VBuffer<U8> src) { if (!src.IsDense) return true; var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (srcValues[i] == 0) return true; } return false; } 1106switch (span.Length) 1187while (ich < span.Length) 1295while (ich < span.Length) 1341if (span.Length == 1 || !TryParseCore(span.Slice(1), out val) || (val > ((ulong)max + 1)))

Data\RowCursorUtils.cs (1)

279int count = srcValues.Length;

DataLoadSave\Binary\Codecs.cs (5)

53for (int i = 0; i < values.Length; ++i) 204int count = values.Length; 926_counts.Add(valueValues.Length); 927if (valueValues.Length > 0) 930for (int i = 0; i < valueIndices.Length; i++)

DataLoadSave\Text\TextSaver.cs (5)

182for (int i = 0; i < srcValues.Length; i++) 191for (int i = 0; i < srcValues.Length; i++) 204if (slotNamesValues.Length == 0) 208for (int i = 0; i < slotNamesValues.Length; i++) 814int ichLim = span.Length;

DataView\Transposer.cs (6)

585if (ii < rbuffIndices.Length && rbuffIndices[ii] == s) 609if (rbuff.GetValues().Length > 0) 629if (++ii < rbuffValues.Length) // Still more stuff. Add another followup item to the heap. 643countSum += _rbuff[irbuff].GetValues().Length; 1233if (indices.Length == 0) 1248while (ii < indices.Length && indices[ii] < lim)

Deprecated\Instances\HeaderSchema.cs (4)

170for (int i = 0; i < nameValues.Length; i++) 176ctx.Writer.Write(nameValues.Length); 177for (int ii = 0; ii < nameIndices.Length; ii++) 179for (int ii = 0; ii < nameValues.Length; ii++)

Deprecated\Vector\VBufferMathUtils.cs (39)

22if (aValues.Length == 0) 51if (aValues.Length == 0) 63if (aValues.Length == 0) 74if (aValues.Length == 0) 86if (c == 1 || dst.GetValues().Length == 0) 104int count = srcValues.Length; 144if (srcValues.Length == 0) 153CpuMathUtils.Add(srcValues, src.GetIndices(), editor.Values, srcValues.Length); 172if (srcValues.Length == 0 || c == 0) 181CpuMathUtils.AddScale(c, srcValues, src.GetIndices(), editor.Values, srcValues.Length); 198if (srcValues.Length == 0 || c == 0) 226if (c == 0 || b.GetValues().Length == 0) 228else if (a.GetValues().Length == 0) 246if (srcValues.Length == 0 || c == 0) 256CpuMathUtils.AddScale(c, srcValues, values, srcValues.Length); 258CpuMathUtils.AddScale(c, srcValues, src.GetIndices(), values, srcValues.Length); 268int dMin = dstIndices.Length == 0 ? 0 : dstIndices.FindIndexSorted(0, dstIndices.Length, offset); 269int dLim = dstIndices.Length == 0 ? 0 : dstIndices.FindIndexSorted(dMin, dstIndices.Length, offset + src.Length); 277gapCount = srcValues.Length; 279for (int iS = 0, iD = dMin; iS < srcIndices.Length && iD < dLim;) 298dstValues.Length + gapCount, 306if (dstValues.Length != dLim) 308Contracts.Assert(dLim < dstValues.Length); 309indices.Slice(dLim, dstValues.Length - dLim) 311values.Slice(dLim, dstValues.Length - dLim) 340int iS = srcIndices.Length - 1; 387else if (src.GetValues().Length == 0 || c == 0) 413if (srcValues.Length == 0) 418Contracts.Assert(-1 <= ind && ind < srcValues.Length); 437while (ind < srcIndices.Length && srcIndices[ind] == ind) 439Contracts.Assert(ind <= srcIndices.Length); 440Contracts.Assert(ind == srcIndices.Length || ind < srcIndices[ind]); 449if (srcValues.Length == 0) 454Contracts.Assert(-1 <= ind && ind < srcValues.Length); 473while (ind < srcIndices.Length && srcIndices[ind] == ind) 475Contracts.Assert(ind <= srcIndices.Length); 476Contracts.Assert(ind == srcIndices.Length || ind < srcIndices[ind]);

Deprecated\Vector\VectorUtils.cs (36)

34if (bValues.Length == 0) 38return CpuMathUtils.DotProductSparse(a, bValues, b.GetIndices(), bValues.Length); 47if (aValues.Length == 0 || bValues.Length == 0) 54return CpuMathUtils.DotProductSparse(aValues, bValues, b.GetIndices(), bValues.Length); 58return CpuMathUtils.DotProductSparse(bValues, aValues, a.GetIndices(), aValues.Length); 59return DotProductSparse(aValues, a.GetIndices(), 0, aValues.Length, bValues, b.GetIndices(), 0, bValues.Length); 83for (int i = 0; i < aValues.Length; i++) 175Contracts.Assert(valuesA.Length == indicesA.Length); 176Contracts.Assert(valuesB.Length == indicesB.Length); 182while (ia < indicesA.Length && ib < indicesB.Length) 205while (ia < indicesA.Length) 212while (ib < indicesB.Length) 225if (valuesB.Length == 0) 228var dotP = CpuMathUtils.DotProductSparse(valuesA, valuesB, indicesB, valuesB.Length); 235Contracts.Assert(0 <= length && length <= valuesA.Length); 236Contracts.Assert(0 <= length && length <= valuesB.Length); 258if (aValues.Length == 0 || bValues.Length == 0) 264return CpuMathUtils.DotProductSparse(aValues.Slice(offset), bValues, b.GetIndices(), bValues.Length); 270int aMin = Utils.FindIndexSorted(aIndices, 0, aIndices.Length, offset); 271int aLim = Utils.FindIndexSorted(aIndices, 0, aIndices.Length, offset + b.Length); 279for (int iA = aMin, iB = 0; iA < aLim && iB < bIndices.Length;) 309if (bValues.Length == 0) 314return CpuMathUtils.DotProductSparse(a.AsSpan(offset), bValues, b.GetIndices(), bValues.Length); 323Contracts.Assert(0 <= ia && ia < iaLim && iaLim <= aIndices.Length); 324Contracts.Assert(0 <= ib && ib < ibLim && ibLim <= bIndices.Length); 447if (srcValues.Length == 0 || c == 0) 451CpuMathUtils.AddScale(c, srcValues, dst, srcValues.Length); 455for (int i = 0; i < srcValues.Length; i++) 475if (srcValues.Length == 0 || c == 0) 486for (int i = 0; i < srcValues.Length; i++)

Evaluators\EvaluatorUtils.cs (3)

698srcValues.Length); 712for (int j = 0; j < srcValues.Length; j++) 1452for (int i = 0; i < values.Length; i++)

Evaluators\MultiOutputRegressionEvaluator.cs (2)

251Contracts.Assert(score.Length >= length); 252Contracts.Assert(label.Length >= length);

Evaluators\QuantileRegressionEvaluator.cs (5)

149for (int i = 0; i < scoreValues.Length; i++) 161for (int i = 0; i < scoreValues.Length; i++) 180for (int i = 0; i < lossValues.Length; i++) 187for (int i = 0; i < lossValues.Length; i++) 199for (int i = 0; i < srcValues.Length; i++)

Transforms\ColumnConcatenatingTransformer.cs (4)

723dstCount = checked(dstCount + tmpBufs[i].GetValues().Length); 746Contracts.Assert(bufferValues.Length <= dstCount - count); 750for (int i = 0; i < bufferValues.Length; i++) 759for (int i = 0; i < bufferValues.Length; i++)

Transforms\Hashing.cs (29)

Transforms\InvertHashUtils.cs (1)

419writer.WriteLine("# Number of terms = {0} of length {1}", v.GetValues().Length, v.Length);

Transforms\KeyToValue.cs (3)

348if (0 < uintSrc && uintSrc <= values.Length) 390int srcCount = srcValues.Length; 479for (int i = 0; i < keyValues.Length; ++i)

Transforms\KeyToVector.cs (2)

531int count = values.Length; 576int cntSrc = values.Length;

Transforms\NormalizeColumn.cs (1)

944for (int i = 0; i < values.Length; i++)

Transforms\NormalizeColumnDbl.cs (52)

Transforms\NormalizeColumnSng.cs (9)

359var count = values.Length; 471var count = values.Length; 985int count = values.Length; 1016int count = values.Length; 1062int count = values.Length; 1262int count = values.Length; 1288for (int ii = 0; ii < indices.Length; ii++) 1474int count = values.Length; 2100int count = values.Length;

Transforms\ValueMapping.cs (1)

924for (int ich = 0; ich < values.Length; ich++)

Transforms\ValueToKeyMappingTransformerImpl.cs (7)

401for (int i = 0; i < values.Length; ++i) 419for (int i = 0; i < values.Length; ++i) 793for (int i = 0; i < srcValues.Length; ++i) 965int count = values.Length; 1014int nextExplicitSlot = indices.Length == 0 ? src.Length : indices[0]; 1021_host.Assert(islot < values.Length); 1025nextExplicitSlot = ++islot == indices.Length ? src.Length : indices[islot];

Utilities\SlotDropper.cs (2)

153var newCount = Math.Min(srcValues.Length, newLength); 173while (iiSrc < srcValues.Length)

src\Microsoft.ML.Core\Utilities\ArrayUtils.cs (1)

51Debug.Assert(0 <= min && min <= lim && lim <= input.Length);

VBuffer.cs (4)

53/// Note that if this vector <see cref="IsDense"/>, then this will be the same as the <see cref="ReadOnlySpan{T}.Length"/> 55/// this is a sparse representation, then that <see cref="ReadOnlySpan{T}.Length"/> will be somewhat shorter, as this 61/// The explicitly represented values. When this <see cref="IsDense"/>, the <see cref="ReadOnlySpan{T}.Length"/> 364/// items, which is to say, the <see cref="ReadOnlySpan{Int32}.Length"/> of the return value of <see cref="GetIndices"/>.

EnsembleUtils.cs (3)

60for (int i = 0; i < srcValues.Length; i++) 69for (int i = 0; i < srcValues.Length; i++) 90for (int i = 0; i < srcValues.Length; i++)

FeatureCombiner.cs (1)

133for (int i = 0; i < metadataValues.Length; i++)

BinFile\BinFinder.cs (2)

57var explicitValuesCount = explicitValues.Length; 232var valuesCount = values.GetValues().Length;

FastTree.cs (12)

1010Contracts.Assert(values.Length == indices.Length); 1013for (int i = 0; i < values.Length; ++i) 1210else if (!values.IsDense && zeroBin == 0 && valuesValues.Length < (1 - sparsifyThreshold) * values.Length) 1231for (int i = 0; i < valuesValues.Length; ++i) 1237firstBinCount += values.Length - valuesValues.Length; 1241for (int i = 0; i < valuesValues.Length; i++) 1311var editor = VBufferEditor.Create(ref dst, src.Length, srcValues.Length); 1312if (srcValues.Length > 0) 1318for (int i = 0; i < srcValues.Length; ++i) 1508for (int index = 0; index < doubleTempValues.Length; ++index) 1591for (int i = 0; i < tempValues.Length; ++i)

GamModelParameters.cs (4)

211for (int i = 0; i < featuresValues.Length; ++i) 222for (int i = 0; i < featuresValues.Length; ++i) 242for (int i = 0; i < featuresValues.Length; ++i) 256for (int i = 0; i < featuresValues.Length; ++i)

TreeEnsemble\InternalRegressionTree.cs (3)

918Contracts.Assert(featIndices.Length == featValues.Length); 922int count = featValues.Length;

Utils\LinqExtensions.cs (2)

28if (span.Length == 0) 31for (int i = 1; i < span.Length; i++)

MLImage.cs (1)

98if (imagePixelData.Length != width * height * 4)

VectorToImageTransform.cs (1)

359if (src.GetValues().Length == 0)

KMeansModelParameters.cs (3)

189for (int j = 0; j < values.Length; j++) 196else if (values.Length > 0) 245writer.Write(values.Length);

OlsLinearRegression.cs (2)

916for (int i = 0; i < coeffs.Length; i++) 931for (int i = 0; i < coeffs.Length; i++)

SymSgdClassificationTrainer.cs (1)

426var instArrayLength = instArray.Length;

VectorWhitening.cs (2)

683int count = values.Length; 711Contracts.Assert(count <= indices.Length);

OnnxUtils.cs (2)

563string[] stringData = new string[data.Length]; 564for (int i = 0; i < data.Length; i++)

PcaTransformer.cs (1)

439if (FloatUtils.IsFinite(weight) && weight >= 0 && (featureValues.Length == 0 || FloatUtils.IsFinite(featureValues)))

TestTransposer.cs (1)

47for (int i = 0; i < tempValues.Length; ++i)

Dynamic\Transforms\Conversion\Hash.cs (1)

86for (int i = 0; i < indices.Length; i++)

Dynamic\Transforms\Conversion\HashWithOptions.cs (1)

100for (int i = 0; i < indices.Length; i++)

Dynamic\Transforms\ImageAnalytics\ConvertToGrayScaleInMemory.cs (1)

60for (int i = 0; i < imageData.Length; i += pixelSize)

Optimizer\SgdOptimizer.cs (9)

408for (int i = 0; i < xValues.Length; i++) 418for (int ii = 0; ii < xValues.Length; ii++) 431while (j < xprevValues.Length) 441for (int jj = 0; jj < xprevValues.Length; jj++) 454while (i < xValues.Length) 467while (ii < xValues.Length && jj < xprevValues.Length) 488while (ii < xValues.Length) 494while (jj < xprevValues.Length)

Standard\LinearPredictorUtils.cs (2)

53if (featureNames.GetValues().Length > 0) 120inputBuilder.AppendLine("Name=" + (featureNames.GetValues().Length == 0 ? "Feature_" + idx : name.IsEmpty ? $"f{idx}" : name.ToString()));

Standard\LogisticRegression\LbfgsPredictorBase.cs (1)

777for (int i = BiasCount; i < values.Length; i++)

Standard\LogisticRegression\LogisticRegression.cs (1)

293for (int i = 1; i < currentWeightsValues.Length; i++)

Standard\LogisticRegression\MulticlassLogisticRegression.cs (5)

698for (int i = 0; i < fwValues.Length; i++) 711count += fwIndices.Length; 726for (int i = 0; i < fwValues.Length; i++) 738count += fwValues.Length; 759for (int i = 0; i < values.Length; i++)

Standard\ModelStatistics.cs (1)

320Env.Assert(coeffStdErrorValues.Length == ParametersCount);

Standard\MulticlassClassification\MulticlassNaiveBayesTrainer.cs (2)

614for (int iFeature = 0; iFeature < srcValues.Length; iFeature += 1) 622for (int iFeature = 0; iFeature < srcValues.Length; iFeature += 1)

Standard\Online\LinearSvm.cs (2)

193if (_weightsUpdate.GetValues().Length == 0) 206Contracts.Assert(_weightsUpdate.GetValues().Length == 0);

Standard\SdcaBinary.cs (3)

880CpuMathUtils.SdcaL1UpdateDense(primalUpdate, featureValues.Length, featureValues, l1Threshold, l1IntermediateWeightsEditor.Values, weightsEditor.Values); 881else if (featureValues.Length > 0) 882CpuMathUtils.SdcaL1UpdateSparse(primalUpdate, featureValues.Length, featureValues, features.GetIndices(), l1Threshold, l1IntermediateWeightsEditor.Values, weightsEditor.Values);

Standard\SdcaMulticlass.cs (6)

298CpuMathUtils.SdcaL1UpdateDense(-primalUpdate, featureValues.Length, featureValues, l1Threshold, l1IntermediateWeightsEditor.Values, weightsEditor.Values); 299else if (featureValues.Length > 0) 300CpuMathUtils.SdcaL1UpdateSparse(-primalUpdate, featureValues.Length, featureValues, features.GetIndices(), l1Threshold, l1IntermediateWeightsEditor.Values, weightsEditor.Values); 329CpuMathUtils.SdcaL1UpdateDense(labelPrimalUpdate, featureValues.Length, featureValues, l1Threshold, l1IntermediateWeightsEditor.Values, weightsEditor.Values); 330else if (featureValues.Length > 0) 331CpuMathUtils.SdcaL1UpdateSparse(labelPrimalUpdate, featureValues.Length, featureValues, features.GetIndices(), l1Threshold, l1IntermediateWeightsEditor.Values, weightsEditor.Values);

TensorflowTests.cs (16)

320Assert.Equal(sample.OneDim.Length, oneDimValues.Length); 324Assert.Equal(sample.TwoDim.Length, twoDimValues.Length); 328Assert.Equal(sample.ThreeDim.Length, threeDimValues.Length); 332Assert.Equal(sample.FourDim.Length, fourDimValues.Length); 336Assert.Equal(sample.FourDimKnown.Length, fourDimKnownValues.Length); 461Assert.Equal(2, f64Values.Length); 464Assert.Equal(2, f32Values.Length); 467Assert.Equal(2, i64Values.Length); 470Assert.Equal(2, i32Values.Length); 473Assert.Equal(2, i16Values.Length); 476Assert.Equal(2, i8Values.Length); 479Assert.Equal(2, u64Values.Length); 482Assert.Equal(2, u32Values.Length); 485Assert.Equal(2, u16Values.Length); 488Assert.Equal(2, u8Values.Length); 491Assert.Equal(2, bValues.Length);

DataPipe\TestDataPipe.cs (1)

930TestCommon.CompareVec(in buffer, in expected[index++], buffer.GetValues().Length, (s1, s2) => s1.Span.SequenceEqual(s2.Span));

TestSparseDataView.cs (2)

60Assert.True(value.GetValues().Length == 3); 100Assert.True(value.GetValues().Length == 3);

TestCommon.cs (2)

164int iv1 = v1.IsDense ? iiv1 : iiv1 < v1Indices.Length ? v1Indices[iiv1] : v1.Length; 165int iv2 = v2.IsDense ? iiv2 : iiv2 < v2Indices.Length ? v2Indices[iiv2] : v2.Length;

ImagesTests.cs (13)

SvmLightTests.cs (2)

334Assert.True(features.GetValues().Length == 1); 335Assert.True(features.GetIndices().Length == 1);

TermEstimatorTests.cs (1)

149Assert.True(names1.GetValues().Length > 0);

AdaptiveSingularSpectrumSequenceModeler.cs (2)

1507var horizon = meanForecast.Length; 1509Contracts.Check(sdForecast.Length >= horizon, "The forecast standard deviation values are not available.");

Model\BPETokenizer.cs (41)

856span = span.Slice(0, span.Length - EndOfWordSuffix.Length); 953sSpan = sSpan.Slice(0, sSpan.Length - EndOfWordSuffix!.Length); 960if (sSpan.Length > buffer.Length) 967charsWritten += sSpan.Length; 968buffer = buffer.Slice(sSpan.Length); 1013if (specialTokenSpan.Length > buffer.Length) 1019buffer = buffer.Slice(specialTokenSpan.Length); 1020charsWritten += specialTokenSpan.Length; 1032span = span.Slice(0, span.Length - EndOfWordSuffix.Length); 1042if (current.Length < span.Length) 1047for (int i = 0; i < span.Length; i++) 1052current = utf8bytes.Slice(incompleteUtf8BytesInBufferIndex, incompleteUtf8BytesInBuffer + span.Length); 1188Word word = Word.WithCapacity(w.Length); 1195while (i < w.Length) 1199if (Char.IsHighSurrogate(w[i]) && i < w.Length - 1 && Char.IsLowSurrogate(w[i + 1])) 1213if (ContinuingSubwordPrefix.Length + s.Length <= buffer.Length) 1217s = buffer.Slice(0, ContinuingSubwordPrefix.Length + s.Length); 1231if (i + length >= w.Length && EndOfWordSuffix is not null) 1233if (s.Length + EndOfWordSuffix.Length <= buffer.Length) 1236EndOfWordSuffix.AsSpan().CopyTo(buffer.Slice(s.Length)); 1237s = buffer.Slice(0, s.Length + EndOfWordSuffix.Length); 1307tokens.Add(new EncodedToken(value.specialTokenId, value.specialToken, new Range(offset, offset + text.Length))); 1319int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1350if (textSpan.Length <= MaxWordLengthToCache) 1417charsConsumed = text.Length; 1432int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1455int res = WordToIds(ref hit, accumulatedIds, out charsConsumed, textSpan.Length, maxTokens); 1458charsConsumed = charsConsumed >= textSpan.Length ? text.Length : mapping[charsConsumed]; 1466if (textSpan.Length <= MaxWordLengthToCache) 1476int result = WordToIds(ref word, accumulatedIds, out charsConsumed, textSpan.Length, maxTokens); 1479charsConsumed = charsConsumed >= textSpan.Length ? text.Length : mapping[charsConsumed]; 1512int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1535int res = WordToIdsFromEnd(ref hit, accumulatedIds, out textIndex, textSpan.Length, maxTokens); 1539textIndex = textIndex >= textSpan.Length ? text.Length : mapping[textIndex]; 1547if (textSpan.Length <= MaxWordLengthToCache) 1557int result = WordToIdsFromEnd(ref word, accumulatedIds, out textIndex, textSpan.Length, maxTokens); 1561textIndex = textIndex >= textSpan.Length ? text.Length : mapping[textIndex];

Model\CodeGenTokenizer.cs (40)

Model\EnglishRobertaTokenizer.cs (15)

363char[] token = ArrayPool<char>.Shared.Rent(text.Length); 364int[] indexMapping = ArrayPool<int>.Shared.Rent(text.Length); 369for (int i = 0; i < text.Length; i++) 672return EncodeToIdsResult(hit, accumulatedIds, maxTokens, text.Length, out charsConsumed); 675char[] token = ArrayPool<char>.Shared.Rent(text.Length); 676int[] indexMapping = ArrayPool<int>.Shared.Rent(text.Length); 681for (int i = 0; i < text.Length; i++) 695charsConsumed = text.Length; 704return EncodeToIdsResult(result, accumulatedIds, maxTokens, text.Length, out charsConsumed); 711textIndex = text.Length; 717return EncodeToIdsFromEndResult(hit, accumulatedIds, maxTokens, text.Length, out textIndex); 720char[] token = ArrayPool<char>.Shared.Rent(text.Length); 721int[] indexMapping = ArrayPool<int>.Shared.Rent(text.Length); 726for (int i = 0; i < text.Length; i++) 749return EncodeToIdsFromEndResult(result, accumulatedIds, maxTokens, text.Length, out textIndex);

Model\SentencePieceBaseModel.cs (8)

678if (tokenSpan.Length > buffer.Length) 692buffer = buffer.Slice(tokenSpan.Length); 693charsConsumed += tokenSpan.Length; 700if (tokenSpan[tokenSpan.Length - 1] == prefixSuffixChar) 702suffixIndex = charsConsumed + tokenSpan.Length - 1; 705if (tokenSpan.Length > buffer.Length) 719charsConsumed += tokenSpan.Length; 741charsConsumed += tokenSpan.Length;

Model\SentencePieceBpeModel.cs (34)

86if (textToEncode.Length == 0) 131if (currentOffset < text.Length) 138tokens.Add(new EncodedToken(EndOfSentenceId, EndOfSentenceToken, new Range(text.Length, text.Length))); 152BpeSymbol[] symbols = ArrayPool<BpeSymbol>.Shared.Rent(text.Length); 203tokens.Add(new EncodedToken(EndOfSentenceId, EndOfSentenceToken, new Range(text.Length, text.Length))); 211for (int i = 0; i < text.Length; i++) 228int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 237int length = text.Length - i; 393if (currentOffset < text.Length && idsCount < maxTokens) 435BpeSymbol[] symbols = ArrayPool<BpeSymbol>.Shared.Rent(text.Length); 507for (int i = 0; i < text.Length; i++) 528int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 546charsConsumed += text.Length - i; 669if (currentOffset < text.Length && idsCount < maxTokens) 703BpeSymbol[] symbols = ArrayPool<BpeSymbol>.Shared.Rent(text.Length); 771for (int i = 0; i < text.Length; i++) 791int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 805charsConsumed += text.Length - i; 897Debug.Assert(text.Length > 0); 899textIndex = text.Length; 919if (current.Offset + current.Length < text.Length) 923textIndex -= splitText.Length - splitTextIndex; 941textIndex -= splitText.Length - splitTextIndex; 964textIndex = text.Length; 972BpeSymbol[] symbols = ArrayPool<BpeSymbol>.Shared.Rent(text.Length); 1047for (int i = text.Length - 1; i >= 0; i--) 1067int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 1131Debug.Assert(text.Length > 0); 1132Debug.Assert(symbols.Length >= text.Length); 1137while (spanIndex < text.Length) 1139int len = (Char.IsHighSurrogate(text[spanIndex]) && spanIndex < text.Length - 1 && Char.IsLowSurrogate(text[spanIndex + 1])) ? 2 : 1; 1143next: spanIndex + len >= text.Length ? -1 : symbolIndex + 1,

Model\SentencePieceTokenizer.cs (1)

125CharsConsumed = normalizedText?.Length ?? text?.Length ?? textSpan.Length

Model\SentencePieceUnigramModel.cs (27)

112int[] buffer = ArrayPool<int>.Shared.Rent(textToEncode.Length * 3); 115char[] normalizedString = ArrayPool<char>.Shared.Rent(textToEncode.Length + 2); 147if (text.Length > remainingLength) 155text.CopyTo(normalizedString.AsSpan(normalizedString.Length - normalizedStringCountFromEnd - text.Length)); 156normalizedStringCountFromEnd += text.Length; 174Debug.Assert(bytesConsumed == utf8Bytes.Length); 183if (text.Length > utf16NormalizedString.Length) 190normalizedStringIndex += text.Length; 196if (Encoding.UTF8.GetMaxCharCount(normalizationSpan.Length) > normalizedUtf16Span.Length) 246if (currentOffset < text.Length) 294Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) * 3 <= buffer.Length * sizeof(int)); 473Debug.Assert(normalized.Length > 0); 475int size = normalized.Length; 584int[] buffer = ArrayPool<int>.Shared.Rent(textToEncode.Length * 3); 587char[]? normalizedString = maxTokenCount == int.MaxValue ? null : ArrayPool<char>.Shared.Rent(textToEncode.Length + 2); 686if (currentOffset < text.Length) 853charsConsumed += text.Length; 891if (index + utf8UnknownBytes.Length > maxTokenCount) 896addedTokensCount += utf8UnknownBytes.Length - 1; 974int[] buffer = ArrayPool<int>.Shared.Rent(textToEncode.Length * 3); 977char[]? normalizedString = maxTokenCount == int.MaxValue ? null : ArrayPool<char>.Shared.Rent(textToEncode.Length + 2); 1056if (currentOffset < text.Length && tokenCount < maxTokenCount) 1226return textToEncode.Length; 1236return textToEncode.Length; 1241int[] buffer = ArrayPool<int>.Shared.Rent(textToEncode.Length * 3); 1244char[]? normalizedString = maxTokenCount == int.MaxValue ? null : ArrayPool<char>.Shared.Rent(textToEncode.Length + 2); 1295if (current.Offset + current.Length < text.Length)

Model\TiktokenTokenizer.cs (20)

323int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 329indexMappingSpan[encodedLength] = text.Length; 341if (text.Length <= MaxWordLengthToCache) 430return EncodeToIdsResult(value, accumulatedIds, maxTokenCount, text.Length, out charsConsumed); 435charsConsumed = text.Length; 440int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 446indexMappingSpan[encodedLength] = text.Length; 455if (text.Length <= MaxWordLengthToCache) 461return EncodeToIdsResult(encodedTokens, accumulatedIds, maxTokenCount, text.Length, out charsConsumed); 596return EncodeToIdsResult(value, accumulatedIds: null, maxTokens, text.Length, out charsConsumed); 601charsConsumed = text.Length; 605int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 611indexMappingSpan[encodedLength] = text.Length; 620if (text.Length <= MaxWordLengthToCache) 626return EncodeToIdsResult(encodedTokens, accumulatedIds: null, maxTokens, text.Length, out charsConsumed); 722return EncodeToIdsFromEndResult(value, accumulatedIds: null, maxTokens, text.Length, out textIndex); 731int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 737indexMappingSpan[encodedLength] = text.Length; 746if (text.Length <= MaxWordLengthToCache) 752return EncodeToIdsFromEndResult(encodedTokens, accumulatedIds: null, maxTokens, text.Length, out textIndex);

Model\WordPieceTokenizer.cs (12)

317if (text.Length > MaxInputCharsPerWord) 319tokens.Add(new EncodedToken(UnknownTokenId, UnknownToken, new Range(offset, offset + text.Length))); 329int textLength = text.Length; 346subStr = buffer.Slice(0, ContinuingSubwordPrefix.Length + subStr.Length); 456if (text.Length > MaxInputCharsPerWord) 459charsConsumed = text.Length; 469int textLength = text.Length; 487subStr = buffer.Slice(0, ContinuingSubwordPrefix.Length + subStr.Length); 632if (charsConsumed != textSpanToEncode.Length) 635return fromEnd ? textSpanToEncode.Length : 0; 638return fromEnd ? 0 : textSpanToEncode.Length; 663return fromEnd ? 0 : textSpanToEncode.Length;

Normalizer\LowerCaseNormalizer.cs (2)

45char[] arrayPoolArray = ArrayPool<char>.Shared.Rent(original.Length); 48Debug.Assert(length == original.Length);

Normalizer\SentencePieceNormalizer.cs (6)

107int endIndex = original.Length - 1; 392while (isPrevSpace && sp.Length > 0 && sp[0] == (byte)' ') 399for (int n = 0; n < sp.Length; ++n) 426isPrevSpace = sp[sp.Length - 1] == (byte)' '; 490if (blob.Length <= sizeof(uint)) 505if (trieBlobSize >= blob.Length)

Normalizer\UpperCaseNormalizer.cs (2)

45char[] arrayPoolArray = ArrayPool<char>.Shared.Rent(original.Length); 48Debug.Assert(length == original.Length);

PreTokenizer\CompositePreTokenizer.cs (2)

149char[] buffer = ArrayPool<char>.Shared.Rent(text.Length); 152IEnumerable<(int Offset, int Length)> result = PreTokenize(buffer, text.Length);

PreTokenizer\PreTokenizer.cs (2)

136char[] buffer = ArrayPool<char>.Shared.Rent(text.Length); 138return SplitText(buffer, regex, text.Length);

PreTokenizer\RegexPreTokenizer.cs (2)

104char[] buffer = ArrayPool<char>.Shared.Rent(text.Length); 106return SplitText(buffer, _regex, _specialTokensRegex, text.Length);

Tokenizer.cs (2)

257return tokens.NormalizedText?.Length ?? textSpan.Length; 456fullTextLength = textSpan.Length;

Utils\BytePairEncoder.cs (1)

102while (finalEndIndex < indexMappingSpan.Length && indexMappingSpan[finalEndIndex] == mappedEndIndex)

Utils\DoubleArrayTrie.cs (1)

1072for (int i = 0; i < key.Length; ++i)

Utils\Helpers.cs (16)

57while (utf8Bytes.Length > 0) 61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length)); 70Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 75for (int i = 0; i < text.Length; i++) 96if (i < text.Length - 1 && char.IsSurrogatePair((char)c, text[i + 1])) 141if (text.Length > 1 && char.IsSurrogatePair((char)c, text[1])) 162Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 168for (int i = 0; i < text.Length; i++) 189if (i < text.Length - 1 && char.IsSurrogatePair((char)c, text[i + 1])) 217for (int i = 0; i < text.Length; i++) 244while (byteIndex < utf8Bytes.Length) 283if (byteIndex + additionalBytes >= utf8Bytes.Length) 321Debug.Assert(input.Length > 0); 328else if (input.Length >= 2 && (input[0] & 0xE0) == 0xC0) 337else if (input.Length >= 3 && (input[0] & 0xF0) == 0xE0) 346else if (input.Length >= 4 && (input[0] & 0xf8) == 0xF0)

Utils\Helpers.netcoreapp.cs (1)

81Debug.Assert(textIndex < text.Length);

Utils\LruCache.cs (1)

78if (_cache.TryGetValue(new StringSpanOrdinalKey(ptr, key.Length), out LinkedListNode<KeyValuePair<string, TValue>>? cached))

Utils\StringSpanOrdinalKey.cs (4)

103return _map.TryGetValue(new StringSpanOrdinalKey(ptr, key.Length), out value!); 181return map.TryGetValue(new StringSpanOrdinalKey(ptr, key.Length), out value!); 193return map.TryGetValue(new StringSpanOrdinalKeyPair(ptr1, key1.Length, ptr2, key2.Length), out value!);

Utils\ValueStringBuilder.cs (3)

352if (pos > _chars.Length - value.Length) 354Grow(value.Length); 358_pos += value.Length;

NormalizerTests.cs (3)

95StringBuilder sb = new StringBuilder(original.Length); 110if (start >= original.Length) 118for (int i = start; i < original.Length; i++)

PreTokenizerTests.cs (3)

90while (index < text.Length && char.IsWhiteSpace(text[index])) 96while (end < text.Length && !char.IsWhiteSpace(text[end])) 101if (index < text.Length)

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

1072for (int i = 0; i < key.Length; ++i)

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

57while (utf8Bytes.Length > 0) 61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length)); 70Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 75for (int i = 0; i < text.Length; i++) 96if (i < text.Length - 1 && char.IsSurrogatePair((char)c, text[i + 1])) 141if (text.Length > 1 && char.IsSurrogatePair((char)c, text[1])) 162Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 168for (int i = 0; i < text.Length; i++) 189if (i < text.Length - 1 && char.IsSurrogatePair((char)c, text[i + 1])) 217for (int i = 0; i < text.Length; i++) 244while (byteIndex < utf8Bytes.Length) 283if (byteIndex + additionalBytes >= utf8Bytes.Length) 321Debug.Assert(input.Length > 0); 328else if (input.Length >= 2 && (input[0] & 0xE0) == 0xC0) 337else if (input.Length >= 3 && (input[0] & 0xF0) == 0xE0) 346else if (input.Length >= 4 && (input[0] & 0xf8) == 0xF0)

src\Microsoft.ML.Tokenizers\Utils\Helpers.netcoreapp.cs (1)

81Debug.Assert(textIndex < text.Length);

AutoFormerV2\ObjectDetectionTrainer.cs (2)

398Contracts.Assert(boxValues.Length == labelValues.Length * 4, "Must have 4 coordinates for each label");

Utils\DataUtils.cs (14)

79var array = new T[s1.Length + s2.Length]; 81s2.CopyTo(array.AsSpan(s1.Length)); 87var array = new T[s1.Length + s2.Length + s3.Length]; 89s2.CopyTo(array.AsSpan(s1.Length)); 90s3.CopyTo(array.AsSpan(s1.Length + s2.Length)); 96var array = new T[s1.Length + 1]; 98array.AsSpan(s1.Length)[0] = s2; 104var array = new T[s1.Length + 2]; 106array.AsSpan(s1.Length)[0] = s2; 107array.AsSpan(s1.Length + 1)[0] = s3;

Dracula\CountTableTransformer.cs (2)

291for (int i = 0; i < indices.Length; i++) 722for (int i = 0; i < srcIndices.Length; i++)

ExpressionTransformer.cs (6)

620int count = src0.GetValues().Length; 647int count = src0.GetValues().Length; 694int count = src0.GetValues().Length; 757int count = src0.GetValues().Length; 823int count = src0.GetValues().Length; 892int count = src0.GetValues().Length;

GcnTransform.cs (15)

476int count = srcValues.Length; 529Contracts.Assert(0 <= values.Length && values.Length <= length); 530if (values.Length == 0) 535if (values.Length != length && tmpMean != 0) 539sumSq = (length - values.Length) * meanSq; 551Contracts.Assert(0 <= values.Length && values.Length <= length); 552if (values.Length == 0) 555if (values.Length != length && mean != 0) 559sumSq = (length - values.Length) * meanSq; 571if (values.Length == 0) 582if (values.Length == 0) 593if (values.Length == 0) 600if (length == 0 || src.Length == 0)

LearnerFeatureSelection.cs (8)

128if (scoresValues.Length == 0) 145for (int i = 0; i < scoresValues.Length; i++) 161while (++i < scoresValues.Length) 192Contracts.Assert(max < scoresValues.Length); 195range.max = max == scoresIndices.Length - 1 ? scores.Length - 1 : scoresIndices[max + 1] - 1; 211for (; ii <= scoresIndices.Length; ii++) 214var gapMax = ii == scoresIndices.Length ? scores.Length - 1 : scoresIndices[ii] - 1; 236for (int i = 0; i < scores.Length; i++)

MissingValueDroppingTransformer.cs (13)

259for (int i = 0; i < srcValues.Length; i++) 264Host.Assert(newCount <= srcValues.Length); 272if (newCount == srcValues.Length) 277Host.Assert(dst.GetValues().Length == newCount); 287for (int i = 0; i < srcValues.Length; i++) 303for (int i = 0; i < srcValues.Length; i++) 308Host.Assert(newCount <= srcValues.Length); 312VBufferUtils.Resize(ref dst, src.Length - srcValues.Length, 0); 316if (newCount == srcValues.Length) 326for (int i = 0; i < srcValues.Length; i++) 339var newLength = src.Length - srcValues.Length - newCount; 344for (int i = 0; i < srcValues.Length; i++) 356Host.Assert(offset == srcValues.Length - newCount);

MissingValueIndicatorTransform.cs (4)

300var editor = VBufferEditor.Create(ref buffer, size * 2, values.Length); 306for (int ivSrc = 0; ivSrc < values.Length; ivSrc++) 331for (int iivSrc = 0; iivSrc < values.Length; iivSrc++) 354ectx.Assert(0 <= iivDst && iivDst <= values.Length);

MissingValueIndicatorTransformer.cs (1)

307var srcCount = srcValues.Length;

MissingValueReplacing.cs (3)

261for (int slot = 0; slot < srcValues.Length; slot++) 714int srcCount = srcValues.Length; 788int srcCount = srcValues.Length;

MissingValueReplacingUtils.cs (2)

221var srcCount = srcValues.Length; 245var srcCount = srcValues.Length;

MutualInformationFeatureSelection.cs (12)

733for (int i = 0; i < labelsValues.Length; i++) 746for (int i = 0; i < labelsValues.Length; i++) 750if (ii == featureIndices.Length || i < featureIndices[ii]) 761Contracts.Assert(ii == featureIndices.Length); 800var bounds = _binFinder.FindBins(numBins, _singles, input.Length - input.GetValues().Length); 819for (int i = 0; i < inputValues.Length; i++) 826var bounds = _binFinder.FindBins(numBins, _singles, input.Length - inputValues.Length); 845for (int i = 0; i < inputValues.Length; i++) 852var bounds = _binFinder.FindBins(numBins, _doubles, input.Length - inputValues.Length); 894var editor = VBufferEditor.Create(ref output, input.Length, inputValues.Length); 895for (int i = 0; i < inputValues.Length; i++) 901if (!input.IsDense && inputValues.Length > 0)

RandomFourierFeaturizing.cs (2)

578featuresAligned.CopyFrom(srcIndices, srcValues, 0, 0, srcValues.Length, zeroItems: false); 580srcValues.Length, productAligned, transformInfo.NewDim);

SvmLight\SvmLightLoader.cs (2)

307for (int i = 0; i < inputValues.Length; i++) 692for (int i = 0; i < values.Length; ++i)

Text\LdaSingleBox.cs (14)

199Contracts.Check(termID.Length >= termNum); 200Contracts.Check(termVal.Length >= termNum); 203int[] pVal = new int[termVal.Length]; 204for (int i = 0; i < termVal.Length; i++) 215Contracts.Check(termVal.Length >= termNum); 218int[] pVal = new int[termVal.Length]; 219for (int i = 0; i < termVal.Length; i++) 264Contracts.Check(termVal.Length >= termNum); 265Contracts.Check(termID.Length >= termNum); 268int[] pVal = new int[termVal.Length]; 269for (int i = 0; i < termVal.Length; i++) 296Contracts.Check(termVal.Length >= termNum); 297int[] pVal = new int[termVal.Length]; 298for (int i = 0; i < termVal.Length; i++)

Text\LdaTransform.cs (4)

426for (int i = 0; i < inputValues.Length; i++) 484if (srcValues.Length == 0) 494for (int i = 0; i < srcValues.Length; i++) 884for (int termID = 0; termID < srcValues.Length; termID++)

Text\NgramUtils.cs (1)

100if (iindex < srcIndices.Length && i == srcIndices[iindex])

Text\StopWordsRemovingTransformer.cs (2)

426for (int i = 0; i < srcValues.Length; i++) 1114for (int i = 0; i < srcValues.Length; i++)

Text\TextNormalizing.cs (1)

372for (int i = 0; i < srcValues.Length; i++)

Text\TokenizingByCharacters.cs (4)

520for (int i = 0; i < srcValues.Length; i++) 534for (int i = 0; i < srcValues.Length; i++) 559for (int i = 0; i < srcValues.Length; i++) 587for (int i = 0; i < srcValues.Length; i++)

Text\WordEmbeddingsExtractor.cs (1)

579for (int word = 0; word < srcValues.Length; word++)

Text\WordTokenizing.cs (1)

293for (int i = 0; i < srcValues.Length; i++)

UngroupTransform.cs (2)

662while (cachedIndex < rowIndices.Length && _pivotColPosition > rowIndices[cachedIndex]) 665if (cachedIndex < rowIndices.Length && _pivotColPosition == rowIndices[cachedIndex])

ContentDispositionHeaderValue.cs (9)

546var requiredLength = MimePrefix.Length + 548MimeSuffix.Length; 556var bufferContent = buffer.Slice(MimePrefix.Length); 563var result = Encoding.UTF8.GetString(buffer.Slice(0, MimePrefix.Length + base64ContentLength + MimeSuffix.Length)); 622while (remaining.Length > 0) 627length = remaining.Length; 632if (remaining.Length == 0) 640length = remaining.Length;

SetCookieHeaderValue.cs (1)

326span = span.Slice(other.Length);

src\Shared\HttpRuleParser.cs (1)

65return (firstNonTokenCharIdx == -1) ? subspan.Length : firstNonTokenCharIdx;

InternableString.cs (9)

68if (newCharIndex < _string._inlineSpan.Length) 124Length = span.Length; 188if (_inlineSpan.SequenceCompareTo(other.AsSpan(0, _inlineSpan.Length)) != 0) 195int otherStart = _inlineSpan.Length; 221if (_inlineSpan.Length == Length) 249Unsafe.CopyBlockUnaligned(destPtr, sourcePtr, 2 * (uint)_inlineSpan.Length); 251destPtr += _inlineSpan.Length; 288if (_inlineSpan.Length == Length) 327hash = GetHashCodeHelper(charPtr, _inlineSpan.Length, hash, ref hashedOddNumberOfCharacters);

SpanBasedStringBuilder.cs (9)

172if (_spans.Count == 0 || other.IsEmpty || Length != other.Length) 272while (i < span.Length && char.IsWhiteSpace(span[i])) 294while (i < span.Length && span[i] == c) 318int i = span.Length - 1; 323if (i + 1 < span.Length) 326Length -= span.Length - (i + 1); 340int i = span.Length - 1; 345if (i + 1 < span.Length) 348Length -= span.Length - (i + 1);

MS\Internal\MarkupCompiler\PathInternal.cs (6)

196int pathLength = path.Length; 290path.Length >= DevicePrefixLength 303return path.Length >= UncExtendedPrefixLength 328return path.Length >= DevicePrefixLength 339=> path.Length > 0 && PathInternal.IsDirectorySeparator(path[path.Length - 1]);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\ReflectionUtils.cs (5)

66fullName = fullName.Slice(0, fullName.Length - nameSlice.Length + commaIndex); 108int tokenLength = tokenEnding == 0 ? assemblyName.Slice(versionIndex).Length : tokenEnding; 118int tokenLength = tokenEnding == 0 ? assemblyName.Slice(tokenIndex).Length : tokenEnding; 123if (assemblyToken.Length != 16)

MS\Internal\Ink\InkSerializedFormat\AlgoModule.cs (1)

48int i = DefaultFirstSquareRoot.Length - 2;

MS\Internal\Ink\InkSerializedFormat\InkSerializer.cs (3)

88int isfBase64PrefixLength = Base64HeaderBytes.Length; 2091if (data.Length < Base64HeaderBytes.Length) 2096for (int x = 0; x < Base64HeaderBytes.Length; x++)

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

407ptrMultiByte, multiByte.Length, ptrOutputChars, outputChars.Length);

System\Windows\PresentationSource.cs (1)

577for (int i = 1; i < visuals.Length; i++)

MS\Internal\AppModel\ResourceContainer.cs (12)

199int totalLength = assemblyName.Length + assemblyVersion.Length + assemblyToken.Length; 210UpdateCachedRMW(key.Slice(0, assemblyName.Length), assembly); 215assemblyVersion.CopyTo(key.Slice(assemblyName.Length)); 216UpdateCachedRMW(key.Slice(0, assemblyName.Length + assemblyVersion.Length), assembly); 224assemblyToken.CopyTo(key.Slice(assemblyName.Length + assemblyVersion.Length)); 229assemblyToken.CopyTo(key.Slice(assemblyName.Length)); 230UpdateCachedRMW(key.Slice(0, assemblyName.Length + assemblyToken.Length), assembly);

MS\Internal\Commands\CommandHelpers.cs (1)

104for (int i = 0; i < inputGestures.Length; i++)

MS\Internal\Globalization\BamlResourceContent.cs (6)

103StringBuilder stringBuilder = new(contentSpan.Length); 106for (int i = firstEscapeToken; i < contentSpan.Length; i++) 110if (contentSpan.Length > i + 1) // Check whether we're at the end 131if (contentSpan.Length > 5 && contentSpan[5] == ';') 146else if (contentSpan.Length > 4 && contentSpan[4] == ';') 155else if (contentSpan.Length > 3 && contentSpan[3] == ';')

MS\Internal\Ink\LassoHelper.cs (2)

167int marginCount = (points.Length * percentIntersect) / 100; 169if ((0 == marginCount) || (50 <= ((points.Length * percentIntersect) % 100)))

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

249for (int i = 0; i < RomanNumericSizeIncrements.Length; i++) 261if (i < RomanNumericSizeIncrements.Length - 1)

MS\Internal\TraceData.cs (1)

92for (int i = 0; i < parameters.Length; i++)

System\Windows\Controls\DataGridLengthConverter.cs (2)

242if (valueSpan.Length == strLenUnit) 258ReadOnlySpan<char> valueString = valueSpan.Slice(0, valueSpan.Length - strLenUnit);

System\Windows\Controls\DocumentViewer.cs (3)

1137(_zoomLevelIndex < ZoomLevelCollection.Length - 1)) 2223if ((_zoomLevelIndex < 0) || (_zoomLevelIndex >= ZoomLevelCollection.Length)) 2245for (loopIndex = 0; loopIndex < ZoomLevelCollection.Length - 1; loopIndex++)

System\Windows\Controls\VirtualizingStackPanel.cs (1)

12253return args.IsEmpty ? string.Empty : string.Format(CultureInfo.InvariantCulture, s_format[args.Length], args);

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

4838return args.IsEmpty ? string.Empty : string.Format(CultureInfo.InvariantCulture, s_format[args.Length], args);

System\Windows\Documents\XamlToRtfWriter.cs (6)

3545if (s.Length == 0) 3551int n = s.Length - 1; 3558if (n < s.Length - 1) 3814while (s < thickness.Length) 3818while (e < thickness.Length && thickness[e] != ',') 3824if (onenum.Length > 0)

System\Windows\LengthConverter.cs (1)

204valueSpan = valueSpan.Slice(0, valueSpan.Length - pixelUnit.Name.Length);

System\Windows\Markup\Primitives\ExtensionSimplifierMarkupObject.cs (2)

357if (value.Length > 1 && value[1] == '}') 371for (int i = 0; i < value.Length; i++)

System\Windows\Markup\Primitives\MarkupWriter.cs (1)

1640for (int i = 0; i < ns.Length; i++)

System\Windows\Markup\XamlFigureLengthSerializer.cs (2)

229if (valueSpan.Length == strLenUnit && unit != FigureUnitType.Pixel) 240ReadOnlySpan<char> valueString = valueSpan.Slice(0, valueSpan.Length - strLenUnit);

System\Windows\Markup\XamlGridLengthSerializer.cs (2)

229if (valueSpan.Length == strLenUnit 240ReadOnlySpan<char> valueString = valueSpan.Slice(0, valueSpan.Length - strLenUnit);

MS\Internal\Documents\DocumentApplicationDocumentViewer.cs (3)

1860if ((!culture.IsNeutralCulture) && (zoomString.Length > 0)) 1868if (zoomString.Length - 1 == zoomString.LastIndexOf( 1872zoomString = zoomString.Slice(0, zoomString.Length - 1);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (1)

302for (var i = 0; i < names.Length; i++)

JsonSchemaExporter\JsonSchemaExporter.cs (1)

561for (int i = 0; i < path.Length; i++)

ServerSentEvents\Helpers.cs (4)

52Span<byte> buffer = writer.GetSpan(value.Length); 53Debug.Assert(value.Length <= buffer.Length); 55writer.Advance(value.Length); 65int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length);

ServerSentEvents\SseFormatter.cs (1)

156if (data[i++] == '\r' && i < data.Length && data[i] == '\n')

ServerSentEvents\SseParser_1.cs (7)

125while (FillLineBuffer() != 0 && _lineLength < Utf8Bom.Length); 205while (await FillLineBufferAsync(cancellationToken).ConfigureAwait(false) != 0 && _lineLength < Utf8Bom.Length) ; 392ReadOnlySpan<byte> remainder = _lineBuffer.AsSpan(_newlineIndex + newlineLength, _lineLength - line.Length - newlineLength); 394(remainder[0] is LF || (remainder[0] is CR && remainder.Length > 1))) 396advance = line.Length + newlineLength + (remainder.StartsWith(CRLF) ? 2 : 1); 420_dataLength += fieldValue.Length; 462advance = line.Length + GetNewLineLength();

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

45bitArrayIndex < (uint)span.Length &&

System\Collections\Generic\PriorityQueue.cs (2)

892for (int i = 0; i < nodes.Length; i++) 902for (int i = 0; i < nodes.Length; i++)

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

54Dictionary<TKey, TValue> d = new(source.Length, comparer);

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

148Debug.Assert(hashCodes.Length != 0); 149Debug.Assert(!hashCodesAreUnique || new HashSet<int>(hashCodes.ToArray()).Count == hashCodes.Length); 158int uniqueCodesCount = hashCodes.Length; 163new HashSet<int>(hashCodes.Length); 184while ((uint)minPrimeIndexInclusive < (uint)primes.Length && minNumBuckets > primes[minPrimeIndexInclusive]) 189if (minPrimeIndexInclusive >= primes.Length) 202while ((uint)maxPrimeIndexExclusive < (uint)primes.Length && maxNumBuckets > primes[maxPrimeIndexExclusive]) 207if (maxPrimeIndexExclusive < primes.Length) 232if (codes is not null && uniqueCodesCount != hashCodes.Length)

System\Collections\Frozen\FrozenSet.cs (2)

31if (source.Length == 0) 40new(source.Length, equalityComparer); // we assume there are few-to-no duplicates when using this API

System\Collections\Frozen\String\Hashing.cs (2)

24int length = s.Length; 88int length = s.Length;

System\Collections\Frozen\String\KeyAnalyzer.cs (2)

54int acceptableNonUniqueCount = uniqueStrings.Length / 20; 68uniqueStrings.Length,

System\Collections\Frozen\String\LengthBucketsFrozenDictionary.AlternateLookup.cs (1)

32int bucketIndex = (key.Length - _minLength) * LengthBuckets.MaxPerLength;

System\Collections\Frozen\String\LengthBucketsFrozenSet.AlternateLookup.cs (1)

32int bucketIndex = (item.Length - _minLength) * LengthBuckets.MaxPerLength;

System\Collections\Frozen\String\OrdinalStringFrozenDictionary.AlternateLookup.cs (2)

36if ((uint)(key.Length - _minimumLength) <= (uint)_maximumLengthDiff) 38if (CheckLengthQuick((uint)key.Length))

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

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(s.Length + HashIndex, HashCount));

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

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(s.Length + HashIndex, HashCount));

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

27private protected override int GetHashCode(ReadOnlySpan<char> s) => s[s.Length + HashIndex];

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

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinal(s.Slice(s.Length + HashIndex, HashCount));

System\Collections\Frozen\String\OrdinalStringFrozenSet.AlternateLookup.cs (2)

36if ((uint)(item.Length - _minimumLength) <= (uint)_maximumLengthDiff) 38if (CheckLengthQuick((uint)item.Length))

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

27private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(s.Length + HashIndex, HashCount));

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

27private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(s.Length + HashIndex, HashCount));

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

24private protected override int GetHashCode(ReadOnlySpan<char> s) => s[s.Length + HashIndex];

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

25private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinal(s.Slice(s.Length + HashIndex, HashCount));

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

436this.Count += items.Length; 438items.CopyTo(new Span<T>(_elements, offset, items.Length)); 449this.Count += items.Length; 451var elements = new Span<T>(_elements, offset, items.Length); 452for (int i = 0; i < items.Length; i++)

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

990if (items.Length == 1) 1514var tmp = new T[Length + items.Length]; 1519items.CopyTo(new Span<T>(tmp, index, items.Length)); 1522Array.Copy(array!, index, tmp, index + items.Length, Length - index);

System\Collections\Immutable\ImmutableList_1.Node.cs (2)

273int rightCount = (items.Length - 1) / 2; 274int leftCount = (items.Length - 1) - rightCount;

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

95for (int i = items.Length - 1; i >= 0; i--)

System\Collections\Immutable\ImmutableSortedSet_1.cs (3)

332if (this.IsEmpty || (this.Count + other.Length) * RefillOverIncrementalThreshold > this.Count) 1184list = new List<T>(addedItems.Length); 1191list = new List<T>(this.Count + addedItems.Length);

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

169dst = dst.Slice(prefix.Length, 32);

System\ComponentModel\DataAnnotations\PhoneAttribute.cs (1)

110if (potentialExtension.Length == 0)

System\Drawing\PointConverter.cs (1)

30if (text.Length == 0)

System\Drawing\RectangleConverter.cs (1)

30if (text.Length == 0)

System\Drawing\SizeConverter.cs (1)

30if (text.Length == 0)

System\Drawing\SizeFConverter.cs (1)

30if (text.Length == 0)

System\Data\Filter\Operators.cs (1)

142return (uint)op < (uint)priorities.Length ? priorities[op] : PriMax;

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

331return span.Length; 352if (buffer.Length > _rgbBuf.Length - offset) 420if (buffer.Length != 0) 422Span<byte> span = _rgbBuf.AsSpan((int)offset, buffer.Length); 427if (_lCurLen < offset + buffer.Length) 428_lCurLen = offset + buffer.Length; 763_lPosition += buffer.Length;

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

786Debug.Assert(rglData.Length >= 4); 2464Debug.Assert(rgulS.Length >= ciulS, "rgulS.Length >= ciulS", "Invalid array length"); 2605Debug.Assert(rgulU.Length == s_cNumeMax); 3025Debug.Assert(rguiData.Length == 4);

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\Diagnostics\Activity.cs (8)

1901if (idData.Length != 16) 1914if (idData.Length != 32 || !ActivityTraceId.IsLowerCaseHexAndNotAllZeros(idData)) 1962if (idData.Length != 32) 2025Debug.Assert(outBytes.Length * 2 == charData.Length); 2046for (; i < idData.Length; i++) 2094if (idData.Length != 8) 2107if (idData.Length != 16 || !ActivityTraceId.IsLowerCaseHexAndNotAllZeros(idData)) 2152if (idData.Length != 16)

System\Diagnostics\DsesFilterAndTransform.cs (3)

239if (suffixPart.Length > 0) 303if (eventName.Length > 0) 334if (activityName.Length > 0 && activitySourceName.Length == 1 && activitySourceName[0] == '*')

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

336int expectedLabels = labels.Length; 343if (l.Length != expectedLabels) 398LabelInstruction[] valueFetches = new LabelInstruction[labels.Length]; 399for (int i = 0; i < labels.Length; i++) 438if (labels.Length != _expectedLabelCount)

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

21private static readonly int s_maxGenerations = Math.Min(GC.GetGCMemoryInfo().GenerationInfo.Length, s_genNames.Length);

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

40_tagsCount = tagList.Length; 280for (int i = 0; i < tags.Length; i++) 290for (int i = 0; i < tags.Length; i++)

System\Diagnostics\W3CPropagator.cs (12)

103if (keyValueSeparator <= 0 || keyValueSeparator >= currentEntry.Length - 1) 118} while (baggageSpan.Length > 0); 152int delta = entry.Length + (commaIndex >= 0 ? 1 : 0); // +1 for the comma 160if (equalIndex <= 0 || equalIndex >= entry.Length - 1) 267for (int i = 0; i < valueSpan.Length; i++) 296if (i + 5 >= valueSpan.Length || valueSpan[i + 3] != Percent || !TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || (b1 & 0xC0) != 0x80) 312if (i + 8 >= valueSpan.Length || 333if (i + 11 >= valueSpan.Length || 378Debug.Assert(span.Length > 0 && span[0] == Percent); 380if (span.Length < 3 || !TryDecodeHexDigit(span[1], out byte byte1) || !TryDecodeHexDigit(span[2], out byte byte2)) 523for (int i = 0; i < value.Length; i++) 549if (i < value.Length - 1 && char.IsSurrogatePair((char)c, value[i + 1]))

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

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

277pts.Length).ThrowIfFailed(); 306pts.Length).ThrowIfFailed(); 335pts.Length).ThrowIfFailed(); 369pts.Length).ThrowIfFailed();

System\Drawing\Drawing2D\PathGradientBrush.cs (4)

40if (points.Length < 2) 48points.Length, 81if (points.Length < 2) 89points.Length,

System\Drawing\Font.cs (1)

502if (name.Length > 1 && name[0] == '@')

System\Drawing\FontFamily.cs (1)

95Debug.Assert(n is null || n[name.Length] == '\0', "Expected null-terminated string.");

System\Drawing\Graphics.cs (31)

System\Drawing\Icon.cs (2)

551_handle = PInvoke.CreateIconFromResourceEx(b, (uint)bestImage.Length, fIcon: true, 0x00030000, 0, 0, 0); 558_handle = PInvoke.CreateIconFromResourceEx(b, (uint)bestImage.Length, fIcon: true, 0x00030000, 0, 0, 0);

System\Drawing\Imaging\ColorMatrix.cs (1)

340ArgumentOutOfRangeException.ThrowIfNotEqual(newColorMatrix.Length, 25, nameof(newColorMatrix));

System\Drawing\Imaging\Effects\ColorLookupTableEffect.cs (4)

41ArgumentOutOfRangeException.ThrowIfGreaterThan(redLookupTable.Length, 256, nameof(redLookupTable)); 42ArgumentOutOfRangeException.ThrowIfGreaterThan(greenLookupTable.Length, 256, nameof(greenLookupTable)); 43ArgumentOutOfRangeException.ThrowIfGreaterThan(blueLookupTable.Length, 256, nameof(blueLookupTable)); 44ArgumentOutOfRangeException.ThrowIfGreaterThan(alphaLookupTable.Length, 256, nameof(alphaLookupTable));

System\Drawing\Imaging\ImageAttributes.cs (6)

361using BufferScope<(ARGB, ARGB)> buffer = new(stackBuffer, map.Length); 363for (int i = 0; i < map.Length; i++) 374(uint)map.Length, 386using BufferScope<(ARGB, ARGB)> buffer = new(stackBuffer, map.Length); 388for (int i = 0; i < map.Length; i++) 399(uint)map.Length,

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

83ImageCodecInfo[] codecs = new ImageCodecInfo[codecInfo.Length]; 85for (int i = 0; i < codecInfo.Length; i++)

System\Drawing\KnownColorTable.cs (3)

478Debug.Assert(ColorValueTable.Length == ColorKindTable.Length); 481for (int index = 1; index < colorValueTable.Length; ++index)

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

184if (source.Length <= bytesConsumed)

System\Formats\Asn1\AsnCharacterStringEncodings.cs (11)

47return encoding.GetByteCount(strPtr, str.Length); 71return encoding.GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length); 261for (int i = 0; i < chars.Length; i++) 279return chars.Length; 289for (int i = 0; i < bytes.Length; i++) 309return bytes.Length; 330for (int i = 0; i < chars.Length; i++) 363if (bytes.Length % 2 != 0) 366bytes.Slice(bytes.Length - 1).ToArray(), 367bytes.Length - 1); 375for (int i = 0; i < bytes.Length; i += 2)

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

82if (localValue.Length == 0 || normalizedLastByte == localValue[localValue.Length - 1]) 189if (value.Length > destination.Length) 199bytesWritten = value.Length; 295if (localValue.Length > 0) 340if (ruleSet == AsnEncodingRules.CER && source.Length > MaxCERSegmentSize) 346if (source.Length == 0) 359if (source.Length == 1) 378byte lastByte = source[source.Length - 1]; 404if (value.Length == 0) 411destination[value.Length - 1] = normalizedLastByte; 502int localLen = headerLength + encodedValue.Length; 506totalLength += contents.Length; 507lastSegmentLength = encodedValue.Length; 512curDest = curDest.Slice(contents.Length); 552readerStack.Push((curOffset, cur.Length, isIndefinite, bytesRead)); 672bytesConsumed = headerLength + encodedValue.Length;

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

59if (contents.Length != 1)

System\Formats\Asn1\AsnDecoder.cs (10)

205bytesConsumed = headerLength + ret.Length; 374if (lengthLength + 1 > source.Length) 513if (totalLength > source.Length) 611cur = cur.Slice(tlv.Length); 612totalLen += tlv.Length; 631consumed == data.Length) 641int len = Math.Min(longestPermitted, source.Length); 649if (length < 0 || source.Length - offset < length) 668if (lengthVal < 0 || source.Length - offset < lengthVal) 685return bigger.Slice(offset, smaller.Length);

System\Formats\Asn1\AsnDecoder.GeneralizedTime.cs (6)

74CryptoPool.Return(rented, contents.Length); 117if (strict && contentOctets.Length < 15) 122else if (contentOctets.Length < 10) 165while (state == HmsState && contents.Length != 0) 251if (contents.Length != 0) 303if (contents.Length != 0)

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

443if (contents.Length > sizeLimit) 453for (int i = 0; i < contents.Length; i++) 492if (contents.Length > 1 && contents[0] == 0) 497if (contents.Length > sizeLimit) 506for (int i = 0; i < contents.Length; i++)

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

368Debug.Assert(valueSpan.Length <= sizeof(long)); 373for (int byteIdx = 0; byteIdx < valueSpan.Length; byteIdx++)

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

56if (contents.Length != 0)

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

86if (contents.Length > destination.Length) 94bytesWritten = contents.Length; 177CryptoPool.Return(rented, contents.Length); 214if (ruleSet == AsnEncodingRules.CER && encodedValue.Length > MaxCERSegmentSize) 220bytesConsumed = headerLength + encodedValue.Length; 361int localLen = headerLength + contents.Length; 365totalLength += contents.Length; 366lastSegmentLength = contents.Length; 377curDest = curDest.Slice(contents.Length); 417readerStack.Push((curOffset, cur.Length, isIndefinite, bytesRead));

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

85Debug.Assert(source.Length > 0); 127for (idx = 0; idx < source.Length; idx++) 234if (contents.Length < 1) 250StringBuilder builder = new StringBuilder(((byte)contents.Length) * 4);

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

78if (length.Value > source.Length - headerLength)

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

125contentLength = contents.Length; 126bytesConsumed = headerLength + contents.Length + suffix;

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

354if (contents.Length > destination.Length) 362bytesWritten = contents.Length; 449if (contents.Length == 0) 461str = encoding.GetString(bytePtr, contents.Length); 473CryptoPool.Return(rented, contents.Length); 509CryptoPool.Return(rented, contents.Length);

System\Formats\Asn1\AsnDecoder.UtcTime.cs (12)

99Debug.Fail($"UtcTime did not fit in tmpSpace ({contents.Length} total)"); 100CryptoPool.Return(rented, contents.Length); 134if (contentOctets.Length != HasSecondsZulu) 142if (contentOctets.Length < NoSecondsZulu || 143contentOctets.Length > HasSecondsOffset || 144(contentOctets.Length & 1) != 1) 161if (contentOctets.Length == HasSecondsOffset || 162contentOctets.Length == HasSecondsZulu) 167if (contentOctets.Length == NoSecondsZulu || 168contentOctets.Length == HasSecondsZulu) 178contentOctets.Length == NoSecondsOffset || 179contentOctets.Length == HasSecondsOffset);

System\Formats\Asn1\AsnWriter.BitString.cs (10)

57if (bitString.Length == 0 && unusedBitCount != 0) 62byte lastByte = bitString.IsEmpty ? (byte)0 : bitString[bitString.Length - 1]; 80if (bitString.Length >= AsnReader.MaxCERSegmentSize) 90WriteLength(bitString.Length + 1); 94_offset += bitString.Length; 147Debug.Assert(payload.Length > MaxCERContentSize); 149int expectedSize = DetermineCerBitStringTotalLength(tag, payload.Length); 164while (remainingData.Length > MaxCERContentSize) 181WriteLength(remainingData.Length + 1); 188_offset += remainingData.Length;

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

581if (!read || consumed != value.Length) 588EnsureWriteCapacity(value.Length); 590_offset += value.Length;

System\Formats\Asn1\AsnWriter.Integer.cs (6)

227if (value.Length > 1 && value[0] == 0 && value[1] < 0x80) 237WriteLength(checked(value.Length + 1)); 243WriteLength(value.Length); 247_offset += value.Length; 272WriteLength(value.Length); 275_offset += value.Length;

System\Formats\Asn1\AsnWriter.OctetString.cs (8)

88if (octetString.Length > AsnReader.MaxCERSegmentSize) 97WriteLength(octetString.Length); 99_offset += octetString.Length; 106Debug.Assert(payload.Length > MaxCERSegmentSize); 111int fullSegments = Math.DivRem(payload.Length, MaxCERSegmentSize, out int lastSegmentSize); 144while (remainingData.Length > MaxCERSegmentSize) 158WriteLength(remainingData.Length); 161_offset += remainingData.Length;

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

65WriteLength(wellKnownContents.Length); 67_offset += wellKnownContents.Length; 81if (oidValue.Length < 3) 89byte[] tmp = CryptoPool.Rent(oidValue.Length / 2); 153endIndex = oidValue.Length; 155else if (endIndex == 0 || endIndex == oidValue.Length - 1) 173oidValue = oidValue.Slice(Math.Min(oidValue.Length, endIndex + 1));

System\Formats\Asn1\SetOfValueComparer.cs (4)

17int min = Math.Min(x.Length, y.Length); 51diff = x.Length - y.Length;

System\Formats\Cbor\CborConformanceLevel.cs (8)

242if (left.Length != right.Length) 244return left.Length - right.Length; 261if (left.Length != right.Length) 263return left.Length - right.Length;

System\Formats\Cbor\Reader\CborReader.cs (1)

283if (buffer.Length < requiredLength)

System\Formats\Cbor\Reader\CborReader.Integer.cs (1)

148if (length > (ulong)(data.Length - bytesRead))

System\Formats\Cbor\Reader\CborReader.Map.cs (1)

52if (2 * (ulong)mapSize > (ulong)(buffer.Length - bytesRead))

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

134EnsureWriteCapacity(encodedValue.Length); 148_offset += encodedValue.Length; 157using var manager = new PointerMemoryManager<byte>(ptr, encodedValue.Length); 192if (encoding.Length > destination.Length) 198return encoding.Length; 210if (encoding.Length > destination.Length) 217bytesWritten = encoding.Length;

System\Formats\Cbor\Writer\CborWriter.Map.cs (1)

169s = s.Slice(keyValuePairEncoding.Length);

System\Formats\Cbor\Writer\CborWriter.String.cs (5)

41WriteUnsignedInteger(CborMajorType.ByteString, (ulong)value.Length); 42EnsureWriteCapacity(value.Length); 50_currentIndefiniteLengthStringRanges.Add((_offset, value.Length)); 54_offset += value.Length; 144_currentIndefiniteLengthStringRanges.Add((_offset, value.Length));

System\Formats\Nrbf\NrbfDecoder.cs (3)

42=> bytes.Length >= SerializedStreamHeaderRecord.Size 44&& bytes.Slice(SerializedStreamHeaderRecord.Size - HeaderSuffix.Length, HeaderSuffix.Length).SequenceEqual(HeaderSuffix);

src\libraries\Common\src\System\IO\Archiving.Utils.Unix.cs (1)

18nonSlash = path.Length;

src\libraries\Common\src\System\IO\PathInternal.cs (11)

16internal static bool StartsWithDirectorySeparator(ReadOnlySpan<char> path) => path.Length > 0 && IsDirectorySeparator(path[0]); 22=> path.Length == GetRootLength(path); 142for (int i = skip; i < path.Length; i++) 146if (IsDirectorySeparator(c) && i + 1 < path.Length) 157if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && 166if (i + 2 < path.Length && 167(i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && 176sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\.. 201if (!flippedSeparator && sb.Length == path.Length) 235path.Slice(0, path.Length - 1) : 242path.Length > 0 && IsDirectorySeparator(path[^1]);

src\libraries\Common\src\System\IO\PathInternal.Unix.cs (1)

24return path.Length > 0 && IsDirectorySeparator(path[0]) ? 1 : 0;

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

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

596if (pathNameBytes.Length <= FieldLengths.Name) 618while (prefix.Length - name.Length > FieldLengths.Prefix) 630if (prefix.Length <= FieldLengths.Prefix && name.Length <= FieldLengths.Name) 632Debug.Assert(prefix.Length != 1 || !PathInternal.Utf8DirectorySeparators.Contains(prefix[0])); 1062int numToCopy = Math.Min(bytesToWrite.Length, destination.Length); 1079int numToCopy = Math.Min(bytesToWrite.Length, destination.Length - 1); 1081int copyPos = destination.Length - 1 - bytesToWrite.Length; 1221string.Concat("/tmp", result.AsSpan(tmp.Length)) :

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

246if (buffer.Length == 0) 281int trimmedLength = buffer.Length; 293while (newStart < buffer.Length && buffer[newStart] is 0 or 32)

src\libraries\Common\src\System\IO\Archiving.Utils.Unix.cs (1)

18nonSlash = path.Length;

src\libraries\Common\src\System\IO\PathInternal.cs (11)

16internal static bool StartsWithDirectorySeparator(ReadOnlySpan<char> path) => path.Length > 0 && IsDirectorySeparator(path[0]); 22=> path.Length == GetRootLength(path); 142for (int i = skip; i < path.Length; i++) 146if (IsDirectorySeparator(c) && i + 1 < path.Length) 157if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && 166if (i + 2 < path.Length && 167(i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && 176sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\.. 201if (!flippedSeparator && sb.Length == path.Length) 235path.Slice(0, path.Length - 1) : 242path.Length > 0 && IsDirectorySeparator(path[^1]);

src\libraries\Common\src\System\IO\PathInternal.Unix.cs (1)

24return path.Length > 0 && IsDirectorySeparator(path[0]) ? 1 : 0;

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\IO\FileSystemWatcher.cs (1)

377if (name.Length == 0)

System\IO\Hashing\Crc32.Arm.cs (6)

18if (source.Length >= sizeof(ulong)) 21int longLength = source.Length & ~0x7; // Exclude trailing bytes not a multiple of 8 33for (int i = 0; i < source.Length; i++) 46if (source.Length >= sizeof(uint)) 49int intLength = source.Length & ~0x3; // Exclude trailing bytes not a multiple of 4 61for (int i = 0; i < source.Length; i++)

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

206for (int i = 0; i < source.Length; i++)

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

23&& source.Length >= Vector128<byte>.Count * (System.Runtime.Intrinsics.Arm.Crc32.IsSupported ? 8 : 1); 39int length = source.Length;

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

190for (int i = 0; i < source.Length; i++)

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

37private static bool CanBeVectorized(ReadOnlySpan<byte> source) => VectorHelper.IsSupported && source.Length >= Vector128<byte>.Count; 53int length = source.Length;

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

131uint length = (uint)source.Length;

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

129uint length = (uint)source.Length;

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

97if (source.Length >= remain) 108_length += source.Length; 113while (source.Length >= StripeSize) 120if (source.Length > 0) 124_length += source.Length; 254int totalLength = source.Length; 257while (source.Length >= StripeSize)

System\IO\Hashing\XxHash32.State.cs (3)

39Debug.Assert(source.Length >= StripeSize); 75while (remaining.Length >= sizeof(uint)) 85for (int i = 0; i < remaining.Length; i++)

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

97if (source.Length >= remain) 108_length += source.Length; 113while (source.Length >= StripeSize) 120if (source.Length > 0) 124_length += source.Length; 254int totalLength = source.Length; 257while (source.Length >= StripeSize)

System\IO\Hashing\XxHash64.State.cs (4)

50Debug.Assert(source.Length >= StripeSize); 110while (remaining.Length >= sizeof(ulong)) 122if (remaining.Length >= sizeof(uint)) 133for (int i = 0; i < remaining.Length; i++)

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

244state.TotalLength += (uint)source.Length; 249if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 251source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 252state.BufferedCount += (uint)source.Length; 272Debug.Assert(sourceIndex < source.Length); 275if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 277ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 301Debug.Assert(sourceIndex < source.Length); // at least some bytes left 307else if (source.Length - sourceIndex > InternalBufferLengthBytes) 315while (source.Length - sourceIndex > InternalBufferLengthBytes); 322Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 323Debug.Assert(sourceIndex < source.Length);

System\IO\Packaging\ContentType.cs (4)

315if (parameterAndValue.Length == 1) 327if (equalSignIndex <= 0 || equalSignIndex == (parameterAndValue.Length - 1)) 370length = s.Length; 460for (int i = 0; i < quotedText.Length; i++)

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

309if (buffer.Length == 0) 331while (totalBytesWritten < buffer.Length) 334int numBytesToWriteInCurrentPiece = buffer.Length - totalBytesWritten; 364if (!_dir.IsLastPiece(pieceNumber) && totalBytesWritten < buffer.Length) 384Debug.Assert(totalBytesWritten == buffer.Length);

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

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

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

818int numBytes = Interop.Serial.Write(_handle, bufPtr, buff.Length);

System\Linq\Aggregate.cs (1)

31for (int i = 1; i < span.Length; i++)

System\Linq\Average.cs (5)

32if (Vector.IsHardwareAccelerated && span.Length >= Vector<int>.Count) 42while (i <= span.Length - Vector<int>.Count); 46for (; (uint)i < (uint)span.Length; i++) 51return (double)sum / span.Length; 101return TResult.CreateChecked(Sum<TSource, TAccumulator>(span)) / TResult.CreateChecked(span.Length);

System\Linq\Max.cs (4)

113for (i = 0; i < span.Length && T.IsNaN(span[i]); i++) ; 115if (i == span.Length) 120for (value = span[i]; (uint)i < (uint)span.Length; i++) 233for (int i = 1; (uint)i < (uint)span.Length; i++)

System\Linq\MaxMin.cs (7)

40if (!Vector128.IsHardwareAccelerated || !Vector128<T>.IsSupported || span.Length < Vector128<T>.Count) 43for (int i = 1; i < span.Length; i++) 51else if (!Vector256.IsHardwareAccelerated || !Vector256<T>.IsSupported || span.Length < Vector256<T>.Count) 54ref T lastVectorStart = ref Unsafe.Add(ref current, span.Length - Vector128<T>.Count); 75else if (!Vector512.IsHardwareAccelerated || !Vector512<T>.IsSupported || span.Length < Vector512<T>.Count) 78ref T lastVectorStart = ref Unsafe.Add(ref current, span.Length - Vector256<T>.Count); 102ref T lastVectorStart = ref Unsafe.Add(ref current, span.Length - Vector512<T>.Count);

System\Linq\Min.cs (2)

95for (int i = 1; (uint)i < (uint)span.Length; i++) 213for (int i = 1; (uint)i < (uint)span.Length; i++)

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

390if (span.Length != 0)

System\Linq\SegmentedArrayBuilder.cs (8)

85for (int i = 0; i < segments.Length; i++) 145ReadOnlySpan<T> sourceSlice = sourceSpan.Slice(0, Math.Min(availableSpaceInCurrentSpan, sourceSpan.Length)); 147_countInCurrentSegment += sourceSlice.Length; 148sourceSlice = sourceSpan.Slice(sourceSlice.Length); 152Expand(sourceSlice.Length); 154_countInCurrentSegment = sourceSlice.Length; 312destination = destination.Slice(firstSegment.Length); 322destination = destination.Slice(segment.Length);

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

399if (source.Length == 0) 404var results = new TResult[source.Length]; 414var results = new List<TResult>(source.Length); 415Fill(source, SetCountAndGetSpan(results, source.Length), _selector);

System\Linq\Single.cs (2)

120for (int i = 0; i < span.Length; i++) 125for (i++; (uint)i < (uint)span.Length; i++)

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

170if (minInclusive < span.Length) 172return span.Slice(minInclusive, GetAdjustedCount(minInclusive, _maxIndexInclusive, span.Length)).IndexOf(item);

System\Linq\Sum.cs (3)

55&& span.Length >= Vector<T>.Count * 4) 83Debug.Assert(span.Length >= Vector<T>.Count * 4); 88nuint length = (nuint)span.Length;

System\Linq\ToCollection.cs (2)

181Dictionary<TKey, TSource> d = new Dictionary<TKey, TSource>(source.Length, comparer); 239Dictionary<TKey, TElement> d = new Dictionary<TKey, TElement>(source.Length, comparer);

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

344for (int i = source.Length - 1; i >= 0; i--) 492for (int i = source.Length - 1; i >= 0; i--)

System\Buffers\BuffersExtensions.cs (6)

68if (span.Length > destination.Length) 90destination = destination.Slice(span.Length); 121if (value.Length <= destination.Length) 124writer.Advance(value.Length); 137int writeSize = Math.Min(destination.Length, input.Length); 141if (input.Length > 0)

System\Buffers\ReadOnlySequence.Helpers.cs (1)

688return MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<char, T>(ref MemoryMarshal.GetReference(spanOfChar)), spanOfChar.Length);

System\Buffers\SequenceReader.cs (12)

30_moreData = first.Length > 0; 151if ((CurrentSpanIndex + offset) <= CurrentSpan.Length - 1) 160long remainingOffset = offset - (CurrentSpan.Length - CurrentSpanIndex); 204if (CurrentSpanIndex >= CurrentSpan.Length) 317if ((count & TooBigOrNegative) == 0 && CurrentSpan.Length - CurrentSpanIndex > (int)count) 339if (CurrentSpanIndex >= CurrentSpan.Length) 355Debug.Assert(CurrentSpanIndex < CurrentSpan.Length); 368int remaining = CurrentSpan.Length - CurrentSpanIndex; 417if (firstSpan.Length >= destination.Length) 434Debug.Assert(firstSpan.Length < destination.Length); 436int copied = firstSpan.Length; 444int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);

System\Buffers\SequenceReader.Search.cs (33)

35if (!TryReadToInternal(out ReadOnlySequence<T> sequence, delimiter, advancePastDelimiter, CurrentSpan.Length - CurrentSpanIndex)) 148int i = remaining.Length - 2; 155escapeCount += remaining.Length - 2 - i; 168AdvanceCurrentSpan(remaining.Length); 220AdvanceCurrentSpan(remaining.Length); 300for (int i = remaining.Length; i > 0 && remaining[i - 1].Equals(delimiterEscape); i--, escapeCount++) 302if (priorEscape && escapeCount == remaining.Length) 310Advance(remaining.Length); 331int index = delimiters.Length == 2 347if (!TryReadToAnyInternal(out ReadOnlySequence<T> sequence, delimiters, advancePastDelimiter, CurrentSpan.Length - CurrentSpanIndex)) 378int index = delimiters.Length == 2 398Advance(remaining.Length); 423AdvanceCurrentSpan(index + (advancePastDelimiter ? delimiter.Length : 0)); 453if (delimiter.Length == 0) 470if (delimiter.Length == 1) 489Advance(delimiter.Length); 581for (i = CurrentSpanIndex; i < CurrentSpan.Length && CurrentSpan[i].Equals(value); i++) 613for (i = CurrentSpanIndex; i < CurrentSpan.Length && values.IndexOf(CurrentSpan[i]) != -1; i++) 645for (i = CurrentSpanIndex; i < CurrentSpan.Length; i++) 682for (i = CurrentSpanIndex; i < CurrentSpan.Length; i++) 719for (i = CurrentSpanIndex; i < CurrentSpan.Length; i++) 795AdvanceCurrentSpan(next.Length); 801return unread.Length < next.Length && IsNextSlow(next, advancePast); 809Debug.Assert(currentSpan.Length < next.Length); 811int fullLength = next.Length; 816if (next.Length == currentSpan.Length) 837next = next.Slice(currentSpan.Length); 839if (currentSpan.Length > next.Length) 841currentSpan = currentSpan.Slice(0, next.Length);

System\Buffers\SequenceReaderExtensions.Binary.cs (2)

29if (span.Length < sizeof(T)) 39Debug.Assert(reader.UnreadSpan.Length < sizeof(T));

System\Text\EncodingExtensions.cs (4)

39if (chars.Length <= MaxInputElementsPerIteration) 230if (bytes.Length <= MaxInputElementsPerIteration) 432int byteCountForThisSlice = (chars.Length <= MaxInputElementsPerIteration) 525int charCountForThisSlice = (bytes.Length <= MaxInputElementsPerIteration)

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

89return _position < s.Length ? s[_position++] : -1;

System\BinaryData.cs (2)

430return Encoding.UTF8.GetString(ptr, span.Length); 481if (span.Length > 2 && span[0] == 0xEF && span[1] == 0xBB && span[2] == 0xBF)

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Net\Logging\NetEventSource.Common.DumpBuffer.cs (1)

35Log.DumpBuffer(IdOf(thisOrContextObject), memberName, buffer.Slice(0, Math.Min(buffer.Length, MaxDumpSize)).ToArray());

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

96if (version.Length != 8 || !version.StartsWith("HTTP/", StringComparison.Ordinal))

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

279int preamble = encoding.Preamble.Length;

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\Net\Base64Stream.cs (1)

229if (written < buffer.Length)

System\Net\BufferBuilder.cs (2)

46EnsureBuffer(value.Length); 48_offset += value.Length;

System\Net\BufferedReadStream.cs (2)

92if (buffer.Length == 0) 95int count = buffer.Length;

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

241i = span.Length;

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

86if (buffer.Length == 0) 97byte* end = ptr + buffer.Length;

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

47return LineBreakNeeded(bytes.Length);

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

25for (; cur < buffer.Length; cur++)

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

100for (int i = 0; i < buffer.Length; i++) 105if ((buffer[i] == '\r') && ((i + 1) < buffer.Length) && (buffer[i + 1] == '\n'))

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

235if (written < buffer.Length)

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

49if (bytes.Length == 1 || IsCRLF(bytes)) // preserve same behavior as in EncodeBytes 54int numberOfCharsToAppend = bytes.Length * SizeOfQEncodedChar;

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

207for (; processed < buffer.Length; processed++) 228if (buffer[processed] == '\r' && processed + 1 < buffer.Length && buffer[processed + 1] == '\n') 272(processed + 1 >= buffer.Length)) 349if (written < buffer.Length)

System\Net\Mime\WriteStateInfoBase.cs (3)

82EnsureSpaceInBuffer(bytes.Length); 84_currentLineLength += bytes.Length; 85_currentBufferUsed += bytes.Length;

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

66if (socketAddressBuffer.Length >= SocketAddress.GetMaximumAddressSize(endPoint.AddressFamily) &&

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

66err = Interop.Sys.GetAddressFamily(rawAddress, buffer.Length, (int*)&family); 94err = Interop.Sys.GetPort(rawAddress, buffer.Length, &port); 118err = Interop.Sys.GetIPv4Address(rawAddress, buffer.Length, &ipAddress); 132err = Interop.Sys.GetIPv6Address(rawAddress, buffer.Length, ipAddress, address.Length, &localScope);

src\libraries\Common\src\System\Text\ValueUtf8Converter.cs (1)

26int maxSize = checked(Encoding.UTF8.GetMaxByteCount(value.Length) + 1);

System\Net\NetworkInformation\Ping.RawSocket.cs (2)

486for (int i = 0; i < buffer.Length; i += 2) 490ushort element1 = (i + 1 < buffer.Length)

System\Security\Authentication\ExtendedProtection\ServiceNameCollection.cs (1)

225host.Length == hostPortAndDistinguisher.Length ?

System\Net\ServerSentEvents\Helpers.cs (4)

35Span<byte> buffer = writer.GetSpan(value.Length); 36Debug.Assert(value.Length <= buffer.Length); 38writer.Advance(value.Length); 48int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length);

System\Net\ServerSentEvents\SseFormatter.cs (1)

153if (data[i++] == '\r' && i < data.Length && data[i] == '\n')

System\Net\ServerSentEvents\SseParser_1.cs (7)

109while (FillLineBuffer() != 0 && _lineLength < Utf8Bom.Length) ; 189while (await FillLineBufferAsync(cancellationToken).ConfigureAwait(false) != 0 && _lineLength < Utf8Bom.Length) ; 375ReadOnlySpan<byte> remainder = _lineBuffer.AsSpan(_newlineIndex + newlineLength, _lineLength - line.Length - newlineLength); 377(remainder[0] is LF || (remainder[0] is CR && remainder.Length > 1))) 379advance = line.Length + newlineLength + (remainder.StartsWith(CRLF) ? 2 : 1); 402_dataLength += fieldValue.Length; 444advance = line.Length + GetNewLineLength();

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\IO\ChunkedMemoryStream.cs (2)

50int toCopy = Math.Min(remaining, buffer.Length); 59AppendChunk(buffer.Length);

System\Net\WebClient.cs (2)

1144bomLengthInData = preamble.Length; 1157bomLengthInData = data.AsSpan().StartsWith(preamble) ? preamble.Length : 0;

System\Net\HeaderInfoTable.cs (1)

74equalsPos = lastElement.Length;

System\Net\WebSockets\WebSocketHandle.Managed.cs (2)

319if (value.Length > 0) 490Span<byte> bytes = stackalloc byte[24 /* Base64 guid length */ + wsServerGuidBytes.Length];

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IAggregationOperator.cs (4)

70nuint remainder = (uint)x.Length; 1176if (x.Length != y.Length) 1189nuint remainder = (uint)x.Length;

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBinaryOperator.cs (6)

61if (x.Length != y.Length) 66if (x.Length > destination.Length) 83nuint remainder = (uint)x.Length; 1400if (x.Length > destination.Length) 1415nuint remainder = (uint)x.Length;

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBooleanUnaryOperator.cs (51)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IStatefulUnaryOperator.cs (2)

34if (x.Length > destination.Length) 49nuint remainder = (uint)x.Length;

System\Numerics\Tensors\netcore\Common\TensorPrimitives.ITernaryOperator.cs (12)

46if (x.Length != y.Length || x.Length != z.Length) 51if (x.Length > destination.Length) 70nuint remainder = (uint)x.Length; 1523if (x.Length != y.Length) 1528if (x.Length > destination.Length) 1545nuint remainder = (uint)x.Length; 3016if (x.Length > destination.Length) 3031nuint remainder = (uint)x.Length;

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryInputBinaryOutput.cs (47)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToFourOperator.cs (11)

35if (x.Length > destination.Length) 49oneVectorFromEnd = x.Length - Vector512<TInput>.Count; 66if (i != x.Length) 68i = x.Length - Vector512<TInput>.Count; 86oneVectorFromEnd = x.Length - Vector256<TInput>.Count; 103if (i != x.Length) 105i = x.Length - Vector256<TInput>.Count; 123oneVectorFromEnd = x.Length - Vector128<TInput>.Count; 140if (i != x.Length) 142i = x.Length - Vector128<TInput>.Count; 155while (i < x.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToTwoOperator.cs (11)

35if (x.Length > destination.Length) 49oneVectorFromEnd = x.Length - Vector512<TInput>.Count; 64if (i != x.Length) 66i = x.Length - Vector512<TInput>.Count; 82oneVectorFromEnd = x.Length - Vector256<TInput>.Count; 97if (i != x.Length) 99i = x.Length - Vector256<TInput>.Count; 115oneVectorFromEnd = x.Length - Vector128<TInput>.Count; 130if (i != x.Length) 132i = x.Length - Vector128<TInput>.Count; 143while (i < x.Length)

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOperator.cs (2)

70if (x.Length > destination.Length) 89nuint remainder = (uint)x.Length;

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryTwoToOneOperator.cs (11)

35if (x.Length > destination.Length) 49twoVectorsFromEnd = x.Length - (Vector512<TInput>.Count * 2); 64if (i != x.Length) 66i = x.Length - (Vector512<TInput>.Count * 2); 82twoVectorsFromEnd = x.Length - (Vector256<TInput>.Count * 2); 97if (i != x.Length) 99i = x.Length - (Vector256<TInput>.Count * 2); 115twoVectorsFromEnd = x.Length - (Vector128<TInput>.Count * 2); 130if (i != x.Length) 132i = x.Length - (Vector128<TInput>.Count * 2); 143while (i < x.Length)

System\Numerics\Tensors\netcore\ReadOnlyTensorSpan_1.cs (3)

114_shape = TensorShape.Create(ref reference, span.Length, pinned: false); 144_shape = TensorShape.Create(ref reference, span.Length, lengths, strides, pinned: false); 291public int Rank => Lengths.Length;

System\Numerics\Tensors\netcore\Tensor.cs (35)

System\Numerics\Tensors\netcore\TensorOperation.cs (6)

1906for (int i = 0; i < x.Length; i++) 1924for (int i = 0; i < x.Length; i++) 2009for (int i = 0; i < x.Length; i++) 2022for (int i = 0; i < x.Length; i++) 2173for (int i = 0; i < x.Length; i++) 2192for (int i = 0; i < x.Length; i++)

System\Numerics\Tensors\netcore\TensorPrimitives.Average.cs (1)

28return Sum(x) / T.CreateChecked(x.Length);

System\Numerics\Tensors\netcore\TensorPrimitives.ConvertHelpers.cs (1)

21if (source.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.CosineSimilarity.cs (42)

System\Numerics\Tensors\netcore\TensorPrimitives.Half.cs (1)

307source.Length >= Vector128<short>.Count;

System\Numerics\Tensors\netcore\TensorPrimitives.HammingDistance.cs (29)

22if (x.Length != y.Length) 28for (int i = 0; i < x.Length; i++) 55MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(x)), x.Length), 56MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(y)), y.Length)); 65if (x.Length != y.Length) 75if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count) 77if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 79if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 84int oneVectorFromEnd = x.Length - Vector512<T>.Count; 98if (i != x.Length) 100Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 101Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<T>.Count)); 103Vector512<T> remainderMask = CreateRemainderMaskVector512<T>(x.Length - i); 116int oneVectorFromEnd = x.Length - Vector256<T>.Count; 130if (i != x.Length) 132Vector256<T> xVec = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 133Vector256<T> yVec = Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<T>.Count)); 135Vector256<T> remainderMask = CreateRemainderMaskVector256<T>(x.Length - i); 149int oneVectorFromEnd = x.Length - Vector128<T>.Count; 163if (i != x.Length) 165Vector128<T> xVec = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count)); 166Vector128<T> yVec = Vector128.LoadUnsafe(ref yRef, (uint)(x.Length - Vector128<T>.Count)); 168Vector128<T> remainderMask = CreateRemainderMaskVector128<T>(x.Length - i); 178for (int i = 0; i < x.Length; i++) 189for (int i = 0; i < x.Length; i++) 198Debug.Assert(count >= 0 && count <= x.Length, $"Expected count to be in the range [0, {x.Length}], got {count}.");

System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMax.cs (16)

148if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 190int oneVectorFromEnd = x.Length - Vector512<T>.Count; 215if (i != x.Length) 217current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 218currentIndex += CreateVector512T(x.Length - i); 239if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 281int oneVectorFromEnd = x.Length - Vector256<T>.Count; 306if (i != x.Length) 308current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 309currentIndex += CreateVector256T(x.Length - i); 330if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count) 372int oneVectorFromEnd = x.Length - Vector128<T>.Count; 397if (i != x.Length) 399current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count)); 400currentIndex += CreateVector128T(x.Length - i); 429for (int i = 1; i < x.Length; i++)

System\Numerics\Tensors\netcore\TensorPrimitives.IsCanonical.cs (2)

27if (x.Length > destination.Length) 32destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.IsComplexNumber.cs (2)

27if (x.Length > destination.Length) 32destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsFinite.cs (2)

27if (x.Length > destination.Length) 32destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.IsImaginaryNumber.cs (2)

27if (x.Length > destination.Length) 32destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsInteger.cs (2)

26if (x.Length > destination.Length) 31destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.IsNaN.cs (2)

27if (x.Length > destination.Length) 32destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsNegative.cs (2)

26if (x.Length > destination.Length) 31destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsRealNumber.cs (2)

27if (x.Length > destination.Length) 32destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.Max.cs (13)

409if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 429int oneVectorFromEnd = x.Length - Vector512<T>.Count; 453if (i != x.Length) 455current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 474if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 494int oneVectorFromEnd = x.Length - Vector256<T>.Count; 518if (i != x.Length) 520current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 540if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count) 560int oneVectorFromEnd = x.Length - Vector128<T>.Count; 584if (i != x.Length) 586current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count)); 612for (int i = 1; i < x.Length; i++)

System\Numerics\Tensors\netcore\TensorPrimitives.PopCount.cs (1)

20for (int i = 0; i < x.Length; i++)

System\Numerics\Tensors\netcore\TensorPrimitives.Round.cs (1)

140if ((uint)digits >= (uint)roundPower10.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.SoftMax.cs (1)

32if (x.Length > destination.Length)

System\Numerics\Tensors\netcore\TensorPrimitives.StdDev.cs (1)

30T variance = sumSquaredDiff / T.CreateChecked(x.Length);

System\Numerics\Tensors\netcore\TensorShape.cs (50)

System\Numerics\Tensors\netcore\TensorSpan_1.cs (1)

192public int Rank => Lengths.Length;

System\Numerics\Tensors\TensorPrimitives.Single.cs (1)

855if (x.Length > destination.Length)

src\Internal\VersionResilientHashCode.CoreCLR.cs (1)

70for (int i = 0; i < instantiation.Length; i++)

src\libraries\Common\src\Interop\Interop.ICU.cs (1)

20InitICUFunctions(icuuc, icuin, version.ToString(), suffix.Length > 0 ? suffix.ToString() : null);

src\libraries\Common\src\Interop\Linux\os-release\Interop.OSReleaseFile.cs (2)

65ReadOnlySpan<char> fieldValue = line.Slice(prefix.Length); 68if (fieldValue.Length >= 2 &&

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcMountInfo.cs (6)

32if (mount.MountPoint.Length < currentBestLength) 42if (mount.MountPoint.Length == path.Length) 48if (mount.MountPoint.Length > 1 && path[mount.MountPoint.Length] != '/') 53currentBestLength = mount.MountPoint.Length; 58if (currentFormat.Length > 0)

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadDir.cs (1)

41Debug.Assert(nameBytes.Length > 0, "we shouldn't have gotten a garbage value from the OS");

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (1)

79int length = buffer.Length;

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

45bitArrayIndex < (uint)span.Length &&

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

116Debug.Assert(bytes.Length >= Vector128<int>.Count); 132nuint lengthSubVector128 = (nuint)bytes.Length - (nuint)Vector128<int>.Count; 150if (pos == (nuint)bytes.Length) 167Debug.Assert(chars.Length >= bytes.Length * 2); 170if ((AdvSimd.Arm64.IsSupported || Ssse3.IsSupported) && bytes.Length >= 4) 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 248chars.Length >= Vector128<ushort>.Count * 2) 263Debug.Assert(chars.Length <= bytes.Length * 2); 264Debug.Assert(chars.Length % 2 == 0); 265Debug.Assert(chars.Length >= Vector128<ushort>.Count * 2); 268nuint lengthSubTwoVector128 = (nuint)chars.Length - ((nuint)Vector128<ushort>.Count * 2); 337if (offset == (nuint)chars.Length) 339charsProcessed = chars.Length; 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\IO\PathInternal.cs (11)

16internal static bool StartsWithDirectorySeparator(ReadOnlySpan<char> path) => path.Length > 0 && IsDirectorySeparator(path[0]); 22=> path.Length == GetRootLength(path); 142for (int i = skip; i < path.Length; i++) 146if (IsDirectorySeparator(c) && i + 1 < path.Length) 157if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && 166if (i + 2 < path.Length && 167(i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && 176sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\.. 201if (!flippedSeparator && sb.Length == path.Length) 235path.Slice(0, path.Length - 1) : 242path.Length > 0 && IsDirectorySeparator(path[^1]);

src\libraries\Common\src\System\IO\PathInternal.Unix.cs (1)

24return path.Length > 0 && IsDirectorySeparator(path[0]) ? 1 : 0;

src\libraries\Common\src\System\Memory\FixedBufferExtensions.cs (3)

27return length < 0 ? span.Length : length; 36if (value == null || value.Length > span.Length) 49return i == span.Length || span[i] == '\0';

src\libraries\Common\src\System\Number.Formatting.Common.cs (29)

src\libraries\Common\src\System\Number.Parsing.Common.cs (2)

289if (!TryParseNumber(ref p, p + value.Length, styles, ref number, info) 290|| ((int)(p - stringPointer) < value.Length && !TrailingZeros(value, (int)(p - stringPointer))))

src\libraries\Common\src\System\Reflection\AssemblyNameFormatter.cs (1)

108if (s.Length != span.Trim().Length || span.IndexOfAny('\"', '\'') >= 0)

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (2)

63if (input.Length == 0) 348if (_index < _input.Length)

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

src\libraries\Common\src\System\Text\ValueUtf8Converter.cs (1)

26int maxSize = checked(Encoding.UTF8.GetMaxByteCount(value.Length) + 1);

src\libraries\System.Private.CoreLib\src\System\AppDomain.cs (1)

143parameters: entry.GetParametersAsSpan().Length > 0 ? [args] : null,

src\libraries\System.Private.CoreLib\src\System\Array.cs (3)

737Debug.Assert(indices.Length == Rank); 743for (int i = 0; i < indices.Length; i++) 745int index = indices[i] - Unsafe.Add(ref bounds, indices.Length + i);

src\libraries\System.Private.CoreLib\src\System\BitConverter.cs (14)

src\libraries\System.Private.CoreLib\src\System\Boolean.cs (4)

269int originalLength = value.Length; 273if (value.Length != originalLength) 295while (start < value.Length) 304int end = value.Length - 1;

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReverseEndianness.cs (8)

289if (destination.Length < source.Length) 310while (i <= source.Length - Vector256<T>.Count) 319while (i <= source.Length - Vector128<T>.Count) 326while (i < source.Length) 338int i = source.Length; 381if (destination.Length < source.Length) 391for (int i = 0; i < source.Length; i++) 399for (int i = source.Length - 1; i >= 0; i--)

src\libraries\System.Private.CoreLib\src\System\Buffers\SharedArrayPool.cs (1)

530if (!value.IsEmpty && value.Length <= 10)

src\libraries\System.Private.CoreLib\src\System\Buffers\StandardFormat.cs (3)

99if (format.Length == 0) 104if (format.Length == 1) 111for (int srcIndex = 1; srcIndex < format.Length; srcIndex++)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (10)

32int srcLength = decoder.SrcLength(isFinalBlock, source.Length); 155if (src == srcBytes + source.Length) 233if (srcLength != source.Length) 244if (srcLength != source.Length && isFinalBlock) 279bytesConsumed += source.Length; 462for (; encodedIdx < source.Length && (uint)bufferIdx < (uint)buffer.Length; ++encodedIdx) 487hasAnotherBlock = source.Length >= BlockSize; 491hasAnotherBlock = source.Length > 1; 524for (int i = 0; i < source.Length; ++i) 1453for (int i = 0; i < span.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (1)

31int srcLength = source.Length;

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64ValidatorHelper.cs (3)

23if ((uint)index >= (uint)base64Text.Length) 25length += base64Text.Length; 26lastChar = base64Text[base64Text.Length - 1];

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs (7)

164int upperBound = GetMaxDecodedLength(source.Length); 219for (; encodedIdx < source.Length && (uint)bufferIdx < (uint)buffer.Length; ++encodedIdx) 244hasAnotherBlock = source.Length >= BlockSize; 248hasAnotherBlock = source.Length > 1; 281for (int i = 0; i < source.Length; ++i) 380int upperBound = GetMaxDecodedLength(source.Length); 841for (int i = 0; i < span.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs (4)

88byte[] destination = new byte[GetEncodedLength(source.Length)]; 139char[] destination = new char[GetEncodedLength(source.Length)]; 155int encodedLength = GetEncodedLength(source.Length); 161Debug.Assert(buffer.Length == charsWritten, $"The source length: {source.Length}, bytes written: {charsWritten}");

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\FormattingHelpers.CountDigits.cs (3)

25Debug.Assert(log2ToPow10.Length == 64); 54Debug.Assert((elementOffset + 1) <= powersOf10.Length); 102Debug.Assert(table.Length == 32, "Every result of uint.Log2(value) needs a long entry in the table.");

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Boolean.cs (2)

32if (source.Length >= 4) 42if (source.Length > 4)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.Default.cs (1)

18if (source.Length < 26)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.G.cs (1)

17if (source.Length < 19)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.O.cs (3)

21if (source.Length < 27) 196byte offsetChar = (source.Length <= 27) ? default : source[27]; 228if (source.Length < 33)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.R.cs (1)

17if (source.Length < 29)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Float.cs (1)

116int remaining = source.Length;

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Guid.cs (2)

56if (text.Length < 32) 109if (source.Length < expectedCodingUnits)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.D.cs (34)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.N.cs (24)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.D.cs (27)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.N.cs (20)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.X.cs (20)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs (11)

26if (source.Length == 0) 47if (srcIndex >= source.Length) 64while (srcIndex < source.Length) 72if (srcIndex == source.Length) 82while (srcIndex < source.Length) 118if (srcIndex == source.Length) 137while (srcIndex < source.Length) 182if (srcIndex == source.Length) 226if (srcIndex == source.Length) 242if (srcIndex == source.Length) 271while (srcIndex < source.Length)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.BigG.cs (8)

12while (srcIndex < source.Length) 20if (srcIndex == source.Length) 32if (srcIndex == source.Length) 48if (srcIndex == source.Length || source[srcIndex++] != Utf8Constants.Colon) 63if (srcIndex == source.Length || source[srcIndex++] != Utf8Constants.Colon) 78if (srcIndex == source.Length || source[srcIndex++] != Utf8Constants.Colon) 93if (srcIndex == source.Length || source[srcIndex++] != Utf8Constants.Period) 120if (srcIndex != source.Length && (source[srcIndex] == Utf8Constants.Period || source[srcIndex] == Utf8Constants.Colon))

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.cs (2)

47if (srcIndex == source.Length) 66while (srcIndex < source.Length)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpanSplitter.cs (5)

41while (srcIndex < source.Length) 49if (srcIndex == source.Length) 60if (srcIndex == source.Length) 166if (srcIndex != source.Length && (source[srcIndex] == Utf8Constants.Period || source[srcIndex] == Utf8Constants.Colon)) 181if (srcIndex == source.Length)

src\libraries\System.Private.CoreLib\src\System\Byte.cs (5)

301if (source.Length != 0) 312if ((source.Length > sizeof(byte)) && (source[..^sizeof(byte)].ContainsAnyExcept((byte)0x00))) 322result = Unsafe.Add(ref MemoryMarshal.GetReference(source), source.Length - sizeof(byte)); 334if (source.Length != 0) 345if ((source.Length > sizeof(byte)) && (source[sizeof(byte)..].ContainsAnyExcept((byte)0x00)))

src\libraries\System.Private.CoreLib\src\System\Char.cs (12)

81private static bool IsLatin1(char c) => (uint)c < (uint)Latin1CharInfo.Length; 205if (s.Length != 1) 224if (s.Length != 1) 238bytesConsumed != utf8Text.Length) 255bytesConsumed != utf8Text.Length || 1215if (source.Length != 0) 1226if ((source.Length > sizeof(char)) && (source[..^sizeof(char)].ContainsAnyExcept((byte)0x00))) 1237if (source.Length >= sizeof(char)) 1239sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(char)); 1265if (source.Length != 0) 1276if ((source.Length > sizeof(char)) && (source[sizeof(char)..].ContainsAnyExcept((byte)0x00))) 1287if (source.Length >= sizeof(char))

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\CollectionExtensions.cs (7)

105if (list._items.Length - list._size < source.Length) 107list.Grow(checked(list._size + source.Length)); 111list._size += source.Length; 137if (list._items.Length - list._size < source.Length) 139list.GrowForInsertion(index, source.Length); 146Array.Copy(list._items, index, list._items, index + source.Length, list._size - index); 153list._size += source.Length;

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\RandomizedStringEqualityComparer.cs (2)

91(uint)alternate.Length * 2, 136alternate.Length,

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(_span.Length - _pos + source.Length); 89_pos += source.Length; 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 98Grow(source.Length); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length)); 103_pos += source.Length;

src\libraries\System.Private.CoreLib\src\System\Convert.Base64.cs (3)

36int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 42if (utf16.Length == 0) 142if (srcLength != utf16.Length)

src\libraries\System.Private.CoreLib\src\System\Convert.cs (35)

2350if (bytes.Length == 0) 2356int outputLength = ToBase64_CalculateAndValidateOutputLength(bytes.Length, insertLineBreaks); 2360if (Vector128.IsHardwareAccelerated && !insertLineBreaks && bytes.Length >= Base64VectorizationLengthThreshold) 2371int charsWritten = ConvertToBase64Array(charsPtr, bytesPtr, 0, bytes.Length, insertLineBreaks); 2436if (bytes.Length == 0) 2444int charLengthRequired = ToBase64_CalculateAndValidateOutputLength(bytes.Length, insertLineBreaks); 2451if (Vector128.IsHardwareAccelerated && !insertLineBreaks && bytes.Length >= Base64VectorizationLengthThreshold) 2460int converted = ConvertToBase64Array(outChars, inData, 0, bytes.Length, insertLineBreaks); 2477Debug.Assert(bytes.Length >= Base64VectorizationLengthThreshold); 2677while (chars.Length != 0) 2688Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 2696if (indexOfFirstNonSpace == chars.Length) 2705if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 2717Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 2745for (int i = 0; i < chars.Length; i++) 2768for (int i = 0; i < chars.Length; i++) 2781consumed = chars.Length; 2945if (chars.Length == 0) 2947if ((uint)chars.Length % 2 != 0) 2950byte[] result = GC.AllocateUninitializedArray<byte>(chars.Length >> 1); 2992(int quotient, int remainder) = Math.DivRem(source.Length, 2); 3014source = source.Slice(0, source.Length - 1); 3032charsConsumed = source.Length; 3081if (bytes.Length == 0) 3083ArgumentOutOfRangeException.ThrowIfGreaterThan(bytes.Length, int.MaxValue / 2, nameof(bytes)); 3097if (source.Length == 0) 3102else if (source.Length > int.MaxValue / 2 || destination.Length < source.Length * 2) 3109charsWritten = source.Length * 2; 3158if (bytes.Length == 0) 3160ArgumentOutOfRangeException.ThrowIfGreaterThan(bytes.Length, int.MaxValue / 2, nameof(bytes)); 3174if (source.Length == 0) 3179else if (source.Length > int.MaxValue / 2 || destination.Length < source.Length * 2) 3186charsWritten = source.Length * 2;

src\libraries\System.Private.CoreLib\src\System\DateOnly.cs (3)

495if (format.Length == 1) 794if (format.Length == 0) 799if (format.Length == 1)

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (2)

293if (bits.Length == 4) 640Debug.Assert(span.Length >= 16);

src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (46)

58paramOrder[i] = new int[(par.Length > args.Length) ? par.Length : args.Length]; 63for (j = 0; j < par.Length; j++) 110if (par.Length == 0) 126else if (par.Length > args.Length) 131for (j = args.Length; j < par.Length - 1; j++) 137if (j != par.Length - 1) 152else if (par.Length < args.Length) 156int lastArgPos = par.Length - 1; 173int lastArgPos = par.Length - 1; 187int argsToCheck = (paramArrayType != null) ? par.Length - 1 : args.Length; 252if (paramArrayType != null && j == par.Length - 1) 311if (parms.Length == args.Length) 315object[] objs = new object[parms.Length]; 316int lastPos = parms.Length - 1; 323else if (parms.Length > args.Length) 325object?[] objs = new object[parms.Length]; 327for (i = 0; i < parms.Length; i++) 336if (i == parms.Length - 1 && paramArrayTypes[0] != null) 353object[] objs = new object[parms.Length]; 354int paramArrayPos = parms.Length - 1; 401if (parameters.Length == args.Length) 405object[] objs = new object[parameters.Length]; 406int lastPos = parameters.Length - 1; 413else if (parameters.Length > args.Length) 415object?[] objs = new object[parameters.Length]; 420for (; i < parameters.Length - 1; i++) 438object[] objs = new object[parameters.Length]; 439int paramArrayPos = parameters.Length - 1; 566if (par.Length != types.Length) 801if (par.Length == 0) 894if (paramArrayType1 != null && paramOrder1[i] >= p1.Length - 1) 899if (paramArrayType2 != null && paramOrder2[i] >= p2.Length - 1) 923if (p1.Length > p2.Length) 927else if (p2.Length > p1.Length) 1102if (params1.Length != params2.Length) 1105int numParams = params1.Length; 1186bool[] used = new bool[pars.Length]; 1189for (int i = 0; i < pars.Length; i++) 1195for (j = 0; j < pars.Length; j++) 1206if (j == pars.Length) 1212for (int i = 0; i < pars.Length; i++) 1216for (; pos < pars.Length; pos++)

src\libraries\System.Private.CoreLib\src\System\Delegate.cs (1)

45for (int i = 1; i < delegates.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\StackTrace.cs (1)

305for (int j = 0; j < pi.Length; j++)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (2)

24if (payload.Length <= 0) 109for (int j = 1; j < payload.Length; j += 2)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (4)

441descriptors[0].SetMetadata(pMetadata0, providerMetadata.Length, 2); 548descriptors[0].SetMetadata(pMetadata0, providerMetadata.Length, 2); 619descriptors[0].SetMetadata(pMetadata0, providerMetadata.Length, 2); 735bool hasProviderMetadata = ProviderMetadata.Length > 0;

src\libraries\System.Private.CoreLib\src\System\Enum.cs (6)

1055while (value.Length > 0) 1066else if (endIndex != value.Length - 1) 1899if (format.Length == 1) 2109Debug.Assert(foundItems.Length >= 2, $"{nameof(foundItems)} == {foundItems.Length}"); 2111for (int i = foundItems.Length - 1; i != 0; i--)

src\libraries\System.Private.CoreLib\src\System\Environment.Variables.Windows.cs (1)

122currentPtr += variable.Length + 1;

src\libraries\System.Private.CoreLib\src\System\Globalization\CalendricalCalculationsHelper.cs (1)

128for (int i = 1; i < coefficients.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.cs (12)

141if (text.Length == 0) 291InvariantModeCasing.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(string1), string1.Length, ref MemoryMarshal.GetReference(string2), string2.Length) : 438return Ordinal.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(string1), string1.Length, ref MemoryMarshal.GetReference(string2), string2.Length); 452return Ordinal.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(string1), string1.Length, ref MemoryMarshal.GetReference(string2), string2.Length); 611matchLength = (matched) ? prefix.Length : 0; 754matchLength = (matched) ? suffix.Length : 0; 1064return (fromBeginning) ? 0 : source.Length; 1106*matchLengthPtr = value.Length; 1329return source.Length; // Empty target string trivially occurs at the last index of every search space.

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Icu.cs (89)

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Invariant.cs (8)

46Debug.Assert(sortKey.Length >= source.Length * sizeof(char)); 48for (int i = 0; i < source.Length; i++) 58Debug.Assert(sortKey.Length >= source.Length * sizeof(char)); 60for (int i = 0; i < source.Length; i++) 63if (char.IsHighSurrogate(c) && i < source.Length - 1) 93if ((uint)destination.Length < (uint)source.Length * sizeof(char)) 107return source.Length * sizeof(char); 119int byteLength = source.Length * sizeof(char);

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Nls.cs (16)

63source.Length, 65value.Length, 68Debug.Assert(ret >= -1 && ret <= source.Length); 82Debug.Assert(source.Length != 0); 83Debug.Assert(value.Length != 0); 129int sourceLength = source.Length; 241string1.Length, 243string2.Length, 275int lpStringSourceLength = lpStringSource.Length; 294lpStringValue.Length, 300Debug.Assert(result >= -1 && result <= lpStringSource.Length); 314Debug.Assert(target.Length != 0); 354*matchLengthPtr = source.Length - idx; // all chars from idx to the end of the string are consumed 455int sourceLength = source.Length; 534int sourceLength = source.Length; 574return Interop.Kernel32.IsNLSDefinedString(Interop.Kernel32.COMPARE_STRING, 0, IntPtr.Zero, pText, text.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Utf8.cs (2)

83int sourceMaxCharCount = Encoding.UTF8.GetMaxCharCount(source.Length); 114int prefixMaxCharCount = Encoding.UTF8.GetMaxCharCount(prefix.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (5)

72bufferIndex += extension.Length; 367Debug.Assert(icuFormatString.Length < ICU_ULOC_FULLNAME_CAPACITY); 373for (int i = 0; i < icuFormatString.Length; i++) 386if (i + 1 < icuFormatString.Length && icuFormatString[i + 1] == '\'') 402for (; i < icuFormatString.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (15)

200while ((uint)index < (uint)format.Length && format[index] == patternChar) 289int formatLen = format.Length; 346if ((uint)(pos + 1) >= (uint)format.Length) 401for (i = index + tokenLen; i < format.Length && format[i] != patternToMatch; i++) { /* Do nothing here */ } 403if (i < format.Length) 407while (++i < format.Length && format[i] == patternToMatch) 442while (i < format.Length) 628((i + tokenLen < format.Length && format[i + tokenLen] == DateTimeFormatInfoScanner.CJKYearSuff) || 629(i + tokenLen < format.Length - 1 && format[i + tokenLen] == '\'' && format[i + tokenLen + 1] == DateTimeFormatInfoScanner.CJKYearSuff))) 1074else if (format.Length == 1) 1180while (i < format.Length) 1185if (i == format.Length - 1) 1201while (i < format.Length && format[i] != quoteChar) 1206if (i >= format.Length) 1249int length = format.Length;

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (2)

2254} while (i < str.Value.Length && (state != HebrewNumberParsingState.FoundEndOfHebrewNumber)); 2306Debug.Assert(str.Index < str.Value.Length, "DateTimeFormatInfo.Tokenize(): start < value.Length");

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (32)

85if (s.Length == 0) 91if (format.Length == 0) 178if (s.Length == 0) 411if (target.Length > (str.Value.Length - str.Index)) 423if (nextCharIndex < str.Value.Length) 2491if (s.Length == 0) 3301for (int i = 0; i < format.Length; i++) 3322while (i + 1 < format.Length && format[i + 1] == 'd') 3355if (span.Length >= 3) 3456if (span.Length >= 3) 3557if (span.Length >= 3) 3624if (span.Length >= 3) 4397for (int i = 0; i < quotedSpan.Length; i++) 4432if (format.Index >= format.Value.Length - 1 || format.Value[format.Index + 1] == '%') 4526while ((uint)pos < (uint)format.Length) 4541if ((uint)pos < (uint)format.Length) 4599if (formatParam.Length == 1) 4669if (str.Index < str.Value.Length - 1) 4794if (source.Length != 29) 4991if (source.Length < 27 || 5112if (source.Length > 27) 5118if (source.Length != 28) 5130if (source.Length == 33) 5143else if (source.Length == 32) // special-case allowed for compat: only one offset hour digit 5341for (int i = 0; i < str.Length; i++) 5392internal int Length => Value.Length; 5585int valueRemaining = Value.Length - Index; 5603if (thisPosition >= Value.Length - segmentLength) 5631while (thisPosition < Value.Length && char.IsWhiteSpace(Value[thisPosition])) 5649if (thisPosition > Value.Length - segmentLength) 5663if (nextCharIndex < Value.Length) 5898Span<char> result = new char[Value.Length - i];

src\libraries\System.Private.CoreLib\src\System\Globalization\GlobalizationMode.cs (1)

74version = icuSuffixAndVersion.AsSpan(icuSuffix.Length + 1);

src\libraries\System.Private.CoreLib\src\System\Globalization\GlobalizationMode.Unix.cs (1)

65string extension = version.Length > 0 ? "so." : "so";

src\libraries\System.Private.CoreLib\src\System\Globalization\IcuLocaleData.cs (7)

37045 => (LcidSortPrefix5Index, indices.Length), 3711int hi = indices.Length / 4 - 1; 3779Debug.Assert(CulturesCount == (ThreeLetterWindowsLanguageName.Length / 3)); 3821Debug.Assert(CulturesCount * 2 == LocalesNamesIndexes.Length); 3863string result = string.FastAllocateString(buffer.Length); 3864var s = new Span<char>(ref result.GetRawStringData(), buffer.Length); 3865for (int i = 0; i < buffer.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Globalization\InvariantModeCasing.cs (18)

114Debug.Assert(source.Length <= destination.Length); 116for (int i = 0; i < source.Length; i++) 119if (char.IsHighSurrogate(c) && i < source.Length - 1) 140Debug.Assert(source.Length <= destination.Length); 142for (int i = 0; i < source.Length; i++) 145if (char.IsHighSurrogate(c) && i < source.Length - 1) 226Debug.Assert(value.Length > 0); 227Debug.Assert(value.Length <= source.Length); 233char* pSourceLimit = pSource + (source.Length - value.Length); 234char* pValueLimit = pValue + value.Length - 1; 288Debug.Assert(value.Length > 0); 289Debug.Assert(value.Length <= source.Length); 295char* pValueLimit = pValue + value.Length - 1; 296char* pCurrentSource = pSource + (source.Length - value.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.cs (2)

53charsWritten = source.Length; 74return source.Length;

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Icu.cs (5)

35ret = Interop.Globalization.IsNormalized(normalizationForm, pInput, source.Length); 149realLen = Interop.Globalization.NormalizeString(normalizationForm, pInput, source.Length, pDest, destination.Length); 188realLen = Interop.Globalization.NormalizeString(normalizationForm, pInput, source.Length, null, 0); 227for (; (uint)i < (uint)s.Length; i++) 249if ((uint)(i + 1) >= (uint)s.Length || !char.IsLowSurrogate(s[i + 1]))

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Nls.cs (3)

24result = Interop.Normaliz.IsNormalizedString(normalizationForm, pInput, source.Length); 136realLength = Interop.Normaliz.NormalizeString(normalizationForm, pInput, source.Length, pDest, destination.Length); 179realLength = Interop.Normaliz.NormalizeString(normalizationForm, pInput, source.Length, null, 0);

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.cs (17)

331if (value.Length == 0) 336if (value.Length > source.Length) 363int valueTailLength = value.Length - 1; 364int searchSpaceMinusValueTailLength = source.Length - valueTailLength; 465Debug.Assert(offset + ch1ch2Distance + Vector256<ushort>.Count <= source.Length); 507if (EqualsIgnoreCase(ref Unsafe.Add(ref searchSpace, offset + charPos), ref valueRef, value.Length)) 531Debug.Assert(offset + ch1ch2Distance + Vector128<ushort>.Count <= source.Length); 573if (EqualsIgnoreCase(ref Unsafe.Add(ref searchSpace, offset + charPos), ref valueRef, value.Length)) 659if (value.Length == 0) 661return source.Length; 664if (value.Length > source.Length) 692if (destination.Length < source.Length) 698return source.Length; 704return source.Length; 708return source.Length;

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.Utf8.cs (3)

100while ((spanA.Length | spanB.Length) != 0); 410while (spanB.Length != 0);

src\libraries\System.Private.CoreLib\src\System\Globalization\OrdinalCasing.Icu.cs (17)

150for (int i = 0; i < source.Length; i++) 161for (int i = 0; i < source.Length; i++) 170if (char.IsHighSurrogate(c) && i < source.Length - 1) 290Debug.Assert(value.Length > 0); 291Debug.Assert(value.Length <= source.Length); 299char* pSourceLimit = pSource + (source.Length - value.Length); 300char* pValueLimit = pValue + value.Length - 1; 354Debug.Assert(value.Length > 0); 355Debug.Assert(value.Length <= source.Length); 363char* pValueLimit = pValue + value.Length - 1; 364char* pCurrentSource = pSource + (source.Length - value.Length); 417ushort[]?[] table = new ushort[]?[s_casingTableInit.Length * 8]; 418for (int i = 0; i < s_casingTableInit.Length * 8; ++i)

src\libraries\System.Private.CoreLib\src\System\Globalization\StringInfo.cs (1)

220builder.Append(str.Length - remaining.Length); // a new extended grapheme cluster begins at this offset

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (3)

213Debug.Assert(destination.Length >= source.Length); 220Debug.Assert(destination.Length >= source.Length); 254ChangeCaseCore(pSource + charsConsumed, source.Length - charsConsumed, pDestination + charsConsumed, destination.Length - charsConsumed, toUpper);

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanFormat.cs (9)

55if (format.Length == 0) 60if (format.Length == 1) 162requiredOutputLength += decimalSeparator.Length; 172requiredOutputLength += decimalSeparator.Length; 275else if (decimalSeparator.Length == 1) 281decimalSeparator.CopyTo(new Span<TChar>(p, decimalSeparator.Length)); 282p += decimalSeparator.Length; 318while (i < format.Length) 513for (int i = 0; i < format.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanParse.cs (15)

188if ((uint)pos >= (uint)value.Length) 205if ((uint)++pos >= (uint)value.Length || (uint)(digit = value[pos] - '0') > 9) 225while ((uint)++pos < (uint)value.Length) 248while ((uint)++pos < (uint)value.Length && !char.IsAsciiDigit(value[pos])) 258internal bool EOL => _pos >= (_value.Length - 1); 268return (uint)pos < (uint)_value.Length ? 591Debug.Assert(powersOfTen.Length == MaxFractionDigits + 1); 1230if (format.Length == 0) 1235if (format.Length == 1) 1269while ((uint)i < (uint)format.Length) 1451for (int i = 0; i < span.Length; i++) 1479if (_pos < str.Length) 1485_ch = (uint)pos < (uint)str.Length ? 1559if (_pos < _str.Length) 1669if (input.Length == 0)

src\libraries\System.Private.CoreLib\src\System\Globalization\UmAlQuraCalendar.cs (1)

230DateMapping[] mapping = new DateMapping[rawData.Length / 4];

src\libraries\System.Private.CoreLib\src\System\Guid.cs (31)

src\libraries\System.Private.CoreLib\src\System\HashCode.cs (2)

321ref byte end = ref Unsafe.Add(ref pos, value.Length); 323if (value.Length < (sizeof(int) * 4))

src\libraries\System.Private.CoreLib\src\System\Int128.cs (14)

756if (source.Length != 0) 766if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= Size)) 775if (source.Length > Size) 798if (source.Length >= Size) 800sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size); 816for (int i = 0; i < source.Length; i++) 824result |= ((One << ((Size * 8) - 1)) >> (((Size - source.Length) * 8) - 1)); 838if (source.Length != 0) 848if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= Size)) 857if (source.Length > Size) 880if (source.Length >= Size) 898for (int i = 0; i < source.Length; i++) 904result <<= ((Size - source.Length) * 8); 909result |= ((One << ((Size * 8) - 1)) >> (((Size - source.Length) * 8) - 1));

src\libraries\System.Private.CoreLib\src\System\Int16.cs (9)

304if (source.Length != 0) 314if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(short))) 323if (source.Length > sizeof(short)) 346if (source.Length >= sizeof(short)) 348sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(short)); 379if (source.Length != 0) 389if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(short))) 398if (source.Length > sizeof(short)) 421if (source.Length >= sizeof(short))

src\libraries\System.Private.CoreLib\src\System\Int32.cs (14)

324if (source.Length != 0) 334if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(int))) 343if (source.Length > sizeof(int)) 366if (source.Length >= sizeof(int)) 368sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(int)); 384for (int i = 0; i < source.Length; i++) 392result |= ((1 << ((sizeof(int) * 8) - 1)) >> (((sizeof(int) - source.Length) * 8) - 1)); 406if (source.Length != 0) 416if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(int))) 425if (source.Length > sizeof(int)) 448if (source.Length >= sizeof(int)) 466for (int i = 0; i < source.Length; i++) 472result <<= ((sizeof(int) - source.Length) * 8); 477result |= ((1 << ((sizeof(int) * 8) - 1)) >> (((sizeof(int) - source.Length) * 8) - 1));

src\libraries\System.Private.CoreLib\src\System\Int64.cs (14)

321if (source.Length != 0) 331if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(long))) 340if (source.Length > sizeof(long)) 363if (source.Length >= sizeof(long)) 365sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(long)); 381for (int i = 0; i < source.Length; i++) 389result |= ((1L << ((sizeof(long) * 8) - 1)) >> (((sizeof(long) - source.Length) * 8) - 1)); 403if (source.Length != 0) 413if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(long))) 422if (source.Length > sizeof(long)) 445if (source.Length >= sizeof(long)) 463for (int i = 0; i < source.Length; i++) 469result <<= ((sizeof(long) - source.Length) * 8); 474result |= ((1L << ((sizeof(long) * 8) - 1)) >> (((sizeof(long) - source.Length) * 8) - 1));

src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (14)

326if (source.Length != 0) 336if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(nint_t))) 345if (source.Length > sizeof(nint_t)) 368if (source.Length >= sizeof(nint_t)) 370sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(nint_t)); 386for (int i = 0; i < source.Length; i++) 394result |= (((nint)1 << ((sizeof(nint_t) * 8) - 1)) >> (((sizeof(nint_t) - source.Length) * 8) - 1)); 408if (source.Length != 0) 418if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(nint_t))) 427if (source.Length > sizeof(nint_t)) 450if (source.Length >= sizeof(nint_t)) 468for (int i = 0; i < source.Length; i++) 474result <<= ((sizeof(nint_t) - source.Length) * 8); 479result |= (((nint)1 << ((sizeof(nint_t) * 8) - 1)) >> (((sizeof(nint_t) - source.Length) * 8) - 1));

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (4)

392byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length); 396Write(array, 0, buffer.Length); 422if (chars.Length <= MaxArrayPoolRentalSize) 427int maxByteCount = _encoding.GetMaxByteCount(chars.Length);

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (6)

783int bytesToWrite = Math.Min(_bufferSize - _writePos, buffer.Length); 940totalUserbytes = _writePos + buffer.Length; 942useBuffer = ((uint)totalUserbytes + buffer.Length < (_bufferSize + _bufferSize)); 952Debug.Assert(bytesWritten == buffer.Length); 966Debug.Assert(bytesWritten == buffer.Length); 982buffer.CopyTo(new Span<byte>(_buffer, _writePos, buffer.Length));

src\libraries\System.Private.CoreLib\src\System\IO\DirectoryInfo.cs (3)

91&& ((trimmedNewPath.Length == trimmedCurrentPath.Length) || PathInternal.IsDirectorySeparator(newPath[trimmedCurrentPath.Length])))

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

38ReadOnlySpan<char> relativePath = Directory.Slice(RootDirectory.Length);

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEntry.Unix.cs (6)

84if (_fullPath.Length == 0) 86Debug.Assert(Directory.Length + FileName.Length < _pathBuffer.Length, 87$"directory ({Directory.Length} chars) & name ({Directory.Length} chars) too long for buffer ({_pathBuffer.Length} chars)"); 100if (_directoryEntry.NameLength != 0 && _fileName.Length == 0)

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEnumerableFactory.cs (2)

49if (directoryName.Length != 0) 53expression = expression.Substring(directoryName.Length + 1);

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemName.cs (11)

148if (expression.Length == 0 || name.Length == 0) 154if (expression.Length == 1) 169if (name.Length < expressionEnd.Length) 193int maxState = expression.Length * 2; 219if (nameOffset < name.Length) 246while (expressionOffset < expression.Length) 280for (int offset = nameOffset; offset < name.Length; offset++) 338if (++expressionOffset == expression.Length) 374if (++expressionOffset == expression.Length)

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (5)

1508int preambleSize = preamble.Length; 1523int bytesNeeded = checked(preambleSize + encoding.GetMaxByteCount(Math.Min(contents.Length, ChunkSize))); 1541ReadOnlySpan<char> toEncode = contents.Slice(0, Math.Min(contents.Length, ChunkSize)); 1542contents = contents.Slice(toEncode.Length); 1615if (contents.Length < ChunkSize)

src\libraries\System.Private.CoreLib\src\System\IO\FileStatus.Unix.cs (2)

195Debug.Assert(handle is not null || path.Length > 0); 500Debug.Assert(handle is not null || path.Length > 0);

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

353stackDir.Append(mkdirPath.Length);

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

636int i = _position + buffer.Length; 658buffer.CopyTo(new Span<byte>(_buffer, _position, buffer.Length));

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (58)

161int end = path.Length; 197int length = path.Length; 227if (path.Length == result.Length) 238int root = GetPathRoot(path).Length; 257if (path.Length == result.Length) 331for (int i = path.Length - 1; i >= 0; i--) 336return i != path.Length - 1; 390for (int i = 0; i < paths.Length; i++) 417for (int i = firstComponent; i < paths.Length; i++) 448if (path1.Length == 0) 450if (path2.Length == 0) 458if (path1.Length == 0) 461if (path2.Length == 0) 464if (path3.Length == 0) 472if (path1.Length == 0) 475if (path2.Length == 0) 478if (path3.Length == 0) 481if (path4.Length == 0) 552maxSize += paths.Length - 1; 557for (int i = 0; i < paths.Length; i++) 586if (path1.Length == 0 && path2.Length == 0) 589if (path1.Length == 0 || path2.Length == 0) 591ref ReadOnlySpan<char> pathToUse = ref path1.Length == 0 ? ref path2 : ref path1; 592if (destination.Length < pathToUse.Length) 598charsWritten = pathToUse.Length; 603int charsNeeded = path1.Length + path2.Length + (needsSeparator ? 1 : 0); 609destination[path1.Length] = DirectorySeparatorChar; 611path2.CopyTo(destination.Slice(path1.Length + (needsSeparator ? 1 : 0))); 620if (path1.Length == 0 && path2.Length == 0 && path3.Length == 0) 623if (path1.Length == 0) 625if (path2.Length == 0) 627if (path3.Length == 0) 635int charsNeeded = path1.Length + path2.Length + path3.Length + neededSeparators; 646charsWritten += path3.Length; 705Debug.Assert(first.Length > 0 && second.Length > 0, "should have dealt with empty paths"); 716Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0, "should have dealt with empty paths"); 732Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0 && fourth.Length > 0, "should have dealt with empty paths"); 746first.Length + second.Length + third.Length + fourth.Length + state.NeedSeparator1 + state.NeedSeparator2 + state.NeedSeparator3, 752destination = destination.Slice(first.Length); 762destination = destination.Slice(second.Length); 772destination = destination.Slice(third.Length); 781Debug.Assert(fourth.Length == destination.Length);

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

104int totalByteCount = checked(tempPathByteCount + fileTemplate.Length + 1);

src\libraries\System.Private.CoreLib\src\System\IO\RandomAccess.Unix.cs (2)

109int bytesToWrite = GetNumberOfBytesToWrite(buffer.Length); 134if (bytesWritten == buffer.Length)

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

499if (numBytes >= source.Length) 502_writePos += source.Length; 522if (source.Length >= _bufferSize) 541else if (source.Length == 0) 549_writePos = source.Length;

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

245_filePosition += buffer.Length;

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

914byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 918Write(sharedBuffer, 0, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (10)

174int preambleLength = encoding.Preamble.Length; 551Debug.Assert(_bytePos < preamble.Length, "_compressPreamble was called with the current bytePos greater than the preamble buffer length. Are two threads using this StreamReader at the same time?"); 552int len = Math.Min(_byteLen, preamble.Length); 565Debug.Assert(_bytePos <= preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 567if (_bytePos == preamble.Length) 570CompressBuffer(preamble.Length); 596Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 700Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 1138Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 1333Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?");

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (6)

292if (preamble.Length > 0) 403if (buffer.Length <= 4 && // Threshold of 4 chosen based on perf experimentation 404buffer.Length <= _charLen - _charPos) 408for (int i = 0; i < buffer.Length; i++) 428int count = buffer.Length; 503int estimatedLength = checked((format?.Length ?? 0) + args.Length * 8);

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

162char[] array = ArrayPool<char>.Shared.Rent(buffer.Length); 167Write(array, 0, buffer.Length); 366char[] array = ArrayPool<char>.Shared.Rent(buffer.Length); 371WriteLine(array, 0, buffer.Length);

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

632long n = pos + buffer.Length; 663if (bytesLeft < buffer.Length) 672SpanHelpers.Memmove(ref *(pointer + pos + _offset), ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length); 684SpanHelpers.Memmove(ref *(_mem + pos), ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length);

src\libraries\System.Private.CoreLib\src\System\Marvin.cs (1)

23public static int ComputeHash32(ReadOnlySpan<byte> data, ulong seed) => ComputeHash32(ref MemoryMarshal.GetReference(data), (uint)data.Length, (uint)seed, (uint)(seed >> 32));

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (310)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.cs (34)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.Utf8.cs (8)

19if ((span.Length | value.Length) == 0) // span.Length == value.Length == 0 24return Ordinal.EqualsIgnoreCaseUtf8(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length); 70if ((span.Length | value.Length) == 0) // span.Length == value.Length == 0 75return Ordinal.StartsWithIgnoreCaseUtf8(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Trim.cs (47)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Trim.Utf8.cs (3)

22if (span.Length == 0) 48while (span.Length != 0) 60while (span.Length != 0)

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (17)

38ValueStringBuilder sb = valueSpan.Length < 80 ? 40new ValueStringBuilder(valueSpan.Length + 200); 67ValueStringBuilder sb = valueSpan.Length < 80 ? 69new ValueStringBuilder(valueSpan.Length + 200); 80for (int i = 0; i < input.Length; i++) 118if ((uint)(i + 1) < (uint)input.Length && 167ValueStringBuilder sb = valueSpan.Length <= 256 ? 169new ValueStringBuilder(valueSpan.Length); 192ValueStringBuilder sb = valueSpan.Length <= 256 ? 194new ValueStringBuilder(valueSpan.Length); 205for (int i = 0; i < input.Length; i++) 280for (int i = input.IndexOfAnyExcept(s_htmlAsciiNonEncodingChars); (uint)i < (uint)input.Length; i++) 388for (int i = source.IndexOfAnyExcept(s_safeUrlBytes); (uint)i < (uint)source.Length; i++) 945var dictionary = new Dictionary<ulong, char>(tableData.Length / (sizeof(ulong) + sizeof(char))); 963if (entity.Length <= 8) 978Debug.Assert(entity.Length <= 8); 981for (int i = 0; i < entity.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Number.BigInteger.cs (1)

912Debug.Assert((Pow10BigNumTableIndices[^1] + MaxBlockCount + 2) == Pow10BigNumTable.Length);

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (15)

702if (format.Length == 0) 818if (format.Length == 0) 934if (format.Length == 0) 1050if (format.Length == 0) 1167if (format.Length == 0) 1285if (format.Length == 0) 1410int bufferLength = Math.Max(digits, FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length; 1421Debug.Assert(p == buffer + sNegative.Length); 1423for (int i = sNegative.Length - 1; i >= 0; i--) 1843int bufferLength = Math.Max(digits, FormattingHelpers.CountDigits((ulong)(-value))) + sNegative.Length; 1854Debug.Assert(p == buffer + sNegative.Length); 1856for (int i = sNegative.Length - 1; i >= 0; i--) 2273int bufferLength = Math.Max(digits, FormattingHelpers.CountDigits(absValue)) + sNegative.Length; 2284Debug.Assert(p == buffer + sNegative.Length); 2286for (int i = sNegative.Length - 1; i >= 0; i--)

src\libraries\System.Private.CoreLib\src\System\Number.Grisu3.cs (6)

476Debug.Assert((uint)(exponentGuess) < SmallPowersOfTen.Length); 820Debug.Assert(CachedPowersSignificand.Length == CachedPowersBinaryExponent.Length); 821Debug.Assert(CachedPowersSignificand.Length == CachedPowersDecimalExponent.Length); 826Debug.Assert((uint)(index) < CachedPowersSignificand.Length);

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (24)

src\libraries\System.Private.CoreLib\src\System\Numerics\INumberBase.cs (4)

310int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 444int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 546int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 593int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length);

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector.cs (1)

755if (values.Length < Vector<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector_1.cs (2)

92if (values.Length < Count) 110if (values.Length < Vector<byte>.Count)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector2.cs (1)

407if (values.Length < ElementCount)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector3.cs (1)

442if (values.Length < ElementCount)

src\libraries\System.Private.CoreLib\src\System\ParseNumbers.cs (7)

35int length = s.Length; 123int length = s.Length; 208for (; localIndex < s.Length && char.IsWhiteSpace(s[localIndex]); localIndex++) ; 223while (i < s.Length && IsDigit(s[i], radix, out int value)) 250while (i < s.Length && IsDigit(s[i], radix, out int value)) 284while (i < s.Length && IsDigit(s[i], radix, out int value)) 309while (i < s.Length && IsDigit(s[i], radix, out int value))

src\libraries\System.Private.CoreLib\src\System\Random.cs (6)

209choices.Length <= 256) 215if (BitOperations.IsPow2(choices.Length)) 221int mask = choices.Length - 1; 247int mask = (int)BitOperations.RoundUpToPowerOf2((uint)choices.Length) - 1; 270if (masked < (uint)choices.Length) 286destination[i] = choices[Next(choices.Length)];

src\libraries\System.Private.CoreLib\src\System\ReadOnlySpan.cs (2)

227return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length); 255if (index < _span.Length)

src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyName.cs (1)

363charsToCopy = stringToEscape.Length;

src\libraries\System.Private.CoreLib\src\System\Reflection\EventInfo.cs (1)

50for (int i = 0; i < p.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Reflection\InvokerEmitUtil.cs (3)

50for (int i = 0; i < parameters.Length; i++) 118for (int i = 0; i < parameters.Length; i++) 175for (int i = 0; i < parameters.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBase.cs (3)

129if (paramInfo.Length == 0) 134Type[] parameterTypes = new Type[paramInfo.Length]; 135for (int i = 0; i < paramInfo.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBaseInvoker.cs (1)

354for (int i = 0; i < parameters.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Reflection\NullabilityInfoContext.cs (2)

119for (int i = 0; i < parameters.Length; i++) 214ParameterInfo parameter = parameters[parameters.Length - 1];

src\libraries\System.Private.CoreLib\src\System\Reflection\ParameterInfo.cs (2)

84if (PositionImpl < args.Length) 93if (PositionImpl > -1 && PositionImpl < args.Length)

src\libraries\System.Private.CoreLib\src\System\Reflection\TypeNameResolver.cs (2)

109Type[] genericTypes = new Type[genericArgs.Length]; 110for (int i = 0; i < genericArgs.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\DefaultInterpolatedStringHandler.cs (7)

409_pos += value.Length; 430int paddingRequired = alignment - value.Length; 440EnsureCapacityForAdditionalChars(value.Length + paddingRequired); 444_pos += value.Length; 453_pos += value.Length; 616Grow(value.Length); 618_pos += value.Length;

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\RuntimeHelpers.cs (1)

139if ((int)srcET >= primitiveWidenTable.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Java\JavaMarshal.cs (1)

72(nuint)unreachableObjectHandles.Length,

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ReadOnlySpanMarshaller.cs (5)

50numElements = managed.Length; 114if (managed.Length <= buffer.Length) 116_span = buffer[0..managed.Length]; 120int bufferSize = checked(managed.Length * sizeof(TUnmanagedElement)); 122_span = new Span<TUnmanagedElement>(_allocatedMemory, managed.Length);

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

61checked(span.Length * sizeof(T))); 100internal static unsafe ref T GetNonNullPinnableReference<T>(ReadOnlySpan<T> span) => ref (span.Length != 0) ? ref Unsafe.AsRef(in span._reference) : ref Unsafe.AsRef<T>((void*)1); 182uint fromLength = (uint)span.Length; 475if (sizeof(T) > source.Length) 494if (sizeof(T) > (uint)source.Length) 578if (sizeof(T) > (uint)span.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\SafeBuffer.cs (2)

328SpaceCheck(ptr, checked((nuint)(alignedSizeofT * data.Length))); 336for (int i = 0; i < data.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\TypeMapLazyDictionary.cs (2)

112int needed = (utf8TypeName.Length < 1024) 113? Encoding.UTF8.GetMaxCharCount(utf8TypeName.Length)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\ISimdVector_2.cs (1)

253if (values.Length < TSelf.ElementCount)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (1)

936if (values.Length < Vector128<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (1)

952if (values.Length < Vector256<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (1)

853if (values.Length < Vector512<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (1)

925if (values.Length < Vector64<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Versioning\FrameworkName.cs (2)

163if (value.Length > 0 && (value[0] == VersionValuePrefix || value[0] == 'V')) 181if (value.Length > 0)

src\libraries\System.Private.CoreLib\src\System\RuntimeType.cs (1)

659finalist.GetParametersAsSpan().Length == 0 &&

src\libraries\System.Private.CoreLib\src\System\SByte.cs (5)

307if (source.Length != 0) 326if (source.Length > sizeof(sbyte)) 348result = (sbyte)Unsafe.Add(ref MemoryMarshal.GetReference(source), source.Length - sizeof(sbyte)); 360if (source.Length != 0) 379if (source.Length > sizeof(sbyte))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any1CharPackedIgnoreCaseSearchValues.cs (2)

37PackedSpanHelpers.IndexOfAnyIgnoreCase(ref MemoryMarshal.GetReference(span), _lowerCase, span.Length); 42PackedSpanHelpers.IndexOfAnyExceptIgnoreCase(ref MemoryMarshal.GetReference(span), _lowerCase, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any1CharPackedSearchValues.cs (2)

27PackedSpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), _e0, span.Length); 32PackedSpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), _e0, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any1SearchValues.cs (5)

20Debug.Assert(values.Length == 1); 36SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 40SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 44SpanHelpers.LastIndexOfValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any2CharPackedIgnoreCaseSearchValues.cs (4)

44PackedSpanHelpers.IndexOfAnyIgnoreCase(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length); 49PackedSpanHelpers.IndexOfAnyExceptIgnoreCase(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length); 57ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 65ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any2CharPackedSearchValues.cs (2)

27PackedSpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length); 32PackedSpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any2SearchValues.cs (5)

20Debug.Assert(values.Length == 2); 36SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 40SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 44SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any3CharPackedSearchValues.cs (2)

27PackedSpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), _e0, _e1, _e2, span.Length); 32PackedSpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), _e0, _e1, _e2, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any3SearchValues.cs (5)

20Debug.Assert(values.Length == 3); 36SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 40SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 44SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any4SearchValues.cs (5)

20Debug.Assert(values.Length == 4); 39SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 43SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 47SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 51SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Any5SearchValues.cs (5)

20Debug.Assert(values.Length == 5); 40SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 44SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 48SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 52SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\AnyByteSearchValues.cs (6)

32ref MemoryMarshal.GetReference(span), span.Length, ref _state); 40ref MemoryMarshal.GetReference(span), span.Length, ref _state); 48ref MemoryMarshal.GetReference(span), span.Length, ref _state); 56ref MemoryMarshal.GetReference(span), span.Length, ref _state); 64ref MemoryMarshal.GetReference(span), span.Length, ref _state); 72ref MemoryMarshal.GetReference(span), span.Length, ref _state);

src\libraries\System.Private.CoreLib\src\System\SearchValues\AsciiByteSearchValues.cs (6)

48ref MemoryMarshal.GetReference(span), span.Length, ref _state); 56ref MemoryMarshal.GetReference(span), span.Length, ref _state); 64ref MemoryMarshal.GetReference(span), span.Length, ref _state); 72ref MemoryMarshal.GetReference(span), span.Length, ref _state); 80ref MemoryMarshal.GetReference(span), span.Length, ref _state); 88ref MemoryMarshal.GetReference(span), span.Length, ref _state);

src\libraries\System.Private.CoreLib\src\System\SearchValues\AsciiCharSearchValues.cs (6)

49ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 57ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 65ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 73ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 81ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 89ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);

src\libraries\System.Private.CoreLib\src\System\SearchValues\BitmapCharSearchValues.cs (4)

56IndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length); 60IndexOfAny<IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length); 64LastIndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length); 68LastIndexOfAny<IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\EmptySearchValues.cs (1)

25span.Length - 1;

src\libraries\System.Private.CoreLib\src\System\SearchValues\IndexOfAnyAsciiSearcher.cs (1)

103if (!IsVectorizationSupported || values.Length > 16)

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticCharSearchValues.cs (4)

26ProbabilisticMap.IndexOfAny<SearchValues.TrueConst>(ref MemoryMarshal.GetReference(span), span.Length, ref _map); 29ProbabilisticMapState.IndexOfAnySimpleLoop<SearchValues.TrueConst, IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length, ref _map); 32ProbabilisticMap.LastIndexOfAny<SearchValues.TrueConst>(ref MemoryMarshal.GetReference(span), span.Length, ref _map); 35ProbabilisticMapState.LastIndexOfAnySimpleLoop<SearchValues.TrueConst, IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length, ref _map);

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMap.cs (2)

49for (int i = 0; i < values.Length; ++i) 110values.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMapState.cs (3)

133int modulus = HashHelpers.GetPrime(values.Length); 150modulus = HashHelpers.GetPrime(values.Length); 196if (unique.Count == values.Length)

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticWithAsciiCharSearchValues.cs (18)

44if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128<short>.Count && char.IsAscii(span[0])) 61span.Length, 71span.Length, 76if ((uint)offset >= (uint)span.Length || char.IsAscii(span[offset])) 87span.Length, 105if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128<short>.Count && char.IsAscii(span[0])) 110span.Length, 114if ((uint)offset >= (uint)span.Length || char.IsAscii(span[offset])) 125span.Length, 141if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128<short>.Count && char.IsAscii(span[^1])) 160span.Length, 170span.Length, 175if ((uint)offset >= (uint)span.Length || char.IsAscii(span[offset])) 186span.Length, 194if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128<short>.Count && char.IsAscii(span[^1])) 199span.Length, 203if ((uint)offset >= (uint)span.Length || char.IsAscii(span[offset])) 214span.Length,

src\libraries\System.Private.CoreLib\src\System\SearchValues\RangeCharSearchValues.cs (4)

43? PackedSpanHelpers.IndexOfAnyInRange(ref MemoryMarshal.GetReference(span), _lowInclusive, _rangeInclusive, span.Length) 48span.Length); 53? PackedSpanHelpers.IndexOfAnyExceptInRange(ref MemoryMarshal.GetReference(span), _lowInclusive, _rangeInclusive, span.Length) 58span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\SearchValues.cs (13)

35if (values.Length == 1) 48if (values.Length >= 4 && IndexOfAnyAsciiSearcher.CanUseUniqueLowNibbleSearch(values, maxInclusive)) 53if (values.Length <= 5) 55Debug.Assert(values.Length is 2 or 3 or 4 or 5); 56return values.Length switch 88if (values.Length == 1) 105if (values.Length == 2) 123if (values.Length == 3) 138maxInclusive < 128 && values.Length == 4 && minInclusive > 0) 169if (values.Length == 4) 174if (values.Length == 5) 189if (ShouldUseProbabilisticMap(values.Length, maxInclusive)) 260if (range > values.Length)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\AsciiStringSearchValuesTeddyBase.cs (19)

157if (Vector512.IsHardwareAccelerated && Avx512Vbmi.IsSupported && span.Length >= CharsPerIterationAvx512 + MatchStartOffsetN2) 162if (Avx2.IsSupported && span.Length >= CharsPerIterationAvx2 + MatchStartOffsetN2) 177if (Vector512.IsHardwareAccelerated && Avx512Vbmi.IsSupported && span.Length >= CharsPerIterationAvx512 + MatchStartOffsetN3) 182if (Avx2.IsSupported && span.Length >= CharsPerIterationAvx2 + MatchStartOffsetN3) 197if (span.Length < CharsPerIterationVector128 + MatchStartOffsetN2) 203ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationVector128); 252Debug.Assert(span.Length >= CharsPerIterationAvx2 + MatchStartOffsetN2); 255ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx2); 304Debug.Assert(span.Length >= CharsPerIterationAvx512 + MatchStartOffsetN2); 307ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx512); 356if (span.Length < CharsPerIterationVector128 + MatchStartOffsetN3) 362ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationVector128); 429Debug.Assert(span.Length >= CharsPerIterationAvx2 + MatchStartOffsetN3); 432ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx2); 484Debug.Assert(span.Length >= CharsPerIterationAvx512 + MatchStartOffsetN3); 487ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx512); 548int lengthRemaining = span.Length - offsetFromStart; 595int lengthRemaining = span.Length - offsetFromStart; 640int lengthRemaining = span.Length - offsetFromStart;

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasick.cs (8)

92int remainingLength = span.Length - i; 115if ((uint)i >= (uint)span.Length) 122Debug.Assert((uint)i < (uint)span.Length); 204int remainingLength = span.Length - i; 224if ((uint)i >= (uint)span.Length) 231Debug.Assert((uint)i < (uint)span.Length); 246(uint)(i + 1) < (uint)span.Length && 268Ordinal.ToUpperOrdinal(span.Slice(i, i + 1 == span.Length ? 1 : 2), destination);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasickBuilder.cs (1)

29for (int i = 1; i < values.Length; i++)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\CharacterFrequencyHelper.cs (1)

89for (int i = 1; i < span.Length; i++)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\RabinKarp.cs (8)

42Debug.Assert(values.Length <= MaxValues); 112Debug.Assert(span.Length <= MaxInputLength, "Teddy should have handled short inputs."); 118if (span.Length >= hashLength) 120ref char end = ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (uint)(span.Length - hashLength)); 139if (StartsWith<TCaseSensitivity>(ref current, span.Length - startOffset, bucket)) 164Debug.Assert(span.Length <= MaxInputLength, "Teddy should have handled long inputs."); 166if (_hashLength > span.Length) 172Span<char> upperCase = stackalloc char[MaxInputLength].Slice(0, span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\StringSearchValuesHelper.cs (1)

35int availableLength = span.Length - currentOffset;

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\TeddyBucketizer.cs (6)

17Debug.Assert(values.Length <= 8); 22for (int i = 0; i < values.Length; i++) 78Debug.Assert(values.Length > bucketCount, "Should be using a non-bucketized implementation."); 79Debug.Assert(values.Length <= RabinKarp.MaxValues); 83Span<int> bucketIndexes = stackalloc int[RabinKarp.MaxValues].Slice(0, values.Length); 90for (int i = 0; i < values.Length; i++)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\MultiStringIgnoreCaseSearchValuesFallback.cs (1)

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

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (1)

75IndexOf(ref MemoryMarshal.GetReference(span), span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (10)

28if (values.Length == 0) 33if (values.Length == 1) 44var uniqueValues = new HashSet<string>(values.Length, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 124if (values.Length == 1) 189if (values.Length > RabinKarp.MaxValues) 259values.Length < TeddyBucketCount && 293Debug.Assert(values.Length > 1); 296if (values.Length > TeddyBucketCount) 318Debug.Assert(values.Length < maxValues); 340Debug.Assert(newValuesCount > values.Length, "Shouldn't have been called if there were no letters present");

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValuesBase.cs (2)

57for (int i = 0; i < span.Length; i++) 71for (int i = span.Length - 1; i >= 0; i--)

src\libraries\System.Private.CoreLib\src\System\Security\SecureString.cs (2)

37_buffer = UnmanagedBuffer.Allocate(GetAlignedByteSize(value.Length)); 38_decryptedLength = value.Length;

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.BinarySearch.cs (1)

20return BinarySearch(ref MemoryMarshal.GetReference(span), span.Length, comparable);

src\libraries\System.Private.CoreLib\src\System\StartupHookProvider.cs (2)

111for (int j = 0; j < disallowedSimpleAssemblyNameChars.Length; j++) 209initializeMethod.GetParametersAsSpan().Length == 0);

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (8)

456=> SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(strA), strA.Length, ref MemoryMarshal.GetReference(strB), strB.Length); 779return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)value.Length * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 812return Marvin.ComputeHash32OrdinalIgnoreCase(ref MemoryMarshal.GetReference(value), value.Length /* in chars, not bytes */, (uint)seed, (uint)(seed >> 32)); 865int length = span.Length; 975int length = span.Length; 1052return GetNonRandomizedHashCodeOrdinalIgnoreCaseSlow(hash1, hash2, span.Slice(span.Length - length)); 1057int length = str.Length;

src\libraries\System.Private.CoreLib\src\System\String.cs (5)

313if (value.Length == 0) 316string result = FastAllocateString(value.Length); 317Buffer.Memmove(ref result._firstChar, ref MemoryMarshal.GetReference(value), (uint)value.Length); 774if (s.Length > MaxLength) 783if (s.Length <= MaxLength)

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (75)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.CaseConversion.cs (2)

170if (source.Length <= destination.Length) 172numElementsToConvert = (uint)source.Length;

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.cs (2)

22IsValidCore(ref MemoryMarshal.GetReference(value), value.Length); 32IsValidCore(ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(value)), value.Length);

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Equality.cs (18)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Transcoding.cs (4)

25if (source.Length <= destination.Length) 27numElementsToConvert = (uint)source.Length; 60if (source.Length <= destination.Length) 62numElementsToConvert = (uint)source.Length;

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Trimming.cs (2)

57for (; start < value.Length; start++) 67int end = value.Length - 1;

src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (8)

146return GetByteCountCommon(charsPtr, chars.Length); 321return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length); 331int written = GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length, throwForDestinationOverflow: false); 393int numElementsToConvert = Math.Min(chars.Length, bytes.Length); 488return GetCharCountCommon(bytesPtr, bytes.Length); 612return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length); 622int written = GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length, throwForDestinationOverflow: false); 681int numElementsToConvert = Math.Min(bytes.Length, chars.Length);

src\libraries\System.Private.CoreLib\src\System\Text\CompositeFormat.cs (1)

343if ((uint)pos >= (uint)format.Length)

src\libraries\System.Private.CoreLib\src\System\Text\Decoder.cs (3)

114return GetCharCount(bytesPtr, bytes.Length, flush); 201return GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length, flush); 307Convert(bytesPtr, bytes.Length, charsPtr, chars.Length, flush, out bytesUsed, out charsUsed, out completed);

src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (2)

210return (Fallback(remainingBytes.Slice(0, fallbackLength).ToArray(), index: _originalByteCount - remainingBytes.Length)) 217if (Fallback(remainingBytes.Slice(0, fallbackLength).ToArray(), index: _originalByteCount - remainingBytes.Length))

src\libraries\System.Private.CoreLib\src\System\Text\DecoderNLS.cs (3)

211_leftoverByteCount = bytes.Length; 380for (int i = 0; i < srcLeft.Length; i++) 392for (int i = 0; i < srcRight.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Text\Encoder.cs (3)

112return GetByteCount(charsPtr, chars.Length, flush); 198return GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length, flush); 306Convert(charsPtr, chars.Length, bytesPtr, bytes.Length, flush, out charsUsed, out bytesUsed, out completed);

src\libraries\System.Private.CoreLib\src\System\Text\EncoderFallback.cs (2)

137if (chars.Length > 1) 145int index = originalCharCount - chars.Length;

src\libraries\System.Private.CoreLib\src\System\Text\EncoderLatin1BestFitFallback.cs (3)

126int highBound = ArrayCharBestFit.Length; 142Debug.Assert(index + 1 < ArrayCharBestFit.Length, 163Debug.Assert(index + 1 < ArrayCharBestFit.Length,

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (5)

585return GetByteCount(charsPtr, chars.Length); 732return GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length); 787return GetCharCount(bytesPtr, bytes.Length); 881return GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length); 917return string.CreateStringFromEncoding(bytesPtr, bytes.Length, this);

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (15)

273charsLength: chars.Length, 366charsLength: chars.Length, 550charsLength: chars.Length, 571encoder._charsUsed = originalCharCount - chars.Length; // total number of characters consumed up until now 608Debug.Assert(charsConsumedThisIteration == chars.Length, "If returning NeedMoreData, should out the entire buffer length as chars consumed."); 653charsLength: chars.Length, 697Debug.Assert(originalCharsLength >= chars.Length, "About to report a negative number of chars used?"); 698encoder._charsUsed = originalCharsLength - chars.Length; // number of chars consumed 873bytesLength: bytes.Length, 962bytesLength: bytes.Length, 1153bytesLength: bytes.Length, 1210Debug.Assert(bytesConsumedThisIteration == bytes.Length, "If returning NeedMoreData, should out the entire buffer length as bytes consumed."); 1253bytesLength: bytes.Length, 1294Debug.Assert(originalBytesLength >= bytes.Length, "About to report a negative number of bytes used?"); 1295decoder._bytesUsed = originalBytesLength - bytes.Length; // number of bytes consumed

src\libraries\System.Private.CoreLib\src\System\Text\EncodingTable.cs (10)

53int right = EncodingNameIndices.Length - 2; 57Debug.Assert(EncodingNameIndices.Length == CodePagesByName.Length + 1); 68Debug.Assert(index < EncodingNameIndices.Length - 1); 91Debug.Assert(left < EncodingNameIndices.Length - 1); 111EncodingInfo[] arrayEncodingInfo = new EncodingInfo[(LocalAppContextSwitches.EnableUnsafeUTF7Encoding) ? mappedCodePages.Length : (mappedCodePages.Length - 1)]; 116for (int i = 0; i < mappedCodePages.Length; i++) 142for (int i = 0; i < mappedCodePages.Length; i++) 180Interlocked.CompareExchange<CodePageDataItem?[]?>(ref s_codePageToCodePageData, new CodePageDataItem[MappedCodePages.Length], null);

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.cs (7)

85return GetByteCountCommon(charsPtr, chars.Length); 233return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length); 243int written = GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length, throwForDestinationOverflow: false); 380return bytes.Length; 528return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length); 535if (bytes.Length <= chars.Length) 540charsWritten = GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length);

src\libraries\System.Private.CoreLib\src\System\Text\Rune.cs (16)

341if (source.Length > 1) 370charsConsumed = source.Length; 446if (source.Length <= 1) 500if (source.Length <= 2) 525if (source.Length <= 3) 577int index = source.Length - 1; 578if ((uint)index < (uint)source.Length) 597if ((uint)index < (uint)source.Length) 621charsConsumed = (int)((uint)(-source.Length) >> 31); // 0 -> 0, all other lengths -> 1 637int index = source.Length - 1; 638if ((uint)index < (uint)source.Length) 672if ((uint)index >= (uint)source.Length) 713if (tempBytesConsumed == source.Length) 839if (input.Length <= 1) 947if (bytesConsumed == utf8Text.Length) 961if (DecodeFromUtf8(utf8Text, out Rune result, out int bytesConsumed) != OperationStatus.Done || bytesConsumed != utf8Text.Length)

src\libraries\System.Private.CoreLib\src\System\Text\SpanLineEnumerator.cs (2)

57if ((uint)idx < (uint)remaining.Length) 61if (remaining[idx] == '\r' && (uint)(idx + 1) < (uint)remaining.Length && remaining[idx + 1] == '\n')

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (33)

952long insertingChars = (long)value.Length * count; 963ReplaceInPlaceAtChunk(ref chunk!, ref indexInChunk, ref MemoryMarshal.GetReference(value), value.Length); 1096Append(ref MemoryMarshal.GetReference(value), value.Length); 1279for (int i = 1; i < values.Length; i++) 1404if (value.Length != 0) 1406Insert(index, ref MemoryMarshal.GetReference(value), value.Length); 1699if ((uint)index >= (uint)args.Length) 1746if (itemFormatSpan.Length != 0) 1882format.ValidateNumberOfArgs(args.Length); 1883return args.Length switch 2025if (span.Length != Length) 2040if (!chunk.EqualsOrdinal(span.Slice(span.Length - offset, chunk_length))) 2091if (oldValue.Length == 0) 2110while (oldValue.Length <= remainingChunk.Length) 2121remainingChunk = remainingChunk.Slice(foundPos + oldValue.Length); 2122indexInChunk += oldValue.Length; 2123count -= foundPos + oldValue.Length; 2138int move = remainingChunk.Length - (oldValue.Length - 1); 2145Debug.Assert(oldValue.Length > Math.Min(count, chunk.m_ChunkLength - indexInChunk), 2146$"oldValue.Length = {oldValue.Length}, chunk.m_ChunkLength - indexInChunk = {chunk.m_ChunkLength - indexInChunk}, count == {count}"); 2154indexInChunk += oldValue.Length; 2155count -= oldValue.Length; 2176ReplaceAllInChunk(replacements.AsSpan(), chunk, oldValue.Length, newValue); 2177index += (newValue.Length - oldValue.Length) * replacements.Length; 2362long longDelta = (value.Length - removeCount) * (long)replacements.Length; 2383ReplaceInPlaceAtChunk(ref targetChunk!, ref targetIndexInChunk, ref MemoryMarshal.GetReference<char>(value), value.Length); 2386if ((uint)i >= replacements.Length) 2423for (int i = 0; i < value.Length; i++) 3080int paddingRequired = alignment - value.Length;

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (1)

484int rentalLength = Math.Clamp(buffer.Length, MinWriteRentedArraySize, MaxWriteRentedArraySize);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (4)

64inputLength: source.Length, 155inputLength: source.Length, 250inputLength: source.Length, 604_pos += utf8Value.Length;

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.cs (2)

32byte* pFirstInvalidByte = GetPointerToFirstInvalidByte(pUtf8Data, utf8Data.Length, out int utf16CodeUnitCountAdjustment, out _); 36return (index < utf8Data.Length) ? index : -1;

src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (6)

196return GetByteCountCommon(charsPtr, chars.Length); 368return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length); 378int written = GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length, throwForDestinationOverflow: false); 489return GetCharCountCommon(bytesPtr, bytes.Length); 563return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length); 573int written = GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length, throwForDestinationOverflow: false);

src\libraries\System.Private.CoreLib\src\System\Text\ValueStringBuilder.AppendFormat.cs (2)

194if ((uint)index >= (uint)args.Length) 233if (itemFormatSpan.Length != 0)

src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (3)

886return tokens.Length switch 954_linkingRegistrations = new CancellationTokenRegistration[tokens.Length]; 956for (int i = 0; i < tokens.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (8)

4978for (int i = tasks.Length - 1; i >= 0; i--) 4995AddToList(task, ref waitedOnTaskList, initSize: tasks.Length); 5001if (!taskIsCompleted) AddToList(task, ref waitedOnTaskList, initSize: tasks.Length); 6028tasks.Length != 0 ? new WhenAllPromise(tasks) : CompletedTask; 6038Debug.Assert(tasks.Length != 0, "Expected a non-zero length task array"); 6065_remainingToComplete = tasks.Length; 6544if (tasks.Length == 2) 6944if (tasks.Length != 0)

src\libraries\System.Private.CoreLib\src\System\Threading\WaitHandle.cs (17)

242Debug.Assert(waitHandles.Length > 0); 243Debug.Assert(waitHandles.Length <= MaxWaitHandles); 249for (int i = 0; i < waitHandles.Length; ++i) 264for (int i = 0; i < waitHandles.Length; ++i) 299if (waitHandles.Length == 0) 303if (waitHandles.Length > MaxWaitHandles) 311SafeWaitHandle?[]? safeWaitHandles = RentSafeWaitHandleArray(waitHandles.Length); 319IntPtr[] unsafeWaitHandles = new IntPtr[waitHandles.Length]; 325Span<IntPtr> unsafeWaitHandles = stackalloc IntPtr[waitHandles.Length]; 330if (waitResult >= WaitAbandoned && waitResult < WaitAbandoned + waitHandles.Length) 347for (int i = 0; i < waitHandles.Length; ++i) 367Debug.Assert(safeWaitHandles.Length != 0); 368Debug.Assert(safeWaitHandles.Length <= MaxWaitHandles); 377IntPtr[] unsafeWaitHandles = new IntPtr[safeWaitHandles.Length]; 378for (int i = 0; i < safeWaitHandles.Length; ++i) 387Span<IntPtr> unsafeWaitHandles = stackalloc IntPtr[safeWaitHandles.Length]; 388for (int i = 0; i < safeWaitHandles.Length; ++i)

src\libraries\System.Private.CoreLib\src\System\TimeOnly.cs (3)

666if (format.Length == 1) 966if (format.Length == 0) 971if (format.Length == 1)

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (12)

775if (offset.Length > 0) 931if ((uint)index >= (uint)date.Length || !char.IsAsciiDigit(date[index])) 942} while ((uint)index < (uint)date.Length && char.IsAsciiDigit(date[index])); 946if (julianDay == 0 || julianDay > days[days.Length - 1]) 952while (i < days.Length && julianDay > days[i]) 957Debug.Assert(i > 0 && i < days.Length); 1023if (index < posixFormat.Length && posixFormat[index] == ',') 1028if (index < posixFormat.Length && posixFormat[index] == ',') 1041bool isBracketEnclosed = index < posixFormat.Length && posixFormat[index] == '<'; 1050if (index < posixFormat.Length && posixFormat[index] == '>') 1074if (index < posixFormat.Length && posixFormat[index] == '/') 1090for (; index < posixFormat.Length; index++)

src\libraries\System.Private.CoreLib\src\System\Type.Helpers.cs (1)

513str = str.Slice(0, str.Length - 1);

src\libraries\System.Private.CoreLib\src\System\UInt128.cs (13)

827if (source.Length != 0) 838if ((source.Length > Size) && (source[..^Size].ContainsAnyExcept((byte)0x00))) 849if (source.Length >= Size) 851sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size); 867for (int i = 0; i < source.Length; i++) 884if (source.Length != 0) 895if ((source.Length > Size) && (source[Size..].ContainsAnyExcept((byte)0x00))) 906if (source.Length >= Size) 924for (int i = 0; i < source.Length; i++) 1094Debug.Assert(left.Length >= right.Length); 1100for (int i = 0; i < right.Length; i++) 1264Debug.Assert(left.Length >= right.Length); 1272for (int i = 0; i < right.Length; i++)

src\libraries\System.Private.CoreLib\src\System\UInt16.cs (7)

298if (source.Length != 0) 309if ((source.Length > sizeof(ushort)) && (source[..^sizeof(ushort)].ContainsAnyExcept((byte)0x00))) 320if (source.Length >= sizeof(ushort)) 322sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(ushort)); 348if (source.Length != 0) 359if ((source.Length > sizeof(ushort)) && (source[sizeof(ushort)..].ContainsAnyExcept((byte)0x00))) 370if (source.Length >= sizeof(ushort))

src\libraries\System.Private.CoreLib\src\System\UInt32.cs (9)

319if (source.Length != 0) 330if ((source.Length > sizeof(uint)) && (source[..^sizeof(uint)].ContainsAnyExcept((byte)0x00))) 341if (source.Length >= sizeof(uint)) 343sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(uint)); 359for (int i = 0; i < source.Length; i++) 376if (source.Length != 0) 387if ((source.Length > sizeof(uint)) && (source[sizeof(uint)..].ContainsAnyExcept((byte)0x00))) 398if (source.Length >= sizeof(uint)) 416for (int i = 0; i < source.Length; i++)

src\libraries\System.Private.CoreLib\src\System\UInt64.cs (9)

318if (source.Length != 0) 329if ((source.Length > sizeof(ulong)) && (source[..^sizeof(ulong)].ContainsAnyExcept((byte)0x00))) 340if (source.Length >= sizeof(ulong)) 342sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(ulong)); 358for (int i = 0; i < source.Length; i++) 375if (source.Length != 0) 386if ((source.Length > sizeof(ulong)) && (source[sizeof(ulong)..].ContainsAnyExcept((byte)0x00))) 397if (source.Length >= sizeof(ulong)) 415for (int i = 0; i < source.Length; i++)

src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (9)

322if (source.Length != 0) 333if ((source.Length > sizeof(nuint_t)) && (source[..^sizeof(nuint_t)].ContainsAnyExcept((byte)0x00))) 344if (source.Length >= sizeof(nuint_t)) 346sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(nuint_t)); 362for (int i = 0; i < source.Length; i++) 379if (source.Length != 0) 390if ((source.Length > sizeof(nuint_t)) && (source[sizeof(nuint_t)..].ContainsAnyExcept((byte)0x00))) 401if (source.Length >= sizeof(nuint_t)) 419for (int i = 0; i < source.Length; i++)

src\libraries\System.Reflection.Metadata\src\System\Reflection\Metadata\TypeNameParser.cs (3)

57int errorIndex = typeName.Length - parser._inputString.Length; 255_inputString = _inputString.Slice(candidate.Length);

src\libraries\System.Reflection.Metadata\src\System\Reflection\Metadata\TypeNameParserHelpers.cs (5)

43return input.Length; // no type name end chars were found, the whole input is the type name 53isNestedType = offset > 0 && offset < input.Length && input[offset] == '+'; 59for (; offset < input.Length; offset++) 66if (offset == input.Length || // invalid name that ends with escape character 154for (; offset < input.Length; offset++)

src\System\Reflection\Emit\DynamicILGenerator.cs (4)

95stackchange -= meth.GetParametersAsSpan().Length; 412if (paramInfo.Length != 0) 414parameterTypes = new Type[paramInfo.Length]; 418for (int i = 0; i < paramInfo.Length; i++)

src\System\Reflection\Emit\RuntimeModuleBuilder.cs (2)

460Type[] parameterTypes = new Type[parameters.Length]; 464for (int i = 0; i < parameters.Length; i++)

src\System\Reflection\Emit\RuntimeTypeBuilder.cs (1)

95attr, attr.Length);

src\System\Reflection\Metadata\MetadataUpdater.cs (3)

50ApplyUpdate(new QCallAssembly(ref rtAsm), metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length);

src\System\Reflection\RuntimeAssembly.cs (2)

215nestedTypeNames.Length, 223nestedTypeNames.Length,

src\System\Reflection\RuntimeCustomAttributeData.cs (5)

264if (parameters.Length != 0) 266m_ctorParams = new CustomAttributeCtorParameter[parameters.Length]; 267for (int i = 0; i < parameters.Length; i++) 405Debug.Assert(allCtors[0].GetParametersAsSpan().Length == 0); 930Debug.Assert(size <= (_blob.Length - _curr));

src\System\Reflection\RuntimeEventInfo.cs (1)

68(parameters = m_addMethod.GetParametersAsSpan()).Length == 0)

src\System\Reflection\RuntimePropertyInfo.cs (2)

286numParams = methParams.Length; 296numParams = methParams.Length - 1;

src\System\Reflection\TypeNameResolver.CoreCLR.cs (2)

146if (typeName.Length == 0) 321for (int i = 0; i < nestedTypeNames.Length; i++)

src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (1)

215PrepareMethod(methodInfo.Value, pInstantiation, instantiationHandles.Length);

src\System\Runtime\Loader\AssemblyLoadContext.CoreCLR.cs (2)

78LoadFromStream(_nativeAssemblyLoadContext, new IntPtr(ptrAssembly), arrAssembly.Length, 79new IntPtr(ptrSymbols), arrSymbols.Length, ObjectHandleOnStack.Create(ref loadedAssembly));

src\System\RuntimeHandles.cs (6)

1846ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref type)); 1901return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstantiationContext.Length, methodInstArgs, methodInstantiationContext.Length); 1952ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref field));

src\System\RuntimeType.CoreCLR.cs (6)

2281if (argumentTypes.Length != parameterInfos.Length) 2290bool excessSuppliedArguments = argumentTypes.Length > parameterInfos.Length; 2328if (parameterInfos.Length == 0) 2332bool shortByMoreThanOneSuppliedArgument = argumentTypes.Length < parameterInfos.Length - 1; 2358for (int i = 0; i < parameterInfos.Length; i++) 3920if (invokeMethod.GetParametersAsSpan().Length == 0)

src\System\StubHelpers.cs (1)

452int numChars = Math.Min(managed.Length, length - 1);

src\System\Text\StringBuilder.CoreCLR.cs (1)

44ArgumentOutOfRangeException.ThrowIfGreaterThan(source.Length, m_MaxCapacity, "capacity");

src\System\Threading\WaitHandle.CoreCLR.cs (1)

15=> WaitMultipleIgnoringSyncContext(waitHandles, waitHandles.Length, waitAll, millisecondsTimeout);

EventSourceGenerator.Parser.cs (2)

109byte[] combinedBytes = new byte[namespaceBytes.Length + bytes.Length]; 111bytes.CopyTo(combinedBytes, namespaceBytes.Length);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(_span.Length - _pos + source.Length); 89_pos += source.Length; 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 98Grow(source.Length); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length)); 103_pos += source.Length;

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (2)

264while (buffer.Length > 0) 266int size = Math.Min(_chars.Length, buffer.Length);

System\Xml\EncodingStreamWrapper.cs (1)

184if (bom.Length > 0)

System\Xml\XmlBinaryWriter.cs (19)

System\Xml\XmlStreamNodeWriter.cs (7)

230if (bytes.Length < bufferLength) 232var buffer = GetBuffer(bytes.Length, out int offset).AsSpan(offset, bytes.Length); 234Advance(bytes.Length); 279if (value.Length < bufferLength) 281byte[] buffer = GetBuffer(value.Length, out int offset); 283Advance(value.Length);

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Net\IPv6AddressHelper.Common.cs (7)

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\DomainNameHelper.cs (7)

121length = hostname.Length; 148int labelLength = dotIndex < 0 ? hostname.Length : dotIndex; 246string asciiForm = s_idnMapping.GetAscii(hostname, i, label.Length); 264dest.Append(s_idnMapping.GetUnicode(hostname, i, label.Length)); 276int charsWritten = label.ToLowerInvariant(dest.AppendSpan(label.Length)); 277Debug.Assert(charsWritten == label.Length); 281i += label.Length;

System\Uri.cs (5)

1632charsWritten = result.Length; 2771charsWritten = copied ? result.Length : 0; 3729switch (scheme.Length) 3769if (scheme.Length == 0 || 3777if (scheme.Length > c_MaxUriSchemeName)

System\UriExt.cs (5)

595Debug.Assert(backingString is null || backingString.Length == charsToUnescape.Length); 607vsb.EnsureCapacity(charsToUnescape.Length - indexOfFirstToUnescape); 633charsWritten = charsToUnescape.Length; 652vsb.EnsureCapacity(charsToUnescape.Length - indexOfFirstToUnescape); 666Debug.Assert(newLength <= charsToUnescape.Length);

System\UriHelper.cs (12)

16return string.Create(span.Length, span, static (buffer, span) => 137if (destination.Length < charsToEscape.Length) 148charsWritten = charsToEscape.Length; 161vsb.EnsureCapacity(charsToEscape.Length); 171Debug.Assert(newLength > charsToEscape.Length); 208Debug.Assert(backingString is null || backingString.Length == charsToEscape.Length); 222vsb.EnsureCapacity(charsToEscape.Length); 292if (stringToEscape.Length > 2 && char.IsAsciiHexDigit(stringToEscape[1]) && char.IsAsciiHexDigit(stringToEscape[2])) 311charsToCopy = stringToEscape.Length; 376UnescapeString(pStr, 0, input.Length, ref dest, rsvd1, rsvd2, rsvd3, unescapeMode, syntax, isQuery); 612Debug.Assert(backingString is null || strToClean.Length == backingString.Length); 646stripped = string.Create(strToClean.Length - charsToRemove, strToClean, static (buffer, strToClean) =>

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

44for (int i = 0; i < encoded.Length; i += 2)

System\SpanHelpers.cs (2)

17if (source.Length >= destination.Length) 25destination[source.Length] = '\0';

System\SpanReader.cs (14)

30readonly get => Span.Length - _unread.Length; 103if (count > _unread.Length) 140if (sizeof(TValue) > _unread.Length * sizeof(T)) 174if (sizeof(TValue) * count > _unread.Length * sizeof(T)) 205UnsafeAdvance(next.Length); 224count = _unread.Length; 245public void Rewind(int count) => _unread = Span[(Span.Length - _unread.Length - count)..]; 259Debug.Assert((uint)count <= (uint)_unread.Length); 260UncheckedSlice(ref _unread, count, _unread.Length - count); 269Debug.Assert((uint)length <= (uint)span.Length); 279Debug.Assert((uint)start <= (uint)span.Length && (uint)length <= (uint)(span.Length - start));

System\SpanWriter.cs (2)

49if (_unwritten.Length >= values.Length) 53UnsafeAdvance(values.Length);

System\Text\ValueStringBuilder.cs (3)

296if (pos > _chars.Length - value.Length) 298Grow(value.Length); 302_pos += value.Length;

System\TypeExtensions.cs (5)

254if (publicKey1.Length == publicKey2.Length) 259if (publicKey1.Length == 0 || publicKey2.Length == 0) 266return publicKey1.Length == PublicKeyTokenLength

Windows\Win32\Graphics\Gdi\ARGB.cs (3)

49Color[] colors = new Color[argbColors.Length]; 50for (int i = 0; i < argbColors.Length; i++) 61argbColors.Length));

System\Drawing\CoreImageExtensions.cs (1)

21if (format == PInvokeCore.ImageFormatGIF && image.Data is { } rawData && rawData.Length > 0)

System\Drawing\ImageCodecInfoHelper.cs (2)

52s_encoders = new (Guid Format, Guid Encoder)[codecInfo.Length]; 54for (int i = 0; i < codecInfo.Length; i++)

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\Xml\Base64Decoder.cs (5)

123while ((uint)iChar < (uint)chars.Length) 145if (ch >= mapBase64.Length || (digit = mapBase64[ch]) == Invalid) 166if ((uint)iChar < (uint)chars.Length && chars[iChar] == '=') 173} while ((uint)iChar < (uint)chars.Length && chars[iChar] == '='); 176while ((uint)iChar < (uint)chars.Length)

System\Xml\BinaryXml\XmlBinaryReader.cs (1)

3491Debug.Assert(data.Length % 2 == 0, "Data size should not be odd");

System\Xml\BinHexDecoder.cs (2)

107int len = chars.Length; 144for (; iChar < chars.Length; iChar++)

System\Xml\Core\ReadOnlyTernaryTree.cs (1)

194if (stringPos == stringToFind.Length)

System\Xml\Core\XmlEncodedRawTextWriter.cs (1)

170if (bom.Length != 0)

System\Xml\Core\XmlTextEncoder.cs (1)

252int len = text.Length;

System\Xml\Core\XmlTextReaderImpl.cs (4)

3199_ps.bytePos = preamble.Length; 9581for (int i = 0; i < chars.Length; i++) 9597if ((uint)nextIdx < (uint)chars.Length && chars[nextIdx] == '\n') 9607lineInfo.linePos = chars.Length - lastNewLinePos;

System\Xml\Core\XmlUtf8RawTextWriter.cs (3)

115if (bom.Length != 0) 118_bufPos += bom.Length; 119_textPos += bom.Length;

System\Xml\XmlCharType.cs (2)

149for (; (uint)i < (uint)str.Length; i++) 154if ((uint)(i + 1) >= (uint)str.Length || !char.IsSurrogatePair(c, str[i + 1]))

System\Xml\XmlConvert.cs (3)

1058if (value.Length != 0 && value[0] != '+') 1721charsWritten = valueSpan.Length; 1745charsWritten = valueSpan.Length;

System\Xml\XPath\Internal\XPathScanner.cs (2)

337for (i = 1; i < span.Length && XmlCharType.IsNCNameSingleChar(span[i]); i++); 339if ((uint)i < (uint)span.Length)

System\Xml\Xsl\Runtime\NumberFormatter.cs (1)

112for (int idx = RomanDigitValue.Length; idx-- != 0;)

System\Reflection\Emit\CustomAttributeWrapper.cs (2)

42if (binaryAttribute.Length < 2) 44throw new ArgumentException(SR.Format(SR.Argument_InvalidCustomAttributeLength, ctor.DeclaringType, binaryAttribute.Length), nameof(binaryAttribute));

System\Reflection\Emit\FieldBuilderImpl.cs (1)

59Debug.Assert(binaryAttribute.Length >= 6);

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Reflection\AssemblyNameFormatter.cs (1)

108if (s.Length != span.Trim().Length || span.IndexOfAny('\"', '\'') >= 0)

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (2)

66Debug.Assert(input.Length > 0); 348if (_index < _input.Length)

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\Reflection\Internal\Utilities\Hash.cs (1)

47for (int i = 0; i < data.Length; i++)

System\Reflection\Internal\Utilities\MemoryBlock.cs (1)

328numberOfBytesRead = length = span.Length;

System\Reflection\Metadata\BlobBuilder.cs (3)

674int bytesToCurrent = Math.Min(FreeBytes, buffer.Length); 683Expand(remaining.Length); 686AddLength(remaining.Length);

System\Reflection\Metadata\BlobContentId.cs (3)

49if (id.Length != Size) 56var reader = new BlobReader(ptr, id.Length); 88if (hashCode.Length < minHashSize)

System\Reflection\Metadata\BlobWriter.cs (1)

152int start = Advance(buffer.Length);

System\Reflection\Metadata\Ecma335\MetadataBuilder.Heaps.cs (2)

224_blobHeapSize += BlobWriterImpl.GetCompressedIntegerSize(value.Length) + value.Length;

System\Reflection\Metadata\TypeNameParser.cs (3)

57int errorIndex = typeName.Length - parser._inputString.Length; 255_inputString = _inputString.Slice(candidate.Length);

System\Reflection\Metadata\TypeNameParserHelpers.cs (5)

43return input.Length; // no type name end chars were found, the whole input is the type name 53isNestedType = offset > 0 && offset < input.Length && input[offset] == '+'; 59for (; offset < input.Length; offset++) 66if (offset == input.Length || // invalid name that ends with escape character 154for (; offset < input.Length; offset++)

System\Reflection\PortableExecutable\ManagedTextSection.cs (2)

113CorEntryPointName.Length + 117CorEntryPointDll.Length + 1 + sizeof(ushort);

System\Reflection\PortableExecutable\PEBuilder.cs (2)

157Debug.Assert(DosHeader.Length == DosHeaderSize); 160builder.WriteBytes(ptr, header.Length);

System\Reflection\TypeLoading\Modules\GetTypeCoreCache.cs (1)

50for (int i = 0; i < name.Length; i++)

System\Resources\Extensions\TypeNameComparer.cs (7)

80typeSpan1 = typeSpan1.Length > type1.Length ? typeSpan1.Slice(type1.Length + 1).TrimStart(s_whiteSpaceChars) : ReadOnlySpan<char>.Empty; 81typeSpan2 = typeSpan2.Length > type2.Length ? typeSpan2.Slice(type2.Length + 1).TrimStart(s_whiteSpaceChars) : ReadOnlySpan<char>.Empty; 127for (int i = 0; i < typeName.Length; i++)

src\libraries\Common\src\System\Number.Formatting.Common.cs (29)

src\libraries\Common\src\System\Number.Parsing.Common.cs (2)

289if (!TryParseNumber(ref p, p + value.Length, styles, ref number, info) 290|| ((int)(p - stringPointer) < value.Length && !TrailingZeros(value, (int)(p - stringPointer))))

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\FormattingHelpers.CountDigits.cs (3)

25Debug.Assert(log2ToPow10.Length == 64); 54Debug.Assert((elementOffset + 1) <= powersOf10.Length); 102Debug.Assert(table.Length == 32, "Every result of uint.Log2(value) needs a long entry in the table.");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(_span.Length - _pos + source.Length); 89_pos += source.Length; 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 98Grow(source.Length); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length)); 103_pos += source.Length;

System\Number.BigInteger.cs (51)

85if (value.Length == 0) 90if (value.Length < 255) 92buffer = stackalloc byte[value.Length + 1 + 1]; 96buffer = arrayFromPool = ArrayPool<byte>.Shared.Rent(value.Length + 1 + 1); 149for (whiteIndex = 0; whiteIndex < value.Length; whiteIndex++) 161for (whiteIndex = value.Length - 1; whiteIndex >= 0; whiteIndex--) 180int leadingBitsCount = value.Length % TParser.DigitsPerBlock; 235int wholeBlockCount = value.Length / TParser.DigitsPerBlock; 331ReadOnlySpan<byte> fracDigitsSpan = number.Digits.Slice(intDigits.Length); 348int base1E9Length = (intDigits.Length + PowersOf1e9.MaxPartialDigits - 1) / PowersOf1e9.MaxPartialDigits; 355ReadOnlySpan<byte> leadingDigits = intDigits[..(intDigits.Length % PowersOf1e9.MaxPartialDigits)]; 356if (leadingDigits.Length != 0) 361intDigits = intDigits.Slice(leadingDigits.Length); 362Debug.Assert(intDigits.Length % PowersOf1e9.MaxPartialDigits == 0); 369Debug.Assert(intDigits.Length == 0); 404int valueDigits = (base1E9.Length - 1) * PowersOf1e9.MaxPartialDigits + FormattingHelpers.CountDigits(base1E9[^1]); 418int leadingLength = checked((int)(digitRatio * PowersOf1e9.MaxPartialDigits * base1E9.Length) + 3); 449if (base1E9.Length < BigIntegerParseNaiveThresholdInRecursive) 456while (base1E9.Length <= multiplier1E9Length) 463Debug.Assert(multiplier1E9Length < base1E9.Length && base1E9.Length <= multiplier1E9Length * 2); 476Span<uint> bitsUpper = bits.Slice(multiplierTrailingZeroCount, buffer2.Length + multiplier.Length); 477if (multiplier.Length < buffer2.Length) 494if (base1E9.Length == 0) 522if (base1E9.Length == 0) 527for (int i = base1E9.Length - 2; i >= 0; i--) 749Debug.Assert(formatString == null || formatString.Length == formatSpan.Length); 823int valueDigits = (base1E9Value.Length - 1) * MaxPartialDigits + FormattingHelpers.CountDigits(base1E9Value[^1]); 858strResult = string.Create(strLength, (digits, ptr: (IntPtr)ptr, base1E9Value.Length, sNegative), static (span, state) => 929for (int i = 0; i < base1E9Value.Length - 1; i++) 1056Debug.Assert(Indexes[6] == LeadingPowers1E9.Length); 1057if (pow1E9.Length <= LeadingPowers1E9.Length) 1062LeadingPowers1E9.CopyTo(pow1E9.Slice(0, LeadingPowers1E9.Length)); 1067for (int i = 6; i + 1 < Indexes.Length; i++) 1069Debug.Assert(2 * src.Length - (Indexes[i + 1] - Indexes[i]) is 0 or 1); 1070if (pow1E9.Length - toExclusive < (src.Length << 1)) 1072Span<uint> dst = pow1E9.Slice(toExclusive, src.Length << 1); 1087if ((uint)index < (uint)Indexes.Length) 1091maxIndex = Indexes.Length - 2; 1115if (trailingZeroCount < UInt32PowersOfTen.Length) 1117BigIntegerCalculator.Multiply(left, UInt32PowersOfTen[trailingZeroCount], bits.Slice(0, left.Length + 1)); 1136int curLength = first.Length; 1151Debug.Assert(fi + 1 < Indexes.Length); 1158Span<uint> dst = powersOfTen2.Slice(0, curLength += power.Length); 1160if (power.Length < src.Length) 1179Span<uint> bits2 = bits.Slice(omittedLength, curLength += left.Length); 1180if (left.Length < powersOfTen.Length) 1237Debug.Assert(destination.Length * TParser.DigitsPerBlock == input.Length); 1238ref TChar lastWholeBlockStart = ref Unsafe.Add(ref MemoryMarshal.GetReference(input), input.Length - TParser.DigitsPerBlock);

System\Numerics\BigInteger.cs (42)

278int byteCount = value.Length; 299byteCount = value.Length; 505if (value.Length > MaxLength) 510if (value.Length == 0) 514else if (value.Length == 1) 923if (rightBits.Length == 1) 928else if (rightBits.Length == 2) 930Span<uint> bits = (leftBits.Length <= BigIntegerCalculator.StackAllocThreshold 932: bitsFromPool = ArrayPool<uint>.Shared.Rent(leftBits.Length)).Slice(0, leftBits.Length); 943Span<uint> bits = (leftBits.Length <= BigIntegerCalculator.StackAllocThreshold 945: bitsFromPool = ArrayPool<uint>.Shared.Rent(leftBits.Length)).Slice(0, leftBits.Length); 1459curByte = length - srcBytes.Length; 1460Span<byte> destBytes = destination.Slice(curByte, srcBytes.Length); 1467curByte = srcBytes.Length; 1685int size = rightBits.Length + 1; 1697int size = leftBits.Length + 1; 1705else if (leftBits.Length < rightBits.Length) 1709int size = rightBits.Length + 1; 1721int size = leftBits.Length + 1; 1763int size = rightBits.Length; 1775int size = leftBits.Length; 1785int size = rightBits.Length; 1797int size = leftBits.Length; 2738int size = right.Length + 1; 2750int size = left.Length + 1; 2760int size = left.Length + right.Length; 2768else if (left.Length < right.Length) 2772int size = left.Length + right.Length; 2785int size = left.Length + right.Length; 3278int xl = bits.Length; 3279if (negx && (bits[^1] >= kuMaskHighBit) && ((bits[^1] != kuMaskHighBit) || bits.IndexOfAnyExcept(0u) != (bits.Length - 1))) 3433int xl = bits.Length; 3434if (negx && (bits[^1] >= kuMaskHighBit) && ((bits[^1] != kuMaskHighBit) || bits.IndexOfAnyExcept(0u) != (bits.Length - 1))) 5309int xl = bits.Length; 5310if (negx && (bits[^1] >= kuMaskHighBit) && ((bits[^1] != kuMaskHighBit) || bits.IndexOfAnyExcept(0u) != (bits.Length - 1)))

System\Numerics\BigIntegerCalculator.AddSub.cs (29)

21Debug.Assert(left.Length >= 1); 22Debug.Assert(bits.Length == left.Length + 1); 29Debug.Assert(right.Length >= 1); 30Debug.Assert(left.Length >= right.Length); 31Debug.Assert(bits.Length == left.Length + 1); 54} while (i < right.Length); 61Debug.Assert(left.Length >= right.Length); 74for (; i < right.Length; i++) 92Debug.Assert(left.Length >= 1); 93Debug.Assert(left[0] >= right || left.Length >= 2); 94Debug.Assert(bits.Length == left.Length); 101Debug.Assert(right.Length >= 1); 102Debug.Assert(left.Length >= right.Length); 104Debug.Assert(bits.Length == left.Length); 127} while (i < right.Length); 134Debug.Assert(left.Length >= right.Length); 150for (; i < right.Length; i++) 177if (left.Length <= CopyToThreshold) 179for (; i < left.Length; i++) 186Unsafe.Add(ref resultPtr, left.Length) = unchecked((uint)carry); 190for (; i < left.Length;) 205Unsafe.Add(ref resultPtr, left.Length) = unchecked((uint)carry); 207if (i < left.Length) 224if (left.Length <= CopyToThreshold) 226for (; i < left.Length; i++) 235for (; i < left.Length;) 250if (i < left.Length)

System\Numerics\BigIntegerCalculator.DivRem.cs (120)

System\Numerics\BigIntegerCalculator.FastReducer.cs (21)

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); 46Debug.Assert(value.Length <= _modulus.Length * 2); 49if (value.Length < _modulus.Length) 54int l1 = DivMul(value, _mu, _q1, _modulus.Length - 1); 58int l2 = DivMul(_q1.Slice(0, l1), _modulus, _q2, _modulus.Length + 1); 61var length = SubMod(value, _q2.Slice(0, l2), _modulus, _modulus.Length + 1); 72Debug.Assert(bits.Length + k >= left.Length + right.Length); 79if (left.Length > k) 83if (left.Length < right.Length) 87bits.Slice(0, left.Length + right.Length)); 93bits.Slice(0, left.Length + right.Length)); 96return ActualLength(bits.Slice(0, left.Length + right.Length)); 111if (right.Length > k)

System\Numerics\BigIntegerCalculator.GcdInv.cs (22)

46Debug.Assert(left.Length >= 1); 59Debug.Assert(left.Length >= 2); 60Debug.Assert(right.Length >= 2); 62Debug.Assert(result.Length == left.Length); 67Span<uint> rightCopy = (right.Length <= StackAllocThreshold ? 69: rightCopyFromPool = ArrayPool<uint>.Shared.Rent(right.Length)).Slice(0, right.Length); 225Debug.Assert(xBuffer.Length >= 3); 226Debug.Assert(yBuffer.Length >= 3); 227Debug.Assert(xBuffer.Length >= yBuffer.Length); 232ulong xh = xBuffer[xBuffer.Length - 1]; 233ulong xm = xBuffer[xBuffer.Length - 2]; 234ulong xl = xBuffer[xBuffer.Length - 3]; 239switch (xBuffer.Length - yBuffer.Length) 242yh = yBuffer[yBuffer.Length - 1]; 243ym = yBuffer[yBuffer.Length - 2]; 244yl = yBuffer[yBuffer.Length - 3]; 249ym = yBuffer[yBuffer.Length - 1]; 250yl = yBuffer[yBuffer.Length - 2]; 256yl = yBuffer[yBuffer.Length - 1];

System\Numerics\BigIntegerCalculator.PowMod.cs (33)

23Debug.Assert(bits.Length == PowBound(power, value.Length)); 36valueCopy.Slice(value.Length).Clear(); 38Span<uint> result = PowCore(valueCopy, value.Length, temp, power, bits); 74int resultLength = leftLength + right.Length; 76if (leftLength >= right.Length) 170for (int i = 0; i < power.Length - 1; i++) 182return PowCore(value, power[power.Length - 1], modulus, result); 212Debug.Assert(bits.Length == modulus.Length + modulus.Length); 218int size = Math.Max(value.Length, bits.Length); 226valueCopy.Slice(value.Length).Clear(); 228if (value.Length > modulus.Length) 230Remainder(value, modulus, valueCopy.Slice(0, value.Length)); 261Debug.Assert(bits.Length == modulus.Length + modulus.Length); 266int size = Math.Max(value.Length, bits.Length); 275valueCopy.Slice(value.Length).Clear(); 277if (value.Length > modulus.Length) 279Remainder(value, modulus, valueCopy.Slice(0, value.Length)); 316if (modulus.Length < ReducerThreshold) 324int size = modulus.Length * 2 + 1; 331size = r.Length - modulus.Length + 1; 338size = modulus.Length * 2 + 2; 376if (modulus.Length < ReducerThreshold) 384int size = modulus.Length * 2 + 1; 391size = r.Length - modulus.Length + 1; 398size = modulus.Length * 2 + 2; 440for (int i = 0; i < power.Length - 1; i++) 456return PowCore(value, valueLength, power[power.Length - 1], modulus, result, resultLength, temp); 499for (int i = 0; i < power.Length - 1; i++) 515return PowCore(value, valueLength, power[power.Length - 1], reducer, result, resultLength, temp);

System\Numerics\BigIntegerCalculator.SquMul.cs (49)

23Debug.Assert(bits.Length == value.Length + value.Length); 34if (value.Length < SquareThreshold) 51for (int i = 0; i < value.Length; i++) 81int n = value.Length >> 1; 98int foldLength = valueHigh.Length + 1; 133Debug.Assert(bits.Length == left.Length + 1); 143for (; i < left.Length; i++) 161Debug.Assert(left.Length >= right.Length); 162Debug.Assert(bits.Length >= left.Length + right.Length); 175if (right.Length < MultiplyKaratsubaThreshold) 207int n = (left.Length + 1) >> 1; 209if (right.Length <= n) 214Debug.Assert(leftLow.Length >= leftHigh.Length); 217Span<uint> bitsLow = bits.Slice(0, n + right.Length); 223int carryLength = right.Length; 229Span<uint> carryOrig = bits.Slice(n, right.Length); 234if (leftHigh.Length < right.Length) 235MultiplyKaratsuba(right, leftHigh, bitsHigh.Slice(0, leftHigh.Length + right.Length), (right.Length + 1) >> 1); 237Multiply(leftHigh, right, bitsHigh.Slice(0, leftHigh.Length + right.Length)); 249Debug.Assert(left.Length >= right.Length); 250Debug.Assert(2 * n - left.Length is 0 or 1); 251Debug.Assert(right.Length > n); 252Debug.Assert(bits.Length >= left.Length + right.Length); 254if (right.Length < MultiplyKaratsubaThreshold) 272Debug.Assert(leftLow.Length >= leftHigh.Length); 273Debug.Assert(rightLow.Length >= rightHigh.Length); 277MultiplyKaratsuba(leftLow, rightLow, bitsLow, (leftLow.Length + 1) >> 1); 320Debug.Assert(ActualLength(core) <= left.Length + 1); 333Debug.Assert(right.Length < MultiplyKaratsubaThreshold); 346for (int i = 0; i < right.Length; i++) 350for (int j = 0; j < left.Length; j++) 357Unsafe.Add(ref resultPtr, i + left.Length) = (uint)carry; 364Debug.Assert(left.Length >= right.Length); 365Debug.Assert(core.Length >= left.Length); 382for (; i < right.Length; i++) 389for (; i < left.Length; i++)

System\Numerics\BigIntegerCalculator.Utils.cs (22)

20Debug.Assert(left.Length <= right.Length || left.Slice(right.Length).ContainsAnyExcept(0u)); 21Debug.Assert(left.Length >= right.Length || right.Slice(left.Length).ContainsAnyExcept(0u)); 23if (left.Length != right.Length) 24return left.Length < right.Length ? -1 : 1; 26int iv = left.Length; 36if (left.Length != right.Length) 38if (left.Length < right.Length) 40if (ActualLength(right.Slice(left.Length)) > 0) 42right = right.Slice(0, left.Length); 46if (ActualLength(left.Slice(right.Length)) > 0) 48left = left.Slice(0, right.Length); 59int length = value.Length; 70if (bits.Length >= modulus.Length) 74return ActualLength(bits.Slice(0, modulus.Length));

System\Numerics\Complex.cs (2)

2098if ((s.Length < 5) || (openBracket == -1) || (semicolon == -1) || (closeBracket == -1) || (openBracket > semicolon) || (openBracket > closeBracket) || (semicolon > closeBracket)) 2135if ((closeBracket != (s.Length - 1)) && (((style & NumberStyles.AllowTrailingWhite) == 0) || !s.Slice(closeBracket).IsWhiteSpace()))

System\Security\Cryptography\Cose\CoseMessage.cs (8)

112using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, cborPayload.Length)) 197using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, cborPayload.Length)) 424CoseHelpers.WriteByteStringLength(toBeSignedBuilder, (ulong)contentBytes.Length); 498Debug.Assert(signProtected.Length == 0); 509Debug.Assert(bytesWritten == ComputeToBeSignedEncodedSize(context, bodyProtected.Length, signProtected.Length, associatedData.Length, content.Length));

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (3)

211int expectedSize = ComputeEncodedSize(signer, protectedHeaders, unprotectedHeaders, content.Length, isDetached); 349int expectedSize = ComputeEncodedSize(signer, protectedHeaders, unprotectedHeaders, content.Length, isDetached); 775associatedData.Length,

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

169Debug.Assert(contentStream == null || (isDetached && contentBytes.Length == 0)); 173int expectedSize = ComputeEncodedSize(signer, contentBytes.Length, isDetached); 280int expectedSize = ComputeEncodedSize(signer, content.Length, isDetached); 773Debug.Assert(contentStream == null || contentBytes.Length == 0); 793associatedData.Length,

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

653associatedData.Length,

Internal\Cryptography\Pal\AnyOS\ManagedPal.Asn.cs (1)

18using (var manager = new PointerMemoryManager<byte>(pin, encodedMessage.Length))

Internal\Cryptography\Pal\AnyOS\ManagedPal.Decode.cs (1)

87using (var manager = new PointerMemoryManager<byte>(pin, encodedMessage.Length))

src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (6)

68consumed != source.Length) 105if (encodedOid.Length == 2 && encodedOid[0] == 0x06 && encodedOid[1] == 0x00) 118if (consumed != encodedOid.Length) 183if (consumed != input.Length) 190return encodedOctetString.Slice(offset, primitive.Length); 198if (consumed != input.Length)

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Security\Cryptography\Asn1\AlgorithmIdentifierAsn.manual.cs (1)

49if (span.Length != 2)

src\libraries\Common\src\System\Security\Cryptography\Asn1\AlgorithmIdentifierAsn.xml.cs (1)

101decoded.Parameters = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\AttributeAsn.xml.cs (1)

111tmpItem = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\DigestInfoAsn.xml.cs (1)

81decoded.Digest = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\DirectoryStringAsn.xml.cs (1)

160decoded.UniversalString = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\EncryptedPrivateKeyInfoAsn.xml.cs (1)

81decoded.EncryptedData = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\GeneralNameAsn.xml.cs (3)

228decoded.X400Address = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 234decoded.DirectoryName = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 253decoded.IPAddress = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\OtherNameAsn.xml.cs (1)

98decoded.Value = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\PBEParameter.xml.cs (1)

80decoded.Salt = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pbkdf2SaltChoice.xml.cs (1)

105decoded.Specified = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\CertBagAsn.xml.cs (1)

98decoded.CertValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\MacData.xml.cs (1)

115decoded.MacSalt = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SafeBagAsn.xml.cs (1)

114decoded.BagValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SecretBagAsn.xml.cs (1)

98decoded.SecretValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\CertificateChoiceAsn.xml.cs (4)

200decoded.Certificate = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 205decoded.ExtendedCertificate = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 210decoded.AttributeCertificateV1 = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 215decoded.AttributeCertificateV2 = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\ContentInfoAsn.xml.cs (1)

98decoded.Content = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncapsulatedContentInfoAsn.xml.cs (1)

105decoded.Content = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncryptedContentInfoAsn.xml.cs (1)

99decoded.EncryptedContent = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\IssuerAndSerialNumberAsn.xml.cs (2)

99decoded.Issuer = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 101decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\OtherCertificateFormat.xml.cs (1)

93decoded.OtherCert = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignedDataAsn.xml.cs (1)

189tmpItem = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerIdentifierAsn.xml.cs (1)

112decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerInfoAsn.xml.cs (2)

134decoded.SignedAttributes = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 141decoded.SignatureValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\PrivateKeyInfoAsn.xml.cs (1)

105decoded.PrivateKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Rc2CbcParameters.xml.cs (1)

86decoded.Iv = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\SubjectPublicKeyInfoAsn.xml.cs (1)

81decoded.SubjectPublicKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\X509ExtensionAsn.xml.cs (1)

128decoded.ExtnValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1Reader\AsnValueReader.cs (1)

58_span = _span.Slice(value.Length);

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

95bytesWritten = source.Length; 209if (bytesRead != data.Length)

src\libraries\Common\src\System\Security\Cryptography\KeyFormatHelper.cs (6)

25using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 44read = reader.PeekEncodedValue().Length; 75read = reader.PeekEncodedValue().Length; 101using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 116int read = reader.PeekEncodedValue().Length; 143int read = reader.PeekEncodedValue().Length;

src\libraries\Common\src\System\Security\Cryptography\KeyFormatHelper.Encrypted.cs (6)

27using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 44using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 108read = reader.PeekEncodedValue().Length; 285using (PointerMemoryManager<byte> manager = new(pointer, source.Length)) 316using (PointerMemoryManager<byte> manager = new(pointer, source.Length)) 351localRead = reader.PeekEncodedValue().Length;

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (23)

51if (passwordBytes.Length > 0 && password.Length == 0) 75Debug.Assert(destination.Length >= encryptedData.Length); 155if (password.IsEmpty && passwordBytes.Length > 0) 176if (passwordBytes.Length > 0 || password.Length == 0) 333if (passwordBytes.Length == 0 && password.Length > 0) 337else if (passwordBytes.Length == 0) 343pwdTmpBytes = new byte[passwordBytes.Length]; 353Debug.Assert(password.Length > 0 || passwordBytes.IsEmpty); 376if (passwordBytes.Length > 0) 378Debug.Assert(pwdTmpBytes!.Length == passwordBytes.Length); 381else if (password.Length > 0) 461if (passwordBytes.Length > 0 || password.Length == 0) 706if (!gotIv || bytesWritten != length || consumed != source.Length) 771byte[] tmpPassword = new byte[password.Length]; 922byte[] tmpKey = new byte[key.Length]; 923byte[] tmpIv = new byte[iv.Length]; 924byte[] rentedEncryptedData = CryptoPool.Rent(encryptedData.Length); 947encryptedData.Length, 970CryptoPool.Return(rentedEncryptedData, encryptedData.Length);

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

79int localRead = reader.PeekEncodedValue().Length;

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (7)

115int SLen = ((salt.Length - 1 + vBytes) / vBytes) * vBytes; 118int passLen = checked((password.Length + 1) * 2); 238Debug.Assert(into.Length == addend.Length); 252Debug.Assert(bytes.Length > 0); 256if (destination.Length >= bytes.Length) 259destination = destination.Slice(bytes.Length); 271int fullCopyLen = password.Length * 2;

System\Security\Cryptography\Pkcs\Asn1\CadesIssuerSerial.xml.cs (1)

103decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\EssCertId.xml.cs (1)

85decoded.Hash = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\EssCertIdV2.xml.cs (1)

125decoded.Hash = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\KeyAgreeRecipientInfoAsn.xml.cs (1)

120decoded.Ukm = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\KeyTransRecipientInfoAsn.xml.cs (1)

92decoded.EncryptedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\MessageImprint.xml.cs (1)

81decoded.HashedMessage = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OriginatorIdentifierOrKeyAsn.xml.cs (1)

123decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OriginatorInfoAsn.xml.cs (1)

144tmpItem = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OriginatorPublicKeyAsn.xml.cs (1)

81decoded.PublicKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OtherKeyAttributeAsn.xml.cs (1)

101decoded.KeyAttr = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\PkiStatusInfo.xml.cs (1)

115decoded.StatusString = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\PolicyQualifierInfo.xml.cs (1)

93decoded.Qualifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\RecipientEncryptedKeyAsn.xml.cs (1)

81decoded.EncryptedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\RecipientIdentifierAsn.xml.cs (1)

112decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\RecipientKeyIdentifier.xml.cs (1)

92decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TimeStampReq.xml.cs (1)

160decoded.Nonce = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TimeStampResp.xml.cs (1)

94decoded.TimeStampToken = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TstInfo.xml.cs (2)

168decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 194decoded.Nonce = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\CmsSignature.cs (11)

194if (val.Length > fieldSize && val[0] == 0) 199if (val.Length <= fieldSize) 201val.CopyTo(ieeeSignature.Slice(fieldSize - val.Length, val.Length)); 206if (val.Length > fieldSize && val[0] == 0) 211if (val.Length <= fieldSize) 213val.CopyTo(ieeeSignature.Slice(fieldSize + fieldSize - val.Length, val.Length)); 230int fieldSize = ieeeSignature.Length / 2; 233fieldSize * 2 == ieeeSignature.Length, 234$"ieeeSignature.Length ({ieeeSignature.Length}) must be even");

System\Security\Cryptography\Pkcs\CmsSignature.RSA.cs (1)

72valueHash.Length);

System\Security\Cryptography\Pkcs\Rfc3161TimestampRequest.cs (6)

88int localBytesRead = reader.PeekEncodedValue().Length; 270if (nonceSpan.Length == 0 || nonceSpan[0] >= 0x80) 272byte[] temp = new byte[nonceSpan.Length + 1]; 281while (slice < nonceSpan.Length && nonceSpan[slice] == 0) 287if (slice == nonceSpan.Length || nonceSpan[slice] >= 0x80) 367bytesConsumed = firstElement.Length;

System\Security\Cryptography\Pkcs\Rfc3161TimestampToken.cs (1)

298int bytesActuallyRead = reader.PeekEncodedValue().Length;

System\Security\Cryptography\Pkcs\SignedCms.cs (1)

217using (var manager = new PointerMemoryManager<byte>(pin, encodedMessage.Length))

System\Security\Cryptography\Pkcs\SubjectIdentifier.cs (1)

61for (int i = 0; i < serial.Length; i++)

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (1)

79int length = buffer.Length;

System\Security\Cryptography\ProtectedData.cs (2)

339DATA_BLOB userDataBlob = new DATA_BLOB((IntPtr)pInputData, (uint)(inputData.Length)); 343optionalEntropyBlob = new DATA_BLOB((IntPtr)pOptionalEntropy, (uint)(optionalEntropy.Length));

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

203byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 204Memory<byte> memBuffer = new Memory<byte>(sharedBuffer, 0, buffer.Length);

System\Text\EncodingTable.cs (10)

107int right = encodingNameIndices.Length - 2; 111Debug.Assert(encodingNameIndices.Length == CodePagesByName.Length + 1); 112Debug.Assert(encodingNameIndices[encodingNameIndices.Length - 1] == EncodingNames.Length); 122Debug.Assert(index < encodingNameIndices.Length - 1); 144Debug.Assert(left < encodingNameIndices.Length - 1); 185Debug.Assert(MappedCodePages.Length + 1 == indices.Length); 186Debug.Assert(indices[indices.Length - 1] == names.Length); 201Debug.Assert(i < indices.Length - 1);

System\Text\ISO2022Encoding.cs (1)

403if (bTrailByte < 0x21 || bTrailByte >= 0x21 + HalfToFullWidthKanaTable.Length)

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (1)

70Debug.Assert(definedCharsBitmapAsLittleEndian.Length == thisAllowedCharactersBitmap.Length * sizeof(uint));

System\Text\Encodings\Web\OptimizedInboxTextEncoder.cs (9)

142if ((uint)source.Length <= (uint)srcIdx) 190if ((uint)source.Length > (uint)srcIdxTemp) 261if ((uint)source.Length <= (uint)srcIdx) 368if ((uint)asciiBytesSkipped >= (uint)data.Length || UnicodeUtility.IsAsciiCodePoint(data[asciiBytesSkipped])) 375int dataOriginalLength = data.Length; 392return (data.IsEmpty) ? -1 : dataOriginalLength - data.Length; 402if (data.Length >= 8) 406if ((uint)asciiCharsSkipped >= (uint)data.Length || char.IsAscii(data[asciiCharsSkipped])) 416nuint lengthInChars = (uint)data.Length;

System\Text\Encodings\Web\TextEncoder.cs (19)

166Span<char> destBuffer = stringBuilder.AppendSpan(Math.Max(remainingInput.Length, minBufferBumpEachIteration)); 293if (utf8Destination.Length < utf8Source.Length) 301idxOfFirstByteToEncode = sourceSearchSpace.Length; 305if (idxOfFirstByteToEncode == utf8Source.Length) 307bytesConsumed = utf8Source.Length; 308bytesWritten = utf8Source.Length; 329int originalUtf8SourceLength = utf8Source.Length; 382bytesConsumed = originalUtf8SourceLength - utf8Source.Length; 423if (destination.Length < source.Length) 431idxOfFirstCharToEncode = sourceSearchSpace.Length; 435if (idxOfFirstCharToEncode == source.Length) 437charsConsumed = source.Length; 438charsWritten = source.Length; 454int originalSourceLength = source.Length; 498charsConsumed = originalSourceLength - source.Length; 521char[] rentedArray = ArrayPool<char>.Shared.Rent(Math.Max(value.Length, minBufferBumpEachIteration)); 545return FindFirstCharacterToEncode(pText, text.Length); 561int utf8TextOriginalLength = utf8Text.Length; 573return (utf8Text.IsEmpty) ? -1 : utf8TextOriginalLength - utf8Text.Length;

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

src\libraries\System.Private.CoreLib\src\System\Marvin.cs (1)

23public static int ComputeHash32(ReadOnlySpan<byte> data, ulong seed) => ComputeHash32(ref MemoryMarshal.GetReference(data), (uint)data.Length, (uint)seed, (uint)(seed >> 32));

src\libraries\System.Text.Json\Common\JsonSeparatorNamingPolicy.cs (3)

37int initialBufferLength = (int)(1.2 * chars.Length); 45for (int i = 0; i < chars.Length; i++) 75if (i + 1 < chars.Length && char.IsLower(chars[i + 1]))

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

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

177byte[] owned = new byte[utf8Json.Length]; 578int payloadLength = reader.ValueSpan.Length + 2; 603payloadLength += reader.ValueSpan.Length; 644int length = valueSpan.IsEmpty ? checked((int)valueSequence.Length) : valueSpan.Length; 812long expectedLength = Math.Max(utf8Bom.Length, stream.Length - stream.Position) + 1; 826Debug.Assert(rented.Length >= utf8Bom.Length); 831utf8Bom.Length - written); 834} while (lastRead > 0 && written < utf8Bom.Length); 837if (written == utf8Bom.Length && 838utf8Bom.SequenceEqual(rented.AsSpan(0, utf8Bom.Length))) 889int utf8BomLength = JsonConstants.Utf8Bom.Length; 909Debug.Assert(rented.Length >= JsonConstants.Utf8Bom.Length);

System\Text\Json\Document\JsonDocument.TryGetProperty.cs (6)

26int maxBytes = JsonReaderHelper.s_utf8Encoding.GetMaxByteCount(propertyName.Length); 50int minBytes = propertyName.Length; 172if (currentPropertyName.Length > propertyName.Length) 178if (propertyName.Length > idx && 181int remaining = currentPropertyName.Length - idx;

System\Text\Json\JsonEncodedText.cs (2)

68if (value.Length == 0) 115if (utf8Value.Length == 0)

System\Text\Json\JsonHelpers.cs (25)

231Span<char> charBuffer = utf8Key.Length <= JsonConstants.StackallocCharThreshold ? 233(rentedBuffer = ArrayPool<char>.Shared.Rent(utf8Key.Length)); 336Debug.Assert(left.Length > 0 && right.Length > 0); 353(nDigits = (leftIntegral.Length + leftFractional.Length)) != 354rightIntegral.Length + rightFractional.Length) 369int diff = leftIntegral.Length - rightIntegral.Length; 376int rightOffset = rightIntegral.Length + diff; 392int leftOffset = leftIntegral.Length - diff; 402Debug.Assert(leftFirst.Length == rightFirst.Length); 403Debug.Assert(leftMiddle.Length == rightMiddle.Length); 404Debug.Assert(leftLast.Length == rightLast.Length); 431Debug.Assert(span.Length > 0); 476Debug.Assert(span.Length >= 10); 491Debug.Assert(intg.Length == 1, "Leading zeros not permitted in JSON numbers."); 511exp += intg.Length - fz; 517exp -= frac.Length; 536return firstNonZero < 0 ? span.Length - 1 : firstNonZero - 1; 554return lastNonZero == span.Length - 1 ? -1 : lastNonZero + 1;

System\Text\Json\JsonHelpers.Date.cs (19)

146Debug.Assert(source.Length >= 10); 183if (source.Length == 10) 225if (source.Length < 16) 240Debug.Assert(source.Length >= 16); 241if (source.Length == 16) 254return sourceIndex == source.Length; 266if (source.Length < 19 273Debug.Assert(source.Length >= 19); 274if (source.Length == 19) 287return sourceIndex == source.Length; 300if (source.Length < 21) 308int fractionEnd = Math.Min(sourceIndex + JsonConstants.DateTimeParseNumFractionDigits, source.Length); 332Debug.Assert(sourceIndex <= source.Length); 333if (sourceIndex == source.Length) 345return sourceIndex == source.Length; 357if (offsetData.Length < 2 365if (offsetData.Length == 2) 372if (offsetData.Length != 5 386Debug.Assert(source.Length == 2);

System\Text\Json\JsonHelpers.Escaping.cs (7)

33Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= utf8Value.Length); 34Debug.Assert(firstEscapeIndexVal >= 0 && firstEscapeIndexVal < utf8Value.Length); 38int length = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal); 61Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= utf8Value.Length); 62Debug.Assert(firstEscapeIndexVal >= 0 && firstEscapeIndexVal < utf8Value.Length); 66int length = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal); 86int length = utf8Value.Length;

System\Text\Json\Nodes\JsonArray.cs (1)

163List<JsonNode?> list = new(items.Length);

System\Text\Json\Reader\JsonReaderHelper.cs (14)

84if (!JsonHelpers.IsValidDateTimeOffsetParseLength(segment.Length)) 110Debug.Assert(source.Length <= JsonConstants.MaximumEscapedDateTimeOffsetParseLength); 132if (!JsonHelpers.IsValidDateTimeOffsetParseLength(segment.Length)) 158Debug.Assert(source.Length <= JsonConstants.MaximumEscapedDateTimeOffsetParseLength); 180Debug.Assert(source.Length <= JsonConstants.MaximumEscapedGuidLength); 203if (span.Length == 3) 211else if (span.Length == 8) 219else if (span.Length == 9) 235if (span.Length == 3) 243else if (span.Length == 8) 251else if (span.Length == 9) 266if (span.Length == 3) 274else if (span.Length == 8) 282else if (span.Length == 9)

System\Text\Json\Reader\JsonReaderHelper.Unescaping.cs (29)

18Span<byte> utf8Unescaped = utf8Source.Length <= JsonConstants.StackallocByteThreshold ? 20(unescapedArray = ArrayPool<byte>.Shared.Rent(utf8Source.Length)); 45int length = utf8Source.Length; 72int length = utf8Source.Length; 96Debug.Assert(utf8Source.Length >= other.Length && utf8Source.Length / JsonConstants.MaxExpansionFactorWhileEscaping <= other.Length); 100Span<byte> utf8Unescaped = utf8Source.Length <= JsonConstants.StackallocByteThreshold ? 102(unescapedArray = ArrayPool<byte>.Shared.Rent(utf8Source.Length)); 124Debug.Assert(utf8Source.Length >= other.Length && utf8Source.Length / JsonConstants.MaxExpansionFactorWhileEscaping <= other.Length); 173Span<byte> utf8Unescaped1 = utf8Source1.Length <= JsonConstants.StackallocByteThreshold ? 175(unescapedArray1 = ArrayPool<byte>.Shared.Rent(utf8Source1.Length)); 177Span<byte> utf8Unescaped2 = utf8Source2.Length <= JsonConstants.StackallocByteThreshold ? 179(unescapedArray2 = ArrayPool<byte>.Shared.Rent(utf8Source2.Length)); 222Span<byte> byteSpan = utf8Unescaped.Length <= JsonConstants.StackallocByteThreshold ? 224(pooledArray = ArrayPool<byte>.Shared.Rent(utf8Unescaped.Length)); 240Debug.Assert(bytesConsumed == utf8Unescaped.Length); 446Debug.Assert(destination.Length >= source.Length); 457Debug.Assert(idx >= 0 && idx < source.Length); 459Debug.Assert(destination.Length >= source.Length); 481Debug.Assert(idx >= 0 && idx < source.Length); 532Debug.Assert(source.Length >= idx + 5); 550if (source.Length < idx + 7 || source[idx + 1] != '\\' || source[idx + 2] != 'u') 587if (++idx == source.Length) 598nextUnescapedSegmentLength = remaining.Length; 628Debug.Assert(idx == source.Length || source[idx] == JsonConstants.BackSlash); 630if (idx == source.Length)

System\Text\Json\Reader\Utf8JsonReader.cs (52)

55internal readonly int ValueLength => HasValueSequence ? checked((int)ValueSequence.Length) : ValueSpan.Length; 531if (MatchNotPossible(text.Length)) 540int length = checked(text.Length * JsonConstants.MaxExpansionFactorWhileTranscoding); 587if (localSequence.Length != other.Length) 600matchedSoFar += span.Length; 615if (localSpan.Length < other.Length || localSpan.Length / JsonConstants.MaxExpansionFactorWhileEscaping > other.Length) 641if (sequenceLength < other.Length || sequenceLength / JsonConstants.MaxExpansionFactorWhileEscaping > other.Length) 682matchedSoFar += span.Length; 703int sourceLength = ValueSpan.Length; 919if (_consumed >= (uint)_buffer.Length) 949if (_consumed >= (uint)_buffer.Length) 1011for (; _consumed < localBuffer.Length; _consumed++) 1094if (_consumed >= (uint)_buffer.Length) 1136Debug.Assert(span.Length > 0); 1144ValueSpan = span.Slice(0, literal.Length); 1146_consumed += literal.Length; 1147_bytePositionInLine += literal.Length; 1153Debug.Assert(span.Length > 0 && span[0] == literal[0]); 1157for (int i = 1; i < literal.Length; i++) 1159if (span.Length > i) 1174Debug.Assert(indexOfFirstMismatch > 0 && indexOfFirstMismatch < literal.Length); 1216if (_consumed >= (uint)_buffer.Length) 1230((_consumed < _buffer.Length) && 1233|| (_isNotPrimitive ^ (_consumed >= (uint)_buffer.Length))); 1281Debug.Assert(_buffer.Length >= _consumed + 1); 1314_bytePositionInLine += localBuffer.Length + 1; // Account for the start quote 1326Debug.Assert(idx >= 0 && idx < data.Length); 1336for (; idx < data.Length; idx++) 1370idx = data.Length; 1385if (idx >= data.Length) 1407for (int j = idx; j < data.Length; j++) 1428Debug.Assert(data.Length > 0); 1545if (i >= data.Length) 1570if (i < data.Length) 1607for (; i < data.Length; i++) 1615if (i >= data.Length) 1639if (i >= data.Length) 1661if (i >= data.Length) 1675if (i >= data.Length) 1760if (_consumed >= (uint)_buffer.Length) 1897if (_consumed >= (uint)_buffer.Length) 2229if (_consumed >= (uint)_buffer.Length) 2319if (localBuffer.Length > 0) 2358if (idx < localBuffer.Length - 1) 2381idx = localBuffer.Length; 2384_bytePositionInLine += 2 + localBuffer.Length; 2435if (localBuffer.Length < 2) 2496if (localBuffer.Length > 0)

System\Text\Json\Reader\Utf8JsonReader.MultiSegment.cs (65)

System\Text\Json\Reader\Utf8JsonReader.TryGet.cs (21)

System\Text\Json\Schema\JsonSchemaExporter.cs (1)

473using ValueStringBuilder sb = new(initialCapacity: path.Length * 10);

System\Text\Json\Serialization\Converters\Collection\ReadOnlyMemoryConverter.cs (2)

61for (; index < value.Length; index++) 68for (; index < value.Length; index++)

System\Text\Json\Serialization\Converters\Object\ObjectDefaultConverter.cs (2)

387while (state.Current.EnumeratorIndex < propertyCache.Length) 416if (state.Current.EnumeratorIndex == propertyCache.Length)

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.cs (3)

366ArrayPool<FoundProperty>.Shared.Rent(Math.Max(1, state.Current.JsonTypeInfo.PropertyCache.Length)); 562argumentState.FoundPropertiesAsync = ArrayPool<FoundPropertyAsync>.Shared.Rent(Math.Max(1, state.Current.JsonTypeInfo.PropertyCache.Length)); 595if (jsonTypeInfo.ParameterCount != jsonTypeInfo.ParameterCache.Length)

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.Large.cs (1)

56object?[] arguments = ArrayPool<object>.Shared.Rent(typeInfo.ParameterCache.Length);

System\Text\Json\Serialization\Converters\Value\BooleanConverter.cs (1)

28&& propertyName.Length == bytesConsumed))

System\Text\Json\Serialization\Converters\Value\TimeOnlyConverter.cs (1)

70if (!result || source.Length != bytesConsumed)

System\Text\Json\Serialization\Converters\Value\TimeSpanConverter.cs (1)

69if (!result || source.Length != bytesConsumed)

System\Text\Json\Serialization\JsonSerializer.Read.HandleMetadata.cs (3)

316(propertyName.Length > 0 && propertyName[0] == '$') || 322if (propertyName.Length > 0 && propertyName[0] == '$') 324switch (propertyName.Length)

System\Text\Json\Serialization\JsonSerializer.Read.Span.cs (2)

148Debug.Assert(reader.BytesConsumed == (actualByteCount ?? utf8Json.Length) || reader.CurrentState.Options.AllowMultipleValues); 165Debug.Assert(reader.BytesConsumed == (actualByteCount ?? utf8Json.Length) || reader.CurrentState.Options.AllowMultipleValues);

System\Text\Json\Serialization\JsonSerializer.Read.String.cs (6)

389json.Length <= (JsonConstants.StackallocByteThreshold / JsonConstants.MaxExpansionFactorWhileTranscoding) ? stackalloc byte[JsonConstants.StackallocByteThreshold] : 391json.Length <= (JsonConstants.ArrayPoolMaxSizeBeforeUsingNormalAlloc / JsonConstants.MaxExpansionFactorWhileTranscoding) ? tempArray = ArrayPool<byte>.Shared.Rent(json.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) : 420json.Length <= (JsonConstants.StackallocByteThreshold / JsonConstants.MaxExpansionFactorWhileTranscoding) ? stackalloc byte[JsonConstants.StackallocByteThreshold] : 422json.Length <= (JsonConstants.ArrayPoolMaxSizeBeforeUsingNormalAlloc / JsonConstants.MaxExpansionFactorWhileTranscoding) ? tempArray = ArrayPool<byte>.Shared.Rent(json.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) :

System\Text\Json\Serialization\JsonSerializer.Read.Utf8JsonReader.cs (2)

401int payloadLength = reader.ValueSpan.Length + 2; 420: reader.ValueSpan.Length + 2;

System\Text\Json\Serialization\Metadata\JsonTypeInfo.Cache.cs (1)

96int count = utf8PropertyCacheSpan.Length;

System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.ReadHelper.cs (2)

120Debug.Assert(reader.BytesConsumed <= bufferState.Bytes.Length); 121Debug.Assert(!bufferState.IsFinalBlock || reader.AllowMultipleValues || reader.BytesConsumed == bufferState.Bytes.Length,

System\Text\Json\Serialization\Metadata\PropertyRef.cs (10)

System\Text\Json\Serialization\ReadBufferState.cs (4)

46_buffer = ArrayPool<byte>.Shared.Rent(Math.Max(initialBufferSize, JsonConstants.Utf8Bom.Length)); 169Debug.Assert(_buffer.Length >= JsonConstants.Utf8Bom.Length); 172_offset = (byte)JsonConstants.Utf8Bom.Length; 173_count -= JsonConstants.Utf8Bom.Length;

System\Text\Json\ThrowHelper.cs (22)

System\Text\Json\ThrowHelper.Node.cs (2)

58Debug.Assert(supportedTypeNames.Length > 0); 59string concatenatedNames = supportedTypeNames.Length == 1 ? supportedTypeNames[0] : string.Join(", ", supportedTypeNames.ToArray());

System\Text\Json\ThrowHelper.Serialization.cs (1)

355if (str.Length <= MaxLength)

System\Text\Json\Writer\JsonWriterHelper.cs (32)

System\Text\Json\Writer\JsonWriterHelper.Escaping.cs (7)

75return (encoder ?? JavaScriptEncoder.Default).FindFirstCharacterToEncode(ptr, value.Length); 101Debug.Assert(encoderBytesConsumed == value.Length || (result == OperationStatus.NeedMoreData && !isFinalBlock)); 112Debug.Assert(indexOfFirstByteToEscape >= 0 && indexOfFirstByteToEscape < value.Length); 128while (indexOfFirstByteToEscape < value.Length) 219Debug.Assert(encoderBytesConsumed == value.Length || (result == OperationStatus.NeedMoreData && !isFinalBlock)); 230Debug.Assert(indexOfFirstByteToEscape >= 0 && indexOfFirstByteToEscape < value.Length); 246while (indexOfFirstByteToEscape < value.Length)

System\Text\Json\Writer\Utf8JsonWriter.cs (18)

128Debug.Assert(partialStringDataBytes.Length == 3); 138Debug.Assert(value.Length <= 3); 143_partialStringDataLength = (byte)value.Length; 157Debug.Assert(partialStringDataBytes.Length == 3); 166Debug.Assert(value.Length <= 1); 171_partialStringDataLength = (byte)(2 * value.Length); 185Debug.Assert(partialStringDataBytes.Length == 3); 194Debug.Assert(value.Length < 3); 199_partialStringDataLength = (byte)value.Length; 722Debug.Assert(utf8PropertyName.Length <= JsonConstants.MaxUnescapedTokenSize); 786Debug.Assert(propertyIdx >= -1 && propertyIdx < utf8PropertyName.Length); 814Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= utf8PropertyName.Length); 815Debug.Assert(firstEscapeIndexProp >= 0 && firstEscapeIndexProp < utf8PropertyName.Length); 819int length = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp); 935Debug.Assert(propertyIdx >= -1 && propertyIdx < propertyName.Length); 963Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= propertyName.Length); 964Debug.Assert(firstEscapeIndexProp >= 0 && firstEscapeIndexProp < propertyName.Length); 968int length = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp);

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Bytes.cs (23)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.DateTime.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.DateTimeOffset.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Decimal.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Double.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Float.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.FormattedNumber.cs (8)

86Debug.Assert(propertyIdx >= -1 && propertyIdx < propertyName.Length); 102Debug.Assert(propertyIdx >= -1 && propertyIdx < utf8PropertyName.Length); 116Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= propertyName.Length); 117Debug.Assert(firstEscapeIndexProp >= 0 && firstEscapeIndexProp < propertyName.Length); 121int length = JsonWriterHelper.GetMaxEscapedLength(propertyName.Length, firstEscapeIndexProp); 139Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= utf8PropertyName.Length); 140Debug.Assert(firstEscapeIndexProp >= 0 && firstEscapeIndexProp < utf8PropertyName.Length); 144int length = JsonWriterHelper.GetMaxEscapedLength(utf8PropertyName.Length, firstEscapeIndexProp);

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Guid.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Helpers.cs (12)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Literal.cs (44)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.SignedNumber.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.String.cs (121)

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.UnsignedNumber.cs (19)

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Bytes.cs (6)

56if (bytes.Length > MaxLengthAllowed) 58ThrowHelper.ThrowArgumentException_ValueTooLarge(bytes.Length); 61int encodingLength = Base64.GetMaxEncodedToUtf8Length(bytes.Length); 99if (bytes.Length > maxLengthAllowed) 101ThrowHelper.ThrowArgumentException_ValueTooLarge(bytes.Length); 104int encodingLength = Base64.GetMaxEncodedToUtf8Length(bytes.Length);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Comment.cs (10)

80Debug.Assert(value.Length < (int.MaxValue / JsonConstants.MaxExpansionFactorWhileTranscoding) - 4); 84int maxRequired = (value.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) + 4; 114Debug.Assert(value.Length < (int.MaxValue / JsonConstants.MaxExpansionFactorWhileTranscoding) - indent - 4 - _newLineLength); 118int maxRequired = indent + (value.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) + 4 + _newLineLength; 195Debug.Assert(utf8Value.Length < int.MaxValue - 4); 197int maxRequired = utf8Value.Length + 4; // /*...*/ 210BytesPending += utf8Value.Length; 221Debug.Assert(utf8Value.Length < int.MaxValue - indent - 4 - _newLineLength); 223int minRequired = indent + utf8Value.Length + 4; // /*...*/ 245BytesPending += utf8Value.Length;

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.FormattedNumber.cs (5)

49int maxRequired = utf8Value.Length + 1; // Optionally, 1 list separator 64BytesPending += utf8Value.Length; 72Debug.Assert(utf8Value.Length < int.MaxValue - indent - 1 - _newLineLength); 74int maxRequired = indent + utf8Value.Length + 1 + _newLineLength; // Optionally, 1 list separator and 1-2 bytes for new line 99BytesPending += utf8Value.Length;

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Helpers.cs (1)

133Debug.Assert(consumed == bytes.Length);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Literal.cs (6)

66Debug.Assert(utf8Value.Length <= 5); 68int maxRequired = utf8Value.Length + 1; // Optionally, 1 list separator 83BytesPending += utf8Value.Length; 90Debug.Assert(utf8Value.Length <= 5); 92int maxRequired = indent + utf8Value.Length + 1 + _newLineLength; // Optionally, 1 list separator and 1-2 bytes for new line 117BytesPending += utf8Value.Length;

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Raw.cs (7)

105if (utf8Json.Length == int.MaxValue) 195if (json.Length > JsonConstants.MaxUtf16RawValueLength) 197ThrowHelper.ThrowArgumentException_ValueTooLarge(json.Length); 205json.Length <= (JsonConstants.StackallocByteThreshold / JsonConstants.MaxExpansionFactorWhileTranscoding) ? stackalloc byte[JsonConstants.StackallocByteThreshold] : 207json.Length <= (JsonConstants.ArrayPoolMaxSizeBeforeUsingNormalAlloc / JsonConstants.MaxExpansionFactorWhileTranscoding) ? tempArray = ArrayPool<byte>.Shared.Rent(json.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) : 230int len = utf8Json.Length;

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.String.cs (19)

21Debug.Assert(utf8Value.Length <= JsonConstants.MaxUnescapedTokenSize); 86Debug.Assert(valueIdx >= -1 && valueIdx < value.Length); 118Debug.Assert(escapedValue.Length < (int.MaxValue / JsonConstants.MaxExpansionFactorWhileTranscoding) - 3); 122int maxRequired = (escapedValue.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) + 3; 148Debug.Assert(escapedValue.Length < (int.MaxValue / JsonConstants.MaxExpansionFactorWhileTranscoding) - indent - 3 - _newLineLength); 152int maxRequired = indent + (escapedValue.Length * JsonConstants.MaxExpansionFactorWhileTranscoding) + 3 + _newLineLength; 185Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= value.Length); 186Debug.Assert(firstEscapeIndexVal >= 0 && firstEscapeIndexVal < value.Length); 190int length = JsonWriterHelper.GetMaxEscapedLength(value.Length, firstEscapeIndexVal); 233Debug.Assert(valueIdx >= -1 && valueIdx < utf8Value.Length); 265Debug.Assert(escapedValue.Length < int.MaxValue - 3); 267int minRequired = escapedValue.Length + 2; // 2 quotes 284BytesPending += escapedValue.Length; 295Debug.Assert(escapedValue.Length < int.MaxValue - indent - 3 - _newLineLength); 297int minRequired = indent + escapedValue.Length + 2; // 2 quotes 325BytesPending += escapedValue.Length; 332Debug.Assert(int.MaxValue / JsonConstants.MaxExpansionFactorWhileEscaping >= utf8Value.Length); 333Debug.Assert(firstEscapeIndexVal >= 0 && firstEscapeIndexVal < utf8Value.Length); 337int length = JsonWriterHelper.GetMaxEscapedLength(utf8Value.Length, firstEscapeIndexVal);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.StringSegment.cs (45)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

src\libraries\Common\src\SourceGenerators\SourceWriter.cs (2)

93lineLength = remainingText.Length; 118builder.Append(ptr, span.Length);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(_span.Length - _pos + source.Length); 89_pos += source.Length; 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 98Grow(source.Length); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length)); 103_pos += source.Length;

src\libraries\System.Text.Json\Common\JsonSeparatorNamingPolicy.cs (3)

37int initialBufferLength = (int)(1.2 * chars.Length); 45for (int i = 0; i < chars.Length; i++) 75if (i + 1 < chars.Length && char.IsLower(chars[i + 1]))

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(_span.Length - _pos + source.Length); 89_pos += source.Length; 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 98Grow(source.Length); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length)); 103_pos += source.Length;

System\Text\RegularExpressions\Regex.Count.cs (1)

38Count(input, RightToLeft ? input.Length : 0);

System\Text\RegularExpressions\Regex.cs (5)

435int stoppos = span.Length; 467Debug.Assert(startat <= input.Length); 488if (runner.runtextstart == input.Length) 530Debug.Assert((uint)startat <= (uint)inputSpan.Length); 577int stoppos = inputSpan.Length;

System\Text\RegularExpressions\Regex.EnumerateMatches.cs (1)

80new ValueMatchEnumerator(this, input, RightToLeft ? input.Length : 0);

System\Text\RegularExpressions\Regex.EnumerateSplits.cs (5)

136EnumerateSplits(input, count, startat: RightToLeft ? input.Length : 0); 166if ((uint)startat > (uint)input.Length) 201_lastMatch = (rtl ? input.Length : 0, -1); 224_currentSplit = !_regex.RightToLeft ? (_lastMatch.Index + _lastMatch.Length).._input.Length : 0.._lastMatch.Index; 243_currentSplit = start.._input.Length;

System\Text\RegularExpressions\Regex.Match.cs (1)

104IsMatch(input, RightToLeft ? input.Length : 0);

System\Text\RegularExpressions\Regex.Replace.cs (1)

235dest = dest.Slice(segment.Length);

System\Text\RegularExpressions\RegexCharClass.cs (13)

414for (i = 0; i < set.Length - 1; i += 2) 419if (i < set.Length) 1225return (uint)chDiv8 < (uint)ascii.Length ? 1244return (uint)chDiv8 < (uint)ascii.Length ? 1395for (int i = 0; i < categorySetSegment.Length; i++) 1550for (int index = 0; index < chars.Length - 1; index++) 1556switch (chars.Length) 1587int count = chars.Length * 2; 1588if (chars[chars.Length - 1] == LastChar) 1989Span<char> invertedGroup = group.Length <= scratch.Length ? scratch.Slice(0, group.Length) : new char[group.Length]; 1990for (int i = 0; i < group.Length; i++)

System\Text\RegularExpressions\RegexCompiler.cs (3)

6156Debug.Assert(chars.Length > 3, $"chars.Length == {chars.Length}"); 6160if (chars.Length is 4 or 5 && !RegexCharClass.IsAscii(chars))

System\Text\RegularExpressions\RegexFindOptimizations.cs (32)

System\Text\RegularExpressions\RegexInterpreter.cs (8)

217if (inputSpan.Length - runtextpos < c) 257if (inputSpan.Length - runtextpos < length) 355if (TryMatchAtCurrentPosition(text) || runtextpos == text.Length) 732if ((uint)m1 < (uint)inputSpan.Length && inputSpan[m1] != '\n') 743if ((uint)runtextpos < (uint)inputSpan.Length && inputSpan[runtextpos] != '\n') 802if (runtextpos < inputSpan.Length - 1 || ((uint)runtextpos < (uint)inputSpan.Length && inputSpan[runtextpos] != '\n')) 811if (runtextpos < inputSpan.Length)

System\Text\RegularExpressions\RegexNode.cs (9)

1251Debug.Assert(startingSpan.Length > 0); 1273if (startingSpan.Length != 1) 1283int minLength = Math.Min(startingSpan.Length, startingNode.Str.Length); 1304Debug.Assert(startingSpan.Length > 0); 1310var prefix = startingSpan.Length == 1 ? 1327Debug.Assert(startingSpan.Length == 1); 1336if (node.Str!.Length == startingSpan.Length) 1341else if (node.Str.Length - 1 == startingSpan.Length) 1349node.Str = node.Str.Substring(startingSpan.Length);

System\Text\RegularExpressions\RegexParser.cs (3)

166ValueStringBuilder vsb = input.Length <= (EscapeMaxBufferSize / 3) ? 168new ValueStringBuilder(input.Length + 200); 205indexOfMetachar = input.Length;

System\Text\RegularExpressions\RegexReplacement.cs (1)

275for (int i = 0; i < span.Length; i += 2)

System\Text\RegularExpressions\RegexRunner.cs (10)

142if (s == null || text != s.AsSpan(beginning, text.Length)) 159InternalScan(runregex!, beginning, beginning + text.Length); 284runtextend = text.Length; 292new Match(runregex, runregex.capsize, runtext, text.Length) : 293new MatchSparse(runregex, runregex.caps, runregex.capsize, runtext, text.Length); 297m.Reset(runtext, text.Length); 417return ((uint)indexM1 < (uint)inputSpan.Length && RegexCharClass.IsBoundaryWordChar(inputSpan[indexM1])) != 418((uint)index < (uint)inputSpan.Length && RegexCharClass.IsBoundaryWordChar(inputSpan[index])); 433return ((uint)indexM1 < (uint)inputSpan.Length && RegexCharClass.IsECMAWordChar(inputSpan[indexM1])) != 434((uint)index < (uint)inputSpan.Length && RegexCharClass.IsECMAWordChar(inputSpan[index]));

System\Text\RegularExpressions\Symbolic\BDD.cs (3)

344Debug.Assert(bytes.Length > 1, "All inputs are expected to be larger than a single byte, which would map to False or True."); 350int n = (bytes.Length - 1) / bytesPerLong; 353Debug.Assert((bytes.Length - 1) % bytesPerLong == 0);

System\Text\RegularExpressions\Symbolic\CharSetSolver.cs (4)

162if (sets.Length == 0) 168for (int i = 1; i < sets.Length; i++) 181if (sets.Length == 0) 187for (int i = 1; i < sets.Length; i++)

System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.cs (22)

356Debug.Assert(startat >= 0 && startat <= input.Length, $"{nameof(startat)} == {startat}, {nameof(input.Length)} == {input.Length}"); 495int lengthMinus1 = input.Length - 1; 513innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length; 521if (done || pos >= input.Length) 579innerLoopLength = _checkTimeout && input.Length - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : input.Length; 587innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length; 594if (done || pos >= input.Length) 636if (pos == input.Length) 661if (pos == input.Length) 694if (pos + 1 < input.Length) 864Debug.Assert(matchStartBoundary >= 0 && matchStartBoundary <= input.Length, $"{nameof(matchStartBoundary)} == {matchStartBoundary}"); 1482if ((uint)pos < (uint)input.Length) 1486return c == '\n' && pos == input.Length - 1 ? 1500(uint)pos < (uint)input.Length ? 1558Debug.Assert(pos == input.Length); 1589Debug.Assert(pos == input.Length); 1619Debug.Assert(pos == input.Length);

System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.Dgml.cs (3)

152Debug.Assert(deltas.Length == matcher._minterms.Length); 153for (int i = 0; i < deltas.Length; ++i) 167if (nfaDeltas.Length > 0 && nfaDeltas[i] is int[] nfaTargets)

System\Text\RegularExpressions\Symbolic\SymbolicRegexRunnerFactory.cs (1)

108runtextpos = text.Length;

RegexGenerator.Emitter.cs (2)

399Debug.Assert(chars.Length > 3); 405return chars.Length > 5 || RegexCharClass.IsAscii(chars)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (2)

162switch (span.Length) 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 185Span<char> result = bytes.Length > 16 ? 186new char[bytes.Length * 2].AsSpan() : 187stackalloc char[bytes.Length * 2]; 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(_span.Length - _pos + source.Length); 89_pos += source.Length; 96if ((uint)(_pos + source.Length) > (uint)_span.Length) 98Grow(source.Length); 101_span.Slice(0, _pos).CopyTo(_span.Slice(source.Length)); 103_pos += source.Length;

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (13)

414for (i = 0; i < set.Length - 1; i += 2) 419if (i < set.Length) 1225return (uint)chDiv8 < (uint)ascii.Length ? 1244return (uint)chDiv8 < (uint)ascii.Length ? 1395for (int i = 0; i < categorySetSegment.Length; i++) 1550for (int index = 0; index < chars.Length - 1; index++) 1556switch (chars.Length) 1587int count = chars.Length * 2; 1588if (chars[chars.Length - 1] == LastChar) 1989Span<char> invertedGroup = group.Length <= scratch.Length ? scratch.Slice(0, group.Length) : new char[group.Length]; 1990for (int i = 0; i < group.Length; i++)

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexNode.cs (9)

1251Debug.Assert(startingSpan.Length > 0); 1273if (startingSpan.Length != 1) 1283int minLength = Math.Min(startingSpan.Length, startingNode.Str.Length); 1304Debug.Assert(startingSpan.Length > 0); 1310var prefix = startingSpan.Length == 1 ? 1327Debug.Assert(startingSpan.Length == 1); 1336if (node.Str!.Length == startingSpan.Length) 1341else if (node.Str.Length - 1 == startingSpan.Length) 1349node.Str = node.Str.Substring(startingSpan.Length);

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexParser.cs (4)

166ValueStringBuilder vsb = input.Length <= (EscapeMaxBufferSize / 3) ? 168new ValueStringBuilder(input.Length + 200); 205indexOfMetachar = input.Length; 1950for (int i = 0; i < input.Length; i++)

Stubs.cs (3)

22return stringBuilder.Append(ptr, span.Length); 48int length = Math.Min(span.Length, other.Length);

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

167Debug.Assert(chars.Length >= bytes.Length * 2); 176for (int pos = 0; pos < bytes.Length; pos++) 198return string.Create(bytes.Length * 2, args, static (chars, args) => 359Debug.Assert(chars.Length % 2 == 0, "Un-even number of characters provided"); 360Debug.Assert(chars.Length / 2 == bytes.Length, "Target buffer not right-sized for provided characters"); 390return c >= CharToHexLookup.Length ? 0xFF : CharToHexLookup[c];

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

241if (pos > _chars.Length - value.Length) 243Grow(value.Length); 247_pos += value.Length;

System\Web\Util\HttpEncoder.cs (5)

75for (int i = 0; i < remaining.Length; i++) 210int count = bytes.Length; 323int count = value.Length; 414byte[] expandedBytes = new byte[bytes.Length + cUnsafe * 2]; 569byte[] bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(toEncode.Length));

System\Windows\Forms\ActiveX\AxHost.VBFormat.cs (3)

53if (format.Length >= buffer.Length) 60buffer[format.Length] = '\0'; 61*rcb = (ushort)(format.Length * sizeof(char));

System\Windows\Forms\ActiveX\DataStreamFromComStream.cs (2)

141_comStream->Write(b, (uint)buffer.Length, &bytesWritten); 144if (bytesWritten < buffer.Length)

System\Windows\Forms\Controls\ImageList\ImageListStreamer.cs (2)

39int length = RunLengthEncoder.GetEncodedLength(input) + HeaderMagic.Length; 44Debug.Assert(written == length - HeaderMagic.Length, "RLE compression failure");

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\MultiSelectRootGridEntry.PropertyMerger.cs (3)

100var objectProperties = new PropertyDescriptorCollection[objects.Length]; 108for (int i = 0; i < objects.Length; i++) 131var matchArray = new PropertyDescriptor[objects.Length];

System\Windows\Forms\Dialogs\CommonDialogs\FileDialog.cs (7)

459var fileNames = fileBuffer[(directory.Length + 1)..]; 463if (fileNames.Length == 0 || fileNames[0] == '\0') 470while (fileName.Length > 0) 476fileNames = fileNames[(fileName.Length + 1)..]; 634Debug.Assert(currentExtension.Length == 0 || currentExtension[0] == '.', 639? $"{fileName[..^currentExtension.Length]}.{extensions[j]}" 640: fileName[..^currentExtension.Length];

System\Windows\Forms\SendKeys\SendKeys.cs (1)

322if (keystate.Length < 256)

System\ComponentModel\Design\ByteViewer.cs (5)

185Debug.Assert(charsBuffer.Length >= lineBuffer.Length); 186Span<char> charsToDraw = charsBuffer[..lineBuffer.Length]; 187for (int i = 0; i < lineBuffer.Length; i++) 207Debug.Assert(charsBuffer.Length >= lineBuffer.Length * 3 + 1); 209for (int i = 0; i < lineBuffer.Length; i++)

System\ComponentModel\Design\Serialization\CodeDomSerializerBase.cs (1)

1305for (int i = 0; i < compatibleTypes.Length; i++)

System\Windows\Forms\DeviceContextExtensions.cs (2)

82Debug.Assert((lines.Length % 4) == 0); 90for (int i = 0; i < lines.Length; i += 4)

System\Windows\Forms\SystemDrawingExtensions.cs (2)

56Debug.Assert((lines.Length % 4) == 0); 58for (int i = 0; i < lines.Length; i += 4)

Windows\Win32\PInvoke.DrawTextEx.cs (1)

20return DrawTextEx(hdc, (PWSTR)c, lpchText.Length, lprc, format, lpdtp);

Windows\Win32\UI\Controls\LVITEMW.cs (3)

15if (cchTextMax <= text.Length) 21cchTextMax = text.Length + 1; 27pszText.Value[text.Length] = '\0';

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

42written.Should().Be(data.Length);

Extensions\AssertExtensions.cs (7)

481if (expected.Length != actual.Length) 483throw new XunitException($"Expected: Span of length {expected.Length}{Environment.NewLine}Actual: Span of length {actual.Length}"); 491for (int i = 0; i < expected.Length; i++) 505message += $"Total number of differences: {diffCount} out of {expected.Length}"; 516for (int i = 0; i < actual.Length; i++)

Extensions\SpanExtensions.cs (2)

10T2[] output = new T2[span.Length]; 11for (int i = 0; i < span.Length; i++)

PathLengthTests.cs (2)

38entry.Directory.Length + entry.FileName.Length > maxLength

TestAccessorTests.cs (1)

220private int ToStringLength(ReadOnlySpan<char> value) => value.Length;

Infra\ScreenRecordService.cs (8)

286for (int column = 0; column < previousFrameLine.Length; column++) 301for (int column = previousFrameLine.Length - 1; column > lastChangedColumn; column--) 382WriteChunkHeader(stream, buffer, crc, Fdat, (uint)(data.Length + 4)); 540if (bytes.Length < buffer.Length) 543stream.Write(buffer, 0, bytes.Length); 547for (ReadOnlySpan<byte> remaining = bytes; !remaining.IsEmpty; remaining = remaining[Math.Min(buffer.Length, remaining.Length)..]) 549ReadOnlySpan<byte> current = remaining[..Math.Min(buffer.Length, remaining.Length)]; 551stream.Write(buffer, 0, current.Length);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\ReflectionUtils.cs (5)

66fullName = fullName.Slice(0, fullName.Length - nameSlice.Length + commaIndex); 108int tokenLength = tokenEnding == 0 ? assemblyName.Slice(versionIndex).Length : tokenEnding; 118int tokenLength = tokenEnding == 0 ? assemblyName.Slice(tokenIndex).Length : tokenEnding; 123if (assemblyToken.Length != 16)

System\Xaml\Parser\GenericTypeNameScanner.cs (1)

146while (pos < subscript.Length);

System\Xaml\Schema\XamlNamespace.cs (1)

144while (pos < subscript.Length);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

799var sb = new StringBuilder(path.Length); 802if (path.Length > 1 && IsAnyDirectorySeparator(path[0]) && IsAnyDirectorySeparator(path[1])) 810for (int i = start; i < path.Length; i++)

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

135uint length = (uint)source.Length;

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

253state.TotalLength += (uint)source.Length; 258if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) 260source.CopyTo(new Span<byte>(buffer + state.BufferedCount, source.Length)); 261state.BufferedCount += (uint)source.Length; 281Debug.Assert(sourceIndex < source.Length); 284if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) 286ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; 310Debug.Assert(sourceIndex < source.Length); // at least some bytes left 316else if (source.Length - sourceIndex > InternalBufferLengthBytes) 324while (source.Length - sourceIndex > InternalBufferLengthBytes); 331Span<byte> remaining = new Span<byte>(buffer, source.Length - sourceIndex); 332Debug.Assert(sourceIndex < source.Length);

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

50int length = path.Length;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (3)

231for (int i = 0; i < data.Length; i++) 295for (int i = 0; i < data.Length; i++) 399for (int i = 0; i < data.Length; i++)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (4)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length); 532for (var i = 0; i < ascii.Length; i++) 538if (ascii.Length != text.Length) 543for (var i = 0; i < ascii.Length; i++)

src\Dependencies\Collections\Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

126if (remaining[index] == '\r' && remaining.Length > index + 1 && remaining[index + 1] == '\n')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (2)

330WriteArrayLength(span.Length); 368var spanLength = span.Length;

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

87while (chars.Length != 0) 98Debug.Assert(chars.Length != 0); // If TryDecodeFromUtf16() consumed the entire buffer, it could not have returned false. 106if (indexOfFirstNonSpace == chars.Length) 115if ((bytesWrittenInThisIteration % 3) != 0 && chars.Length != 0) 127Debug.Assert(chars.Length != 0 && !chars[0].IsSpace()); 155for (int i = 0; i < chars.Length; i++) 178for (int i = 0; i < chars.Length; i++) 191consumed = chars.Length; 199int srcLength = utf16.Length & ~0x3; // only decode input up to the closest multiple of 4. 205if (utf16.Length == 0) 305if (srcLength != utf16.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (8)

170return source.Length <= target.Length 182Debug.Assert(source.Length <= target.Length); 187while (source.Length > 0 && source[^1] == target[^1]) 193while (source.Length > 0 && source[0] == target[0]) 207var sourceLength = source.Length; 208var targetLength = target.Length;

MS\Internal\AutomationProxies\ProxyHwnd.cs (2)

85if (aEvents.Length > 0) 114if (aEvents.Length > 0)

MS\Internal\AutomationProxies\WindowsComboBox.cs (2)

307if (editPortionEvents.Length > 0) 343if (editPortionEvents.Length > 0)

MS\Internal\AutomationProxies\WinEventTracker.cs (1)

586private static Hashtable[] _ahp = new Hashtable[EventIdToIndex.Length];

Sdk\CollectionTracker.cs (2)

593 var endIndex = Math.Min(span.Length - 1, startIndex + ArgumentFormatter.MAX_ENUMERABLE_LENGTH - 1); 596 var moreItemsPastEndIndex = endIndex < span.Length - 1;

StringAsserts.cs (4)

916 var expectedLength = expected.Length; 917 var actualLength = actual.Length; 1669 if (index < value.Length && value[index] == '\n') 1683 while (index < value.Length)