Length

Commands\GroupedHelpWriter.cs (2)

222while (remaining.Length > 0) 236if (remaining.Length <= descriptionWidth)

Mcp\Docs\DocsIndexService.cs (1)

551var endOk = endIndex >= text.Length || !char.IsLetterOrDigit(text[endIndex]);

Mcp\Docs\LlmsTxtParser.cs (23)

130while (position < span.Length) 140if (position < span.Length && IsH1Start(span[position..])) 158if (trimmed.Length < 2) 165&& (trimmed[1] is ' ' || trimmed.Length is 1); 184if (title.Length is 0) 220while (hashCount < trimmed.Length && trimmed[hashCount] is '#') 232if (textStart < trimmed.Length && trimmed[textStart] is ' ') 247while (position < content.Length) 251while (lineStart < content.Length && content[lineStart] is ' ' or '\t') 257if (lineStart < content.Length && content[lineStart] is '>') 267if (quoteText.Length > 0) 283if (position < content.Length && content[position] is '#') 312var endIndex = docSpan.Length; 343while (position < content.Length - 2) 356if (searchStart >= content.Length) 365regions.Add((absoluteOpen, content.Length)); 429while (position < docSpan.Length) 484while (whitespaceSkipped < remaining.Length && remaining[whitespaceSkipped] is ' ' or '\t') 498while (level < trimmed.Length && trimmed[level] is '#') 504if (level >= trimmed.Length || trimmed[level] is not ' ') 549var end = headingSpan.Length; 575while (position < span.Length - 2) 586if (absoluteIndex + 2 < span.Length && span[absoluteIndex + 2] is '#')

src\Shared\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')

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

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

Utils\CliTestHelper.cs (1)

637while (remaining.Length > 0)

Extensions\StringExtensions.cs (1)

46if (s.Length == 0)

Model\Assistant\Markdown\AspireEnrichmentParser.cs (1)

147if (input.Length >= (marker.Length * 2) && input.StartsWith(marker) && input.EndsWith(marker))

Model\TextVisualizerViewModel.cs (1)

230|| span.Length > 1 && char.IsLetter(span[1]); // element name

Otlp\Model\OtlpHelpers.cs (1)

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

src\Shared\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')

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

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

Dcp\DcpLogParser.cs (1)

64if (line.Length > 0 && line[^1] == '\r')

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

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

EventSourceGenerator.Parser.cs (2)

177byte[] combinedBytes = new byte[namespaceBytes.Length + bytes.Length]; 179bytes.CopyTo(combinedBytes, namespaceBytes.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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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); 646for (; 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); 646for (; 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); 646for (; 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); 646for (; 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); 646for (; 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);

RegexGenerator.g.cs (13)

91base.runtextpos != inputSpan.Length) 110if (pos <= inputSpan.Length - 3) 115for (int i = 0; i < span.Length - 2; i++) 127if ((uint)(i + 1) >= (uint)span.Length) 142base.runtextpos = inputSpan.Length; 166iteration = slice.Length - 1; 179if ((uint)slice.Length < 2 || slice[1] != '}') 230base.runtextpos != inputSpan.Length) 248if (pos <= inputSpan.Length - 4) 253for (int i = 0; i < span.Length; i++) 264base.runtextpos = inputSpan.Length; 285iteration = slice.Length; 334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

src\tools\illink\src\ILLink.Shared\DataFlow\CompilerGeneratedNames.cs (5)

18return memberName.Length > 0 && memberName[0] == '<'; 66return typeName.Length > i + 1 && typeName[i + 1] == 'd'; 92return fieldName.Length > i + 1 && fieldName[i + 1] == '2'; 130return methodName.Length > i + 1 && methodName[i + 1] == 'b'; 161return methodName.Length > i + 1 && methodName[i + 1] == 'g';

CompilationExtensions.cs (2)

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

INamedTypeSymbolExtensions.cs (1)

19while (roSpan.Length > 0)

src\libraries\Common\src\System\Buffers\SearchValuesPolyfills.cs (2)

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

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 226Span<char> result = (bytes.Length > 16) ? 227new char[bytes.Length * 2].AsSpan() : 228stackalloc char[bytes.Length * 2]; 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (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)

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

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)

40return input.Length; // no type name end chars were found, the whole input is the type name 48isNestedType = offset > 0 && offset < input.Length && input[offset] == '+'; 54for (; offset < input.Length; offset++) 61if (offset == input.Length || // invalid name that ends with escape character 146for (; offset < input.Length; offset++)

src\tools\illink\src\ILLink.Shared\DataFlow\CompilerGeneratedNames.cs (5)

18return memberName.Length > 0 && memberName[0] == '<'; 66return typeName.Length > i + 1 && typeName[i + 1] == 'd'; 92return fieldName.Length > i + 1 && fieldName[i + 1] == '2'; 130return methodName.Length > i + 1 && methodName[i + 1] == 'b'; 161return methodName.Length > i + 1 && methodName[i + 1] == 'g';

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)

641if (span.Length > 0)

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

42if (buffer.Length != 0)

Program.cs (2)

286var destinationSpan = destination.GetSpan(plaintext.Length); 296var destinationSpan = destination.GetSpan(ciphertext.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.Length;

Internal\DefaultAntiforgeryTokenSerializer.cs (4)

110if (tokenBytes.Length < minCookieTokenLength) 140if (tokenBytes.Length < minRequestTokenPayloadLength) 153if (tokenBytes.Length < claimUidByteLength + 1) // +1 for additionalData prefix 178if (tokenBytes.Length != 0)

src\Shared\Encoding\Int7BitEncodingUtils.cs (2)

72if (shift == 35 || index >= source.Length) 144if (bytes.Length < consumed + length)

RegexGenerator.g.cs (5)

71base.runtextpos = inputSpan.Length; 89base.runtextpos = inputSpan.Length; 113iteration = slice.Length; 121if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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

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

NavigationManager.cs (1)

207var pathOnlyLength = queryOrFragmentIndex >= 0 ? queryOrFragmentIndex : currentUri.Length;

NavigationManagerExtensions.cs (2)

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

PersistentState\PersistentStateValueProviderKeyResolver.cs (1)

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

RegexGenerator.g.cs (5)

71base.runtextpos = inputSpan.Length; 89base.runtextpos = inputSpan.Length; 113iteration = slice.Length; 121if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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)

209if (currentUriAbsolute.Length == hrefAbsolute.Length - 1) 219if (hrefAbsolute[hrefAbsolute.Length - 1] == '/' && 220currentUriAbsolute.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");

Cng\CbcAuthenticatedEncryptor.cs (6)

69if (ciphertext.Length < checked(KEY_MODIFIER_SIZE_IN_BYTES + _symmetricAlgorithmBlockSizeInBytes + _hmacAlgorithmDigestLengthInBytes)) 74var cbEncryptedDataLength = checked(ciphertext.Length - (int)(KEY_MODIFIER_SIZE_IN_BYTES + _symmetricAlgorithmBlockSizeInBytes + _hmacAlgorithmDigestLengthInBytes)); 94cbLabel: (uint)additionalAuthenticatedData.Length, 278cbLabel: (uint)additionalAuthenticatedData.Length, 302cbInput: (uint)plaintext.Length, 337cbInput: (uint)plaintext.Length,

Cng\CngGcmAuthenticatedEncryptor.cs (7)

64if (ciphertext.Length < KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + TAG_SIZE_IN_BYTES) 69var plaintextLength = checked(ciphertext.Length - (int)(KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + TAG_SIZE_IN_BYTES)); 88cbLabel: (uint)additionalAuthenticatedData.Length, 227var totalRequiredSize = checked((int)(KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + plaintext.Length + TAG_SIZE_IN_BYTES)); 238byte* pbAuthTag = &pbEncryptedData[plaintext.Length]; 252cbLabel: (uint)additionalAuthenticatedData.Length, 271cbPlaintextData: (uint)plaintext.Length,

KeyManagement\KeyRingBasedSpanDataProtector.cs (1)

83if (protectedData.Length < _magicHeaderKeyIdSize)

Managed\AesGcmAuthenticatedEncryptor.cs (6)

74if (ciphertext.Length < KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + TAG_SIZE_IN_BYTES) 79var plaintextBytes = ciphertext.Length - (KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + TAG_SIZE_IN_BYTES); 203CryptoUtil.Assert(refPooledBuffer.WrittenSpan.Length == outputSize, "writtenSpan length should equal calculated outputSize"); 223var totalRequiredSize = checked(KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + plaintext.Length + TAG_SIZE_IN_BYTES); 265var encrypted = buffer.Slice(KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES, plaintext.Length); 266var tag = buffer.Slice(KEY_MODIFIER_SIZE_IN_BYTES + NONCE_SIZE_IN_BYTES + plaintext.Length, TAG_SIZE_IN_BYTES);

Managed\ManagedAuthenticatedEncryptor.cs (5)

82if (ciphertext.Length < checked(KEY_MODIFIER_SIZE_IN_BYTES + _symmetricAlgorithmBlockSizeInBytes + _validationAlgorithmDigestLengthInBytes)) 88var estimatedDecryptedSize = ciphertext.Length - (KEY_MODIFIER_SIZE_IN_BYTES + _symmetricAlgorithmBlockSizeInBytes + _validationAlgorithmDigestLengthInBytes); 97var macOffset = ciphertext.Length - _validationAlgorithmDigestLengthInBytes; 179var cipherTextLength = symmetricAlgorithmForSizing.GetCiphertextLengthCbc(plaintext.Length); 300CryptoUtil.Assert(refPooledBuffer.WrittenSpan.Length == outputSize, "bytesWritten == size");

SP800_108\ManagedSP800_108_CTR_HMACSHA512.cs (7)

48if (kdk.Length < FipsMinimumKeyLengthInBytes) 96var prfInputLength = checked(sizeof(uint) /* [i]_2 */ + label.Length + 1 /* 0x00 */ + (contextHeader.Length + contextData.Length) + sizeof(uint) /* [K]_2 */); 119contextHeader.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1)); 120contextData.CopyTo(prfInput.Slice(sizeof(uint) + label.Length + 1 + contextHeader.Length));

src\Shared\Encoding\Int7BitEncodingUtils.cs (2)

72if (shift == 35 || index >= source.Length) 144if (bytes.Length < consumed + length)

Benchmarks\SpanDataProtectorComparison.cs (4)

104return protectedSpan.Length + unProtectedSpan.Length; 126return protectedSpan.Length + unProtectedSpan.Length;

Internal\RoundtripEncryptionHelpers.cs (4)

50Assert.Equal(decipheredtext.Length, decryptedResult2.Length); 71Assert.Equal(protectedData.Length, protectedResult.Length); 77Assert.Equal(unprotectedData.Length, unProtectedResult.Length); 88Assert.Equal(unprotectedData.Length, unProtectedResult.Length);

KeyManagement\KeyRingBasedDataProtectorTests.cs (1)

731Assert.Equal(plaintextSize, unprotectedData.Length);

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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)

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

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

ResponseBufferingStream.cs (1)

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

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

RegexGenerator.g.cs (5)

71base.runtextpos = inputSpan.Length; 89base.runtextpos = inputSpan.Length; 113iteration = slice.Length; 121if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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)

289chunk.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) =>

Windows.Win32.byte.InlineArrays.g.cs (1)

60 int initLength = value.Length;

Windows.Win32.char.InlineArrays.g.cs (4)

55 internal readonly bool Equals(ReadOnlySpan<char> value) => value.Length == SpanLength ? AsReadOnlySpan().SequenceEqual(value) : AsReadOnlySpan().SliceAtNull().SequenceEqual(value); 78 int initLength = value.Length; 117 int initLength = value.Length; 157 int initLength = value.Length;

Windows.Win32.HTTP_KNOWN_HEADER.InlineArrays.g.cs (2)

53 int initLength = value.Length; 93 int initLength = value.Length;

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

667 uint __result = PInvoke.HttpSendResponseEntityBody(RequestQueueHandleLocal, RequestId, Flags, (ushort )EntityChunks.Length, EntityChunksLocal, BytesSentLocal, default, default, Overlapped, LogData.HasValue ? &LogDataLocal : null); 697 uint __result = PInvoke.HttpSendResponseEntityBody(RequestQueueHandleLocal, RequestId, Flags, (ushort )EntityChunks.Length, EntityChunksLocal, default(uint* ), default, default, Overlapped, LogData.HasValue ? &LogDataLocal : null); 770 uint __result = PInvoke.HttpSetRequestQueueProperty(RequestQueueHandleLocal, Property, (void* )PropertyInformationLocal, (uint )PropertyInformation.Length, default, default); 816 uint __result = PInvoke.HttpSetUrlGroupProperty(UrlGroupId, Property, (void* )PropertyInformationLocal, (uint )PropertyInformation.Length);

Windows.Win32.ushort.InlineArrays.g.cs (1)

60 int initLength = value.Length;

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); 646for (; 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) =>

Windows.Win32.byte.InlineArrays.g.cs (1)

60 int initLength = value.Length;

Windows.Win32.char.InlineArrays.g.cs (4)

55 internal readonly bool Equals(ReadOnlySpan<char> value) => value.Length == SpanLength ? AsReadOnlySpan().SequenceEqual(value) : AsReadOnlySpan().SliceAtNull().SequenceEqual(value); 78 int initLength = value.Length; 117 int initLength = value.Length; 157 int initLength = value.Length;

Windows.Win32.HTTP_KNOWN_HEADER.InlineArrays.g.cs (1)

53 int initLength = value.Length;

Windows.Win32.ushort.InlineArrays.g.cs (1)

60 int initLength = value.Length;

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

96var array = new byte[span.Length + (lineFeedOnly ? 1 : 2)]; 251if ((uint)nameEnd >= (uint)headerLine.Length) 274if ((uint)valueStart < (uint)headerLine.Length) 283if ((uint)valueStart < (uint)headerLine.Length) 291for (; valueStart < headerLine.Length; valueStart++) 305var valueEnd = headerLine.Length - 1; 342return (requestLine.Length >= MinTlsRequestSize && requestLine[0] == SslRecordTypeHandshake); 405if (next == 0 || requestLine.Length == 0) 427if ((uint)offset >= (uint)requestLine.Length) 468for (; (uint)offset < (uint)requestLine.Length; offset++) 482while ((uint)offset < (uint)requestLine.Length && requestLine[offset] == ByteSpace) 491if ((uint)offset + 9 != (uint)requestLine.Length || requestLine[offset + 8] != ByteCR) 496if (_disableHttp1LineFeedTerminators || (uint)offset + 8 != (uint)requestLine.Length) 510var versionLength = remaining.Length > 0 && remaining[^1] == ByteCR ? remaining.Length - 1 : remaining.Length; 532return HttpParseResult.Error(reason, baseOffset, span.Length); 544return HttpParseResult.Error(reason, baseOffset, requestLine.Length); 550reader.Rewind(requestLine.Length + 1); 551reader.TryReadExact(requestLine.Length + 1, out var requestLineSequence); 556return HttpParseResult.Error(reason, baseOffset, fullLine.Length); 570if (span.Length >= 2 && span[0] == ByteCR && span[1] == ByteLF) 594if ((uint)span.Length > (uint)(crIndex + 1) && span[crIndex + 1] == ByteLF) 602span = span.Slice(0, span.Length - 1); 648if (span.Length == 0) 682var headerLineLength = span.Length + terminatorSize;

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); 1583_totalParsedHeaderSize += name.Length + value.Length; 1674for (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)

433Span<byte> pathBuffer = pathSegment.Length <= MaxPathBufferStackAllocSize 436? stackalloc byte[MaxPathBufferStackAllocSize].Slice(0, pathSegment.Length) 439: new byte[pathSegment.Length]; 441for (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)

300_totalParsedHeaderSize += name.Length + value.Length; 382for (var i = 0; i < name.Length; i++) 1197Span<byte> pathBuffer = pathSegment.Length <= MaxPathBufferStackAllocSize 1200? stackalloc byte[MaxPathBufferStackAllocSize].Slice(0, pathSegment.Length) 1203: new byte[pathSegment.Length]; 1205for (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;

RegexGenerator.g.cs (5)

71base.runtextpos = inputSpan.Length; 89base.runtextpos = inputSpan.Length; 113iteration = slice.Length; 121if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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); 646for (; 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) 695for (; 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)

417if (name.Length == 0)

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

641if (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) =>

Buffers\PooledArrayBufferWriterTests.cs (2)

118Assert.Equal(2, writtenSpan.Length); 148Assert.Equal(0, writer.WrittenSpan.Length);

Buffers\RefPooledArrayBufferWriterTests.cs (5)

151Assert.Equal(2, writtenSpan.Length); 185Assert.Equal(94, writer.WrittenSpan.Length); 198Assert.Equal(256, writer.WrittenSpan.Length); 256Assert.Equal(5, written.Length); 300Assert.Equal(iterations * 10, written.Length);

RegexGenerator.g.cs (22)

121base.runtextpos != inputSpan.Length) 139if (pos <= inputSpan.Length - 14) 152base.runtextpos = inputSpan.Length; 176while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 203iteration1 = slice.Length; 282base.runtextpos = inputSpan.Length; 294if (pos <= inputSpan.Length - 3) 304base.runtextpos = inputSpan.Length; 328iteration = slice.Length; 351iteration1 = slice.Length - 1; 364if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 415base.runtextpos != inputSpan.Length) 433if (pos <= inputSpan.Length - 4) 436if (pos < inputSpan.Length - 5) 438base.runtextpos = inputSpan.Length - 5; 444base.runtextpos = inputSpan.Length; 509if ((uint)slice.Length < 2) 519if ((uint)slice.Length < 3 || slice[2] != 't') 531if ((uint)slice.Length < 3 || slice[2] != 'r') 580if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

runtime\Http3\QPackDecoderTest.cs (1)

417if (name.Length == 0)

src\Shared\Encoding\Int7BitEncodingUtils.cs (2)

72if (shift == 35 || index >= source.Length) 144if (bytes.Length < consumed + 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\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); 646for (; 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) 695for (; 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];

Windows.Win32.byte.InlineArrays.g.cs (2)

60 int initLength = value.Length; 106 int initLength = value.Length;

Windows.Win32.CHAR.InlineArrays.g.cs (8)

53 int initLength = value.Length; 93 int initLength = value.Length; 133 int initLength = value.Length; 175 internal readonly bool Equals(ReadOnlySpan<char> value) => value.Length == SpanLength ? AsReadOnlySpan().SequenceEqual(value) : AsReadOnlySpan().SliceAtNull().SequenceEqual(value); 198 int initLength = value.Length; 239 internal readonly bool Equals(ReadOnlySpan<char> value) => value.Length == SpanLength ? AsReadOnlySpan().SequenceEqual(value) : AsReadOnlySpan().SliceAtNull().SequenceEqual(value); 262 int initLength = value.Length; 301 int initLength = value.Length;

Windows.Win32.HTTP_KNOWN_HEADER.InlineArrays.g.cs (2)

53 int initLength = value.Length; 93 int initLength = value.Length;

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

Windows.Win32.ulong.InlineArrays.g.cs (2)

60 int initLength = value.Length; 106 int initLength = value.Length;

Windows.Win32.ushort.InlineArrays.g.cs (1)

60 int initLength = value.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\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)

175while (buffer.Length > 0)

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

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

175while (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];

BackEnd\Components\Logging\BuildErrorTelemetryTracker.cs (1)

244if (codeSpan.Length < 7 || !TryParseErrorNumber(codeSpan, out int errorNumber))

BuildCheck\Checks\ExecCliBuildCheck.cs (5)

72while (start < commandSpan.Length) 74var nextSeparatorIndex = commandSpan.Slice(start, commandSpan.Length - start).IndexOfAny(s_knownCommandSeparators); 116Span<char> normalizedBuildCommand = command.Length <= maxStackLimit ? stackalloc char[command.Length] : new char[command.Length];

Evaluation\ConditionEvaluator.cs (1)

113if (input.Length < beginning + 3 ||

Evaluation\Expander.cs (3)

730int length = expression.Length; 3866if (expressionRoot.Length > methodStartIndex + 2 && expressionRoot[methodStartIndex] == ':' && expressionRoot[methodStartIndex + 1] == ':') 4530ProjectErrorUtilities.VerifyThrowInvalidProject(netPropertyName.Length > 0, elementLocation, "InvalidFunctionPropertyExpression", expressionFunction, String.Empty);

FileMatcher.cs (1)

1699int inputLength = input.Length;

ImmutableArrayExtensions.cs (1)

1325int high = array.Length - 1;

Logging\OptimizedStringIndenter.cs (2)

124for (int i = 0; i < input.Length; i++) 149segments[i] = new StringSegment(start, input.Length);

Logging\TerminalLogger\Terminal.cs (1)

173ReadOnlySpan<char> truncatedText = text.Slice(0, Math.Min(text.Length, Width - 1));

Logging\TerminalLogger\TerminalLogger.cs (10)

929if (outputPathSpan.Length > workingDirectorySpan.Length 930&& (outputPathSpan[workingDirectorySpan.Length] == Path.DirectorySeparatorChar 931|| outputPathSpan[workingDirectorySpan.Length] == Path.AltDirectorySeparatorChar)) 933projectDisplayPathSpan = outputPathSpan.Slice(workingDirectorySpan.Length + 1); 942if (outputPathSpan.Length > sourceRootSpan.Length 944&& (outputPathSpan[sourceRootSpan.Length - 1] == Path.DirectorySeparatorChar 945|| outputPathSpan[sourceRootSpan.Length - 1] == Path.AltDirectorySeparatorChar)) 948projectDisplayPathSpan = Path.Combine(relativePathFromWorkingDirToSourceRoot.ToString(), outputPathSpan.Slice(sourceRootSpan.Length).ToString()).AsSpan();

ProcessExtensions.cs (3)

113char[] charBuffer = ArrayPool<char>.Shared.Rent(data.Length); 695=> sysctl(name, (uint)name.Length, oldp, ref oldlenp, ReadOnlySpan<byte>.Empty, 0); 733if (data.Length < sizeof(int))

Utilities\SimpleVersion.cs (1)

134if (span.Length > 0 && (span[0] is 'v' or 'V'))

FileUtilities.cs (1)

837bool shouldCheckFileOrDirectory = !shouldCheckDirectory && value.Length > 0 && value[0] == '/';

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] != '"')

FileMatcher.cs (1)

1699int inputLength = input.Length;

FileMatcher.cs (1)

1699int inputLength = input.Length;

ProcessExtensions.cs (3)

113char[] charBuffer = ArrayPool<char>.Shared.Rent(data.Length); 695=> sysctl(name, (uint)name.Length, oldp, ref oldlenp, ReadOnlySpan<byte>.Empty, 0); 733if (data.Length < sizeof(int))

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)

542return string.Create(hash.Length * 2, hash, (destination, hash) => toHex(hash, destination));

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)

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

Operations\ControlFlowGraphBuilder.cs (1)

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

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.Length;

Extensions\MemoryExtensions.cs (1)

20int high = span.Length - 1;

CommandLine\CSharpCommandLineParser.cs (2)

1802while (index < valueSpan.Length) 1812if (nextIndex < valueSpan.Length)

CSharpParseOptions.cs (1)

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

Lowering\ExtensionMethodBodyRewriter.cs (1)

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

Parser\LanguageParser_InterpolatedString.cs (9)

283while (currentIndex < text.Length) 301var isBlankLine = (currentIndex == text.Length && isLast) || (currentIndex < text.Length && SyntaxFacts.IsNewLine(text[currentIndex])); 328currentIndex = Math.Min(currentIndex, lineStartPosition + indentationWhitespace.Length); 425for (int i = 0, n = Math.Min(currentLineWhitespace.Length, indentationLineWhitespace.Length); i < n; i++) 452while (currentIndex < text.Length && SyntaxFacts.IsWhitespace(text[currentIndex])) 460while (currentIndex < text.Length) 469currentIndex += SlidingTextWindow.GetNewLineWidth(ch, currentIndex + 1 < text.Length ? text[currentIndex + 1] : '\0');

Parser\Lexer.cs (1)

1336if (currentIndex == textWindowCharSpan.Length)

Parser\QuickScanner.cs (3)

200textWindowCharSpan = textWindowCharSpan[..Math.Min(MaxCachedTokenSize, textWindowCharSpan.Length)]; 205var charPropLength = CharProperties.Length; 209for (; currentIndex < textWindowCharSpan.Length; currentIndex++)

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)

740Debug.Assert(params1.Length == params2.Length); 742var numParams = params1.Length;

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

1154Span<short> shortSpan = stackalloc short[charSpan.Length];

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

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

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (1)

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

Completion\CompletionProviders\FileBasedPrograms\AbstractAppDirectiveCompletionProvider.cs (2)

93for (var i = 0; i < span.Length; i++) 99return span.Length;

SyncedSource\FileBasedPrograms\FileLevelDirectiveHelpers.cs (2)

324if (Patterns.DisallowedNameCharacters.Match(context.DirectiveText, beginning: 0, length: firstPart.Length).Success) 338Debug.Assert(secondPart.Length == 0,

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

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

104while (current < operations.Length && 116if (operations.Length == 0) 130if (current < operations.Length)

EmbeddedLanguages\RegularExpressions\RegexCharClass.cs (1)

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

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

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

158if (input.Length % 2 != 0) 163var 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] != '.')

FindSymbols\TopLevelSyntaxTree\NavigateToSearchIndex.NavigateToSearchInfo.cs (17)

414if (pattern.Length == 0) 420while (pattern.Length > 0) 429var end = sepIndex < 0 ? pattern.Length : sepIndex; 446while (pattern.Length > 0 && !PatternMatcher.IsWordChar(pattern[0])) 449while (pattern.Length > 0 && !PatternMatcher.IsWordChar(pattern[^1])) 452if (pattern.Length == 0) 478if (_containerCharSet == null || patternContainer.Length == 0) 526if (patternName.Length == 0) 578var n = pattern.Length; 665if (_trigramFilter == null || !isAllLowercase || pattern.Length < 3) 668for (var i = 0; i + 3 <= pattern.Length; i++) 687if (_symbolNameLengthBitset == 0 || pattern.Length < WordSimilarityChecker.MinFuzzyLength) 690var threshold = WordSimilarityChecker.GetThreshold(pattern.Length); 694var candidateLength = pattern.Length + delta; 744var k = WordSimilarityChecker.GetThreshold(pattern.Length); 745var minShared = pattern.Length - 1 - 2 * k; 750for (var i = 0; i < pattern.Length - 1; i++)

PatternMatching\CompoundPatternMatcher.cs (1)

24_matchers = ArrayBuilder<PatternMatcher>.GetInstance(matchers.Length);

Shared\Utilities\BloomFilter.cs (1)

126var numberOfCharsLeft = key.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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

581for (int i = 0; i < span.Length; i++) 600for (int i = 0; i < span.Length; i++) 619for (int i = 0; i < span.Length; i++) 638for (int i = 0; i < span.Length; i++) 657for (int i = 0; i < span.Length; i++) 676for (int i = 0; i < span.Length; i++) 695for (int i = 0; i < span.Length; i++) 714for (int i = 0; i < span.Length; i++) 733for (int i = 0; i < span.Length; i++) 752for (int i = 0; i < span.Length; i++) 771for (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)

140int length = FixedValuesCount + additionalValues.Length + clientValues.Length; 149clientValues.CopyTo(arr, FixedValuesCount + additionalValues.Length);

ChatCompletion\FunctionInvokingChatClient.cs (2)

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

Embeddings\DistributedCachingEmbeddingGenerator.cs (2)

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

ToolReduction\EmbeddingToolReductionStrategy.cs (1)

227var result = new List<AITool>(capacity: toolInfo.Length);

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

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

Internal\HybridCachePayload.cs (3)

188if (bytes.Length < 19) // minimum needed for empty payload and zero tags 293if (bytes.Length != payloadLength + 2 336|| 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;

Chunkers\DocumentTokenChunker.cs (1)

115_ = stringBuilder.Append(ptr, overlapContent.Length);

Chunkers\ValueStringBuilder.cs (3)

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

Processors\ClassificationEnricher.cs (1)

57if (predefinedClasses.Length == 0)

Processors\KeywordEnricher.cs (2)

65if (predefinedKeywords.Length == 0) 84if (predefinedKeywords.Length > 0)

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)

136stat = stat.Slice(StartingTokens.Length, stat.Length - StartingTokens.Length); 223ReadOnlySpan<char> inactiveMemorySlice = memoryFile.Slice(index + TotalInactiveFile.Length, memoryFile.Length - index - TotalInactiveFile.Length); 271ReadOnlySpan<char> totalMemory = firstLine.Slice(MemTotal.Length, firstLine.Length - MemTotal.Length); 280if (next == -1 || totalMemory.Length - next < 2) 285ReadOnlySpan<char> unit = totalMemory.Slice(totalMemory.Length - 2, 2); 384while (numberStart < buffer.Length && char.IsWhiteSpace(buffer[numberStart])) 389if (numberStart == buffer.Length || !char.IsDigit(buffer[numberStart])) 398while (numberEnd < buffer.Length && char.IsDigit(buffer[numberEnd])) 406return numberEnd < buffer.Length ? numberEnd : -1; 416if (quotaBuffer.IsEmpty || (quotaBuffer.Length == 2 && quotaBuffer[0] == '-' && quotaBuffer[1] == '1')) 434if (periodBuffer.IsEmpty || (periodBuffer.Length == 2 && periodBuffer[0] == '-' && periodBuffer[1] == '1')) 472if (cpuPodWeightBuffer.IsEmpty || (cpuPodWeightBuffer.Length == 2 && cpuPodWeightBuffer[0] == '-' && cpuPodWeightBuffer[1] == '1'))

Linux\LinuxUtilizationParserCgroupV2.cs (14)

129if (colonIndex == -1 || colonIndex + 1 >= fileContent.Length) 182stat = stat.Slice(StartingTokens.Length, stat.Length - StartingTokens.Length); 374ReadOnlySpan<char> inactiveMemorySlice = memoryFile.Slice(index + InactiveFile.Length, memoryFile.Length - index - InactiveFile.Length); 418ReadOnlySpan<char> totalMemory = firstLine.Slice(MemTotal.Length, firstLine.Length - MemTotal.Length); 427if (next == -1 || totalMemory.Length - next < 2) 432ReadOnlySpan<char> unit = totalMemory.Slice(totalMemory.Length - 2, 2); 614while (numberStart < buffer.Length && char.IsWhiteSpace(buffer[numberStart])) 619if (numberStart == buffer.Length || !char.IsDigit(buffer[numberStart])) 628while (numberEnd < buffer.Length && char.IsDigit(buffer[numberEnd])) 636return numberEnd < buffer.Length ? numberEnd : -1; 674if (quotaBuffer.IsEmpty || (quotaBuffer.Length == 2 && quotaBuffer[0] == '-' && quotaBuffer[1] == '1')) 695ReadOnlySpan<char> cpuPeriodSlice = quotaBuffer.Slice(index + quotaString.Length, quotaBuffer.Length - index - quotaString.Length); 736else if (content.Length >= 2 && content[0] == '-' && content[1] == '1') 807if (cpuPodWeightBuffer.IsEmpty || (cpuPodWeightBuffer.Length == 2 && cpuPodWeightBuffer[0] == '-' && cpuPodWeightBuffer[1] == '1'))

Http\HttpDependencyMetadataResolver.cs (8)

113if (routeSpan.Length > 1 && routeSpan[routeSpan.Length - 1] == '/') 115routeSpan = routeSpan.Slice(0, routeSpan.Length - 1); 126else if (routeSpan.Length != route.Length) 367if (requestRouteAsSpan.Length > 1) 369if (requestRouteAsSpan[requestRouteAsSpan.Length - 1] == '/') 371requestRouteAsSpan = requestRouteAsSpan.Slice(0, requestRouteAsSpan.Length - 1); 382var requestPathEndIndex = requestRouteAsSpan.Length;

Latency\Internal\HttpClientLatencyLogEnricher.cs (3)

105var checkpointCount = latencyData.Checkpoints.Length; 126var measureCount = latencyData.Measures.Length; 146var tagCount = latencyData.Tags.Length;

Logging\Internal\HttpRequestReader.cs (1)

163int length = querySpan.Length;

Base32.cs (2)

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

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_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)

727=> 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\System\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(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\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)

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

74if (startIndex >= httpPathAsSpan.Length) 92length = httpPathAsSpan.Slice(startIndex).Length;

Http\HttpRouteParser.cs (2)

67if (startIndex < httpPathAsSpan.Length) 76length = httpPathAsSpan.Slice(startIndex).Length;

Latency\Internal\LatencyConsoleExporter.cs (12)

54latencyData.Checkpoints.Length, 55latencyData.Tags.Length, 56latencyData.Measures.Length); 59if (_outputCheckpoints && latencyData.Checkpoints.Length > 0) 62for (int i = 0; i < latencyData.Checkpoints.Length; i++) 68for (int i = 0; i < latencyData.Checkpoints.Length; i++) 75if (_outputTags && latencyData.Tags.Length > 0) 78for (int i = 0; i < latencyData.Tags.Length; i++) 84for (int i = 0; i < latencyData.Tags.Length; i++) 91if (_outputMeasures && latencyData.Measures.Length > 0) 94for (int i = 0; i < latencyData.Measures.Length; i++) 100for (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++)

ComInterfaceGeneratorHelpers.cs (2)

41var literals = new CollectionElementSyntax[bytes.Length]; 43for (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 (13)

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) 1881featureValues += cursor.Features.GetValues().Length;

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

LightGbmTrainerBase.cs (5)

755nonZeroCount += cursor.Features.GetValues().Length; 896for (int i = 0; i < cursorFeaturesValues.Length; ++i) 927cnt = cursorFeaturesValues.Length; 1095if (numElem + cursor.Features.GetValues().Length > features.Length) 1174int numValue = cursor.Features.GetValues().Length;

OlsLinearRegression.cs (6)

238ch.Assert(values.Length + 1 == m); 249for (int j = 0; j < indices.Length; ++j) 322ch.Assert(values.Length + 1 == m); 341for (int ii = 0; ii < values.Length; ++ii) 916for (int i = 0; i < coeffs.Length; i++) 931for (int i = 0; i < coeffs.Length; i++)

SymSgdClassificationTrainer.cs (2)

426var instArrayLength = instArray.Length; 594int featureCount = featureValues.Length;

VectorWhitening.cs (2)

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

OneDalUtils.cs (2)

58channel.Assert(values.Length == numberOfFeatures); 69for (int j = 0; j < indices.Length; ++j)

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

509ch.Assert(values.Length == nFeatures); 520for (int j = 0; j < indices.Length; ++j) 777for (int i = BiasCount; i < values.Length; i++)

Standard\LogisticRegression\LogisticRegression.cs (2)

293for (int i = 1; i < currentWeightsValues.Length; i++) 383for (int ii = 0; ii < values.Length; ++ii)

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

179for (int i = 0; i < featureValues.Length; i += 1) 188for (int i = 0; i < featureValues.Length; i += 1) 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)

321Assert.Equal(sample.OneDim.Length, oneDimValues.Length); 325Assert.Equal(sample.TwoDim.Length, twoDimValues.Length); 329Assert.Equal(sample.ThreeDim.Length, threeDimValues.Length); 333Assert.Equal(sample.FourDim.Length, fourDimValues.Length); 337Assert.Equal(sample.FourDimKnown.Length, fourDimKnownValues.Length); 462Assert.Equal(2, f64Values.Length); 465Assert.Equal(2, f32Values.Length); 468Assert.Equal(2, i64Values.Length); 471Assert.Equal(2, i32Values.Length); 474Assert.Equal(2, i16Values.Length); 477Assert.Equal(2, i8Values.Length); 480Assert.Equal(2, u64Values.Length); 483Assert.Equal(2, u32Values.Length); 486Assert.Equal(2, u16Values.Length); 489Assert.Equal(2, u8Values.Length); 492Assert.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)

860span = span.Slice(0, span.Length - EndOfWordSuffix.Length); 957sSpan = sSpan.Slice(0, sSpan.Length - EndOfWordSuffix!.Length); 964if (sSpan.Length > buffer.Length) 971charsWritten += sSpan.Length; 972buffer = buffer.Slice(sSpan.Length); 1017if (specialTokenSpan.Length > buffer.Length) 1023buffer = buffer.Slice(specialTokenSpan.Length); 1024charsWritten += specialTokenSpan.Length; 1036span = span.Slice(0, span.Length - EndOfWordSuffix.Length); 1046if (current.Length < span.Length) 1051for (int i = 0; i < span.Length; i++) 1056current = utf8bytes.Slice(incompleteUtf8BytesInBufferIndex, incompleteUtf8BytesInBuffer + span.Length); 1192Word word = Word.WithCapacity(w.Length); 1199while (i < w.Length) 1203if (Char.IsHighSurrogate(w[i]) && i < w.Length - 1 && Char.IsLowSurrogate(w[i + 1])) 1217if (ContinuingSubwordPrefix.Length + s.Length <= buffer.Length) 1221s = buffer.Slice(0, ContinuingSubwordPrefix.Length + s.Length); 1235if (i + length >= w.Length && EndOfWordSuffix is not null) 1237if (s.Length + EndOfWordSuffix.Length <= buffer.Length) 1240EndOfWordSuffix.AsSpan().CopyTo(buffer.Slice(s.Length)); 1241s = buffer.Slice(0, s.Length + EndOfWordSuffix.Length); 1311tokens.Add(new EncodedToken(value.specialTokenId, value.specialToken, new Range(offset, offset + text.Length))); 1323int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1354if (textSpan.Length <= MaxWordLengthToCache) 1421charsConsumed = text.Length; 1436int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1459int res = WordToIds(ref hit, accumulatedIds, out charsConsumed, textSpan.Length, maxTokens); 1462charsConsumed = charsConsumed >= textSpan.Length ? text.Length : mapping[charsConsumed]; 1470if (textSpan.Length <= MaxWordLengthToCache) 1480int result = WordToIds(ref word, accumulatedIds, out charsConsumed, textSpan.Length, maxTokens); 1483charsConsumed = charsConsumed >= textSpan.Length ? text.Length : mapping[charsConsumed]; 1516int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1539int res = WordToIdsFromEnd(ref hit, accumulatedIds, out textIndex, textSpan.Length, maxTokens); 1543textIndex = textIndex >= textSpan.Length ? text.Length : mapping[textIndex]; 1551if (textSpan.Length <= MaxWordLengthToCache) 1561int result = WordToIdsFromEnd(ref word, accumulatedIds, out textIndex, textSpan.Length, maxTokens); 1565textIndex = 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)

151char[] buffer = ArrayPool<char>.Shared.Rent(text.Length); 154IEnumerable<(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);

RegexGenerator.g.cs (74)

Tokenizer.cs (2)

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

Utils\BytePairEncoder.cs (2)

111while (finalEndIndex < indexMappingSpan.Length && indexMappingSpan[finalEndIndex] == mappedEndIndex) 268while (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);

System\ISpanFormattableTests.cs (1)

16string formatted = _value.ToString(format.Length > 0 ? format.ToString() : null, provider);

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)

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

1856if ((!culture.IsNeutralCulture) && (zoomString.Length > 0)) 1864if (zoomString.Length - 1 == zoomString.LastIndexOf( 1868zoomString = zoomString.Slice(0, zoomString.Length - 1);

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.Length;

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

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

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

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)

887for (int i = 0; i < nodes.Length; i++) 897for (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)

25int length = s.Length; 89int length = s.Length;

System\Collections\Frozen\String\KeyAnalyzer.cs (2)

52int acceptableNonUniqueCount = uniqueStrings.Length / 20; 66uniqueStrings.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)

RegexGenerator.g.cs (13)

91base.runtextpos != inputSpan.Length) 110if (pos <= inputSpan.Length - 3) 115for (int i = 0; i < span.Length - 2; i++) 127if ((uint)(i + 1) >= (uint)span.Length) 142base.runtextpos = inputSpan.Length; 166iteration = slice.Length - 1; 179if ((uint)slice.Length < 2 || slice[1] != '}') 230base.runtextpos != inputSpan.Length) 248if (pos <= inputSpan.Length - 4) 253for (int i = 0; i < span.Length; i++) 264base.runtextpos = inputSpan.Length; 285iteration = slice.Length; 334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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)

src\libraries\Common\src\System\Text\ConsoleEncoding.cs (1)

11if (encoding.Preamble.Length == 0)

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\ConsolePal.Unix.cs (2)

654for (int i = 0; i < src.Length; i++) 986int count = buffer.Length;

System\IO\CachedConsoleStream.cs (1)

27int maxCharCount = _encoding.GetMaxCharCount(buffer.Length);

System\IO\KeyParser.cs (4)

60if (input.Length < MinimalSequenceLength || input[0] != Escape || (input[1] != '[' && input[1] != 'O')) 71if (input[1] == 'O' || char.IsAsciiLetter(input[2]) || input.Length == MinimalSequenceLength) 122|| SequencePrefixLength + digitCount >= input.Length) // it's too short to be a complete sequence 155|| SequencePrefixLength + digitCount + 2 >= input.Length

System\IO\StdInReader.cs (1)

61int maxCharsCount = _encoding.GetMaxCharCount(buffer.Length);

RegexGenerator.g.cs (13)

91base.runtextpos != inputSpan.Length) 110if (pos <= inputSpan.Length - 3) 115for (int i = 0; i < span.Length - 2; i++) 127if ((uint)(i + 1) >= (uint)span.Length) 142base.runtextpos = inputSpan.Length; 166iteration = slice.Length - 1; 179if ((uint)slice.Length < 2 || slice[1] != '}') 230base.runtextpos != inputSpan.Length) 248if (pos <= inputSpan.Length - 4) 253for (int i = 0; i < span.Length; i++) 264base.runtextpos = inputSpan.Length; 285iteration = slice.Length; 334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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); 2471Debug.Assert(rgulS.Length >= ciulS, "rgulS.Length >= ciulS", "Invalid array length"); 2612Debug.Assert(rgulU.Length == s_cNumeMax); 3032Debug.Assert(rguiData.Length == 4);

RegexGenerator.g.cs (43)

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\Diagnostics\Activity.cs (7)

1913if (idData.Length != 16) 1926if (idData.Length != 32 || !ActivityTraceId.IsLowerCaseHexAndNotAllZeros(idData)) 1974if (idData.Length != 32) 2037Debug.Assert(outBytes.Length * 2 == charData.Length); 2092if (idData.Length != 8) 2105if (idData.Length != 16 || !ActivityTraceId.IsLowerCaseHexAndNotAllZeros(idData)) 2150if (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; 284for (int i = 0; i < tags.Length; i++) 294for (int i = 0; i < tags.Length; i++)

System\Diagnostics\W3CPropagator.cs (12)

103if (keyValueSeparator <= 0 || keyValueSeparator >= currentEntry.Length - 1) 118} while (baggageSpan.Length > 0); 153int delta = entry.Length + (commaIndex >= 0 ? 1 : 0); // +1 for the comma 161if (equalIndex <= 0 || equalIndex >= entry.Length - 1) 268for (int i = 0; i < valueSpan.Length; i++) 297if (i + 5 >= valueSpan.Length || valueSpan[i + 3] != Percent || !TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || (b1 & 0xC0) != 0x80) 313if (i + 8 >= valueSpan.Length || 334if (i + 11 >= valueSpan.Length || 379Debug.Assert(span.Length > 0 && span[0] == Percent); 381if (span.Length < 3 || !TryDecodeHexDigit(span[1], out byte byte1) || !TryDecodeHexDigit(span[2], out byte byte2)) 478for (int i = indexOfInvalidCharacter; i < value.Length; i++) 504if (i < value.Length - 1 && char.IsSurrogatePair(c, value[i + 1]))

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

234for (int index = 0; index < s.Length; index++)

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\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (1)

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

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\Diagnostics\ProcessStartOptions.cs (1)

221if (Path.GetFileName(filename.AsSpan()).Length != filename.Length)

System\DirectoryServices\Protocols\Interop\LdapPal.Linux.cs (1)

131bv_len = new CLong(MemoryMarshal.CreateReadOnlySpanFromNullTerminated((byte*)passwordPtr).Length),

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

Windows.Win32.byte.InlineArrays.g.cs (1)

60 int initLength = value.Length;

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

218for (int i = 0; i < chars.Length; i++) 236return chars.Length; 246for (int i = 0; i < bytes.Length; i++) 266return bytes.Length; 287for (int i = 0; i < chars.Length; i++) 320if (bytes.Length % 2 != 0) 323bytes.Slice(bytes.Length - 1).ToArray(), 324bytes.Length - 1); 332for (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 (11)

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); 1042_data = _data.Slice(encodedValue.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 (4)

352if (contents.Length > destination.Length) 360bytesWritten = contents.Length; 416CryptoPool.Return(rented, contents.Length); 456CryptoPool.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)

135EnsureWriteCapacity(encodedValue.Length); 149_offset += encodedValue.Length; 158using var manager = new PointerMemoryManager<byte>(ptr, encodedValue.Length); 193if (encoding.Length > destination.Length) 199return encoding.Length; 211if (encoding.Length > destination.Length) 218bytesWritten = 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); 138for (int i = skip; i < path.Length; i++) 142if (IsDirectorySeparator(c) && i + 1 < path.Length) 153if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && 162if (i + 2 < path.Length && 163(i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && 172sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\.. 197if (!flippedSeparator && sb.Length == path.Length) 231path.Slice(0, path.Length - 1) : 238path.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)

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

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

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

595if (pathNameBytes.Length <= FieldLengths.Name) 617while (prefix.Length - name.Length > FieldLengths.Prefix) 629if (prefix.Length <= FieldLengths.Prefix && name.Length <= FieldLengths.Name) 631Debug.Assert(prefix.Length != 1 || !PathInternal.Utf8DirectorySeparators.Contains(prefix[0])); 1061int numToCopy = Math.Min(bytesToWrite.Length, destination.Length); 1078int numToCopy = Math.Min(bytesToWrite.Length, destination.Length - 1); 1080int copyPos = destination.Length - 1 - bytesToWrite.Length; 1095if (Vector.IsHardwareAccelerated && bytes.Length >= vectorSize) 1102Debug.Assert(bytes.Length <= 512); 1106for (; i <= bytes.Length - vectorSize; i += vectorSize) 1122for (; i < bytes.Length; i++) 1252string.Concat("/tmp", result.AsSpan(tmp.Length)) :

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

251if (buffer.Length == 0)

System\IO\Compression\Crc32Helper.ZLib.cs (1)

25return Interop.ZLib.crc32(crc32, bufferPtr, buffer.Length);

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

391if ((uint)symbol >= ExtraLengthBits.Length) 413if (_length < 0 || _length >= LengthBase.Length) 551for (int i = _codeLengthCodeCount; i < CodeOrder.Length; i++)

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

580_deflater.SetInput(bufferPtr, buffer.Length);

System\IO\Compression\PositionPreservingWriteOnlyStreamWrapper.cs (1)

40_position += buffer.Length;

System\IO\Compression\ZipArchive.cs (2)

574if (currPosition < sizedFileBuffer.Length) 576_archiveStream.Seek(-(sizedFileBuffer.Length - currPosition), SeekOrigin.Current);

System\IO\Compression\ZipArchiveEntry.cs (2)

1596if (source.Length == 0) 1607_position += source.Length;

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

51if (bytes.Length < SizeOfHeader) 60if ((bytes.Length - SizeOfHeader) < field._size) 250if (data.Length < FieldLengths.UncompressedSize) 270if (data.Length < FieldLengths.CompressedSize) 285if (data.Length < FieldLengths.LocalHeaderOffset) 300if (data.Length < FieldLengths.StartDiskNumber) 711Debug.Assert(buffer.Length >= BlockConstantSectionSize); 801int remainingBufferLength = buffer.Length - FieldLocations.DynamicData;

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

612if (source.Length == 0) 628_position += source.Length;

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

95Debug.Assert(signatureToFind.Length != 0); 117int overlap = totalBytesRead == 0 ? 0 : signatureToFind.Length;

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

154size = (nuint)source.Length, 219ulong frameContentSize = Interop.Zstd.ZSTD_decompressBound(dataPtr, (nuint)data.Length); 257sourcePtr, (nuint)source.Length); 302sourcePtr, (nuint)source.Length, dictionary.DecompressionDictionary);

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

97if (sampleLengths.Length < 5) 105byte[] lengthsArray = ArrayPool<byte>.Shared.Rent(sampleLengths.Length * Unsafe.SizeOf<nuint>()); 108Span<nuint> lengthsAsNuint = MemoryMarshal.Cast<byte, nuint>(lengthsArray.AsSpan(0, sampleLengths.Length * Unsafe.SizeOf<nuint>())); 109Debug.Assert(lengthsAsNuint.Length == sampleLengths.Length); 112for (int i = 0; i < sampleLengths.Length; i++) 123if (totalLength != samples.Length) 142samplesPtr, lengthsAsNuintPtr, (uint)sampleLengths.Length);

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

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

System\IO\Compression\Zstandard\ZstandardStream.Compress.cs (1)

124Debug.Assert(buffer.Length == 0);

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

65nuint availableInput = (nuint)source.Length; 82Debug.Assert(availableInput <= (nuint)source.Length); 85bytesConsumed += source.Length - (int)availableInput; 96source = source.Slice(source.Length - (int)availableInput); 98if (brotliResult == 2 && source.Length == 0) 120bool success = Interop.Brotli.BrotliDecoderDecompress((nuint)source.Length, inBytes, &availableOutput, outBytes) != Interop.BOOL.FALSE;

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

150nuint availableInput = (nuint)source.Length; 166Debug.Assert(availableInput <= (nuint)source.Length); 169bytesConsumed += source.Length - (int)availableInput; 178source = source.Slice(source.Length - (int)availableInput); 218bool success = Interop.Brotli.BrotliEncoderCompress(quality, window, /*BrotliEncoderMode*/ 0, (nuint)source.Length, inBytes, &availableOutput, outBytes) != Interop.BOOL.FALSE;

src\libraries\Common\src\System\IO\Archiving.Utils.Unix.cs (1)

18nonSlash = path.Length;

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\System\IO\PathInternal.cs (11)

16internal static bool StartsWithDirectorySeparator(ReadOnlySpan<char> path) => path.Length > 0 && IsDirectorySeparator(path[0]); 22=> path.Length == GetRootLength(path); 138for (int i = skip; i < path.Length; i++) 142if (IsDirectorySeparator(c) && i + 1 < path.Length) 153if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && 162if (i + 2 < path.Length && 163(i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && 172sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\.. 197if (!flippedSeparator && sb.Length == path.Length) 231path.Slice(0, path.Length - 1) : 238path.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)

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\IO\FileSystemWatcher.cs (1)

377if (name.Length == 0)

System\IO\FileSystemWatcher.Linux.cs (5)

561ReadOnlySpan<WatchedDirectory> dirs = watch is not null ? GetWatchedDirectories(watch, ref _dirBuffer, offset: movedFromDirs.Length) : default; 627movedFromWatchCount = dirs.Length; 1361length = Parent.GetPath("", pathBuffer, fullPath).Length; 1377if (path.Length == 0) 1389length += path.Length;

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

197source.Length >= Vector128<byte>.Count * 2) 199if (Vector512.IsHardwareAccelerated && Avx512BW.IsSupported && source.Length >= Vector512<byte>.Count) 204if (Vector256.IsHardwareAccelerated && Avx2.IsSupported && source.Length >= Vector256<byte>.Count) 224int k = source.Length < NMax ? source.Length : NMax; 235while (source.Length > 0); 244Debug.Assert(source.Length >= Vector128<byte>.Count * 2); 252int length = source.Length; 347Debug.Assert(source.Length >= Vector256<byte>.Count); 355int length = source.Length; 406Debug.Assert(source.Length >= Vector512<byte>.Count); 414int length = source.Length;

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

140if (consumed < source.Length) 174if (consumed < source.Length)

System\IO\Hashing\Crc32ParameterSet.Vectorized.cs (6)

65if (!_canVectorize || source.Length < _shouldVectorizeScale * Vector128<byte>.Count) 77int length = source.Length; 143bytesConsumed = source.Length - length; 204if (!_canVectorize || source.Length < Vector128<byte>.Count) 216int length = source.Length; 283bytesConsumed = source.Length - length;

System\IO\Hashing\Crc32ParameterSet.WellKnown.cs (10)

136if (source.Length >= sizeof(ulong)) 141int longLength = source.Length & ~0x7; 153for (int i = 0; i < source.Length; i++) 166if (source.Length >= sizeof(uint)) 171int intLength = source.Length & ~0x3; 184for (int i = 0; i < source.Length; i++) 223source = source.Slice(ulongData.Length * sizeof(ulong)); 236ReadOnlySpan<byte> remainingBytes = source.Slice(uintData.Length * sizeof(uint)); 251int longLength = source.Length & ~0x7; // Exclude trailing bytes not a multiple of 8 261int intLength = source.Length & ~0x3; // Exclude trailing bytes not a multiple of 4

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

140if (consumed < source.Length) 174if (consumed < source.Length)

System\IO\Hashing\Crc64ParameterSet.Vectorized.cs (6)

75if (!_canVectorize || source.Length < Vector128<byte>.Count) 87int length = source.Length; 153bytesConsumed = source.Length - length; 207if (!_canVectorize || source.Length < Vector128<byte>.Count) 219int length = source.Length; 284bytesConsumed = source.Length - 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\Pipes\PipeStream.Unix.cs (1)

291while (buffer.Length > 0)

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

817int 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 (3)

151if (sourceIndex < sourceSpan.Length) 174if (minInclusive < span.Length) 176return 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.Contains(CurrentSpan[i]); 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 (1)

468if (span.Length > 2 && span[0] == 0xEF && span[1] == 0xBB && span[2] == 0xBF)

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

89return _position < s.Length ? s[_position++] : -1;

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\DynamicTable.cs (2)

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

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HeaderField.cs (1)

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

src\libraries\Common\src\System\Net\Http\aspnetcore\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\libraries\Common\src\System\Net\Http\aspnetcore\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\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\Huffman.cs (1)

692while (i < src.Length)

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

42if (buffer.Length != 0)

src\libraries\Common\src\System\Net\Http\aspnetcore\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\libraries\Common\src\System\Net\Http\aspnetcore\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\libraries\Common\src\System\Net\HttpKnownHeaderNames.TryGetHeaderName.cs (1)

70switch (nameSpan.Length)

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

403if (_length < source.Length) 413if (source.Length <= block.Length)

src\libraries\Common\src\System\Text\SimpleRegex.cs (6)

26while (inputPos < input.Length) 28if (patternPos < pattern.Length && pattern[patternPos] == '*') 35else if (patternPos < pattern.Length && 61while (patternPos < pattern.Length && pattern[patternPos] == '*') 68Debug.Assert(patternPos <= pattern.Length); 69return patternPos == pattern.Length;

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\Net\Http\Headers\AltSvcHeaderParser.cs (9)

203switch (span.Length) 251var builder = value.Length <= 128 ? 253new ValueStringBuilder(value.Length); 262if ((value.Length - idx) < 3 || !TryReadAlpnHexDigit(value[idx + 1], out int hi) || !TryReadAlpnHexDigit(value[idx + 2], out int lo)) 276if (value.Length != 0) 350result = value.Length != 0 ? new string(value) : null; 358if (idx + 1 == value.Length) 378if (value.Length != 0) 417if (value.Length == 0)

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (3)

289dateString = dateString.Slice(1, dateString.Length - 2); 431value.Length > 1 && 433value[value.Length - 1] == '"';

System\Net\Http\Headers\HeaderDescriptor.cs (5)

85Debug.Assert(headerName.Length > 0); 136if (headerValue.Length == 0) 189switch (contentTypeValue.Length) 304Debug.Assert(candidate is null || candidate.Length == contentTypeValue.Length); 313char[] rented = ArrayPool<char>.Shared.Rent(input.Length);

System\Net\Http\Headers\HeaderUtilities.cs (3)

82length = utf8.Length; 97length = utf8.Length; 338for (int i = 0; i < headers.Length; i++)

System\Net\Http\Headers\KnownHeaders.cs (1)

137switch (key.Length)

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

126Debug.Assert(firstBuffer.Length >= 4 || firstBuffer.Length == stream.Length); 177if (firstBuffer.Length == stream.Length) 718return data.StartsWith(UTF8Preamble) ? UTF8Preamble.Length : 0; 721return data.StartsWith(UTF32Preamble) ? UTF32Preamble.Length : 0; 724return data.StartsWith(UnicodePreamble) ? UnicodePreamble.Length : 0; 727return data.StartsWith(BigEndianUnicodePreamble) ? BigEndianUnicodePreamble.Length : 0; 740preambleLength = UTF8Preamble.Length; 747preambleLength = UTF32Preamble.Length; 754preambleLength = UnicodePreamble.Length; 761preambleLength = BigEndianUnicodePreamble.Length; 913if (_maxBufferSize - _totalLength < buffer.Length) 921if (lastBuffer.Length - offset >= buffer.Length) 924_lastBufferOffset = offset + buffer.Length; 925_totalLength += buffer.Length; 935Debug.Assert(_totalLength + buffer.Length <= _maxBufferSize); 943newBufferCapacity = Math.Max(newBufferCapacity, _totalLength + buffer.Length); 975newBuffer = new byte[_totalLength + buffer.Length <= _expectedFinalSize ? _expectedFinalSize : newTotalCapacity]; 983_totalLength += buffer.Length; 998_totalLength = _lastBufferOffset = buffer.Length; 1005_totalLength += buffer.Length; 1010Debug.Assert(remainingInCurrentBuffer.Length < buffer.Length); 1016_lastBufferOffset = buffer.Length;

System\Net\Http\HttpMethod.cs (2)

98if (method.Length >= 3) // 3 == smallest known method 107'p' => method.Length switch

System\Net\Http\HttpRuleParser.cs (2)

44return index < 0 ? slice.Length : index; 171return slice.Length;

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

340if (bytesConsumed != currentLine.Length) 387if (currentLine.Length != 0) 443for (int i = 0; i < lineAfterChunkSize.Length; i++)

System\Net\Http\SocketsHttpHandler\ChunkedEncodingWriteStream.cs (3)

23BytesWritten += buffer.Length; 28if (buffer.Length == 0) 35ValueTask writeTask = connection.WriteHexInt32Async(buffer.Length, async: false);

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

25BytesWritten += buffer.Length;

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

197int requiredSpace = Http2ConnectionPreface.Length + 205_outgoingBuffer.Commit(Http2ConnectionPreface.Length); 715if (frameData.Length == 0) 723if (frameData.Length < padLength) 728frameData = frameData.Slice(0, frameData.Length - padLength); 733if (frameData.Length < FrameHeader.PriorityInfoLength) 767if ((frameHeader.StreamId != 0 && originLength == 0) || (frameHeader.StreamId == 0 && span.Length >= originLength && span.Slice(0, originLength).SequenceEqual(_pool.Http2AltSvcOriginUri))) 793if (frameData.Length > 0 || endStream) 798if (frameData.Length > 0) 800bool windowUpdateSent = ExtendWindow(frameData.Length); 846while (settings.Length > 0) 848Debug.Assert((settings.Length % 6) == 0); 1420if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(bytes.Length)}={bytes.Length}"); 1422headerBuffer.EnsureAvailableSpace(bytes.Length); 1424headerBuffer.Commit(bytes.Length); 1436int headerListSize = entries.Length * HeaderField.RfcOverhead; 1484byte[]? separator = headerValues.Length > 1 ? header.Key.SeparatorBytes : null; 1934Debug.Assert(buffer.Length >= Size);

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

681AdjustHeaderBudget(descriptor.Name.Length + value.Length); 731Debug.Assert(name.Length > 0); 887if (_responseBuffer.ActiveMemory.Length + buffer.Length > _windowManager.StreamWindowSize) 893_responseBuffer.EnsureAvailableSpace(buffer.Length); 895_responseBuffer.Commit(buffer.Length);

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

776int headerListSize = entries.Length * HeaderField.RfcOverhead; 816byte[]? separator = headerValues.Length > 1 ? header.Key.SeparatorBytes : null; 893_sendBuffer.EnsureAvailableSpace(span.Length); 895_sendBuffer.Commit(span.Length); 1003Debug.Assert(name.Length > 0);

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

484_writeBuffer.EnsureAvailableSpace(bytes.Length); 486_writeBuffer.Commit(bytes.Length); 1234int spIdx = name.Length - 1; 1236if ((uint)spIdx < (uint)name.Length) 1254while (value.Length != 0 && value[0] is (byte)' ' or (byte)'\t') 1262int spIdx = value.Length - 1; 1264if ((uint)spIdx >= (uint)value.Length || !(value[spIdx] is (byte)' ' or (byte)'\t')) 1376Debug.Assert(source.Length <= _writeBuffer.AvailableLength); 1378_writeBuffer.Commit(source.Length); 1385if (source.Length <= remaining) 1400if (source.Length >= _writeBuffer.Capacity) 1471if (source.Length <= _writeBuffer.AvailableLength) 1550if (bytes.Length > 0) 1552_writeBuffer.Discard(bytes.Length); 1570if (NetEventSource.Log.IsEnabled()) Trace($"Writing {source.Length} bytes."); 1596if (buffer.Length < MaxChunkBytesAllowed) 1611int length = (uint)carriageReturnIndex < (uint)buffer.Length && buffer[carriageReturnIndex] == '\r' 1713Debug.Assert(buffer.Length > 0); 1715int originalBufferLength = buffer.Length; 1727if (tabOrSpaceIndex == buffer.Length) 1749int toCopy = Math.Min(available.Length, buffer.Length);

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

184if (value.Length != 3 ||

System\Net\Http\SocketsHttpHandler\MultiProxy.cs (5)

203int originalLength = proxyString.Length; 209while (iter < proxyString.Length && ProxyDelimiters.Contains(proxyString[iter])) 214if (iter == proxyString.Length) 257iter = proxyString.Length; 263charactersConsumed = originalLength - proxyString.Length + iter;

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

158if (buffer.Length != 0)

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (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 (10)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\Net\Base64Stream.cs (1)

228if (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) 92int length = 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)

98for (int i = 0; i < buffer.Length; i++) 103if ((buffer[i] == '\r') && ((i + 1) < buffer.Length) && (buffer[i + 1] == '\n'))

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

808if (!extension.IsEmpty && extension[0] != '.' && extension.Length < MaxExtensionLength) 810Span<char> buffer = stackalloc char[1 + extension.Length];

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

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

206for (; processed < buffer.Length; processed++) 227if (buffer[processed] == '\r' && processed + 1 < buffer.Length && buffer[processed + 1] == '\n') 271(processed + 1 >= buffer.Length)) 348if (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\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);

System\Net\Dns.cs (3)

440hostSpan = hostSpan.Slice(0, hostSpan.Length - 1); 445(hostSpan.Length == reservedName.Length || 446hostSpan[hostSpan.Length - reservedName.Length - 1] == '.');

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

System\Net\NetworkInformation\LinuxIPv4InterfaceProperties.cs (1)

46for (int i = 0; i < paths.Length; i++)

System\Net\NetworkInformation\PhysicalAddress.cs (7)

106if ((address.Length + 1) % 3 != 0) 112buffer = new byte[(address.Length + 1) / 3]; // allow any length that's a multiple of 3 147if (address.Length % 2 > 0) 152validSegmentLength = address.Length; 153buffer = new byte[address.Length / 2]; 158for (int i = 0; i < address.Length; i++) 208for (int i = 0; i < address.Length; i++)

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (3)

321if (remoteAddressString.Length <= 8) // IPv4 Address 325else if (remoteAddressString.Length == 32) // IPv6 Address 360Debug.Assert(hexAddress.Length == 32);

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\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (1)

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

System\Net\NetworkInformation\Ping.RawSocket.cs (2)

486for (int i = 0; i < buffer.Length; i += 2) 490ushort element1 = (i + 1 < buffer.Length)

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

66if (socketAddressBuffer.Length >= SocketAddress.GetMaximumAddressSize(endPoint.AddressFamily) &&

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (8)

138while (start < name.Length) 164(uint)(start + 1) < (uint)name.Length && char.IsAsciiDigit((char)ToUShort(name[start + 1]))) 221for (; current < name.Length; current++) 235if (current < name.Length) 254for (; current < name.Length; current++) 273if (current < name.Length && ch == '.') 296else if (current >= name.Length) 299end = name.Length;

src\libraries\Common\src\System\Net\IPv6AddressHelper.Common.cs (8)

src\libraries\Common\src\System\Net\NetworkInformation\InterfaceInfoPal.Unix.cs (1)

33bufferSize = interfaceName.Length + 1;

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

System\Net\Cookie.cs (2)

339int idxOfSeparator = host.Length - domain.Length - 1;

System\Net\IPAddress.cs (4)

142if (address.Length != IPAddressParserStatics.IPv6AddressBytes) 157Debug.Assert(numbers.Length == NumberOfLabels); 184if (address.Length == IPAddressParserStatics.IPv4AddressBytes) 188else if (address.Length == IPAddressParserStatics.IPv6AddressBytes)

System\Net\IPAddressParser.cs (4)

29return address != IPv4AddressHelper.Invalid && end == ipSpan.Length; 67if (tmpAddr != IPv4AddressHelper.Invalid && end == ipSpan.Length) 94if (scopeIdSpan.Length > 1) 252for (int i = zeroEnd; i < address.Length; i++)

System\Net\IPEndPoint.cs (2)

104int addressLength = s.Length; // If there's no port then send the entire string to the address parser 124if (addressLength == s.Length)

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs (1)

44BioWrite(b, ref MemoryMarshal.GetReference(data), data.Length);

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

66if (socketAddressBuffer.Length >= SocketAddress.GetMaximumAddressSize(endPoint.AddressFamily) &&

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (8)

138while (start < name.Length) 164(uint)(start + 1) < (uint)name.Length && char.IsAsciiDigit((char)ToUShort(name[start + 1]))) 221for (; current < name.Length; current++) 235if (current < name.Length) 254for (; current < name.Length; current++) 273if (current < name.Length && ch == '.') 296else if (current >= name.Length) 299end = name.Length;

src\libraries\Common\src\System\Net\IPv6AddressHelper.Common.cs (8)

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

403if (_length < source.Length) 413if (source.Length <= block.Length)

src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (15)

52if (data.Length > 0) 87Span<byte> clientRandomUtf8 = clientRandom.Length <= 1024 ? stackalloc byte[clientRandom.Length * 2] : new byte[clientRandom.Length * 2]; 104if (secret.Length == 0) 111int totalLength = checked(labelUtf8.Length + 1 + clientRandomUtf8.Length + 1 + 2 * secret.Length + 1); 115line[labelUtf8.Length] = (byte)' '; 117clientRandomUtf8.CopyTo(line.Slice(labelUtf8.Length + 1)); 118line[labelUtf8.Length + 1 + clientRandomUtf8.Length] = (byte)' '; 120HexEncode(secret, line.Slice(labelUtf8.Length + 1 + clientRandomUtf8.Length + 1)); 128for (int i = 0; i < source.Length; i++)

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\Net\StreamBuffer.cs (7)

95Debug.Assert(buffer.Length > 0); 107return (false, buffer.Length); 110_buffer.EnsureAvailableSpaceUpToLimit(buffer.Length, _maxBufferSize); 112int bytesWritten = Math.Min(buffer.Length, _buffer.AvailableMemory.Length); 122if (buffer.Length == 0) 135if (buffer.Length == 0) 145Debug.Assert(bytesWritten == buffer.Length);

System\Net\Quic\Internal\ReceiveBuffers.cs (1)

53for (int i = 0; i < quicBuffers.Length; ++i)

System\Net\FtpControlStream.cs (1)

928if (dateTimeLine.Length < 14)

src\libraries\Common\src\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.cs (8)

125inputBytes.Length, 155inputBytes.Length, 186inputBytes.Length, 247return Wrap(out minorStatus, contextHandle, ref isEncrypt, inputBytesPtr, inputBytes.Length, ref outBuffer); 260return Unwrap(out minorStatus, contextHandle, out isEncrypt, inputBytesPtr, inputBytes.Length, ref outBuffer); 272return GetMic(out minorStatus, contextHandle, inputBytesPtr, inputBytes.Length, ref outBuffer); 285return VerifyMic(out minorStatus, contextHandle, inputBytesPtr, inputBytes.Length, tokenBytesPtr, tokenBytes.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs (1)

44BioWrite(b, ref MemoryMarshal.GetReference(data), data.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OCSP.cs (3)

51buf.Length, 55x509Issuers.Length, 88buf.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (7)

680if (input.Length > 0) 682if (Ssl.BioWrite(context.InputBio!, ref MemoryMarshal.GetReference(input), input.Length) != input.Length) 758int retVal = Ssl.SslWrite(context, ref MemoryMarshal.GetReference(input), input.Length, out Ssl.SslErrorCode errorCode); 760if (retVal != input.Length) 1025int bytes = Ssl.BioWrite(bio, ref MemoryMarshal.GetReference(buffer), buffer.Length); 1026if (bytes != buffer.Length)

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs (2)

316Debug.Assert(stapledResponse.Length > 0); 320CryptoNative_SslStapleOcsp(ssl, ptr, stapledResponse.Length);

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (8)

138while (start < name.Length) 164(uint)(start + 1) < (uint)name.Length && char.IsAsciiDigit((char)ToUShort(name[start + 1]))) 221for (; current < name.Length; current++) 235if (current < name.Length) 254for (; current < name.Length; current++) 273if (current < name.Length && ch == '.') 296else if (current >= name.Length) 299end = name.Length;

src\libraries\Common\src\System\Net\IPv6AddressHelper.Common.cs (8)

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

src\libraries\Common\src\System\Net\Security\MD4.cs (5)

101count[0] += (uint)(input.Length << 3); 102if (count[0] < (input.Length << 3)) 107count[1] += (uint)(input.Length >> 29); 112if (input.Length >= partLen) 125for (i = partLen; i + 63 < input.Length; i += 64)

src\libraries\Common\src\System\Net\Security\RC4.cs (3)

60index1 = (byte)((index1 + 1) % key.Length); 78Debug.Assert(input.Length == output.Length); 81for (int counter = 0; counter < input.Length; counter++)

src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (15)

52if (data.Length > 0) 87Span<byte> clientRandomUtf8 = clientRandom.Length <= 1024 ? stackalloc byte[clientRandom.Length * 2] : new byte[clientRandom.Length * 2]; 104if (secret.Length == 0) 111int totalLength = checked(labelUtf8.Length + 1 + clientRandomUtf8.Length + 1 + 2 * secret.Length + 1); 115line[labelUtf8.Length] = (byte)' '; 117clientRandomUtf8.CopyTo(line.Slice(labelUtf8.Length + 1)); 118line[labelUtf8.Length + 1 + clientRandomUtf8.Length] = (byte)' '; 120HexEncode(secret, line.Slice(labelUtf8.Length + 1 + clientRandomUtf8.Length + 1)); 128for (int i = 0; i < source.Length; i++)

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

17int base64Len = ((input.Length + 2) / 3) * 4; 22Debug.Fail($"Convert.TryToBase64 failed with {input.Length} bytes to a {base64.Length} buffer"); 43written += source.Length;

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (22)

364Debug.Assert(HeaderLength == NtlmHeader.Length); 381if (length == 0 || offset + length > payload.Length) 403SetField(ref field, data.Length, offset); 405offset += data.Length; 423if (password.Length > 128) 454Debug.Assert(serverChallenge.Length == ChallengeLength); 456Debug.Assert(ntlm2hash.Length == DigestLength); 458Span<byte> blob = payload.Slice(payloadOffset, sizeof(NtChallengeResponse) + serverInfo.Length); 466serverInfo.CopyTo(MemoryMarshal.CreateSpan(ref temp.ServerInfo[0], serverInfo.Length)); 521byte[] targetInfoBuffer = new byte[targetInfo.Length + 20 /* channel binding */ + 4 + spnSize /* SPN */ + 8 /* flags */]; 526if (targetInfo.Length > 0) 529while (info.Length >= 4) 625!NtlmHeader.SequenceEqual(blob.Slice(0, NtlmHeader.Length))) 789if (signature.Length != SignatureLength || 823Span<byte> output = outputWriter.GetSpan(input.Length + SignatureLength); 824_clientSeal.Transform(input, output.Slice(SignatureLength, input.Length)); 829outputWriter.Advance(input.Length + SignatureLength); 843if (input.Length < SignatureLength) 848Span<byte> output = outputWriter.GetSpan(input.Length - SignatureLength); 849_serverSeal.Transform(input.Slice(SignatureLength), output.Slice(0, input.Length - SignatureLength)); 850if (!VerifyMIC(output.Slice(0, input.Length - SignatureLength), input.Slice(0, SignatureLength))) 856outputWriter.Advance(input.Length - SignatureLength);

System\Net\NegotiateAuthenticationPal.Unix.cs (6)

353encryptedBuffer.Span.CopyTo(outputWriter.GetSpan(encryptedBuffer.Span.Length)); 354outputWriter.Advance(encryptedBuffer.Span.Length); 381decryptedBuffer.Span.CopyTo(outputWriter.GetSpan(decryptedBuffer.Span.Length)); 382outputWriter.Advance(decryptedBuffer.Span.Length); 413unwrappedLength = decryptedBuffer.Span.Length; 533int length = tokenBytes.Length;

System\Net\Security\Pal.Managed\SafeChannelBindingHandle.cs (2)

38_cbtPrefixByteArraySize = cbtPrefix.Length; 41cbtPrefix.CopyTo(new Span<byte>((byte*)cbtPrefixPtr, cbtPrefix.Length));

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

27else if (alpn.Length > 0)

System\Net\Security\SslStream.cs (1)

821PoolingPointerMemoryManager memoryManager = RentPointerMemoryManager(ref _writePointerMemoryManager, ptr, buffer.Length);

System\Net\Security\SslStream.IO.cs (3)

533if ((nextHeader.Type != TlsContentType.Handshake && nextHeader.Type != TlsContentType.ChangeCipherSpec) && !_isRenego || frameSize > availableData.Length - chunkSize) 555if (alert.Length == 0) 1056if (buffer.Length < TlsFrameHelper.HeaderSize)

System\Net\Security\SslStream.Protocol.cs (1)

1432Size = payload.Length;

System\Net\Security\SslStreamPal.Unix.cs (1)

189consumed = inputBuffer.Length;

System\Net\Security\TlsFrameHelper.cs (23)

173if (frame.Length < HeaderSize) 230if (frame.Length < HeaderSize) 254if (info.Header.Type != TlsContentType.Handshake || frame.Length <= HandshakeTypeOffset) 274bool isComplete = frame.Length >= info.Header.Length; 306if (frame.Length < 7 || frame[0] != (byte)TlsContentType.Alert) 382if (sslHandshake.Length < HelloOffset || 392if (helloData.Length < helloLength) 441if (extensionListLength != p.Length) 479if (extensionListLength != p.Length) 493while (extensions.Length >= ExtensionHeader) 500if (extensions.Length < extensionLength) 563if (serverNameListExtension.Length < ServerNameListOffset) 571if (serverNameListLength != serverNameList.Length) 594if (serverName.Length < HostNameStructOffset) 621if (hostNameLength != hostName.Length) 651if (extensionData.Length != supportedVersionLength) 657while (extensionData.Length >= VersionLength) 684if (extensionData.Length < AlpnListOffset) 691if (AlpnListLength != alpnList.Length) 699if (alpnList.Length < protocolLength + 1) 795return (numberOfBytesToSkip < bytes.Length) ? bytes.Slice(numberOfBytesToSkip) : ReadOnlySpan<byte>.Empty; 806if (bytes.Length < OpaqueTypeLengthSize) 820if (bytes.Length < OpaqueTypeLengthSize)

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)

110while (FillLineBuffer() != 0 && _lineLength < Utf8Bom.Length) ; 190while (await FillLineBufferAsync(cancellationToken).ConfigureAwait(false) != 0 && _lineLength < Utf8Bom.Length) ; 376ReadOnlySpan<byte> remainder = _lineBuffer.AsSpan(_newlineIndex + newlineLength, _lineLength - line.Length - newlineLength); 378(remainder[0] is LF || (remainder[0] is CR && remainder.Length > 1))) 380advance = line.Length + newlineLength + (remainder.StartsWith(CRLF) ? 2 : 1); 403_dataLength += fieldValue.Length; 445advance = line.Length + GetNewLineLength();

src\libraries\Common\src\Interop\Unix\System.Native\Interop.Bind.cs (1)

17=> Bind(socket, socketProtocolType, socketAddress, socketAddress.Length);

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

66if (socketAddressBuffer.Length >= SocketAddress.GetMaximumAddressSize(endPoint.AddressFamily) &&

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

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

System\Net\Sockets\SafeSocketHandle.Unix.OptionTracking.cs (2)

85Debug.Assert(values.Length == TrackableOptionCount); 96for (int i = 0; i < values.Length; i++)

System\Net\Sockets\SocketAsyncContext.Unix.cs (1)

1987int bufferIndexIgnored = 0, offset = 0, count = buffer.Length;

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

260SocketAddressLen = socketAddress.Length, 323SocketAddressLen = socketAddress.Length, 957int bufferIndex = 0, offset = 0, count = buffer.Length; 1515Interop.Error err = Interop.Sys.SetRawSockOpt(handle, optionLevel, optionName, optionValuePtr, optionValue.Length);

System\Net\Sockets\UnixDomainSocketEndPoint.cs (2)

71if (socketAddress.Length > s_nativePathOffset) 73_encodedPath = new byte[socketAddress.Length - s_nativePathOffset];

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (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\Compression\WebSocketDeflater.cs (5)

49_buffer = ArrayPool<byte>.Shared.Rent(Math.Max(payload.Length, MinInitialBufferLength)); 60Debug.Assert(consumed == payload.Length); 84if (payload.Length == 0) 130_stream.AvailIn = (uint)input.Length; 140consumed = input.Length - (int)_stream.AvailIn;

System\Net\WebSockets\ManagedWebSocket.cs (9)

642int payloadLength = payloadBuffer.Length; 666if (payloadBuffer.Length > 0) 723if (payload.Length <= 125) 725sendBuffer[1] = (byte)payload.Length; 728else if (payload.Length <= ushort.MaxValue) 731BinaryPrimitives.WriteUInt16BigEndian(sendBuffer.AsSpan(2), (ushort)payload.Length); 737BinaryPrimitives.WriteUInt64BigEndian(sendBuffer.AsSpan(2), (ulong)payload.Length); 1763for (int i = 0; i < span.Length;) 1810while (state.AdditionalBytesExpected > 0 && i < span.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)

111_shape = TensorShape.Create(ref reference, span.Length, pinned: false); 141_shape = TensorShape.Create(ref reference, span.Length, lengths, strides, pinned: false); 288public int Rank => Lengths.Length;

System\Numerics\Tensors\netcore\Tensor.cs (35)

System\Numerics\Tensors\netcore\TensorOperation.cs (7)

1983for (int i = 0; i < x.Length; i++) 2001for (int i = 0; i < x.Length; i++) 2086for (int i = 0; i < x.Length; i++) 2099for (int i = 0; i < x.Length; i++) 2118for (int i = 0; i < x.Length; i++) 2271for (int i = 0; i < x.Length; i++) 2290for (int i = 0; i < x.Length; i++)

System\Numerics\Tensors\netcore\TensorPrimitives.Average.cs (1)

25return Sum(x) / T.CreateChecked(x.Length);

System\Numerics\Tensors\netcore\TensorPrimitives.ConvertHelpers.cs (1)

19if (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) 183int oneVectorFromEnd = x.Length - Vector512<T>.Count; 208if (i != x.Length) 210current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 211currentIndex += CreateVector512T(x.Length - i); 232if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 267int oneVectorFromEnd = x.Length - Vector256<T>.Count; 292if (i != x.Length) 294current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 295currentIndex += CreateVector256T(x.Length - i); 316if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count) 351int oneVectorFromEnd = x.Length - Vector128<T>.Count; 376if (i != x.Length) 378current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count)); 379currentIndex += CreateVector128T(x.Length - i); 408for (int i = 1; i < x.Length; i++)

System\Numerics\Tensors\netcore\TensorPrimitives.IsCanonical.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.IsComplexNumber.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsFinite.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.IsImaginaryNumber.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsInteger.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.IsNaN.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsNegative.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Clear();

System\Numerics\Tensors\netcore\TensorPrimitives.IsRealNumber.cs (2)

23if (x.Length > destination.Length) 28destination.Slice(0, x.Length).Fill(true);

System\Numerics\Tensors\netcore\TensorPrimitives.Max.cs (13)

245if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 265int oneVectorFromEnd = x.Length - Vector512<T>.Count; 289if (i != x.Length) 291current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 310if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 330int oneVectorFromEnd = x.Length - Vector256<T>.Count; 354if (i != x.Length) 356current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 376if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count) 396int oneVectorFromEnd = x.Length - Vector128<T>.Count; 420if (i != x.Length) 422current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count)); 448for (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)

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

29T variance = sumSquaredDiff / T.CreateChecked(x.Length);

System\Numerics\Tensors\netcore\TensorShape.cs (54)

System\Numerics\Tensors\netcore\TensorSpan_1.cs (1)

189public int Rank => Lengths.Length;

System\Numerics\Tensors\TensorPrimitives.Single.cs (1)

852if (x.Length > destination.Length)

LibraryImports.g.cs (2)

1383for (int __i0 = 0; __i0 < __nestedTypeNames_native__managedSpan.Length; ++__i0, ++__nestedTypeNames_native__lastIndexMarshalled) 1450for (int __i0 = 0; __i0 < __nestedTypeNames_native__managedSpan.Length; ++__i0, ++__nestedTypeNames_native__lastIndexMarshalled)

src\Internal\VersionResilientHashCode.CoreCLR.cs (1)

73for (int i = 0; i < instantiation.Length; i++)

src\libraries\Common\src\Internal\VersionResilientHashCode.cs (7)

33if (src.Length == 0) 43for (int i = startIndex; i < src.Length; i += 2) 46if (i + 1 < src.Length) 56_numCharactersHashed += src.Length; 77if (src.Length == 0) 85for (int i = 0; i < src.Length; i += 2) 88if (i + 1 < src.Length)

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\System\Collections\Generic\BitHelper.cs (1)

45bitArrayIndex < (uint)span.Length &&

src\libraries\Common\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(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 (23)

120Debug.Assert(source.Length >= (Vector128<TChar>.Count / 2)); 136nuint lengthSubVector128 = (nuint)source.Length - (nuint)(Vector128<TChar>.Count / 2); 170if (pos == (nuint)source.Length) 187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 190if ((AdvSimd.Arm64.IsSupported || Ssse3.IsSupported) && (source.Length >= (Vector128<byte>.Count / 2))) 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 207if ((AdvSimd.Arm64.IsSupported || Ssse3.IsSupported) && (source.Length >= (Vector128<ushort>.Count / 2))) 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 278(utf8Source.Length >= Vector128<byte>.Count)) 290(source.Length >= (Vector128<ushort>.Count * 2))) 305Debug.Assert(source.Length <= (destination.Length * 2)); 306Debug.Assert((source.Length % 2) == 0); 319Debug.Assert(source.Length >= elementsReadPerIteration); 322nuint lengthSubElementsReadPerIteration = (nuint)source.Length - (nuint)elementsReadPerIteration; 422if (offset == (nuint)source.Length) 424elementsProcessed = source.Length; 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (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); 138for (int i = skip; i < path.Length; i++) 142if (IsDirectorySeparator(c) && i + 1 < path.Length) 153if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && 162if (i + 2 < path.Length && 163(i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && 172sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\.. 197if (!flippedSeparator && sb.Length == path.Length) 231path.Slice(0, path.Length - 1) : 238path.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\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\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (1)

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

src\libraries\Common\src\System\Sha1ForNonSecretPurposes.cs (3)

35int originalLength = source.Length; 37while (source.Length >= 64) 49int pos = source.Length;

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

src\libraries\System.Private.CoreLib\src\System\AppDomain.cs (1)

152parameters: entry.GetParametersAsSpan().Length > 0 ? [args] : null,

src\libraries\System.Private.CoreLib\src\System\Array.cs (3)

742Debug.Assert(indices.Length == Rank); 748for (int i = 0; i < indices.Length; i++) 750int index = indices[i] - Unsafe.Add(ref bounds, indices.Length + i);

src\libraries\System.Private.CoreLib\src\System\BitConverter.cs (15)

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)

536if (!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\Base64Decoder.cs (2)

104int upperBound = GetMaxDecodedLength(source.Length); 236int upperBound = GetMaxDecodedLength(source.Length);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Encoder.cs (4)

94byte[] destination = new byte[GetEncodedLength(source.Length)]; 191char[] destination = new char[GetEncodedLength(source.Length)]; 204string.Create(GetEncodedLength(source.Length), source, static (buffer, source) => 207Debug.Assert(buffer.Length == charsWritten, $"The source length: {source.Length}, chars written: {charsWritten}");

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (16)

35int srcLength = decoder.SrcLength(isFinalBlock, source.Length); 156if (src == srcBytes + source.Length) 239if (srcLength != source.Length) 250if (srcLength != source.Length && isFinalBlock) 291bytesConsumed += source.Length; 487for (; encodedIdx < source.Length && (uint)bufferIdx < (uint)buffer.Length; ++encodedIdx) 507hasAnotherBlock = source.Length >= BlockSize; 511hasAnotherBlock = source.Length > 1; 547for (int i = 0; i < source.Length; ++i) 592for (; encodedIdx < source.Length && (uint)bufferIdx < (uint)buffer.Length; ++encodedIdx) 612hasAnotherBlock = source.Length >= BlockSize; 616hasAnotherBlock = source.Length > 1; 652for (int i = 0; i < source.Length; ++i) 664bytesConsumed += source.Length; 1582for (int i = 0; i < span.Length; i++) 1798for (int i = 0; i < span.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (1)

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

163int upperBound = GetMaxDecodedLength(source.Length); 261int upperBound = GetMaxDecodedLength(source.Length);

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; 224if (s.Length != 1) 243if (s.Length != 1) 257bytesConsumed != utf8Text.Length) 274bytesConsumed != utf8Text.Length || 1234if (source.Length != 0) 1245if ((source.Length > sizeof(char)) && (source[..^sizeof(char)].ContainsAnyExcept((byte)0x00))) 1256if (source.Length >= sizeof(char)) 1258sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(char)); 1284if (source.Length != 0) 1295if ((source.Length > sizeof(char)) && (source[sizeof(char)..].ContainsAnyExcept((byte)0x00))) 1306if (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\Convert.cs (38)

2349if (bytes.Length == 0) 2361int outputLength = ToBase64_CalculateAndValidateOutputLength(bytes.Length, insertLineBreaks: true); 2423if (bytes.Length == 0) 2431int charLengthRequired = ToBase64_CalculateAndValidateOutputLength(bytes.Length, insertLineBreaks); 2455Debug.Assert(destination.Length >= ToBase64_CalculateAndValidateOutputLength(source.Length, insertLineBreaks: true)); 2461int chunkSize = Math.Min(source.Length, Base64LineBreakPosition / 4 * 3); // 76 base64 chars == 57 bytes 2585if (chars.Length == 0) 2590if (!int.IsEvenInteger(chars.Length)) 2595byte[] result = GC.AllocateUninitializedArray<byte>(chars.Length / 2); 2611if (utf8Source.Length == 0) 2616if (!int.IsEvenInteger(utf8Source.Length)) 2621byte[] result = GC.AllocateUninitializedArray<byte>(utf8Source.Length / 2); 2659(int quotient, int remainder) = Math.DivRem(source.Length, 2); 2681source = source.Slice(0, source.Length - 1); 2699charsConsumed = source.Length; 2715(int quotient, int remainder) = Math.DivRem(utf8Source.Length, 2); 2737utf8Source = utf8Source.Slice(0, utf8Source.Length - 1); 2755bytesConsumed = utf8Source.Length; 2799if (bytes.Length == 0) 2803ArgumentOutOfRangeException.ThrowIfGreaterThan(bytes.Length, int.MaxValue / 2, nameof(bytes)); 2815if (source.Length == 0) 2820else if ((source.Length > (int.MaxValue / 2)) || (destination.Length < (source.Length * 2))) 2827charsWritten = source.Length * 2; 2838if (source.Length == 0) 2843else if ((source.Length > (int.MaxValue / 2)) || (utf8Destination.Length < (source.Length * 2))) 2850bytesWritten = source.Length * 2; 2894if (bytes.Length == 0) 2898ArgumentOutOfRangeException.ThrowIfGreaterThan(bytes.Length, int.MaxValue / 2, nameof(bytes)); 2910if (source.Length == 0) 2915else if ((source.Length > (int.MaxValue / 2)) || (destination.Length < (source.Length * 2))) 2922charsWritten = source.Length * 2; 2933if (source.Length == 0) 2938else if ((source.Length > (int.MaxValue / 2)) || (utf8Destination.Length < (source.Length * 2))) 2945bytesWritten = source.Length * 2;

src\libraries\System.Private.CoreLib\src\System\DateOnly.cs (3)

537if (format.Length == 1) 854if (format.Length == 0) 859if (format.Length == 1)

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (1)

293if (bits.Length == 4)

src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (46)

60paramOrder[i] = new int[(par.Length > args.Length) ? par.Length : args.Length]; 65for (j = 0; j < par.Length; j++) 112if (par.Length == 0) 128else if (par.Length > args.Length) 133for (j = args.Length; j < par.Length - 1; j++) 139if (j != par.Length - 1) 154else if (par.Length < args.Length) 158int lastArgPos = par.Length - 1; 175int lastArgPos = par.Length - 1; 189int argsToCheck = (paramArrayType != null) ? par.Length - 1 : args.Length; 254if (paramArrayType != null && j == par.Length - 1) 313if (parms.Length == args.Length) 317object[] objs = new object[parms.Length]; 318int lastPos = parms.Length - 1; 325else if (parms.Length > args.Length) 327object?[] objs = new object[parms.Length]; 329for (i = 0; i < parms.Length; i++) 338if (i == parms.Length - 1 && paramArrayTypes[0] != null) 355object[] objs = new object[parms.Length]; 356int paramArrayPos = parms.Length - 1; 403if (parameters.Length == args.Length) 407object[] objs = new object[parameters.Length]; 408int lastPos = parameters.Length - 1; 415else if (parameters.Length > args.Length) 417object?[] objs = new object[parameters.Length]; 422for (; i < parameters.Length - 1; i++) 440object[] objs = new object[parameters.Length]; 441int paramArrayPos = parameters.Length - 1; 568if (par.Length != types.Length) 803if (par.Length == 0) 896if (paramArrayType1 != null && paramOrder1[i] >= p1.Length - 1) 901if (paramArrayType2 != null && paramOrder2[i] >= p2.Length - 1) 925if (p1.Length > p2.Length) 929else if (p2.Length > p1.Length) 1104if (params1.Length != params2.Length) 1107int numParams = params1.Length; 1188bool[] used = new bool[pars.Length]; 1191for (int i = 0; i < pars.Length; i++) 1197for (j = 0; j < pars.Length; j++) 1208if (j == pars.Length) 1214for (int i = 0; i < pars.Length; i++) 1218for (; 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\EventSource.cs (2)

1777int totalLength = namespaceBytes.Length + nameByteCount; 1781Encoding.BigEndianUnicode.GetBytes(name, source.Slice(namespaceBytes.Length));

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) 1900if (format.Length == 1) 2110Debug.Assert(foundItems.Length >= 2, $"{nameof(foundItems)} == {foundItems.Length}"); 2112for (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\CharUnicodeInfo.cs (5)

96Debug.Assert(index >= 0 && index < s.Length, "index < s.Length"); 103if (index < s.Length - 1) 438Debug.Assert((uint)index < (uint)s.Length, "index < s.Length"); 445if ((uint)index < (uint)s.Length) 452if ((uint)index < (uint)s.Length)

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); 116int sourceLength = source.Length; 228string1.Length, 230string2.Length, 262int lpStringSourceLength = lpStringSource.Length; 281lpStringValue.Length, 287Debug.Assert(result >= -1 && result <= lpStringSource.Length); 301Debug.Assert(target.Length != 0); 341*matchLengthPtr = source.Length - idx; // all chars from idx to the end of the string are consumed 429int sourceLength = source.Length; 484int sourceLength = source.Length; 524return 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)

2248} while (i < str.Value.Length && (state != HebrewNumberParsingState.FoundEndOfHebrewNumber)); 2300Debug.Assert(str.Index < str.Value.Length, "DateTimeFormatInfo.Tokenize(): start < value.Length");

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (33)

86if (s.Length == 0) 92if (format.Length == 0) 179if (s.Length == 0) 409Debug.Assert(DateParsingStates.Length == Width * Height); 421if (target.Length > (str.Value.Length - str.Index)) 433if (nextCharIndex < str.Value.Length) 2497if (s.Length == 0) 3357for (int i = 0; i < format.Length; i++) 3378while (i + 1 < format.Length && format[i + 1] == 'd') 3411if (span.Length >= 3) 3512if (span.Length >= 3) 3613if (span.Length >= 3) 3680if (span.Length >= 3) 4465for (int i = 0; i < quotedSpan.Length; i++) 4500if (format.Index >= format.Value.Length - 1 || format.Value[format.Index + 1] == '%') 4592while ((uint)pos < (uint)format.Length) 4607if ((uint)pos < (uint)format.Length) 4665if (formatParam.Length == 1) 4735if (str.Index < str.Value.Length - 1) 4887if (source.Length != 29) 5084if (source.Length < 27 || 5213if (source.Length > 27) 5219if (source.Length != 28) 5231if (source.Length == 33) 5244else if (source.Length == 32) // special-case allowed for compat: only one offset hour digit 5442for (int i = 0; i < str.Length; i++) 5493internal int Length => Value.Length; 5686int valueRemaining = Value.Length - Index; 5704if (thisPosition >= Value.Length - segmentLength) 5732while (thisPosition < Value.Length && char.IsWhiteSpace(Value[thisPosition])) 5750if (thisPosition > Value.Length - segmentLength) 5764if (nextCharIndex < Value.Length) 5999Span<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\IdnMapping.cs (25)

107if (unicode.Length == 0) 114throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, unicode.Length - 1), nameof(unicode)); 183if (ascii.Length > 0 && ascii[^1] == (char)0) 214Debug.Assert(input.Length > 0); 217originalString.Length == input.Length && 218input.Length == output.Length && 219Ordinal.EqualsIgnoreCase(ref MemoryMarshal.GetReference(input), ref MemoryMarshal.GetReference(output), input.Length)) 262Debug.Assert(unicode.Length >= 1, "[IdnMapping.GetAscii] Expected 0 length strings to fail before now."); 265throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, unicode.Length - 1), nameof(unicode)); 283if (unicode.Length <= destination.Length) 286charsWritten = unicode.Length; 296Debug.Assert(unicode.Length >= 1, "[IdnMapping.GetAscii] Expected 0 length strings to fail before now."); 299throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, unicode.Length - 1), nameof(unicode)); 325if (unicode.Length == 0) 331for (int i = 0; i < unicode.Length; i++) 371if (iLastDot == -1 && unicode.Length > c_labelLimit) 375if (unicode.Length > c_defaultNameLimit - (IsDot(unicode[^1]) ? 0 : 1)) 414if (unicode.Length == 0) 417StringBuilder output = new StringBuilder(unicode.Length); 423while (iNextDot < unicode.Length) 430iNextDot = iNextDot < 0 ? unicode.Length : iNextDot + iAfterLastDot; 436if (iNextDot != unicode.Length) 606if (iNextDot != unicode.Length) 638if (char.IsHighSurrogate(s[index]) && index + 1 < s.Length && char.IsLowSurrogate(s[index + 1]))

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.Icu.cs (4)

60int actualLength = Interop.Globalization.ToAscii(flags, unicode, unicode.Length, destination, destination.Length); 104int realLen = Interop.Globalization.ToUnicode(flags, ascii, ascii.Length, output, output.Length); 131int actualLength = Interop.Globalization.ToUnicode(flags, ascii, ascii.Length, destination, destination.Length); 170for (int i = 0; i < s.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.Nls.cs (6)

46int length = Interop.Normaliz.IdnToAscii(flags, unicode, unicode.Length, output, output.Length); 63int length = Interop.Normaliz.IdnToAscii(flags, unicode, unicode.Length, Span<char>.Empty, 0); 76int actualLength = Interop.Normaliz.IdnToAscii(flags, unicode, unicode.Length, destination, destination.Length); 120int length = Interop.Normaliz.IdnToUnicode(flags, ascii, ascii.Length, output, output.Length); 137int length = Interop.Normaliz.IdnToUnicode(flags, ascii, ascii.Length, Span<char>.Empty, 0); 150int actualLength = Interop.Normaliz.IdnToUnicode(flags, ascii, ascii.Length, destination, destination.Length);

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)

58charsWritten = source.Length; 79return 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); 221for (; (uint)i < (uint)s.Length; i++) 243if ((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 (16)

150for (int i = 0; i < source.Length; i++) 159if (char.IsHighSurrogate(c) && i < source.Length - 1) 279Debug.Assert(value.Length > 0); 280Debug.Assert(value.Length <= source.Length); 288char* pSourceLimit = pSource + (source.Length - value.Length); 289char* pValueLimit = pValue + value.Length - 1; 343Debug.Assert(value.Length > 0); 344Debug.Assert(value.Length <= source.Length); 352char* pValueLimit = pValue + value.Length - 1; 353char* pCurrentSource = pSource + (source.Length - value.Length); 406ushort[]?[] table = new ushort[]?[s_casingTableInit.Length * 8]; 407for (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 (5)

210Debug.Assert(destination.Length >= source.Length); 217Debug.Assert(destination.Length >= source.Length); 267instance.ChangeCaseCore(pSource + charsConsumed, source.Length - charsConsumed, 504if (valueChars.Length == 2) 526if (valueChars.Length == 2)

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)

344if (source.Length != 0) 354if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(nint_t))) 363if (source.Length > sizeof(nint_t)) 386if (source.Length >= sizeof(nint_t)) 388sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(nint_t)); 404for (int i = 0; i < source.Length; i++) 412result |= (((nint)1 << ((sizeof(nint_t) * 8) - 1)) >> (((sizeof(nint_t) - source.Length) * 8) - 1)); 426if (source.Length != 0) 436if (isUnsigned && sbyte.IsNegative(sign) && (source.Length >= sizeof(nint_t))) 445if (source.Length > sizeof(nint_t)) 468if (source.Length >= sizeof(nint_t)) 486for (int i = 0; i < source.Length; i++) 492result <<= ((sizeof(nint_t) - source.Length) * 8); 497result |= (((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)

395byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length); 399Write(array, 0, buffer.Length); 425if (chars.Length <= MaxArrayPoolRentalSize) 430int 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)

94&& ((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 (10)

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) 331if (++expressionOffset == expression.Length) 367if (++expressionOffset == expression.Length)

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (5)

1556int preambleSize = preamble.Length; 1571int bytesNeeded = checked(preambleSize + encoding.GetMaxByteCount(Math.Min(contents.Length, ChunkSize))); 1589ReadOnlySpan<char> toEncode = contents.Slice(0, Math.Min(contents.Length, ChunkSize)); 1590contents = contents.Slice(toEncode.Length); 1663if (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)

637int i = _position + buffer.Length; 659buffer.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)

113int bytesToWrite = GetNumberOfBytesToWrite(buffer.Length); 142if (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)

916byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 920Write(sharedBuffer, 0, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (10)

173int preambleLength = encoding.Preamble.Length; 554Debug.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?"); 555int len = Math.Min(_byteLen, preamble.Length); 568Debug.Assert(_bytePos <= preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 570if (_bytePos == preamble.Length) 573CompressBuffer(preamble.Length); 599Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 703Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 1141Debug.Assert(_bytePos <= _encoding.Preamble.Length, "possible bug in _compressPreamble. Are two threads using this StreamReader at the same time?"); 1336Debug.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)

295if (preamble.Length > 0) 406if (buffer.Length <= 4 && // Threshold of 4 chosen based on perf experimentation 407buffer.Length <= _charLen - _charPos) 411for (int i = 0; i < buffer.Length; i++) 431int count = buffer.Length; 506int estimatedLength = checked((format?.Length ?? 0) + args.Length * 8);

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

152if (valueChars.Length > 1) 192char[] array = ArrayPool<char>.Shared.Rent(buffer.Length); 197Write(array, 0, buffer.Length); 385if (valueChars.Length > 1) 416char[] array = ArrayPool<char>.Shared.Rent(buffer.Length); 421WriteLine(array, 0, buffer.Length); 604if (valueChars.Length > 1) 698if (valueChars.Length > 1)

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

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

922Debug.Assert((Pow10BigNumTableIndices[^1] + MaxBlockCount + 2) == Pow10BigNumTable.Length); 946Debug.Assert((pow10BigNumTableIndex + ((sizeof(BigInteger) + sizeof(uint) - 1) / sizeof(uint))) < Pow10BigNumTable.Length);

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (15)

751if (format.Length == 0) 867if (format.Length == 0) 983if (format.Length == 0) 1099if (format.Length == 0) 1216if (format.Length == 0) 1334if (format.Length == 0) 1459int bufferLength = Math.Max(digits, FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length; 1470Debug.Assert(p == buffer + sNegative.Length); 1472for (int i = sNegative.Length - 1; i >= 0; i--) 1892int bufferLength = Math.Max(digits, FormattingHelpers.CountDigits((ulong)(-value))) + sNegative.Length; 1903Debug.Assert(p == buffer + sNegative.Length); 1905for (int i = sNegative.Length - 1; i >= 0; i--) 2322int bufferLength = Math.Max(digits, FormattingHelpers.CountDigits(absValue)) + sNegative.Length; 2333Debug.Assert(p == buffer + sNegative.Length); 2335for (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\Colors\Argb.T.cs (1)

66if (values.Length < 4)

src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Rgba.T.cs (1)

66if (values.Length < 4)

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)

833if (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 (3)

227return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length); 255if (index < _span.Length) 414var destination = new T[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\Marshalling\ReadOnlySpanMarshaller.cs (5)

50numElements = managed.Length; 119if (managed.Length <= buffer.Length) 121_span = buffer[0..managed.Length]; 125int bufferSize = checked(managed.Length * sizeof(TUnmanagedElement)); 127_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 (source.Length < sizeof(T)) 494if (source.Length < sizeof(T)) 579if (span.Length < sizeof(T))

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)

1023if (values.Length < Vector128<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (1)

1030if (values.Length < Vector256<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (1)

931if (values.Length < Vector512<T>.Count)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (1)

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

678finalist.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)

50ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 58ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 66ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 74ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 82ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 90ref 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)

36int 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\SingleStringSearchValuesPackedThreeChars.cs (1)

79IndexOf(ref MemoryMarshal.GetReference(span), span.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (1)

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

127for (int j = 0; j < disallowedSimpleAssemblyNameChars.Length; j++) 225initializeMethod.GetParametersAsSpan().Length == 0);

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (8)

349=> SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(strA), strA.Length, ref MemoryMarshal.GetReference(strB), strB.Length); 710return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)value.Length * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 743return Marvin.ComputeHash32OrdinalIgnoreCase(ref MemoryMarshal.GetReference(value), value.Length /* in chars, not bytes */, (uint)seed, (uint)(seed >> 32)); 796int length = span.Length; 906int length = span.Length; 983return GetNonRandomizedHashCodeOrdinalIgnoreCaseSlow(hash1, hash2, span.Slice(span.Length - length)); 988int 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 (82)

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)

42int right = EncodingNameIndices.Length - 2; 46Debug.Assert(EncodingNameIndices.Length == CodePagesByName.Length + 1); 57Debug.Assert(index < EncodingNameIndices.Length - 1); 80Debug.Assert(left < EncodingNameIndices.Length - 1); 100EncodingInfo[] arrayEncodingInfo = new EncodingInfo[(LocalAppContextSwitches.EnableUnsafeUTF7Encoding) ? mappedCodePages.Length : (mappedCodePages.Length - 1)]; 105for (int i = 0; i < mappedCodePages.Length; i++) 131for (int i = 0; i < mappedCodePages.Length; i++) 169Interlocked.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)

348if (source.Length > 1) 377charsConsumed = source.Length; 453if (source.Length <= 1) 507if (source.Length <= 2) 532if (source.Length <= 3) 584int index = source.Length - 1; 585if ((uint)index < (uint)source.Length) 604if ((uint)index < (uint)source.Length) 628charsConsumed = (int)((uint)(-source.Length) >> 31); // 0 -> 0, all other lengths -> 1 644int index = source.Length - 1; 645if ((uint)index < (uint)source.Length) 679if ((uint)index >= (uint)source.Length) 720if (tempBytesConsumed == source.Length) 869if (input.Length <= 1) 977if (bytesConsumed == utf8Text.Length) 991if (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)

962long insertingChars = (long)value.Length * count; 973ReplaceInPlaceAtChunk(ref chunk!, ref indexInChunk, ref MemoryMarshal.GetReference(value), value.Length); 1120Append(ref MemoryMarshal.GetReference(value), value.Length); 1303for (int i = 1; i < values.Length; i++) 1443if (value.Length != 0) 1445Insert(index, ref MemoryMarshal.GetReference(value), value.Length); 1734if ((uint)index >= (uint)args.Length) 1781if (itemFormatSpan.Length != 0) 1917format.ValidateNumberOfArgs(args.Length); 1918return args.Length switch 2060if (span.Length != Length) 2075if (!chunk.EqualsOrdinal(span.Slice(span.Length - offset, chunk_length))) 2126if (oldValue.Length == 0) 2145while (oldValue.Length <= remainingChunk.Length) 2156remainingChunk = remainingChunk.Slice(foundPos + oldValue.Length); 2157indexInChunk += oldValue.Length; 2158count -= foundPos + oldValue.Length; 2173int move = remainingChunk.Length - (oldValue.Length - 1); 2180Debug.Assert(oldValue.Length > Math.Min(count, chunk.m_ChunkLength - indexInChunk), 2181$"oldValue.Length = {oldValue.Length}, chunk.m_ChunkLength - indexInChunk = {chunk.m_ChunkLength - indexInChunk}, count == {count}"); 2189indexInChunk += oldValue.Length; 2190count -= oldValue.Length; 2211ReplaceAllInChunk(replacements.AsSpan(), chunk, oldValue.Length, newValue); 2212index += (newValue.Length - oldValue.Length) * replacements.Length; 2431long longDelta = (value.Length - removeCount) * (long)replacements.Length; 2452ReplaceInPlaceAtChunk(ref targetChunk!, ref targetIndexInChunk, ref MemoryMarshal.GetReference<char>(value), value.Length); 2455if ((uint)i >= replacements.Length) 2492for (int i = 0; i < value.Length; i++) 3197int 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)

877return tokens.Length switch 945_linkingRegistrations = new CancellationTokenRegistration[tokens.Length]; 947for (int i = 0; i < tokens.Length; i++)

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (8)

5041for (int i = tasks.Length - 1; i >= 0; i--) 5058AddToList(task, ref waitedOnTaskList, initSize: tasks.Length); 5064if (!taskIsCompleted) AddToList(task, ref waitedOnTaskList, initSize: tasks.Length); 6095switch (tasks.Length) 6121Debug.Assert(tasks.Length != 0, "Expected a non-zero length task array"); 6148_remainingToComplete = tasks.Length; 6627if (tasks.Length == 2) 7027if (tasks.Length != 0)

src\libraries\System.Private.CoreLib\src\System\Threading\WaitHandle.cs (17)

241Debug.Assert(waitHandles.Length > 0); 242Debug.Assert(waitHandles.Length <= MaxWaitHandles); 248for (int i = 0; i < waitHandles.Length; ++i) 263for (int i = 0; i < waitHandles.Length; ++i) 298if (waitHandles.Length == 0) 302if (waitHandles.Length > MaxWaitHandles) 310SafeWaitHandle?[]? safeWaitHandles = RentSafeWaitHandleArray(waitHandles.Length); 318IntPtr[] unsafeWaitHandles = new IntPtr[waitHandles.Length]; 324Span<IntPtr> unsafeWaitHandles = stackalloc IntPtr[waitHandles.Length]; 329if (waitResult >= WaitAbandoned && waitResult < WaitAbandoned + waitHandles.Length) 346for (int i = 0; i < waitHandles.Length; ++i) 366Debug.Assert(safeWaitHandles.Length != 0); 367Debug.Assert(safeWaitHandles.Length <= MaxWaitHandles); 376IntPtr[] unsafeWaitHandles = new IntPtr[safeWaitHandles.Length]; 377for (int i = 0; i < safeWaitHandles.Length; ++i) 386Span<IntPtr> unsafeWaitHandles = stackalloc IntPtr[safeWaitHandles.Length]; 387for (int i = 0; i < safeWaitHandles.Length; ++i)

src\libraries\System.Private.CoreLib\src\System\Threading\WaitSubsystem.Unix.cs (8)

378Debug.Assert(waitHandles.Length > 0); 379Debug.Assert(waitHandles.Length <= WaitHandle.MaxWaitHandles); 385if (waitHandles.Length == 1 && HandleManager.FromHandle(waitHandles[0]) is NamedMutex namedMutex) 392WaitableObject?[] waitableObjects = waitInfo.GetWaitedObjectArray(waitHandles.Length); 397for (int i = 0; i < waitHandles.Length; ++i) 430for (int i = 0; i < waitHandles.Length; ++i) 437if (waitHandles.Length == 1) 448waitHandles.Length,

src\libraries\System.Private.CoreLib\src\System\TimeOnly.cs (3)

707if (format.Length == 1) 1025if (format.Length == 0) 1030if (format.Length == 1)

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (12)

782if (offset.Length > 0) 938if ((uint)index >= (uint)date.Length || !char.IsAsciiDigit(date[index])) 949} while ((uint)index < (uint)date.Length && char.IsAsciiDigit(date[index])); 953if (julianDay == 0 || julianDay > days[days.Length - 1]) 959while (i < days.Length && julianDay > days[i]) 964Debug.Assert(i > 0 && i < days.Length); 1030if (index < posixFormat.Length && posixFormat[index] == ',') 1035if (index < posixFormat.Length && posixFormat[index] == ',') 1048bool isBracketEnclosed = index < posixFormat.Length && posixFormat[index] == '<'; 1057if (index < posixFormat.Length && posixFormat[index] == '>') 1081if (index < posixFormat.Length && posixFormat[index] == '/') 1097for (; index < posixFormat.Length; index++)

src\libraries\System.Private.CoreLib\src\System\Type.Helpers.cs (1)

541str = 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)

340if (source.Length != 0) 351if ((source.Length > sizeof(nuint_t)) && (source[..^sizeof(nuint_t)].ContainsAnyExcept((byte)0x00))) 362if (source.Length >= sizeof(nuint_t)) 364sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(nuint_t)); 380for (int i = 0; i < source.Length; i++) 397if (source.Length != 0) 408if ((source.Length > sizeof(nuint_t)) && (source[sizeof(nuint_t)..].ContainsAnyExcept((byte)0x00))) 419if (source.Length >= sizeof(nuint_t)) 437for (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)

40return input.Length; // no type name end chars were found, the whole input is the type name 48isNestedType = offset > 0 && offset < input.Length && input[offset] == '+'; 54for (; offset < input.Length; offset++) 61if (offset == input.Length || // invalid name that ends with escape character 146for (; offset < input.Length; offset++)

src\System\Reflection\Emit\DynamicILGenerator.cs (4)

95stackchange -= meth.GetParametersAsSpan().Length; 428if (paramInfo.Length != 0) 430parameterTypes = new Type[paramInfo.Length]; 434for (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)

206nestedTypeNames.Length, 214nestedTypeNames.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)

216PrepareMethod(methodInfo.Value, pInstantiation, instantiationHandles.Length);

src\System\Runtime\InteropServices\Java\JavaMarshal.CoreCLR.cs (1)

113(nuint)unreachableObjectHandles.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)

1869ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref type)); 1924return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstantiationContext.Length, methodInstArgs, methodInstantiationContext.Length); 1975ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref field));

src\System\RuntimeType.CoreCLR.cs (6)

2308if (argumentTypes.Length != parameterInfos.Length) 2317bool excessSuppliedArguments = argumentTypes.Length > parameterInfos.Length; 2355if (parameterInfos.Length == 0) 2359bool shortByMoreThanOneSuppliedArgument = argumentTypes.Length < parameterInfos.Length - 1; 2385for (int i = 0; i < parameterInfos.Length; i++) 3965if (invokeMethod.GetParametersAsSpan().Length == 0)

src\System\StubHelpers.cs (1)

486int numChars = Math.Min(managed.Length, length - 1);

src\System\Text\StringBuilder.CoreCLR.cs (1)

44ArgumentOutOfRangeException.ThrowIfGreaterThan(source.Length, m_MaxCapacity, "capacity");

src\libraries\Common\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(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;

RegexGenerator.g.cs (13)

91base.runtextpos != inputSpan.Length) 110if (pos <= inputSpan.Length - 3) 115for (int i = 0; i < span.Length - 2; i++) 127if ((uint)(i + 1) >= (uint)span.Length) 142base.runtextpos = inputSpan.Length; 166iteration = slice.Length - 1; 179if ((uint)slice.Length < 2 || slice[1] != '}') 230base.runtextpos != inputSpan.Length) 248if (pos <= inputSpan.Length - 4) 253for (int i = 0; i < span.Length; i++) 264base.runtextpos = inputSpan.Length; 285iteration = slice.Length; 334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (2)

260while (buffer.Length > 0) 262int 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\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(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 (10)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (8)

138while (start < name.Length) 164(uint)(start + 1) < (uint)name.Length && char.IsAsciiDigit((char)ToUShort(name[start + 1]))) 221for (; current < name.Length; current++) 235if (current < name.Length) 254for (; current < name.Length; current++) 273if (current < name.Length && ch == '.') 296else if (current >= name.Length) 299end = name.Length;

src\libraries\Common\src\System\Net\IPv6AddressHelper.Common.cs (8)

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\DomainNameHelper.cs (5)

121length = hostname.Length; 148int labelLength = dotIndex < 0 ? hostname.Length : dotIndex; 285int charsWritten = label.ToLowerInvariant(dest.AppendSpan(label.Length)); 286Debug.Assert(charsWritten == label.Length); 290i += label.Length;

System\IPv6AddressHelper.cs (4)

137if (name.Length < 3 || (name[1] == ':' && name[2] != ':')) 143for (i = 1; i < name.Length; ++i) 168if (++i == name.Length) 225i = name.Length;

System\IriHelper.cs (3)

78for (int i = 0; (uint)i < (uint)span.Length; i++) 84if ((uint)(i + 2) < (uint)span.Length) 128if (char.IsHighSurrogate(ch) && (uint)(i + 1) < (uint)span.Length)

System\PercentEncodingHelper.cs (2)

16Debug.Assert(input.Length >= 3); 32if ((uint)(input.Length - i) <= 2 || input[i] != '%')

System\UncNameHelper.cs (3)

46for (; i < name.Length; i++) 72for (; (uint)i < (uint)name.Length; i++) 103if ((uint)(i - 1) >= (uint)name.Length || name[i - 1] != '.')

System\Uri.cs (31)

1643charsWritten = result.Length; 1993while (!str.IsEmpty && UriHelper.IsLWS(str[str.Length - 1])) 1995str = str.Slice(0, str.Length - 1); 2013(idx + 1 < str.Length)) 2019for (; (uint)i < (uint)str.Length; i++) 2036if ((uint)(i + 1) < (uint)str.Length && str[i + 1] is ':' or '|' && char.IsAsciiLetter(str[i])) 2038if ((uint)(i + 2) >= (uint)str.Length || str[i + 2] is not ('\\' or '/')) 2068(uint)i < (uint)str.Length && str[i] is not ('?' or '#')) 2089else if ((uint)(idx + 1) < (uint)str.Length) 2169if ((uint)idx < (uint)str.Length) 2730charsWritten = copied ? result.Length : 0; 3467original = original.Slice(0, original.Length - 1); 3474if ((uint)pathLength >= (uint)original.Length || original[pathLength] == '#') 3490if ((uint)fragmentOffset >= (uint)original.Length) 3606switch (scheme.Length) 3646if (scheme.Length == 0 || 3654if (scheme.Length > SchemeLengthLimit) 3677Debug.Assert((uint)startOffset <= (uint)str.Length); 3692if ((uint)startOffset >= (uint)str.Length || ((ch = str[startOffset]) == '/' || (ch == '\\' && (syntaxFlags & UriSyntaxFlags.FileLikeUri) != 0) || ch == '#' || ch == '?')) 3717if ((uint)userInfoLength < (uint)slice.Length && slice[userInfoLength] == '@' && (uint)(++userInfoLength) < (uint)slice.Length) 3741if ((uint)delimiterIdx < (uint)str.Length && 3824char hostDelimiter = (uint)endOfHost < (uint)str.Length ? str[endOfHost] : '\0'; 3848for (i = endOfHost + 1; (uint)i < (uint)str.Length; i++) 3912endOfHost = basicHostEnd >= 0 ? i + basicHostEnd : str.Length; 3935for (endOfHost = i; (uint)endOfHost < (uint)str.Length; endOfHost++) 4021for (i = 0; (uint)i < (uint)span.Length; i++) 4045if ((uint)(i + 1) < (uint)span.Length) 4100if ((uint)(i + 1) < (uint)span.Length && (span[i + 1] == '/' || span[i + 1] == '\\')) 4107if (((uint)(i + 1) >= (uint)span.Length || span[i + 1] == '.' || span[i + 1] == '/' || span[i + 1] == '\\' || span[i + 1] == '?' || span[i + 1] == '#')) 4135if ((uint)(i + 2) < (uint)span.Length && (c = UriHelper.DecodeHexChars(span[i + 1], span[i + 2])) != c_DummyChar)

System\UriExt.cs (5)

509Debug.Assert(backingString is null || backingString.Length == charsToUnescape.Length); 521vsb.EnsureCapacity(charsToUnescape.Length - indexOfFirstToUnescape); 543charsWritten = charsToUnescape.Length; 568vsb.EnsureCapacity(charsToUnescape.Length - indexOfFirstToUnescape); 578Debug.Assert(newLength <= charsToUnescape.Length);

System\UriHelper.cs (19)

16return string.Create(span.Length, span, static (buffer, span) => 66for (; i < self.Length && i < other.Length; ++i) 119for (; i < self.Length; ++i) 136if (destination.Length < charsToEscape.Length) 147charsWritten = charsToEscape.Length; 160vsb.EnsureCapacity(charsToEscape.Length); 170Debug.Assert(newLength > charsToEscape.Length); 207Debug.Assert(backingString is null || backingString.Length == charsToEscape.Length); 221vsb.EnsureCapacity(charsToEscape.Length); 291if (stringToEscape.Length > 2 && char.IsAsciiHexDigit(stringToEscape[1]) && char.IsAsciiHexDigit(stringToEscape[2])) 310charsToCopy = stringToEscape.Length; 321for (int i = 0; (uint)i < (uint)chars.Length;) 323if (chars[i] == '%' && (uint)(i + 2) < (uint)chars.Length) 383for (i = 0; (uint)i < (uint)chars.Length; i++) 394else if ((uint)(i + 2) < (uint)chars.Length) 467if (i < chars.Length) 568Debug.Assert(backingString is null || strToClean.Length == backingString.Length); 602stripped = 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)

28readonly get => Span.Length - _unread.Length; 101if (count > _unread.Length) 138if (sizeof(TValue) > _unread.Length * sizeof(T)) 172if (sizeof(TValue) * count > _unread.Length * sizeof(T)) 203UnsafeAdvance(next.Length); 222count = _unread.Length; 243public void Rewind(int count) => _unread = Span[(Span.Length - _unread.Length - count)..]; 257Debug.Assert((uint)count <= (uint)_unread.Length); 258UncheckedSlice(ref _unread, count, _unread.Length - count); 267Debug.Assert((uint)length <= (uint)span.Length); 277Debug.Assert((uint)start <= (uint)span.Length && (uint)length <= (uint)(span.Length - start));

System\SpanWriter.cs (2)

46if (_unwritten.Length >= values.Length) 50UnsafeAdvance(values.Length);

System\Text\ValueStringBuilder.cs (3)

294if (pos > _chars.Length - value.Length) 296Grow(value.Length); 300_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.byte.InlineArrays.g.cs (1)

60 int initLength = value.Length;

Windows.Win32.char.InlineArrays.g.cs (4)

55 internal readonly bool Equals(ReadOnlySpan<char> value) => value.Length == SpanLength ? AsReadOnlySpan().SequenceEqual(value) : AsReadOnlySpan().SliceAtNull().SequenceEqual(value); 78 int initLength = value.Length; 119 internal readonly bool Equals(ReadOnlySpan<char> value) => value.Length == SpanLength ? AsReadOnlySpan().SequenceEqual(value) : AsReadOnlySpan().SliceAtNull().SequenceEqual(value); 142 int initLength = value.Length;

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

101 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

84 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

267 winmdroot.Foundation.HRESULT __result = this.CopyTo((uint )rgiidExclude.Length, rgiidExcludeLocal, snbExclude, pstgDest);

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

358 if (rgszNames.Length != pMemId.Length) throw new ArgumentException();

Windows.Win32.PInvokeCore.USER32.dll.g.cs (1)

789 int __result = PInvokeCore.MapWindowPoints(hWndFrom, hWndTo, lpPointsLocal, (uint )lpPoints.Length);

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

90 if (rgszNames.Length != pMemId.Length) throw new ArgumentException();

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

71 winmdroot.Foundation.HRESULT __result = @this.CopyTo((uint )rgiidExclude.Length, rgiidExcludeLocal, snbExclude, pstgDest);

Windows\Win32\Graphics\Gdi\ARGB.cs (3)

47Color[] colors = new Color[argbColors.Length]; 48for (int i = 0; i < argbColors.Length; i++) 59argbColors.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++)

Windows.Win32.float.InlineArrays.g.cs (1)

60 int initLength = value.Length;

RegexGenerator.g.cs (13)

91base.runtextpos != inputSpan.Length) 110if (pos <= inputSpan.Length - 3) 115for (int i = 0; i < span.Length - 2; i++) 127if ((uint)(i + 1) >= (uint)span.Length) 142base.runtextpos = inputSpan.Length; 166iteration = slice.Length - 1; 179if ((uint)slice.Length < 2 || slice[1] != '}') 230base.runtextpos != inputSpan.Length) 248if (pos <= inputSpan.Length - 4) 253for (int i = 0; i < span.Length; i++) 264base.runtextpos = inputSpan.Length; 285iteration = slice.Length; 334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_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; 9598for (int i = 0; i < chars.Length; i++) 9614if ((uint)nextIdx < (uint)chars.Length && chars[nextIdx] == '\n') 9624lineInfo.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 (10)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (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)

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_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)

40return input.Length; // no type name end chars were found, the whole input is the type name 48isNestedType = offset > 0 && offset < input.Length && input[offset] == '+'; 54for (; offset < input.Length; offset++) 61if (offset == input.Length || // invalid name that ends with escape character 146for (; 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\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(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\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_1.cs (5)

179int count = text.Length; 217if (text.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc. 231if (pos > _chars.Length - text.Length) 233Grow(text.Length); 237_pos += text.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.");

System\Number.BigInteger.cs (58)

85if (value.Length == 0) 91if (value.Length < 255) 93buffer = stackalloc byte[value.Length + 1 + 1]; 97buffer = arrayFromPool = ArrayPool<byte>.Shared.Rent(value.Length + 1 + 1); 151for (whiteIndex = 0; whiteIndex < value.Length; whiteIndex++) 163for (whiteIndex = value.Length - 1; whiteIndex >= 0; whiteIndex--) 182int leadingBitsCount = value.Length % TParser.DigitsPerBlock; 237int wholeBlockCount = value.Length / TParser.DigitsPerBlock; 339ReadOnlySpan<byte> fracDigitsSpan = number.Digits.Slice(intDigits.Length); 356int base1E9Length = (intDigits.Length + PowersOf1e9.MaxPartialDigits - 1) / PowersOf1e9.MaxPartialDigits; 363ReadOnlySpan<byte> leadingDigits = intDigits[..(intDigits.Length % PowersOf1e9.MaxPartialDigits)]; 364if (leadingDigits.Length != 0) 369intDigits = intDigits.Slice(leadingDigits.Length); 370Debug.Assert(intDigits.Length % PowersOf1e9.MaxPartialDigits == 0); 377Debug.Assert(intDigits.Length == 0); 412int valueDigits = (base1E9.Length - 1) * PowersOf1e9.MaxPartialDigits + FormattingHelpers.CountDigits(base1E9[^1]); 426int leadingLength = checked((int)(digitRatio * PowersOf1e9.MaxPartialDigits * base1E9.Length) + 3); 457if (base1E9.Length < BigIntegerParseNaiveThresholdInRecursive) 464while (base1E9.Length <= multiplier1E9Length) 471Debug.Assert(multiplier1E9Length < base1E9.Length && base1E9.Length <= multiplier1E9Length * 2); 484Span<uint> bitsUpper = bits.Slice(multiplierTrailingZeroCount, buffer2.Length + multiplier.Length); 499if (base1E9.Length == 0) 527if (base1E9.Length == 0) 532for (int i = base1E9.Length - 2; i >= 0; i--) 756Debug.Assert(formatString == null || formatString.Length == formatSpan.Length); 826int valueDigits = (base1E9Value.Length - 1) * PowersOf1e9.MaxPartialDigits + FormattingHelpers.CountDigits(base1E9Value[^1]); 834int strLength = strDigits + sNegative.Length; 958for (int i = 0; i < base1E9Value.Length - 1; i++) 978if (bits.Length <= ToStringNaiveThreshold) 984PowersOf1e9.FloorBufferSize(bits.Length, out int powersOf1e9BufferLength, out int maxIndex); 1003Debug.Assert(bits.Length == 0 || bits[^1] != 0); 1006if (bits.Length <= ToStringNaiveThreshold) 1015while (bits.Length < powOfTen.Length + omittedLength || BigIntegerCalculator.Compare(bits.Slice(omittedLength), powOfTen) < 0) 1022int upperLength = bits.Length - powOfTen.Length - omittedLength + 1; 1028int lowerLength = bits.Length; 1070for (int iuSrc = bits.Length; --iuSrc >= 0;) 1212Debug.Assert(Indexes[6] == LeadingPowers1E9.Length); 1213if (pow1E9.Length <= LeadingPowers1E9.Length) 1218LeadingPowers1E9.CopyTo(pow1E9.Slice(0, LeadingPowers1E9.Length)); 1223for (int i = 6; i + 1 < Indexes.Length; i++) 1225Debug.Assert(2 * src.Length - (Indexes[i + 1] - Indexes[i]) is 0 or 1); 1226if (pow1E9.Length - toExclusive < (src.Length << 1)) 1228Span<uint> dst = pow1E9.Slice(toExclusive, src.Length << 1); 1243if ((uint)index < (uint)Indexes.Length) 1247maxIndex = Indexes.Length - 2; 1275int hi = Indexes.Length - 1; 1295if (trailingZeroCount < UInt32PowersOfTen.Length) 1297BigIntegerCalculator.Multiply(left, UInt32PowersOfTen[trailingZeroCount], bits.Slice(0, left.Length + 1)); 1316int curLength = first.Length; 1331Debug.Assert(fi + 1 < Indexes.Length); 1338Span<uint> dst = powersOfTen2.Slice(0, curLength += power.Length); 1356Span<uint> bits2 = bits.Slice(omittedLength, curLength += left.Length); 1415Debug.Assert(destination.Length * TParser.DigitsPerBlock == input.Length); 1416ref TChar lastWholeBlockStart = ref Unsafe.Add(ref MemoryMarshal.GetReference(input), input.Length - TParser.DigitsPerBlock);

System\Number.Polyfill.cs (1)

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

System\Numerics\BigInteger.cs (43)

278int byteCount = value.Length; 299byteCount = value.Length; 509if (value.Length > MaxLength) 514if (value.Length == 0) 518else if (value.Length == 1) 943if (rightBits.Length == 1) 948else if (rightBits.Length == 2) 950Span<uint> bits = (leftBits.Length <= BigIntegerCalculator.StackAllocThreshold 952: bitsFromPool = ArrayPool<uint>.Shared.Rent(leftBits.Length)).Slice(0, leftBits.Length); 963Span<uint> bits = (leftBits.Length <= BigIntegerCalculator.StackAllocThreshold 965: bitsFromPool = ArrayPool<uint>.Shared.Rent(leftBits.Length)).Slice(0, leftBits.Length); 1479curByte = length - srcBytes.Length; 1480Span<byte> destBytes = destination.Slice(curByte, srcBytes.Length); 1487curByte = srcBytes.Length; 1710int size = rightBits.Length + 1; 1722int size = leftBits.Length + 1; 1730else if (leftBits.Length < rightBits.Length) 1734int size = rightBits.Length + 1; 1746int size = leftBits.Length + 1; 1788int size = rightBits.Length; 1800int size = leftBits.Length; 1810int size = rightBits.Length; 1822int size = leftBits.Length; 2581Debug.Assert(bits.Length > 0); 2589int zLength = bits.Length + digitShift; 2600Span<uint> zd = z.AsSpan(digitShift, bits.Length); 2672Debug.Assert(bits.Length > 0); 2674int zLength = bits.Length - digitShift + 1; 2773int size = right.Length + 1; 2785int size = left.Length + 1; 2795int size = left.Length + right.Length; 2808int size = left.Length + right.Length; 3305Debug.Assert(bits.Length > 0); 3308int zLength = bits.Length; 3312&& (leadingZeroCount != bits.Length - 1 || bits[^1] != kuMaskHighBit)) 5117Debug.Assert(bits.Length > 0); 5119int zLength = bits.Length - digitShift; 5140if (bits[^1] == kuMaskHighBit && negLeadingZeroCount == 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 (118)

System\Numerics\BigIntegerCalculator.FastReducer.cs (15)

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) 82bits = bits.Slice(0, left.Length + right.Length); 101if (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 (32)

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; 163for (int i = 0; i < power.Length - 1; i++) 175return PowCore(value, power[power.Length - 1], modulus, result); 205Debug.Assert(bits.Length == modulus.Length + modulus.Length); 211int size = Math.Max(value.Length, bits.Length); 219valueCopy.Slice(value.Length).Clear(); 221if (value.Length > modulus.Length) 223Remainder(value, modulus, valueCopy.Slice(0, value.Length)); 254Debug.Assert(bits.Length == modulus.Length + modulus.Length); 259int size = Math.Max(value.Length, bits.Length); 268valueCopy.Slice(value.Length).Clear(); 270if (value.Length > modulus.Length) 272Remainder(value, modulus, valueCopy.Slice(0, value.Length)); 309if (modulus.Length < ReducerThreshold) 317int size = modulus.Length * 2 + 1; 324size = r.Length - modulus.Length + 1; 331size = modulus.Length * 2 + 2; 369if (modulus.Length < ReducerThreshold) 377int size = modulus.Length * 2 + 1; 384size = r.Length - modulus.Length + 1; 391size = modulus.Length * 2 + 2; 433for (int i = 0; i < power.Length - 1; i++) 449return PowCore(value, valueLength, power[power.Length - 1], modulus, result, resultLength, temp); 492for (int i = 0; i < power.Length - 1; i++) 508return PowCore(value, valueLength, power[power.Length - 1], reducer, result, resultLength, temp);

System\Numerics\BigIntegerCalculator.SquMul.cs (102)

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)

2150if ((text.Length < 5) || (openBracket == -1) || (semicolon == -1) || (closeBracket == -1) || (openBracket > semicolon) || (openBracket > closeBracket) || (semicolon > closeBracket)) 2198if ((closeBracket != (text.Length - 1)) && (((style & NumberStyles.AllowTrailingWhite) == 0) || !text.Slice(closeBracket).IsWhiteSpace()))

Microsoft\Win32\SafeHandles\SafePasswordHandle.cs (3)

46spanLen = password.Length + 1; 54dest[password.Length] = '\0'; 57Length = password.Length;

src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (3)

68consumed != source.Length) 105if (encodedOid.Length == 2 && encodedOid[0] == 0x06 && encodedOid[1] == 0x00) 118if (consumed != encodedOid.Length)

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Bignum.cs (1)

27SafeBignumHandle ret = BigNumFromBinary(bigEndianValue, bigEndianValue.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs (1)

44BioWrite(b, ref MemoryMarshal.GetReference(data), data.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Dsa.cs (3)

66DsaSign(dsa, ref MemoryMarshal.GetReference(hash), hash.Length, ref MemoryMarshal.GetReference(refSignature), out outSignatureLength); 77hash.Length, 79signature.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Cipher.cs (5)

86return EvpCipherReset(ctx, pIv, iv.Length); 114input.Length); 184if (!EvpCipherSetGcmTag(ctx, ref MemoryMarshal.GetReference(tag), tag.Length)) 199if (!EvpCipherSetAeadTag(ctx, ref MemoryMarshal.GetReference(tag), tag.Length)) 229if (!EvpCipherSetCcmTag(ctx, ref MemoryMarshal.GetReference(tag), tag.Length))

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.cs (3)

78password.Length, 80salt.Length, 99return EvpDigestXOFOneShot(type, source, source.Length, destination, (uint)destination.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Kdf.cs (10)

76ikm.Length, 79salt.Length, 81info.Length, 103prk.Length, 106info.Length, 128ikm.Length, 131salt.Length, 154key.Length, 157label.Length, 159context.Length,

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Kem.cs (2)

109SafeEvpPKeyHandle handle = CryptoNative_EvpKemGeneratePkey(kemName, seed, seed.Length); 154int ret = CryptoNative_EvpKemDecapsulate(key, GetExtraHandle(key), ciphertext, ciphertext.Length, sharedSecret, sharedSecret.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.Mac.cs (6)

72key.Length, 74customizationString.Length, 76data.Length, 131int ret = CryptoNative_EvpMacInit(ctx, key, key.Length, customizationString, customizationString.Length, xof); 143int ret = CryptoNative_EvpMacUpdate(ctx, data, data.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.cs (2)

75source.Length, 98source.Length,

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.EcDsa.cs (3)

32hash.Length, 63hash.Length, 65signature.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.FromData.cs (1)

22SafeEvpPKeyHandle handle = CryptoNative_EvpPKeyFromData(algorithmName, key, key.Length, privateKey);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.MLDsa.cs (12)

64SafeEvpPKeyHandle handle = CryptoNative_MLDsaGenerateKey(algorithmName, seed, seed.Length); 92msg, msg.Length, 93context, context.Length, 117msg, msg.Length, 118context, context.Length, 119signature, signature.Length); 148msg, msg.Length, 170msg, msg.Length, 171signature, signature.Length); 203mu, mu.Length, 229mu, mu.Length, 230signature, signature.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.Rsa.cs (5)

70source.Length, 107source.Length, 150hash.Length, 191hash.Length, 193signature.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.EvpPkey.SlhDsa.cs (8)

91msg, msg.Length, 92context, context.Length, 116msg, msg.Length, 117context, context.Length, 118signature, signature.Length); 147msg, msg.Length, 169msg, msg.Length, 170signature, signature.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Hmac.cs (2)

46int result = HmacOneShot(type, pKey, key.Length, pSource, source.Length, pDestination, &size);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OCSP.cs (3)

51buf.Length, 55x509Issuers.Length, 88buf.Length);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Pkcs7.cs (1)

16DecodePkcs7(ref MemoryMarshal.GetReference(buf), buf.Length);

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

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

src\libraries\Common\src\System\Security\Cryptography\AesGcm.cs (6)

74AesAEAD.CheckKeySize(key.Length); 295if (plaintext.Length != ciphertext.Length) 298if (!nonce.Length.IsLegalSize(NonceByteSizes)) 306if (tag.Length != tagSizeInBytes) 311else if (!tag.Length.IsLegalSize(TagByteSizes))

src\libraries\Common\src\System\Security\Cryptography\Asn1\AlgorithmIdentifierAsn.manual.cs (2)

49if (span.Length != 2) 104if (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\CurveAsn.xml.cs (3)

87decoded.A = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 97decoded.B = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 110decoded.Seed = 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\ECPrivateKey.xml.cs (2)

105decoded.PrivateKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 130decoded.PublicKey = 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\FieldID.xml.cs (1)

93decoded.Parameters = 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\MLDsaPrivateKeyAsn.xml.cs (2)

116decoded.Seed = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 129decoded.ExpandedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\MLDsaPrivateKeyBothAsn.xml.cs (2)

80decoded.Seed = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 90decoded.ExpandedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\MLKemPrivateKeyAsn.xml.cs (2)

116decoded.Seed = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 129decoded.ExpandedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\MLKemPrivateKeyBothAsn.xml.cs (2)

80decoded.Seed = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 90decoded.ExpandedKey = 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)

118decoded.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\RSAPrivateKeyAsn.xml.cs (8)

src\libraries\Common\src\System\Security\Cryptography\Asn1\RSAPublicKeyAsn.xml.cs (2)

78decoded.Modulus = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 80decoded.PublicExponent = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\SpecifiedECDomain.xml.cs (3)

115decoded.Base = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 123decoded.Order = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 128decoded.Cofactor = 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)

131decoded.ExtnValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\AsymmetricAlgorithmHelpers.Der.cs (7)

31Debug.Assert(input.Length % 2 == 0); 32Debug.Assert(input.Length > 1); 36int halfLength = input.Length / 2; 87if (signatureField.Length > response.Length) 89if (signatureField.Length != response.Length + 1 || 94Debug.Fail($"A signature field was longer ({signatureField.Length}) than expected ({response.Length})"); 103int writeOffset = response.Length - signatureField.Length;

src\libraries\Common\src\System\Security\Cryptography\CompositeMLDsa.cs (13)

195/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 208if (context.Length > MaxContextLength) 212context.Length, 312/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 323if (context.Length > MaxContextLength) 327context.Length, 333if (!Algorithm.IsValidSignatureSize(signature.Length)) 670Debug.Assert(read == source.Length); 860Debug.Assert(read == source.Length); 921if (!algorithm.IsValidPublicKeySize(source.Length)) 971if (!algorithm.IsValidPrivateKeySize(source.Length)) 1832AsnWriter writer = new(AsnEncodingRules.BER, initialCapacity: pkcs8.Length); 1863int capacity = checked(32 + publicKey.Length);

src\libraries\Common\src\System\Security\Cryptography\CompositeMLDsaManaged.cs (11)

210Debug.Assert(context.Length <= 255, $"Caller should have checked context.Length, got {context.Length}"); 294Debug.Assert(context.Length <= 255, $"Caller should have checked context.Length, got {context.Length}"); 460MessageRepresentativePrefix.Length + // Prefix 463context.Length + // ctx 473MessageRepresentativePrefix.CopyTo(M_prime.AsSpan(offset, MessageRepresentativePrefix.Length)); 474offset += MessageRepresentativePrefix.Length; 481M_prime[offset] = (byte)context.Length; 485context.CopyTo(M_prime.AsSpan(offset, context.Length)); 486offset += context.Length;

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

70using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 140if (source.Length != 1 + fieldWidth * 2)

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

164if (bytesRead != source.Length) 219if (bytesRead != source.Length)

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

266bytesWritten = derSignature.Length; 329if (signature.Length != expectedSignatureBytes)

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

111if (prfSeed.Length != 64)

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

182if (signature.Length != expectedBytes)

src\libraries\Common\src\System\Security\Cryptography\Helpers.cs (3)

108bytesWritten = source.Length; 151if (hash.Length != outputSize) 267if (bytesRead != data.Length)

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

57while (newStart < integer.Length) 73if (newStart == integer.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\MLDsa.cs (27)

109/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 124if (context.Length > MaxContextLength) 128context.Length, 192/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 205if (context.Length > MaxContextLength) 209context.Length, 215if (signature.Length != Algorithm.SignatureSizeInBytes) 286/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 307if (context.Length > MaxContextLength) 311context.Length, 333if (hashLengthInBytes != hash.Length) 401/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 419if (context.Length > MaxContextLength) 423context.Length, 433signature.Length != Algorithm.SignatureSizeInBytes) 438if (hashLengthInBytes != hash.Length) 577if (externalMu.Length != Algorithm.MuSizeInBytes) 634if (externalMu.Length != Algorithm.MuSizeInBytes || signature.Length != Algorithm.SignatureSizeInBytes) 1383using (PointerMemoryManager<byte> manager = new(pointer, source.Length)) 1391if (publicKey.Length != algorithm.PublicKeySizeInBytes) 1451Debug.Assert(read == source.Length); 1840if (source.Length != algorithm.PublicKeySizeInBytes) 1890if (source.Length != algorithm.PrivateKeySizeInBytes) 1940if (source.Length != algorithm.PrivateSeedSizeInBytes) 2121AsnWriter writer = new(AsnEncodingRules.BER, initialCapacity: pkcs8.Length); 2150AsnWriter writer = new(AsnEncodingRules.BER, initialCapacity: pkcs8.Length);

src\libraries\Common\src\System\Security\Cryptography\MLKem.cs (6)

204if (ciphertext.Length != Algorithm.CiphertextSizeInBytes) 355if (source.Length != algorithm.PrivateSeedSizeInBytes) 414if (source.Length != algorithm.DecapsulationKeySizeInBytes) 471if (source.Length != algorithm.EncapsulationKeySizeInBytes) 1207Debug.Assert(read == source.Length); 1271Debug.Assert(read == source.Length);

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (23)

52if (passwordBytes.Length > 0 && password.Length == 0) 76Debug.Assert(destination.Length >= encryptedData.Length); 156if (password.IsEmpty && passwordBytes.Length > 0) 177if (passwordBytes.Length > 0 || password.Length == 0) 334if (passwordBytes.Length == 0 && password.Length > 0) 338else if (passwordBytes.Length == 0) 344pwdTmpBytes = new byte[passwordBytes.Length]; 354Debug.Assert(password.Length > 0 || passwordBytes.IsEmpty); 377if (passwordBytes.Length > 0) 379Debug.Assert(pwdTmpBytes!.Length == passwordBytes.Length); 382else if (password.Length > 0) 462if (passwordBytes.Length > 0 || password.Length == 0) 707if (!gotIv || bytesWritten != length || consumed != source.Length) 772byte[] tmpPassword = new byte[password.Length]; 923byte[] tmpKey = new byte[key.Length]; 924byte[] tmpIv = new byte[iv.Length]; 925byte[] rentedEncryptedData = CryptoPool.Rent(encryptedData.Length); 948encryptedData.Length, 971CryptoPool.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;

src\libraries\Common\src\System\Security\Cryptography\RSAKeyFormatHelper.cs (3)

48read = reader.PeekEncodedValue().Length; 92using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 121using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length))

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

22using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, keyData.Length)) 100using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, keyData.Length))

src\libraries\Common\src\System\Security\Cryptography\RSAOpenSsl.cs (3)

178if (data.Length != rsaSize) 522read = source.Length; 569read = source.Length;

src\libraries\Common\src\System\Security\Cryptography\RsaPaddingProcessor.cs (20)

124int mLen = source.Length; 134Span<byte> mInEM = destination.Slice(destination.Length - source.Length); 135Span<byte> ps = destination.Slice(2, destination.Length - source.Length - 3); 182Debug.Assert(source.Length > 11); 202int lenIfGood = afterPadding.Length - zeroPos - 1; 204int lenIfBad = ~Choose(hasLen, lenIfGood, source.Length - 11); 217for (int i = source.Length - 1; i >= 0; i--) 263if (source.Length != expectedLength) 268int tLen = digestInfoPrefix.Length + expectedLength; 285source.CopyTo(destination.Slice(paddingLength + 3 + digestInfoPrefix.Length)); 308if (source.Length > maxInput) 325Span<byte> mDest = db.Slice(db.Length - source.Length); 391if (mHash.Length != hLen) 481if (mHash.Length != hLen) 486Debug.Assert(em.Length >= emLen); 498if (em[em.Length - 1] != 0xBC) 519byte[] dbMaskRented = CryptoPool.Rent(maskedDb.Length); 520Span<byte> dbMask = new Span<byte>(dbMaskRented, 0, maskedDb.Length); 637if (a.Length != b.Length) 642for (int i = 0; i < b.Length; i++)

src\libraries\Common\src\System\Security\Cryptography\SlhDsa.cs (21)

119/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 141if (context.Length > MaxContextLength) 145context.Length, 207/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 218if (context.Length > MaxContextLength) 222context.Length, 228if (signature.Length != Algorithm.SignatureSizeInBytes) 299/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 325if (context.Length > MaxContextLength) 329context.Length, 406/// <paramref name="context"/> has a <see cref="ReadOnlySpan{T}.Length"/> in excess of 423if (context.Length > MaxContextLength) 427context.Length, 434if (signature.Length != Algorithm.SignatureSizeInBytes) 1226Debug.Assert(read == source.Length); 1296if (privateKey.Length != info.PrivateKeySizeInBytes) 1306Debug.Assert(read == source.Length); 1685if (source.Length != algorithm.PublicKeySizeInBytes) 1735if (source.Length != algorithm.PrivateKeySizeInBytes) 1899AsnWriter writer = new(AsnEncodingRules.BER, initialCapacity: pkcs8.Length); 1927AsnWriter writer = new(AsnEncodingRules.BER, initialCapacity: pkcs8.Length);

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

17int maxLength = ThrowingUtf8Encoding.GetMaxByteCount(data.Length);

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

198using (PointerMemoryManager<byte> manager = new(pinned, data.Length)) 430using (PointerMemoryManager<byte> manager = new(pinned, data.Length))

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

216bagState.PrepareDecryptBuffer(authSafeContents.Length); 843if (bytesRead != encodedAttribute.Length) 986Debug.Assert(_decryptBuffer.Length - _decryptBufferOffset >= encryptedContent.Length);

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

17int base64Len = ((input.Length + 2) / 3) * 4; 22Debug.Fail($"Convert.TryToBase64 failed with {input.Length} bytes to a {base64.Length} buffer"); 43written += source.Length;

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\Security\Cryptography\Aes.cs (28)

106int outputLength = GetKeyWrapPaddedLength(plaintext.Length); 134int requiredLength = GetKeyWrapPaddedLength(plaintext.Length); 176/// <paramref name="ciphertext"/> has a <see cref="ReadOnlySpan{T}.Length"/> that does not correspond 181if (ciphertext.Length < 16 || ciphertext.Length % 8 != 0) 184using (CryptoPoolLease lease = CryptoPoolLease.Rent(ciphertext.Length - 8, skipClear: true)) 199/// <paramref name="ciphertext"/> has a <see cref="ReadOnlySpan{T}.Length"/> that does not correspond 218if (ciphertext.Length < 16 || ciphertext.Length % 8 != 0) 244/// <paramref name="ciphertext"/> has a <see cref="ReadOnlySpan{T}.Length"/> that does not correspond 256if (ciphertext.Length < 16 || ciphertext.Length % 8 != 0) 259int maxOutput = ciphertext.Length - 8; 359if (source.Length == 16) 380int maxOutput = source.Length - 8; 411Debug.Assert(destination.Length == GetKeyWrapPaddedLength(source.Length)); 414ulong iv = (AIV << 32) | (uint)source.Length; 416if (source.Length <= 8) 431else if (source.Length % 8 == 0) 437int n = checked((source.Length + 7) / 8); 443lease.Span.Slice(source.Length).Clear(); 452Debug.Assert(source.Length % 8 == 0); 453Debug.Assert(source.Length >= 16); 454Debug.Assert(destination.Length == GetKeyWrapPaddedLength(source.Length)); 468for (uint i = 0; i < source.Length; i += 8, t++, R = R.Slice(8)) 489int inlen = source.Length - 8; 490uint t = 6U * (uint)(source.Length / 8) - 6; 497for (int rOffset = source.Length - 16; rOffset >= 0; t--, rOffset -= 8)

System\Security\Cryptography\AesCcm.cs (5)

21AesAEAD.CheckKeySize(key.Length); 83if (plaintext.Length != ciphertext.Length) 86if (!nonce.Length.IsLegalSize(NonceByteSizes)) 89if (!tag.Length.IsLegalSize(TagByteSizes))

System\Security\Cryptography\AesCcm.OpenSsl.cs (8)

40using (SafeEvpCipherCtxHandle ctx = Interop.Crypto.EvpCipherCreatePartial(GetCipher(key.Length * 8))) 48Interop.Crypto.EvpCipherSetCcmNonceLength(ctx, nonce.Length); 51if (associatedData.Length != 0) 54Interop.Crypto.EvpCipherSetInputLength(ctx, plaintext.Length); 109using (SafeEvpCipherCtxHandle ctx = Interop.Crypto.EvpCipherCreatePartial(GetCipher(key.Length * 8))) 112Interop.Crypto.EvpCipherSetCcmNonceLength(ctx, nonce.Length); 117if (associatedData.Length != 0) 120Interop.Crypto.EvpCipherSetInputLength(ctx, ciphertext.Length);

System\Security\Cryptography\AesGcm.cs (1)

20AesAEAD.CheckKeySize(key.Length);

System\Security\Cryptography\AesGcm.OpenSsl.cs (3)

22_ctxHandle = Interop.Crypto.EvpCipherCreatePartial(GetCipher(key.Length * 8)); 46if (associatedData.Length != 0) 91if (associatedData.Length != 0)

System\Security\Cryptography\AesImplementation.cs (2)

90KeySizeValue = checked(BitsPerByte * key.Length); 258long keySize = rgbKey.Length * (long)BitsPerByte;

System\Security\Cryptography\AesImplementation.OpenSsl.cs (5)

23IntPtr algorithm = GetAlgorithm(key.Length * 8, feedback * 8, cipherMode); 38IntPtr algorithm = GetAlgorithm(key.Length * 8, feedback * 8, cipherMode); 61int keySizeInBits = key.Length * 8; 68key.Length * 8, 88checked(source.Length + AesBlockSizeBytes),

System\Security\Cryptography\Base64Transforms.cs (4)

54Debug.Assert(consumed == input.Length); 152int bytesToTransform = _inputIndex + inputBufferSpan.Length; 197int bytesToTransform = _inputIndex + inputBufferSpan.Length; 267return transformBuffer.Slice(0, index + inputBuffer.Length);

System\Security\Cryptography\ChaCha20Poly1305.cs (5)

28CheckKeySize(key.Length); 98if (plaintext.Length != ciphertext.Length) 101if (nonce.Length != NonceSizeInBytes) 104if (tag.Length != TagSizeInBytes)

System\Security\Cryptography\ChaCha20Poly1305.OpenSsl.cs (3)

20_ctxHandle = Interop.Crypto.EvpCipherCreatePartial(GetCipher(key.Length * 8)); 43if (associatedData.Length != 0) 88if (associatedData.Length != 0)

System\Security\Cryptography\ConcurrentSafeKmac.cs (8)

74if (hash.Length > MaxKmacStackAlloc) 76hashBuffer = new byte[hash.Length]; 80hashBuffer = hashBuffer.Slice(0, hash.Length); 88Debug.Assert(written == hash.Length); 103if (hash.Length > MaxKmacStackAlloc) 105hashBuffer = new byte[hash.Length]; 109hashBuffer = hashBuffer.Slice(0, hash.Length); 117Debug.Assert(written == hash.Length);

System\Security\Cryptography\CryptographicOperations.cs (6)

24/// values for <see cref="ReadOnlySpan{T}.Length"/> and the same contents, <c>false</c> 44if (left.Length != right.Length) 49int length = left.Length; 797if (hash.Length != hashSizeInBytes) 888if (hash.Length != hashSizeInBytes)

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

508byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length); 516Write(sharedBuffer, 0, buffer.Length); 520CryptographicOperations.ZeroMemory(sharedBuffer.AsSpan(0, buffer.Length));

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

898byte[] array = ArrayPool<byte>.Shared.Rent(data.Length); 903byte[] ret = HashData(array, 0, data.Length, hashAlgorithm); 909Array.Clear(array, 0, data.Length);

System\Security\Cryptography\EccKeyFormatHelper.cs (7)

134if (publicKeyBytes.Length == 0) 147if (publicKeyBytes.Length != 2 * key.PrivateKey.Length + 1) 195if (publicKeyBytes.Length == 0) 208if ((publicKeyBytes.Length & 0x01) != 1) 213int fieldWidth = publicKeyBytes.Length / 2; 325if (primeValue.Length > (MaxFieldBitSize / 8)) 438if (baseSpan[0] != 0x04 || baseSpan.Length != 2 * primeOrPoly.Length + 1)

System\Security\Cryptography\ECDsa.cs (7)

909hashSpan = HashData(data.ToArray(), 0, data.Length, hashAlgorithm); 1009byte[] array = ArrayPool<byte>.Shared.Rent(data.Length); 1015byte[] hash = HashData(array, 0, data.Length, hashAlgorithm); 1032Array.Clear(array, 0, data.Length); 1218byte[] array = ArrayPool<byte>.Shared.Rent(data.Length); 1223byte[] ret = HashData(array, 0, data.Length, hashAlgorithm); 1229Array.Clear(array, 0, data.Length);

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

14void* memory = NativeMemory.Alloc((nuint)key.Length); 15key.CopyTo(new Span<byte>(memory, key.Length)); 17_length = key.Length;

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

254byte[] array = ArrayPool<byte>.Shared.Rent(source.Length); 256HashCore(array, 0, source.Length); 257Array.Clear(array, 0, source.Length);

System\Security\Cryptography\HashProviderDispenser.Unix.cs (1)

71int ret = Interop.Crypto.EvpDigestOneShot(evpType, pSource, source.Length, pDestination, &length);

System\Security\Cryptography\Helpers.cs (12)

99for (int i = 0; i < s.Length; i++) 105uint cbHex = (uint)(s.Length - whitespaceCount) / 2; 111for (int i = 0; i < s.Length; i++) 172if (consumed != input.Length) 179return encodedOctetString.Slice(offset, primitive.Length); 187if (consumed != input.Length) 339return ref buffer.Length != 0 ? ref MemoryMarshal.GetReference(buffer) : ref Unsafe.AsRef<byte>((void*)1); 528context.Length + // Context 530hash.Length); // Hash 547message[1] = checked((byte)context.Length); 554message.Slice(2 + context.Length), 558hash.CopyTo(message.Slice(2 + context.Length + encodedOidLength));

System\Security\Cryptography\HKDF.cs (1)

125if (prk.Length < hashLength)

System\Security\Cryptography\HKDFManagedImplementation.cs (4)

34if (info.Length > MaxStackInfoBuffer) 36rentedTempInfoBuffer = CryptoPool.Rent(info.Length); 40tempInfoBuffer = tempInfoBuffer.Slice(0, info.Length); 81CryptoPool.Return(rentedTempInfoBuffer, clearSize: info.Length);

System\Security\Cryptography\HMACCommon.cs (1)

68if (key.Length > _blockSize && _blockSize > 0)

System\Security\Cryptography\HMACStatic.cs (2)

26if (hash.Length != THMAC.HashSizeInBytes) 174if (hash.Length != THMAC.HashSizeInBytes)

System\Security\Cryptography\IncrementalHash.cs (1)

476if (hash.Length != ih.HashLengthInBytes)

System\Security\Cryptography\KeyBlobHelpers.cs (2)

27if (span.Length > length) 33span.CopyTo(target.AsSpan(length - span.Length));

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

170if (hash.Length > MaxStackKmacSize) 172hashBuffer = new byte[hash.Length]; 176hashBuffer = hashBuffer.Slice(0, hash.Length);

System\Security\Cryptography\LiteHash.Unix.cs (4)

60Check(Interop.Crypto.EvpDigestUpdate(_ctx, data, data.Length)); 154Check(Interop.Crypto.EvpDigestUpdate(_ctx, data, data.Length)); 223_ctx = Interop.Crypto.HmacCreate(ref MemoryMarshal.GetReference(key), key.Length, algorithm); 240Check(Interop.Crypto.HmacUpdate(_ctx, data, data.Length));

System\Security\Cryptography\MLDsaImplementation.OpenSsl.cs (6)

150Debug.Assert(source.Length == algorithm.PublicKeySizeInBytes, $"Public key was expected to be {algorithm.PublicKeySizeInBytes} bytes, but was {source.Length} bytes."); 157Debug.Assert(source.Length == algorithm.PrivateKeySizeInBytes, $"Private key was expected to be {algorithm.PrivateKeySizeInBytes} bytes, but was {source.Length} bytes."); 164Debug.Assert(source.Length == algorithm.PrivateSeedSizeInBytes, $"Seed was expected to be {algorithm.PrivateSeedSizeInBytes} bytes, but was {source.Length} bytes.");

System\Security\Cryptography\MLKemImplementation.OpenSsl.cs (3)

41Debug.Assert(source.Length == algorithm.PrivateSeedSizeInBytes); 50Debug.Assert(source.Length == algorithm.DecapsulationKeySizeInBytes); 59Debug.Assert(source.Length == algorithm.EncapsulationKeySizeInBytes);

System\Security\Cryptography\OpenSslCipher.cs (4)

44Debug.Assert(input.Length > 0); 45Debug.Assert((input.Length % PaddingSizeInBytes) == 0); 51Debug.Assert((input.Length % PaddingSizeInBytes) == 0); 52Debug.Assert(input.Length <= output.Length);

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

39key.Length * 8, 66byte[] rented = CryptoPool.Rent(input.Length); 106byte[] tmp = CryptoPool.Rent(input.Length);

System\Security\Cryptography\PemEncoding.cs (45)

137if (pemData.Length < T.PreEBPrefix.Length + T.Ending.Length * 2 + T.PostEBPrefix.Length) 149int labelStartIndex = preebIndex + T.PreEBPrefix.Length; 180int contentStartIndex = preebEndIndex + T.Ending.Length; 181int postebLength = T.PostEBPrefix.Length + label.Length + T.Ending.Length; 198if (pemEndIndex < pemData.Length - 1 && 234int size = T.PostEBPrefix.Length + label.Length + T.Ending.Length; 237label.CopyTo(destination.Slice(T.PostEBPrefix.Length)); 238T.Ending.CopyTo(destination.Slice(T.PostEBPrefix.Length + label.Length)); 246Debug.Assert(startPosition <= str.Length); 267for (int index = 0; index < data.Length; index++) 309int end = str.Length - 1; 310for (; start < str.Length && IsWhiteSpaceCharacter(str[start], T.Whitespace); start++); 389Debug.Assert(Utf16PemEncoder.PostEBPrefix.Length == Utf8PemEncoder.PostEBPrefix.Length); 390Debug.Assert(Utf16PemEncoder.PreEBPrefix.Length == Utf8PemEncoder.PreEBPrefix.Length); 391Debug.Assert(Utf16PemEncoder.Ending.Length == Utf8PemEncoder.Ending.Length); 395int preebLength = Utf16PemEncoder.PreEBPrefix.Length + labelLength + Utf16PemEncoder.Ending.Length; 396int postebLength = Utf16PemEncoder.PostEBPrefix.Length + labelLength + Utf16PemEncoder.Ending.Length; 463int encodedSize = GetEncodedSize(label.Length, data.Length); 526int encodedSize = GetEncodedSize(utf8Label.Length, data.Length); 580int encodedSize = GetEncodedSize(utf8Label.Length, data.Length); 595return str.Length; 607while (remainingData.Length >= BytesPerLine) 614Debug.Assert(remainingData.Length < BytesPerLine); 616if (remainingData.Length > 0) 664int encodedSize = GetEncodedSize(label.Length, data.Length); 707int encodedSize = GetEncodedSize(label.Length, data.Length); 792Debug.Assert(bytesConsumed == bytes.Length);

System\Security\Cryptography\RandomNumberGenerator.cs (7)

351Debug.Assert(choices.Length > 0); 356if (choices.Length <= 256) 362if (BitOperations.IsPow2(choices.Length)) 368int mask = choices.Length - 1; 394int mask = (int)BitOperations.RoundUpToPowerOf2((uint)choices.Length) - 1; 417if (masked < (uint)choices.Length) 433destination[i] = choices[GetInt32(choices.Length)];

System\Security\Cryptography\Rfc2898DeriveBytes.cs (1)

115_salt = new byte[salt.Length + sizeof(uint)];

System\Security\Cryptography\Rfc2898DeriveBytes.OneShot.cs (1)

279int maxEncodedSize = s_throwingUtf8Encoding.GetMaxByteCount(password.Length);

System\Security\Cryptography\RSA.cs (5)

318byte[] array = ArrayPool<byte>.Shared.Rent(data.Length); 322result = HashData(array, 0, data.Length, hashAlgorithm); 326Array.Clear(array, 0, data.Length); 879using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length)) 952using (MemoryManager<byte> manager = new PointerMemoryManager<byte>(ptr, source.Length))

System\Security\Cryptography\RSACryptoServiceProvider.Unix.cs (1)

67if (data.Length != (KeySize / 8))

System\Security\Cryptography\SlhDsaImplementation.OpenSsl.cs (4)

99Debug.Assert(source.Length == algorithm.PublicKeySizeInBytes, $"Public key was expected to be {algorithm.PublicKeySizeInBytes} bytes, but was {source.Length} bytes."); 109Debug.Assert(source.Length == algorithm.PrivateKeySizeInBytes, $"Private key was expected to be {algorithm.PrivateKeySizeInBytes} bytes, but was {source.Length} bytes.");

System\Security\Cryptography\SP800108HmacCounterKdfImplementationManaged.cs (1)

16_key = GC.AllocateArray<byte>(key.Length, pinned: true);

System\Security\Cryptography\SymmetricAlgorithm.cs (9)

228long bitLength = key.Length * 8L; 522byte[] decryptBuffer = GC.AllocateUninitializedArray<byte>(ciphertext.Length); 638int ciphertextLength = GetCiphertextLengthEcb(plaintext.Length, paddingMode); 772byte[] decryptRent = ArrayPool<byte>.Shared.Rent(ciphertext.Length); 773Span<byte> decryptBuffer = decryptRent.AsSpan(0, ciphertext.Length); 925int ciphertextLength = GetCiphertextLengthCbc(plaintext.Length, paddingMode); 1124byte[] decryptBuffer = GC.AllocateUninitializedArray<byte>(ciphertext.Length); 1361int ciphertextLength = GetCiphertextLengthCfb(plaintext.Length, paddingMode, feedbackSizeInBits); 1673if (iv.Length != BlockSize >> 3)

System\Security\Cryptography\SymmetricPadding.cs (5)

38int count = block.Length; 167if (block.Slice(block.Length - padBytes, padBytes - 1).ContainsAnyExcept((byte)0)) 194for (int i = block.Length - padBytes; i < block.Length - 1; i++) 213return block.Length - padBytes;

System\Security\Cryptography\UniversalCryptoDecryptor.cs (10)

54Debug.Assert(inputBuffer.Length >= _heldoverCipher.Length); 55inputBuffer.Slice(inputBuffer.Length - _heldoverCipher.Length).CopyTo(_heldoverCipher); 56inputBuffer = inputBuffer.Slice(0, inputBuffer.Length - _heldoverCipher.Length); 57Debug.Assert(inputBuffer.Length % InputBlockSize == 0, "Did not remove whole blocks for depadding"); 60if (inputBuffer.Length > 0) 71if (inputBuffer.Length % PaddingSizeBytes != 0) 88rentedCiphertextSize = inputBuffer.Length; 89rentedCiphertext = CryptoPool.Rent(inputBuffer.Length); 90ciphertext = rentedCiphertext.AsSpan(0, inputBuffer.Length); 95rentedCiphertextSize = _heldoverCipher.Length + inputBuffer.Length;

System\Security\Cryptography\UniversalCryptoOneShot.cs (10)

20if (input.Length % cipher.PaddingSizeInBytes != 0) 38if (output.Length >= input.Length) 69if (!depaddingRequired || input.Length - cipher.BlockSizeInBytes > output.Length) 84if (input.Length <= MaxInStackDecryptionBuffer) 116Debug.Assert(input.Length > cipher.BlockSizeInBytes); 129Debug.Assert(paddedBlock.Length % cipher.BlockSizeInBytes == 0); 130Debug.Assert(paddedBlock.Length <= MaxInStackDecryptionBuffer); 167byte[] rentedBuffer = CryptoPool.Rent(input.Length); 168Span<byte> buffer = rentedBuffer.AsSpan(0, input.Length); 210int ciphertextLength = SymmetricPadding.GetCiphertextLength(input.Length, cipher.PaddingSizeInBytes, paddingMode);

System\Security\Cryptography\X509Certificates\Asn1\CertificateAsn.xml.cs (1)

84decoded.SignatureValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\X509Certificates\Asn1\CertificationRequestAsn.xml.cs (1)

84decoded.SignatureValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\X509Certificates\Asn1\CertificationRequestInfoAsn.xml.cs (1)

113decoded.Subject = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\X509Certificates\Asn1\DistributionPointNameAsn.xml.cs (1)

147decoded.NameRelativeToCRLIssuer = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\X509Certificates\Asn1\PolicyInformationAsn.xml.cs (1)

101decoded.PolicyQualifiers = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\X509Certificates\Asn1\TbsCertificateAsn.xml.cs (5)

213decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 221decoded.Issuer = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 229decoded.Subject = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 237decoded.IssuerUniqueId = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 252decoded.SubjectUniqueId = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\X509Certificates\CertificateRequest.cs (5)

1018if (serialNumber.Length < 1) 1114newSerialNumber = CryptoPool.Rent(serialNumber.Length + 1); 1117return new ArraySegment<byte>(newSerialNumber, 0, serialNumber.Length + 1); 1122while (leadingZeros < serialNumber.Length - 1 && serialNumber[leadingZeros] == 0 && serialNumber[leadingZeros + 1] < 0x80) 1127int contentLength = serialNumber.Length - leadingZeros;

System\Security\Cryptography\X509Certificates\CertificateRequest.Load.cs (1)

142int encodedLength = outer.PeekEncodedValue().Length;

System\Security\Cryptography\X509Certificates\CertificateRevocationListBuilder.cs (1)

140if (serialNumber.Length > 1)

System\Security\Cryptography\X509Certificates\CertificateRevocationListBuilder.Load.cs (1)

95payloadLength = reader.PeekEncodedValue().Length;

System\Security\Cryptography\X509Certificates\OpenSslPkcsFormatReader.cs (2)

32if (Interop.Crypto.BioWrite(bio, rawData) != rawData.Length) 168if (Interop.Crypto.BioWrite(bio, rawData) != rawData.Length)

System\Security\Cryptography\X509Certificates\OpenSslX509CertificateReader.cs (2)

159rawData.Length); 211if (Interop.Crypto.BioWrite(bio, rawData) != rawData.Length)

System\Security\Cryptography\X509Certificates\PublicKey.cs (1)

467read = reader.PeekEncodedValue().Length;

System\Security\Cryptography\X509Certificates\X500DistinguishedName.cs (1)

148var rdn = new X500RelativeDistinguishedName(rawDataMemory.Slice(offset, encodedValue.Length));

System\Security\Cryptography\X509Certificates\X500NameEncoder.cs (6)

207int end = chars.Length; 446valueStart = chars.Length; 479if (str.Length > OidTagPrefix.Length) 499Span<char> destination = chars.Length > MaxStackAllocSize ? 500new char[chars.Length] : 562Debug.Assert(destination.Length >= chars.Length);

System\Security\Cryptography\X509Certificates\X500RelativeDistinguishedName.cs (1)

67_singleElementValue = rawData.Slice(offset, firstValue.Length);

System\Security\Cryptography\X509Certificates\X509Certificate2.cs (4)

412if (rawData.Length == 0) 1776match = match.Slice(0, match.Length - 1); 1807embeddedSpan = embeddedSpan.Slice(0, embeddedSpan.Length - 1); 1810if (allowWildcards && embeddedSpan.StartsWith("*.") && embeddedSpan.Length > 2)

System\Security\Cryptography\X509Certificates\X509Certificate2Collection.cs (1)

731int maxDecodedLength = checked(thumbprintHex.Length + 1) / 2;

System\Security\Cryptography\X509Certificates\X509CertificateLoader.netcore.cs (1)

54using (PointerMemoryManager<byte> manager = new(pinned, data.Length))

System\Security\Cryptography\X509Certificates\X509CertificateLoader.Unix.cs (6)

129using (PointerMemoryManager<byte> manager = new(ptr, data.Length)) 313for (int certBagIdx = certBags.Length - 1; certBagIdx >= 0; certBagIdx--) 336for (int i = 0; i < keyBags.Length; i++) 412for (int i = 0; i < keyBags.Length; i++) 574Debug.Assert(bytesRead == pkcs8.Length); 711Debug.Assert(bytesRead == pkcs8.Length);

System\Security\Cryptography\X509Certificates\X509SubjectAlternativeNameExtension.cs (1)

100Debug.Assert(value.Length is 4 or 16);

System\Security\Cryptography\X509Certificates\X509SubjectKeyIdentifierExtension.cs (1)

127if (subjectKeyIdentifier.Length == 0)

System\Security\Cryptography\XmlKeyHelper.cs (2)

125Debug.Assert(value.Length > 0); 133int length = value.Length;

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)) 447CoseHelpers.WriteByteStringLength(toBeSignedBuilder, (ulong)contentBytes.Length); 521Debug.Assert(signProtected.Length == 0); 532Debug.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 (10)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\Security\Cryptography\Asn1\AlgorithmIdentifierAsn.manual.cs (2)

49if (span.Length != 2) 104if (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)

118decoded.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)

131decoded.ExtnValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

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

108bytesWritten = source.Length; 267if (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)

52if (passwordBytes.Length > 0 && password.Length == 0) 76Debug.Assert(destination.Length >= encryptedData.Length); 156if (password.IsEmpty && passwordBytes.Length > 0) 177if (passwordBytes.Length > 0 || password.Length == 0) 334if (passwordBytes.Length == 0 && password.Length > 0) 338else if (passwordBytes.Length == 0) 344pwdTmpBytes = new byte[passwordBytes.Length]; 354Debug.Assert(password.Length > 0 || passwordBytes.IsEmpty); 377if (passwordBytes.Length > 0) 379Debug.Assert(pwdTmpBytes!.Length == passwordBytes.Length); 382else if (password.Length > 0) 462if (passwordBytes.Length > 0 || password.Length == 0) 707if (!gotIv || bytesWritten != length || consumed != source.Length) 772byte[] tmpPassword = new byte[password.Length]; 923byte[] tmpKey = new byte[key.Length]; 924byte[] tmpIv = new byte[iv.Length]; 925byte[] rentedEncryptedData = CryptoPool.Rent(encryptedData.Length); 948encryptedData.Length, 971CryptoPool.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)

128decoded.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)

163decoded.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)

171decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 197decoded.Nonce = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\CmsSignature.cs (11)

196if (val.Length > fieldSize && val[0] == 0) 201if (val.Length <= fieldSize) 203val.CopyTo(ieeeSignature.Slice(fieldSize - val.Length, val.Length)); 208if (val.Length > fieldSize && val[0] == 0) 213if (val.Length <= fieldSize) 215val.CopyTo(ieeeSignature.Slice(fieldSize + fieldSize - val.Length, val.Length)); 232int fieldSize = ieeeSignature.Length / 2; 235fieldSize * 2 == ieeeSignature.Length, 236$"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 (10)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (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)

61int right = encodingNameIndices.Length - 2; 65Debug.Assert(encodingNameIndices.Length == CodePagesByName.Length + 1); 66Debug.Assert(encodingNameIndices[encodingNameIndices.Length - 1] == EncodingNames.Length); 76Debug.Assert(index < encodingNameIndices.Length - 1); 98Debug.Assert(left < encodingNameIndices.Length - 1); 137Debug.Assert(MappedCodePages.Length + 1 == indices.Length); 138Debug.Assert(indices[indices.Length - 1] == names.Length); 156Debug.Assert(i < indices.Length - 1);

System\Text\ISO2022Encoding.cs (1)

403if (bTrailByte < 0x21 || bTrailByte >= 0x21 + HalfToFullWidthKanaTable.Length)

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_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;

RegexGenerator.g.cs (13)

91base.runtextpos != inputSpan.Length) 110if (pos <= inputSpan.Length - 3) 115for (int i = 0; i < span.Length - 2; i++) 127if ((uint)(i + 1) >= (uint)span.Length) 142base.runtextpos = inputSpan.Length; 166iteration = slice.Length - 1; 179if ((uint)slice.Length < 2 || slice[1] != '}') 230base.runtextpos != inputSpan.Length) 248if (pos <= inputSpan.Length - 4) 253for (int i = 0; i < span.Length; i++) 264base.runtextpos = inputSpan.Length; 285iteration = slice.Length; 334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_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 (24)

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)

206Span<char> charBuffer = utf8Key.Length <= JsonConstants.StackallocCharThreshold ? 208(rentedBuffer = ArrayPool<char>.Shared.Rent(utf8Key.Length)); 310Debug.Assert(left.Length > 0 && right.Length > 0); 327(nDigits = (leftIntegral.Length + leftFractional.Length)) != 328rightIntegral.Length + rightFractional.Length) 343int diff = leftIntegral.Length - rightIntegral.Length; 350int rightOffset = rightIntegral.Length + diff; 366int leftOffset = leftIntegral.Length - diff; 376Debug.Assert(leftFirst.Length == rightFirst.Length); 377Debug.Assert(leftMiddle.Length == rightMiddle.Length); 378Debug.Assert(leftLast.Length == rightLast.Length); 405Debug.Assert(span.Length > 0); 450Debug.Assert(span.Length >= 10); 465Debug.Assert(intg.Length == 1, "Leading zeros not permitted in JSON numbers."); 485exp += intg.Length - fz; 491exp -= frac.Length; 510return firstNonZero < 0 ? span.Length - 1 : firstNonZero - 1; 528return 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 (18)

48for (; i < span.Length; i++) 84for (; i < span.Length; i++) 155if (!JsonHelpers.IsValidDateTimeOffsetParseLength(segment.Length)) 181Debug.Assert(source.Length <= JsonConstants.MaximumEscapedDateTimeOffsetParseLength); 203if (!JsonHelpers.IsValidDateTimeOffsetParseLength(segment.Length)) 229Debug.Assert(source.Length <= JsonConstants.MaximumEscapedDateTimeOffsetParseLength); 251if (segment.Length > JsonConstants.MaximumEscapedGuidLength) 265if (segment.Length == JsonConstants.MaximumFormatGuidLength 278Debug.Assert(source.Length <= JsonConstants.MaximumEscapedGuidLength); 301if (span.Length == 3) 309else if (span.Length == 8) 317else if (span.Length == 9) 333if (span.Length == 3) 341else if (span.Length == 8) 349else if (span.Length == 9) 364if (span.Length == 3) 372else if (span.Length == 8) 380else 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); 358Debug.Assert(destination.Length >= source.Length); 369Debug.Assert(idx >= 0 && idx < source.Length); 371Debug.Assert(destination.Length >= source.Length); 393Debug.Assert(idx >= 0 && idx < source.Length); 444Debug.Assert(source.Length >= idx + 5); 462if (source.Length < idx + 7 || source[idx + 1] != '\\' || source[idx + 2] != 'u') 499if (++idx == source.Length) 510nextUnescapedSegmentLength = remaining.Length; 540Debug.Assert(idx == source.Length || source[idx] == JsonConstants.BackSlash); 542if (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 (19)

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\PropertyRef.cs (10)

System\Text\Json\Serialization\PipeReadBufferState.cs (7)

105if (_sequence.First.Length >= JsonConstants.Utf8Bom.Length) 109_sequence = _sequence.Slice((byte)JsonConstants.Utf8Bom.Length); 117while (matched < JsonConstants.Utf8Bom.Length && _sequence.TryGet(ref pos, out ReadOnlyMemory<byte> mem, advance: true)) 120for (int i = 0; i < span.Length && matched < JsonConstants.Utf8Bom.Length; i++, matched++) 130if (matched == JsonConstants.Utf8Bom.Length) 132_sequence = _sequence.Slice(JsonConstants.Utf8Bom.Length);

System\Text\Json\Serialization\StreamReadBufferState.cs (4)

46_buffer = ArrayPool<byte>.Shared.Rent(Math.Max(initialBufferSize, JsonConstants.Utf8Bom.Length)); 180Debug.Assert(_buffer.Length >= JsonConstants.Utf8Bom.Length); 183_offset = (byte)JsonConstants.Utf8Bom.Length; 184_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 (35)

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\Common\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(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\Collections\Generic\ValueListBuilder.cs (8)

69if (source.Length == 1 && (uint)pos < (uint)span.Length) 83if ((uint)(_pos + source.Length) > (uint)_span.Length) 85Grow(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 (10)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

System\Text\RegularExpressions\Regex.Count.cs (1)

38Count(input, RightToLeft ? input.Length : 0);

System\Text\RegularExpressions\Regex.cs (5)

434int stoppos = span.Length; 466Debug.Assert(startat <= input.Length); 487if (runner.runtextstart == input.Length) 529Debug.Assert((uint)startat <= (uint)inputSpan.Length); 576int 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)

284for (i = 0; i < set.Length - 1; i += 2) 289if (i < set.Length) 1122return (uint)chDiv8 < (uint)ascii.Length ? 1190return (uint)chDiv8 < (uint)ascii.Length ? 1348for (int i = 0; i < categorySetSegment.Length; i++) 1519for (int index = 0; index < chars.Length - 1; index++) 1525switch (chars.Length) 1556int count = chars.Length * 2; 1557if (chars[chars.Length - 1] == LastChar) 1962Span<char> invertedGroup = group.Length <= scratch.Length ? scratch.Slice(0, group.Length) : new char[group.Length]; 1963for (int i = 0; i < group.Length; i++)

System\Text\RegularExpressions\RegexCompiler.cs (3)

6410Debug.Assert(chars.Length > 3, $"chars.Length == {chars.Length}"); 6414if (chars.Length is 4 or 5 && !Ascii.IsValid(chars))

System\Text\RegularExpressions\RegexFindOptimizations.cs (33)

System\Text\RegularExpressions\RegexInterpreter.cs (8)

217if (inputSpan.Length - runtextpos < c) 257if (inputSpan.Length - runtextpos < length) 355if (TryMatchAtCurrentPosition(text) || runtextpos == text.Length) 742if ((uint)m1 < (uint)inputSpan.Length && inputSpan[m1] != '\n') 753if ((uint)runtextpos < (uint)inputSpan.Length && inputSpan[runtextpos] != '\n') 812if (runtextpos < inputSpan.Length - 1 || ((uint)runtextpos < (uint)inputSpan.Length && inputSpan[runtextpos] != '\n')) 821if (runtextpos < inputSpan.Length)

System\Text\RegularExpressions\RegexNode.cs (9)

1361Debug.Assert(startingSpan.Length > 0); 1383if (startingSpan.Length != 1) 1393int minLength = Math.Min(startingSpan.Length, startingNode.Str.Length); 1414Debug.Assert(startingSpan.Length > 0); 1420var prefix = startingSpan.Length == 1 ? 1437Debug.Assert(startingSpan.Length == 1); 1446if (node.Str!.Length == startingSpan.Length) 1451else if (node.Str.Length - 1 == startingSpan.Length) 1459node.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 (12)

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])); 427return (uint)indexMinus1 >= (uint)inputSpan.Length || !RegexCharClass.IsBoundaryWordChar(inputSpan[indexMinus1]); 434(uint)index >= (uint)inputSpan.Length || !RegexCharClass.IsBoundaryWordChar(inputSpan[index]); 448return ((uint)indexM1 < (uint)inputSpan.Length && RegexCharClass.IsECMAWordChar(inputSpan[indexM1])) != 449((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)

153if (sets.Length == 0) 159for (int i = 1; i < sets.Length; i++) 172if (sets.Length == 0) 178for (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}"); 497int lengthMinus1 = input.Length - 1; 515innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length; 523if (done || pos >= input.Length) 581innerLoopLength = _checkTimeout && input.Length - pos > DfaCharsPerTimeoutCheck ? pos + DfaCharsPerTimeoutCheck : input.Length; 589innerLoopLength = _checkTimeout && input.Length - pos > NfaCharsPerTimeoutCheck ? pos + NfaCharsPerTimeoutCheck : input.Length; 596if (done || pos >= input.Length) 638if (pos == input.Length) 663if (pos == input.Length) 696if (pos + 1 < input.Length) 866Debug.Assert(matchStartBoundary >= 0 && matchStartBoundary <= input.Length, $"{nameof(matchStartBoundary)} == {matchStartBoundary}"); 1484if ((uint)pos < (uint)input.Length) 1488return c == '\n' && pos == input.Length - 1 && matcher._containsEndZAnchor ? 1502(uint)pos < (uint)input.Length ? 1560Debug.Assert(pos == input.Length); 1591Debug.Assert(pos == input.Length); 1621Debug.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 (3)

521Debug.Assert(chars.Length > 3); 527return chars.Length > 5 || Ascii.IsValid(chars) 5691if ((uint)cat < (uint)categoryDescriptions.Length &&

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

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

src\libraries\Common\src\System\Buffers\SearchValuesPolyfills.cs (2)

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

src\libraries\Common\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(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 (12)

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 226Span<char> result = (bytes.Length > 16) ? 227new char[bytes.Length * 2].AsSpan() : 228stackalloc char[bytes.Length * 2]; 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

src\libraries\Common\src\System\MemoryExtensionsPolyfills.cs (1)

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

src\libraries\Common\src\System\Text\AsciiPolyfills.cs (1)

21int length = value.Length;

src\libraries\Common\src\System\Text\EncodingPolyfills.cs (6)

17return encoding.GetByteCount(charsPtr, chars.Length); 25return encoding.GetCharCount(bytesPtr, bytes.Length); 39return encoding.GetBytes(charsPtr, chars.Length, bytesPtr, bytes.Length); 48return encoding.GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length); 56return encoding.GetString(bytesPtr, bytes.Length); 79return ref buffer.Length != 0 ? ref MemoryMarshal.GetReference(buffer) : ref Unsafe.AsRef<T>((void*)1);

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_pos += value.Length;

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (13)

284for (i = 0; i < set.Length - 1; i += 2) 289if (i < set.Length) 1122return (uint)chDiv8 < (uint)ascii.Length ? 1190return (uint)chDiv8 < (uint)ascii.Length ? 1348for (int i = 0; i < categorySetSegment.Length; i++) 1519for (int index = 0; index < chars.Length - 1; index++) 1525switch (chars.Length) 1556int count = chars.Length * 2; 1557if (chars[chars.Length - 1] == LastChar) 1962Span<char> invertedGroup = group.Length <= scratch.Length ? scratch.Slice(0, group.Length) : new char[group.Length]; 1963for (int i = 0; i < group.Length; i++)

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexFindOptimizations.cs (1)

898if (c >= frequency.Length)

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexNode.cs (9)

1361Debug.Assert(startingSpan.Length > 0); 1383if (startingSpan.Length != 1) 1393int minLength = Math.Min(startingSpan.Length, startingNode.Str.Length); 1414Debug.Assert(startingSpan.Length > 0); 1420var prefix = startingSpan.Length == 1 ? 1437Debug.Assert(startingSpan.Length == 1); 1446if (node.Str!.Length == startingSpan.Length) 1451else if (node.Str.Length - 1 == startingSpan.Length) 1459node.Str = node.Str.Substring(startingSpan.Length);

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexParser.cs (3)

166ValueStringBuilder vsb = input.Length <= (EscapeMaxBufferSize / 3) ? 168new ValueStringBuilder(input.Length + 200); 205indexOfMetachar = input.Length;

Stubs.cs (3)

22return stringBuilder.Append(ptr, span.Length); 48int length = Math.Min(span.Length, other.Length);

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

187Debug.Assert(utf8Destination.Length >= (source.Length * 2)); 196for (int pos = 0; pos < source.Length; pos++) 204Debug.Assert(destination.Length >= (source.Length * 2)); 213for (int pos = 0; pos < source.Length; pos++) 223return string.Create(bytes.Length * 2, args, static (chars, args) => 456Debug.Assert((utf8Source.Length % 2) == 0, "Un-even number of characters provided"); 457Debug.Assert((utf8Source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 491Debug.Assert((source.Length % 2) == 0, "Un-even number of characters provided"); 492Debug.Assert((source.Length / 2) == destination.Length, "Target buffer not right-sized for provided characters"); 527return (c >= CharToHexLookup.Length) ? 0xFF : CharToHexLookup[c];

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

212if (pos > _chars.Length - value.Length) 214Grow(value.Length); 218_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));

RegexGenerator.g.cs (4)

69base.runtextpos != inputSpan.Length) 87if ((uint)pos < (uint)inputSpan.Length) 100base.runtextpos = inputSpan.Length; 116while ((uint)iteration < (uint)slice.Length && !char.IsWhiteSpace(slice[iteration]))

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)

137var objectProperties = new PropertyDescriptorCollection[objects.Length]; 145for (int i = 0; i < objects.Length; i++) 168var 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)

RegexGenerator.g.cs (4)

69base.runtextpos != inputSpan.Length) 87if ((uint)pos < (uint)inputSpan.Length) 100base.runtextpos = inputSpan.Length; 116while ((uint)iteration < (uint)slice.Length && !char.IsWhiteSpace(slice[iteration]))

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.byte.InlineArrays.g.cs (1)

60 int initLength = value.Length;

Windows.Win32.char.InlineArrays.g.cs (10)

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

90 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

85 this.SetFileTypes((uint )rgFilterSpec.Length, rgFilterSpecLocal);

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

85 this.SetFileTypes((uint )rgFilterSpec.Length, rgFilterSpecLocal);

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

85 this.SetFileTypes((uint )rgFilterSpec.Length, rgFilterSpecLocal);

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

Windows.Win32.int.InlineArrays.g.cs (1)

60 int initLength = value.Length;

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

83 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

1239 this.AddPropertyChangedEventHandlerNativeArray(element, scope, cacheRequest, handler, propertyArrayLocal, propertyArray.Length); 1587 winmdroot.System.Com.SAFEARRAY* __result = this.IntNativeArrayToSafeArray(arrayLocal, array.Length);

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

94 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

82 if (rgszNames.Length != rgDispId.Length) throw new ArgumentException();

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

112 winmdroot.Foundation.BOOL __result = PInvoke.ExtTextOut(hdc, x, y, options, lprect.HasValue ? &lprectLocal : null, lpStringLocal, (uint )lpDx.Length, lpDxLocal); 518 winmdroot.Foundation.BOOL __result = PInvoke.LPtoDP(hdc, lpptLocal, lppt.Length);

Windows.Win32.PInvoke.USER32.dll.g.cs (4)

367 winmdroot.UI.WindowsAndMessaging.HACCEL __result = PInvoke.CreateAcceleratorTable(paccelLocal, paccel.Length); 2446 winmdroot.Foundation.WAIT_EVENT __result = PInvoke.MsgWaitForMultipleObjectsEx((uint )pHandles.Length, pHandlesLocal, dwMilliseconds, dwWakeMask, dwFlags); 2903 uint __result = PInvoke.SendInput((uint )pInputs.Length, pInputsLocal, cbSize); 3162 if (lpKeyState.Length < 256) throw new ArgumentException();

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

48 winmdroot.Foundation.HRESULT __result = @this.AddPropertyChangedEventHandlerNativeArray(element, scope, cacheRequest, handler, propertyArrayLocal, propertyArray.Length); 60 winmdroot.Foundation.HRESULT __result = @this.IntNativeArrayToSafeArray(arrayLocal, array.Length, safeArrayLocal);

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

28 winmdroot.Foundation.HRESULT __result = @this.SetFileTypes((uint )rgFilterSpec.Length, rgFilterSpecLocal);

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

28 winmdroot.Foundation.HRESULT __result = @this.SetFileTypes((uint )rgFilterSpec.Length, rgFilterSpecLocal);

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

28 winmdroot.Foundation.HRESULT __result = @this.SetFileTypes((uint )rgFilterSpec.Length, rgFilterSpecLocal);

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

RegexGenerator.g.cs (6)

71base.runtextpos != inputSpan.Length) 89if (pos <= inputSpan.Length - 3) 94for (int i = 0; i < span.Length - 2; i++) 106if ((uint)(i + 2) >= (uint)span.Length) 122base.runtextpos = inputSpan.Length; 135if ((uint)slice.Length < 3 ||

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

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

RegexGenerator.g.cs (22)

120base.runtextpos != inputSpan.Length) 138if (pos <= inputSpan.Length - 14) 151base.runtextpos = inputSpan.Length; 175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration])) 202iteration1 = slice.Length; 280base.runtextpos = inputSpan.Length; 292if (pos <= inputSpan.Length - 3) 302base.runtextpos = inputSpan.Length; 326iteration = slice.Length; 349iteration1 = slice.Length - 1; 362if (2 < slice.Length || (1 < slice.Length && slice[1] != '\n')) 412base.runtextpos != inputSpan.Length) 430if (pos <= inputSpan.Length - 4) 433if (pos < inputSpan.Length - 5) 435base.runtextpos = inputSpan.Length - 5; 441base.runtextpos = inputSpan.Length; 506if ((uint)slice.Length < 2) 516if ((uint)slice.Length < 3 || slice[2] != 't') 528if ((uint)slice.Length < 3 || slice[2] != 'r') 577if (pos < inputSpan.Length - 1 || ((uint)pos < (uint)inputSpan.Length && inputSpan[pos] != '\n'))

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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)

125if (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\Compiler\Core\Utilities\StringBreaker.cs (2)

25for (var start = 0; start < text.Length;) 43var length = identifier.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)