Slice

ConsoleLogs\AnsiParser.cs (1)

281var paramsEndPosition = span.Slice(2).IndexOfAnyInRange('@', '~');

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

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

Linker\TypeReferenceExtensions.cs (1)

395if (!name.Slice(name.Length - type.Name.Length).Equals(type.Name.AsSpan(), StringComparison.Ordinal))

INamedTypeSymbolExtensions.cs (1)

22var currentName = dot < 0 ? roSpan : roSpan.Slice(dot + 1);

ResponseTests.cs (1)

3437source = source.Slice(charsUsed);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

133value = value.Slice(lastSlashIndex + 1);

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

147get => this.CurrentSpan.Slice(this.CurrentSpanIndex);

Extensions\HttpResponseWritingExtensions.cs (1)

116source = source.Slice(charsUsed);

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

189buffer = buffer.Slice(charsUsed);

IPNetwork.cs (1)

199if (!int.TryParse(networkSpan.Slice(forwardSlashIndex + 1), out prefixLength))

CookieRequestCultureProvider.cs (2)

88var cultureName = potentialCultureName.Slice(_culturePrefix.Length); 89var uiCultureName = potentialUICultureName.Slice(_uiCulturePrefix.Length);

TagHelpers\UrlResolutionTagHelper.cs (1)

293url = url.Slice(start);

Rendering\TagBuilder.cs (1)

193remainingName = remainingName.Slice(indexOfInvalidCharacter + 1);

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

189buffer = buffer.Slice(charsUsed);

FormatterBinaryWriter.cs (1)

203value = value.Slice(start: toWrite);

RecyclableSequenceBuilder.cs (1)

107buffer = buffer.Slice(toWrite);

EndToEndBenchmarks.cs (2)

85value = value.Slice(bytes); 101value = value.Slice(bytes);

Constraints\FileNameRouteConstraint.cs (1)

133value = value.Slice(lastSlashIndex + 1);

Matching\HostMatcherPolicy.cs (2)

101port = host.Slice(pivot + 1); 113MemoryExtensions.EndsWith(requestHost, host.Slice(WildcardHost.Length), StringComparison.OrdinalIgnoreCase))

RequestProcessing\Request.cs (1)

538if (transferEncoding.AsSpan().Slice(index + 1).Trim().Equals("chunked", StringComparison.OrdinalIgnoreCase))

UrlPrefix.cs (1)

131var portValueString = portString.Slice(1); // Trim the leading ":"

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

Core\IISHttpContext.cs (1)

913if (transferEncoding.AsSpan().Slice(index + 1).Trim().Equals("chunked", StringComparison.OrdinalIgnoreCase))

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

Internal\Http\HttpHeaders.cs (10)

378value = value.Slice(offset); 391byteValue = byteValue.Slice(sizeof(ulong)); 396byteValue = byteValue.Slice(sizeof(ulong)); 411byteValue = byteValue.Slice(sizeof(ulong)); 437value = value.Slice(offset); 474value = value.Slice(offset); 565values = values.Slice(offset); 574byteValue = byteValue.Slice(sizeof(ulong)); 598values = values.Slice(offset); 631values = values.Slice(offset);

Internal\Http\HttpParser.cs (3)

118var index = requestLine.Slice(offset).IndexOfAny(ByteSpace, ByteQuestionMark, BytePercentage); 126index = requestLine.Slice(offset).IndexOfAny(ByteSpace, ByteQuestionMark); 175var remaining = requestLine.Slice(offset);

Internal\Http2\Http2FrameWriter.cs (1)

628dataToFrame = dataToFrame.Slice(currentSize);

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

19buffer = buffer.Slice(aLength);

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

19buffer = buffer.Slice(aLength);

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

240source = source.Slice(charsUsed);

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

147source = source.Slice(writable);

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

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

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

189buffer = buffer.Slice(charsUsed);

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

189buffer = buffer.Slice(charsUsed);

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

189buffer = buffer.Slice(charsUsed);

FormPipeReader.cs (2)

175span = span.Slice(keyValuePair.Length + andDelimiter.Length); 219value = keyValuePair.Slice(equals + equalsDelimiter.Length);

HttpResponseStreamWriter.cs (1)

156value = value.Slice(written);

QueryHelpers.cs (1)

89anchorText = uriToBeAppended.Slice(anchorIndex);

Hashing\XxHashShared.cs (2)

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

InternalUtilities\LittleEndianReader.cs (5)

26_span = _span.Slice(sizeof(uint)); 33_span = _span.Slice(sizeof(byte)); 40_span = _span.Slice(sizeof(ushort)); 47_span = _span.Slice(byteCount); 54_span = _span.Slice(sizeof(int));

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

CSharpParseOptions.cs (1)

221singleNamespaceBuilder.Add(@namespace.Slice(currentIndex).ToString());

Attributes\AttributeTests_WellKnownAttributes.cs (1)

40var methodName = spanName.Slice(lastDotIndex + 1);

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (1)

209span = span.Slice(end);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

src\Compilers\Core\Portable\InternalUtilities\LittleEndianReader.cs (5)

26_span = _span.Slice(sizeof(uint)); 33_span = _span.Slice(sizeof(byte)); 40_span = _span.Slice(sizeof(ushort)); 47_span = _span.Slice(byteCount); 54_span = _span.Slice(sizeof(int));

XxHash128Tests.cs (2)

113input = input.Slice(slice.Length); 142var low = BinaryPrimitives.ReadUInt64BigEndian(span.Slice(8));

PrimitiveColumnContainer.BinaryOperations.cs (3)

139arithmetic.HandleOperation(operation, leftSpan.Slice(availableInRetSpan), rightSpan.Slice(availableInRetSpan), nextRetSpan); 181arithmetic.HandleOperation(operation, leftSpan.Slice(availableInRetSpan), right, nextRetSpan);

src\RpmHeader.cs (3)

79Type = (RpmHeaderEntryType)BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(4)), 80Offset = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(8)), 81Count = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(12))

Helpers.cs (1)

50return value.Slice(wordStart.Value);

Common\NGramExtensions.cs (1)

41input = input.Slice(1);

Utilities\JsonOutputFixer.cs (1)

29trimmed = trimmed.Slice(markerLength);

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

162data = data.Slice(i);

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

368fieldValue = line.Slice(colonPos + 1); 371fieldValue = fieldValue.Slice(1);

Internal\HybridCachePayload.cs (7)

205entropy = BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(2)); 206long creationTime = BinaryPrimitives.ReadInt64LittleEndian(bytes.Slice(4)); 207bytes = bytes.Slice(12); // the end of the fixed part 299|| BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(payloadLength)) != UInt16SentinelPrefixPair) 374buffer = buffer.Slice(length); 401buffer = buffer.Slice(index); 417buffer = buffer.Slice(index);

Classification\DataClassificationTypeConverter.cs (1)

104taxonomyValue = valueSpan.Slice(index + 1).ToString();

ConfigurationKeyComparer.cs (3)

54SkipAheadOnDelimiter(xSpan.Slice(xDelimiterIndex + 1)); 56SkipAheadOnDelimiter(ySpan.Slice(yDelimiterIndex + 1)); 65a = a.Slice(1);

Linux\LinuxUtilizationParserCgroupV1.cs (3)

154stat = stat.Slice(next); 348ReadOnlySpan<char> second = group.Slice(rangeIndex + 1); 364stats = stats.Slice(groupIndex + 1);

Linux\LinuxUtilizationParserCgroupV2.cs (10)

198stat = stat.Slice(next); 493ReadOnlySpan<char> second = group.Slice(rangeIndex + 1); 509stats = stats.Slice(groupIndex + 1); 536ReadOnlySpan<char> usageSlice = content.Slice(usageIndex + UsageUsec.Length); 541Throw.InvalidOperationException($"Could not get usage_usec from '{cpuUsageFile}'. Expected positive number, but got '{new string(content.Slice(usageIndex))}'."); 551ReadOnlySpan<char> periodsSlice = content.Slice(periodsIndex + NrPeriods.Length); 556Throw.InvalidOperationException($"Could not get nr_periods from '{cpuUsageFile}'. Expected positive number, but got '{new string(content.Slice(periodsIndex))}'."); 683ReadOnlySpan<char> periodSlice = content.Slice(3); 698ReadOnlySpan<char> periodSlice = content.Slice(2); 723ReadOnlySpan<char> periodSlice = content.Slice(index + quotaString.Length);

Http\DownstreamDependencyMetadataManager.cs (2)

109routeSpan = routeSpan.Slice(1); 375requestRouteAsSpan = requestRouteAsSpan.Slice(1);

LoggerMessageGenerator.Emitter.cs (1)

652=> ContainsSpecialSymbol(variableOrTemplateName) ? variableOrTemplateName.Slice(1) : variableOrTemplateName;

Resolver\DnsPrimitives.cs (12)

29QueryFlags = (QueryFlags)BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(2)), 30QueryCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(4)), 31AnswerCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(6)), 32AuthorityCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(8)), 33AdditionalRecordCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(10)) 277!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(2), out weight) || 278!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(4), out port) || 298!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2), out serial) || 299!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 4), out refresh) || 300!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 8), out retry) || 301!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 12), out expire) || 302!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 16), out minimum))

Http\HttpRouteFormatter.cs (3)

84length = httpPathAsSpan.Slice(startIndex).IndexOf(routeSegments.Segments[i + 1].Content[0]); 88length = httpPathAsSpan.Slice(startIndex).IndexOf(ForwardSlash); 93length = httpPathAsSpan.Slice(startIndex).Length;

Http\HttpRouteParser.cs (2)

73var length = httpPathAsSpan.Slice(startIndex).IndexOf(ForwardSlash); 77length = httpPathAsSpan.Slice(startIndex).Length;

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

42 query = query.Slice(delimeterIndex + 1); 60 var span = segment.Slice(equalIndex + 1);

Color.cs (7)

351 colorAsHex = colorAsHex.Slice(1); 401 colorAsHex = colorAsHex.Slice(1); 936 value = value.Slice(index + 1); 942 value = value.Slice(index + 1); 948 quad3 = value.Slice(index + 1); 978 value = value.Slice(index + 1); 984 triplet2 = value.Slice(index + 1);

Utilities\LineParser.cs (1)

21ReadOnlySpan<char> valuesToParse = trimmedLine.Slice(start: firstSeparatorIndex + 1);

Data\Conversion.cs (1)

1341if (span.Length == 1 || !TryParseCore(span.Slice(1), out val) || (val > ((ulong)max + 1)))

Deprecated\Vector\VectorUtils.cs (2)

263return CpuMathUtils.DotProductDense(aValues.Slice(offset), bValues, b.Length); 264return CpuMathUtils.DotProductSparse(aValues.Slice(offset), bValues, b.GetIndices(), bValues.Length);

Standard\LogisticRegression\LogisticRegression.cs (1)

241var regLoss = VectorUtils.NormSquared(currentWeightsValues.Slice(1)) * L2Weight;

Standard\LogisticRegression\MulticlassLogisticRegression.cs (1)

327var regLoss = VectorUtils.NormSquared(CurrentWeights.GetValues().Slice(BiasCount)) * L2Weight;

Model\BPETokenizer.cs (3)

861span = span.Slice(ContinuingSubwordPrefix.Length); 947sSpan = sSpan.Slice(ContinuingSubwordPrefix!.Length); 1037span = span.Slice(ContinuingSubwordPrefix.Length);

Model\CodeGenTokenizer.cs (2)

1298bytesIndex += Helpers.GetUtf8Bytes(removePrefixSpace ? specialToken.AsSpan().Slice(1) : specialToken.AsSpan(), bytes.AsSpan().Slice(bytesIndex)); 1449specialTokenSpan = specialTokenSpan.Slice(1);

Model\SentencePieceBaseModel.cs (1)

731tokenSpan = tokenSpan.Slice(delta);

Model\SentencePieceBpeModel.cs (7)

133EncodeInternal(text.Slice(currentOffset), addBeginOfSentence: false, addEndOfSentence: false, tokens); 236int bytesWritten = Helpers.GetUtf8Bytes(text.Slice(i), utf8Bytes); 395idsCount += EncodeToIds(text.Slice(currentOffset), addBeginOfSentence: false, addEndOfSentence: false, accumulatedIds, out charsWritten, maxTokens - idsCount); 536int bytesWritten = Helpers.GetUtf8Bytes(text.Slice(i), utf8Bytes); 671idsCount += CountTokens(text.Slice(currentOffset), addBeginOfSentence: false, addEndOfSentence: false, out charsWritten, maxTokens - idsCount); 799int encodedCount = Helpers.GetUtf8Bytes(text.Slice(i), utf8Bytes); 921splitText = text.Slice(current.Offset + current.Length);

Model\SentencePieceUnigramModel.cs (7)

Model\TiktokenTokenizer.cs (1)

936tokenBytes.Span.Slice(bytesConsumed).CopyTo(utf8Bytes);

Model\WordPieceTokenizer.cs (2)

696sb.Append(token.AsSpan().Slice(ContinuingSubwordPrefix.Length)); 759token.AsSpan().Slice(ContinuingSubwordPrefix.Length).CopyTo(buffer);

Normalizer\SentencePieceNormalizer.cs (5)

364input = input.Slice(p); 394sp = sp.Slice(1); 429input = input.Slice(p); 510blob = blob.Slice(sizeof(uint)); 532normalized = blob.Slice((int)trieBlobSize).ToArray();

Utils\Helpers.cs (1)

61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length));

Utils\Helpers.netcoreapp.cs (2)

51=> int.TryParse(s.AsSpan().Slice(offset), NumberStyles.None, CultureInfo.InvariantCulture, out result); 83Rune.DecodeFromUtf16(text.Slice(textIndex), out Rune rune, out int charsConsumed);

NormalizerTests.cs (1)

115index = original.Slice(start).IndexOf('"');

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

61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length));

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

51=> int.TryParse(s.AsSpan().Slice(offset), NumberStyles.None, CultureInfo.InvariantCulture, out result); 83Rune.DecodeFromUtf16(text.Slice(textIndex), out Rune rune, out int charsConsumed);

ContentDispositionHeaderValue.cs (3)

631remaining = remaining.Slice(length); 645Rune.DecodeFromUtf16(remaining.Slice(i), out Rune rune, out var runeLength); 650remaining = remaining.Slice(length);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\ReflectionUtils.cs (5)

61nameSlice = nameSlice.Slice(escapedComma + 2); 107int tokenEnding = assemblyName.Slice(versionIndex + 1).IndexOf(',') + 1; 108int tokenLength = tokenEnding == 0 ? assemblyName.Slice(versionIndex).Length : tokenEnding; 117int tokenEnding = assemblyName.Slice(tokenIndex + 1).IndexOf(',') + 1; 118int tokenLength = tokenEnding == 0 ? assemblyName.Slice(tokenIndex).Length : tokenEnding;

MS\Internal\IO\Packaging\ByteRangeDownloader.cs (1)

794contentRangeSpan = contentRangeSpan.Slice(index + 1);

System\Windows\Input\InputScopeConverter.cs (1)

113spanSource = spanSource.Slice(periodPos + 1);

Microsoft\Win32\FileDialog.cs (1)

735extensions.Add(exts[ext].Slice(i + 1).ToString());

MS\Internal\Globalization\BamlResourceContent.cs (1)

129contentSpan = contentSpan.Slice(i);

System\Windows\Controls\VirtualizingStackPanel.cs (1)

12241name = name.Slice(24); // 24 == length of "s.w.c."

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

440attrValueSpan = attrValueSpan.Slice(_contextColor.Length).Trim();

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

430glyphIndexString = valueSpec.Slice(secondBracket + 1);

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

3560units = s.Slice(n + 1);

System\Windows\Markup\Primitives\ExtensionSimplifierMarkupObject.cs (1)

360value = value.Slice(2);

MS\Internal\Documents\DocumentApplicationDocumentViewer.cs (1)

1882zoomString = zoomString.Slice(1);

Packaging\XpsFixedPageReaderWriter.cs (1)

1852ReadOnlySpan<char> extension = Path.GetExtension(path).Slice(1);

Replay.cs (1)

241var argValue = line.AsSpan().Slice(index + 1).ToString();

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

ServerSentEvents\SseFormatter.cs (1)

162data = data.Slice(i);

ServerSentEvents\SseParser_1.cs (2)

368fieldValue = line.Slice(colonPos + 1); 371fieldValue = fieldValue.Slice(1);

System\Collections\Immutable\ImmutableList_1.Node.cs (1)

276Node right = NodeTreeFromList(items.Slice(leftCount + 1));

System\ComponentModel\DataAnnotations\PhoneAttribute.cs (3)

72ReadOnlySpan<char> extension = potentialPhoneNumber.Slice( 84ReadOnlySpan<char> extension = potentialPhoneNumber.Slice( 96ReadOnlySpan<char> extension = potentialPhoneNumber.Slice(

src\libraries\Common\src\System\Drawing\ColorConverterCommon.cs (2)

97return Convert.ToInt32(text.Slice(1).ToString(), 16); 101return Convert.ToInt32(text.Slice(2).ToString(), 16);

System\Diagnostics\DsesFilterAndTransform.cs (3)

231ReadOnlySpan<char> suffixPart = entry.Slice(eventNameIndex + 1).Trim(); 237suffixPart = suffixPart.Slice(samplingResultIndex + 1).Trim(); 331activityName = activitySourceName.Slice(plusSignIndex + 1).Trim().ToString();

System\Diagnostics\W3CPropagator.cs (10)

109ReadOnlySpan<char> valueSpan = currentEntry.Slice(keyValueSeparator + 1); 117baggageSpan = entrySeparator >= 0 ? baggageSpan.Slice(entrySeparator + 1) : ReadOnlySpan<char>.Empty; 165if (IsInvalidTraceStateKey(Trim(entry.Slice(0, equalIndex))) || IsInvalidTraceStateValue(TrimSpaceOnly(entry.Slice(equalIndex + 1)))) 281if (!TryDecodeEscapedByte(valueSpan.Slice(i), out byte b0)) 296if (i + 5 >= valueSpan.Length || valueSpan[i + 3] != Percent || !TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || (b1 & 0xC0) != 0x80) 315!TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || 316!TryDecodeEscapedByte(valueSpan.Slice(i + 6), out byte b2) || 337!TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || 338!TryDecodeEscapedByte(valueSpan.Slice(i + 6), out byte b2) || 339!TryDecodeEscapedByte(valueSpan.Slice(i + 9), out byte b3) ||

src\libraries\Common\src\System\Drawing\ColorConverterCommon.cs (2)

97return Convert.ToInt32(text.Slice(1).ToString(), 16); 101return Convert.ToInt32(text.Slice(2).ToString(), 16);

System\Formats\Asn1\AsnCharacterStringEncodings.cs (2)

366bytes.Slice(bytes.Length - 1).ToArray(), 377char c = (char)BinaryPrimitives.ReadInt16BigEndian(bytes.Slice(i));

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

308int tooBig = contentsLength ?? SeekEndOfContents(source.Slice(headerLength), ruleSet); 391value = source.Slice(1); 503cur = cur.Slice(localLen); 525cur = topSpan.Slice(bytesRead); 575cur = tmpSpan.Slice(bytesRead);

System\Formats\Asn1\AsnDecoder.cs (10)

74TryReadLength(source.Slice(tagLength), ruleSet, out int? encodedLength, out int lengthLength)) 79source.Slice(headerLength), 153int? encodedLength = ReadLength(source.Slice(tagLength), ruleSet, out int lengthLength); 157source.Slice(headerLength), 185int? encodedLength = ReadLength(source.Slice(tagLength), ruleSet, out int lengthLength); 452int? length = ReadLength(source.Slice(tagBytesRead), ruleSet, out int lengthBytesRead); 602cur = cur.Slice(bytesRead); 611cur = cur.Slice(tlv.Length); 622data = data.Slice(bytesToRead); 663return source.Slice(offset);

System\Formats\Asn1\AsnDecoder.GeneralizedTime.cs (4)

215contents = contents.Slice(1); 239contents = contents.Slice(fracLength); 247contents = contents.Slice(fracLength); 270contents = contents.Slice(1);

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

494contents = contents.Slice(1);

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

362cur = cur.Slice(localLen); 390cur = topSpan.Slice(bytesRead); 440cur = topSpan.Slice(bytesRead); 503contents = source.Slice(headerLength);

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

303contents = contents.Slice(bytesRead); 332contents = contents.Slice(bytesRead);

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

89int len = SeekEndOfContents(source.Slice(headerLength), ruleSet);

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

92int actualLength = SeekEndOfContents(source.Slice(headerLength), ruleSet); 112remaining = remaining.Slice(consumed);

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

190contents = contents.Slice(1);

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

176remainingData = remainingData.Slice(MaxCERContentSize);

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

154remainingData = remainingData.Slice(MaxCERSegmentSize);

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

114ReadOnlySpan<char> remaining = oidValue.Slice(2); 173oidValue = oidValue.Slice(Math.Min(oidValue.Length, endIndex + 1));

System\Formats\Cbor\Reader\CborReader.cs (1)

253private ReadOnlySpan<byte> GetRemainingBytes() => _data.Span.Slice(_offset);

System\Formats\Cbor\Reader\CborReader.Integer.cs (3)

181result = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(1)); 193result = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(1)); 205result = BinaryPrimitives.ReadUInt64BigEndian(data.Slice(1));

System\Formats\Cbor\Reader\CborReader.Simple.cs (5)

32result = HalfHelpers.HalfToFloat(CborHelpers.ReadHalfBigEndian(buffer.Slice(1))); 39result = CborHelpers.ReadSingleBigEndian(buffer.Slice(1)); 73result = HalfHelpers.HalfToDouble(CborHelpers.ReadHalfBigEndian(buffer.Slice(1))); 80result = CborHelpers.ReadSingleBigEndian(buffer.Slice(1)); 87result = CborHelpers.ReadDoubleBigEndian(buffer.Slice(1));

System\Formats\Cbor\Reader\CborReader.Simple.netcoreapp.cs (1)

32result = BinaryPrimitives.ReadHalfBigEndian(buffer.Slice(1));

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

453CborInitialByte nextInitialByte = ReadNextInitialByte(data.Slice(i), type); 457int chunkLength = DecodeDefiniteLength(nextInitialByte, data.Slice(i), out int bytesRead); 462nextInitialByte = ReadNextInitialByte(data.Slice(i), type);

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

143encodedValue = encodedValue.Slice(1);

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

20path = path.Slice(nonSlash);

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

729buffer = buffer.Slice(newlinePos + 1); 737line = line.Slice(spacePos + 1); 747ReadOnlySpan<byte> valueSlice = line.Slice(equalPos + 1);

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

612name = pathNameBytes.Slice(lastIdx + 1); 626name = pathNameBytes.Slice(lastIdx + 1);

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

232return T.ReadBigEndian(buffer.Slice(1), isUnsigned: true); 298return buffer.Slice(newStart);

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

20path = path.Slice(nonSlash);

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

29source = source.Slice(longLength); 57source = source.Slice(intLength);

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

102source = source.Slice(remain); 116source = source.Slice(StripeSize); 260source = source.Slice(StripeSize);

System\IO\Hashing\XxHash32.State.cs (4)

43_acc2 = ApplyRound(_acc2, source.Slice(sizeof(uint))); 44_acc3 = ApplyRound(_acc3, source.Slice(2 * sizeof(uint))); 45_acc4 = ApplyRound(_acc4, source.Slice(3 * sizeof(uint))); 82remaining = remaining.Slice(sizeof(uint));

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

102source = source.Slice(remain); 116source = source.Slice(StripeSize); 260source = source.Slice(StripeSize);

System\IO\Hashing\XxHash64.State.cs (5)

54_acc2 = ApplyRound(_acc2, source.Slice(sizeof(ulong))); 55_acc3 = ApplyRound(_acc3, source.Slice(2 * sizeof(ulong))); 56_acc4 = ApplyRound(_acc4, source.Slice(3 * sizeof(ulong))); 118remaining = remaining.Slice(sizeof(ulong)); 130remaining = remaining.Slice(sizeof(uint));

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

140ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 326source.Slice(sourceIndex).CopyTo(remaining);

System\IO\Packaging\ContentType.cs (7)

288typeAndSubType.Slice(forwardSlashPos + 1).IndexOf('/') >= 0) // more than one slash 294_subType = ValidateToken(typeAndSubType.Slice(forwardSlashPos + 1).ToString()); 319parameterAndValue = parameterAndValue.Slice(1); 339parameterAndValue = parameterAndValue.Slice(parameterStartIndex + parameterValueLength).TrimStart(s_linearWhiteSpaceChars); 358int semicolonIndex = s.Slice(startIndex).IndexOf(';'); 362int lwsIndex = s.Slice(startIndex).IndexOfAny(s_linearWhiteSpaceChars); 383length = s.Slice(startingLength).IndexOf('"');

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

1106source = source.Slice(writable);

System\Linq\Average.cs (1)

37Vector.Widen(new Vector<int>(span.Slice(i)), out Vector<long> low, out Vector<long> high);

System\Linq\SegmentedArrayBuilder.cs (1)

148sourceSlice = sourceSpan.Slice(sourceSlice.Length);

System\Buffers\BuffersExtensions.cs (1)

140input = input.Slice(writeSize);

System\Buffers\ReadOnlySequence.Helpers.cs (2)

187return span.Slice(startIndex); 651first = first.Slice(startIndex);

System\Buffers\SequenceReader.cs (1)

79get => CurrentSpan.Slice(CurrentSpanIndex);

System\Buffers\SequenceReader.Search.cs (1)

837next = next.Slice(currentSpan.Length);

System\Text\EncodingExtensions.cs (2)

440chars = chars.Slice(charsUsedJustNow); 533bytes = bytes.Slice(bytesUsedJustNow);

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

114_content.Span.Slice(_position).CopyTo(buffer); 161destination.Write(_content.Span.Slice(_position));

System\BinaryData.cs (1)

482span = span.Slice(3);

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

104_version = Version.Parse(version.Slice("HTTP/".Length));

System\Net\Base64Stream.cs (2)

228written += EncodeBytes(buffer.Slice(written), false, false); 248written += EncodeBytes(buffer.Span.Slice(written), false, false);

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

33if (_hasSpecialEncodingForCRLF && buffer.Slice(cur).StartsWith("\r\n"u8))

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

234written += EncodeBytes(buffer.Slice(written)); 251written += EncodeBytes(buffer.Span.Slice(written));

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

348written += EncodeBytes(buffer.Slice(written)); 365written += EncodeBytes(buffer.Span.Slice(written));

System\Security\Authentication\ExtendedProtection\ServiceNameCollection.cs (2)

211port = hostAndPort.Slice(colonIndex + 1); // Excludes colon 220port = hostAndPort.Slice(colonIndex);

System\Net\ServerSentEvents\SseFormatter.cs (1)

159data = data.Slice(i);

System\Net\ServerSentEvents\SseParser_1.cs (2)

351fieldValue = line.Slice(colonPos + 1); 354fieldValue = fieldValue.Slice(1);

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

52buffer = buffer.Slice(toCopy);

System\Net\HeaderInfoTable.cs (1)

68ReadOnlySpan<char> lastElement = singleValue.Slice(semiPos + 1);

System\Net\WebSockets\WebSocketHandle.Managed.cs (1)

343!int.TryParse(value.Slice(startIndex + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out int windowBits) ||

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

2338tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2350tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2375tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2387tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2412tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2424tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));

src\libraries\Common\src\Interop\Linux\os-release\Interop.OSReleaseFile.cs (1)

65ReadOnlySpan<char> fieldValue = line.Slice(prefix.Length);

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.TryReadStatusFile.cs (1)

85ReadOnlySpan<char> value = line.Slice(startIndex + 1);

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcMountInfo.TryParseMountInfoLine.cs (1)

59line = line.Slice(endOfOptionalFields + Separator.Length);

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

351bool fallbackResult = TryDecodeFromUtf16_Scalar(chars.Slice((int)offset), bytes.Slice((int)(offset / 2)), out int fallbackProcessed);

src\libraries\Common\src\System\Number.Parsing.Common.cs (1)

306return !value.Slice(index).ContainsAnyExcept(TChar.CastFrom('\0'));

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

268source = source.Slice(bytesConsumed); 297source = source.Slice(localConsumed); 308source = source.Slice(localConsumed); 475source = source.Slice(encodedIdx);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64ValidatorHelper.cs (2)

37base64Text = base64Text.Slice(index + 1); 45base64Text = base64Text.Slice(1);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs (1)

232source = source.Slice(encodedIdx);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Float.cs (2)

159int diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex)) ^ infi); 164diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex + 4)) ^ nity);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Guid.cs (6)

91if (!TryParseUInt64X(text.Slice(20), out ulong i5, out justConsumed) || justConsumed != 12) 132source = source.Slice(1); // skip beginning 157source = source.Slice(9); // justConsumed + 1 for delimiter 180source = source.Slice(5); // justConsumed + 1 for delimiter 203source = source.Slice(5); // justConsumed + 1 for delimiter 226source = source.Slice(5); // justConsumed + 1 for delimiter

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs (1)

261if (!TryParseUInt32D(source.Slice(srcIndex), out uint absoluteExponent, out int bytesConsumedByExponent))

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.BigG.cs (5)

40if (!TryParseUInt32D(source.Slice(srcIndex), out uint days, out int justConsumed)) 55if (!TryParseUInt32D(source.Slice(srcIndex), out uint hours, out justConsumed)) 70if (!TryParseUInt32D(source.Slice(srcIndex), out uint minutes, out justConsumed)) 85if (!TryParseUInt32D(source.Slice(srcIndex), out uint seconds, out justConsumed)) 100if (!TryParseTimeSpanFraction(source.Slice(srcIndex), out uint fraction, out justConsumed))

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpanSplitter.cs (3)

73if (!TryParseUInt32D(source.Slice(srcIndex), out V1, out int justConsumed)) 192if (!TryParseUInt32D(source.Slice(srcIndex), out value, out int bytesConsumed)) 205if (!TryParseTimeSpanFraction(source.Slice(srcIndex), out value, out int bytesConsumed))

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

2685chars = chars.Slice(consumedInThisIteration); 2703chars = chars.Slice(indexOfFirstNonSpace); 2738chars = chars.Slice(consumedFromChars);

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

642int mid = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(4)); 643int hi = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(8)); 644int flags = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(12));

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (15)

src\libraries\System.Private.CoreLib\src\System\Enum.cs (2)

1070value = value.Slice(endIndex + 1); 2261rawData = rawData.Slice(sizeof(long) - size);

src\libraries\System.Private.CoreLib\src\System\Environment.Variables.Windows.cs (1)

110string value = new string(variable.Slice(i + 1));

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Icu.cs (2)

197? source.Slice(endIndex) 839text = text.Slice(charsConsumed);

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

1233if (str.Value.Slice(str.Index + 1).ContainsAnyExcept('\0')) 3354ReadOnlySpan<char> span = str.Value.Slice(str.Index); 3455ReadOnlySpan<char> span = str.Value.Slice(str.Index); 3556ReadOnlySpan<char> span = str.Value.Slice(str.Index); 3623ReadOnlySpan<char> span = str.Value.Slice(str.Index); 5682if (++Index < Length && Value.Slice(Index).StartsWith(str)) 5900Value.Slice(i + 1).CopyTo(result.Slice(1));

src\libraries\System.Private.CoreLib\src\System\Globalization\InvariantModeCasing.cs (2)

60ToLower(src.Slice(i), destination.Slice(i)); 106ToUpper(src.Slice(i), destination.Slice(i));

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.Utf8.cs (4)

97spanA = spanA.Slice(bytesConsumedA); 98spanB = spanB.Slice(bytesConsumedB); 407spanA = spanA.Slice(bytesConsumedA); 408spanB = spanB.Slice(bytesConsumedB);

src\libraries\System.Private.CoreLib\src\System\Globalization\StringInfo.cs (1)

221remaining = remaining.Slice(GetNextTextElementLength(remaining)); // consume this cluster

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanParse.cs (1)

1492int i = _str.Slice(_pos).IndexOfAnyExceptInRange('0', '9');

src\libraries\System.Private.CoreLib\src\System\Guid.cs (9)

683int numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 705numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 727numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 765numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 774numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom('}')); 851guidString = guidString.Slice(1); 856guidString = guidString.Slice(2); 930if (Rune.DecodeFromUtf8(srcUtf8Span.Slice(i), out Rune current, out int bytesConsumed) != Buffers.OperationStatus.Done) 961if (Rune.DecodeFromUtf8(srcUtf8Span.Slice(i), out Rune current, out int bytesConsumed) != Buffers.OperationStatus.Done)

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (1)

455chars = chars.Slice(charsConsumed);

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (1)

955buffer = buffer.Slice(bytesWritten);

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEntry.cs (2)

38ReadOnlySpan<char> relativePath = Directory.Slice(RootDirectory.Length); 40relativePath = relativePath.Slice(1);

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemName.cs (1)

157ReadOnlySpan<char> expressionEnd = expression.Slice(1);

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

1542contents = contents.Slice(toEncode.Length);

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (1)

247return path.Slice(i < root ? root : i + 1);

src\libraries\System.Private.CoreLib\src\System\IO\RandomAccess.Unix.cs (1)

141buffer = buffer.Slice(bytesWritten);

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

509source = source.Slice(numBytes);

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

2358if (span.Slice(pos + 1).StartsWith(value.Slice(1), comparer)) 2364span = span.Slice(pos + 1); 2570if (span.Slice(pos + 1).StartsWith(value.Slice(1), comparer)) 3630SequenceEqual(span.Slice(span.Length - value.Length), value, comparer); 5524span = span.Slice(pos + value.Length); 5554span = span.Slice(pos + value.Length); 5577span = span.Slice(pos + 1); 5597span = span.Slice(pos + 1); 5621span = span.Slice(pos + 1); 5923separatorIndex = _source.Slice(_startNext).IndexOf(_separator); 5928separatorIndex = _source.Slice(_startNext).IndexOfAny(_separatorBuffer); 5933separatorIndex = _source.Slice(_startNext).IndexOf(_separatorBuffer); 5944separatorIndex = _source.Slice(_startNext).IndexOfAny(_searchValues);

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Trim.cs (5)

115=> span.Slice(ClampStart(span, trimElement)); 436return span.Slice(ClampStart(span, trimElements)); 619return span.Slice(start); 684return span.Slice(start); 746return span.Slice(start);

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (7)

43HtmlEncode(valueSpan.Slice(index), ref sb); 72HtmlEncode(valueSpan.Slice(index), ref sb); 172HtmlDecode(valueSpan.Slice(index), ref sb); 197HtmlDecode(valueSpan.Slice(index), ref sb); 214ReadOnlySpan<char> inputSlice = input.Slice(i + 1); 949char value = (char)BinaryPrimitives.ReadUInt16LittleEndian(tableData.Slice(sizeof(ulong))); 951tableData = tableData.Slice(sizeof(ulong) + sizeof(char));

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (4)

305value = value.Slice(index); 988valueTrim = valueTrim.Slice(positiveSign.Length); 1009if (SpanEqualsOrdinalIgnoreCase(valueTrim.Slice(negativeSign.Length), nanSymbol)) 1015if (info.AllowHyphenDuringParsing() && SpanStartsWith(valueTrim, TChar.CastFrom('-')) && SpanEqualsOrdinalIgnoreCase(valueTrim.Slice(1), nanSymbol))

src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyName.cs (3)

343stringToEscape = stringToEscape.Slice(charsConsumed); 355stringToEscape = stringToEscape.Slice(1); 368stringToEscape = stringToEscape.Slice(charsToCopy);

src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyNameHelpers.StrongName.cs (2)

49uint hashAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(4)); 50uint cbPublicKey = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(8));

src\libraries\System.Private.CoreLib\src\System\Runtime\Versioning\FrameworkName.cs (2)

153ReadOnlySpan<char> value = component.Slice(separatorIndex + 1).Trim(); 165value = value.Slice(1);

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticWithAsciiCharSearchValues.cs (2)

82span = span.Slice(offset); 120span = span.Slice(offset);

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

28ReadOnlySpan<char> remaining = span.Slice(i);

src\libraries\System.Private.CoreLib\src\System\Security\SecurityElement.cs (1)

335span = span.Slice(pos + 1);

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

1052return GetNonRandomizedHashCodeOrdinalIgnoreCaseSlow(hash1, hash2, span.Slice(span.Length - length));

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (5)

1248searchSpace = searchSpace.Slice(index + matchLength); 1537remaining = remaining.Slice(idx + stride); 1599text = text.Slice(idx + stride); 1627remaining = remaining.Slice(idx + stride); 2165source = source.Slice(index + separator.Length);

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

403Ascii.FromUtf16(chars.Slice(idx), bytes.Slice(idx), out int charsConsumed); 413chars = chars.Slice(numElementsToConvert); 692Ascii.ToUtf16(bytes.Slice(idx), chars.Slice(idx), out int bytesConsumed); 701bytes = bytes.Slice(numElementsToConvert);

src\libraries\System.Private.CoreLib\src\System\Text\CompositeFormat.cs (1)

135ReadOnlySpan<char> remainder = format.Slice(pos);

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (24)

src\libraries\System.Private.CoreLib\src\System\Text\Rune.cs (2)

663return DecodeFromUtf8(source.Slice(index), out value, out bytesConsumed); 709source = source.Slice(index);

src\libraries\System.Private.CoreLib\src\System\Text\SpanLineEnumerator.cs (1)

67_remaining = remaining.Slice(idx + stride);

src\libraries\System.Private.CoreLib\src\System\Text\SpanRuneEnumerator.cs (1)

50_remaining = _remaining.Slice(_current.Utf16SequenceLength);

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (1)

2121remainingChunk = remainingChunk.Slice(foundPos + oldValue.Length);

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (1)

504buffer = buffer.Slice(bytesConsumed);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\TextSegmentationUtility.cs (1)

229_decoder(_buffer.Slice(CurrentCodeUnitOffset), out Rune thisRune, out _codeUnitLengthOfCurrentScalar);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (5)

108source = source.Slice((int)(pInputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source))) + 1); 198source = source.Slice((int)(pInputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source)))); 202source = source.Slice(bytesConsumedJustNow); 283source = source.Slice((int)(pInputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source)))); 301source = source.Slice(bytesConsumedJustNow);

src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (1)

651bytes = bytes.Slice(bytesRead);

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

780offset = offset.Slice(1); 976ReadOnlySpan<char> weekDaySpan = dateRule.Slice(monthWeekDotIndex + 1); 982int.TryParse(weekDaySpan.Slice(weekDayDotIndex + 1), out int day))

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

507name = name.Slice(name.LastIndexOf('+') + 1);

src\libraries\System.Private.CoreLib\src\System\Version.cs (6)

371int minorEnd = input.Slice(majorEnd + 1).IndexOf(TChar.CastFrom('.')); 375buildEnd = input.Slice(minorEnd + 1).IndexOf(TChar.CastFrom('.')); 379if (input.Slice(buildEnd + 1).Contains(TChar.CastFrom('.'))) 408TryParseComponent(input.Slice(buildEnd + 1), nameof(revision), throwOnFailure, out revision) ? 415return TryParseComponent(input.Slice(minorEnd + 1), nameof(build), throwOnFailure, out build) ? 423return TryParseComponent(input.Slice(majorEnd + 1), nameof(input), throwOnFailure, out minor) ?

src\libraries\System.Reflection.Metadata\src\System\Reflection\Metadata\TypeName.cs (2)

355name = name.Slice(_declaringType._nestedNameLength + 1); 360name = name.Slice(idx + 1);

src\libraries\System.Reflection.Metadata\src\System\Reflection\Metadata\TypeNameParser.cs (2)

86_inputString = _inputString.Slice(fullTypeNameLength); 255_inputString = _inputString.Slice(candidate.Length);

src\libraries\System.Reflection.Metadata\src\System\Reflection\Metadata\TypeNameParserHelpers.cs (5)

213ReadOnlySpan<char> trimmed = span.Slice(1).TrimStart(); 219span = trimmed.Slice(1).TrimStart(); 240int length = GetFullTypeNameLength(input.Slice(totalLength), out isNestedType); 256input = input.Slice(1); 344span = span.Slice(1).TrimStart();

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

270buffer = buffer.Slice(size);

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

159int indexOfTimeZoneOffset = ticksvalue.Slice(1).IndexOf('+'); 163indexOfTimeZoneOffset = ticksvalue.Slice(1).IndexOf('-');

System\DomainNameHelper.cs (1)

180hostname = hostname.Slice(dotIndex + 1);

System\Uri.cs (1)

4747int i = share.Slice(1).IndexOf('/');

System\UriExt.cs (2)

610charsToUnescape.Slice(indexOfFirstToUnescape), ref vsb, 660charsToUnescape.Slice(indexOfFirstToUnescape), ref vsb,

System\UriHelper.cs (8)

168EscapeStringToBuilder(charsToEscape.Slice(indexOfFirstToEscape), ref vsb, Unreserved, checkExistingEscaped: false); 224EscapeStringToBuilder(charsToEscape.Slice(indexOfFirstToEscape), ref vsb, noEscape, checkExistingEscaped); 246EscapeStringToBuilder(stringToEscape.Slice(indexOfFirstToEscape), ref dest, noEscape, checkExistingEscaped); 273stringToEscape = stringToEscape.Slice(charsConsumed); 297stringToEscape = stringToEscape.Slice(3); 303stringToEscape = stringToEscape.Slice(1); 316stringToEscape = stringToEscape.Slice(charsToCopy); 630foreach (char c in strToClean.Slice(indexOfPossibleCharToRemove))

System\Xml\BinaryXml\XmlBinaryReader.cs (3)

3502data = data.Slice(2); // we consumed one ANSI whitespace char 3513data = data.Slice(2); // we consumed one char (possibly a high surrogate) 3533data = data.Slice(2); //consumed a low surrogate char

System\Reflection\Emit\CustomAttributeWrapper.cs (3)

58int numNamed = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(pos)); 136return BinaryPrimitives.ReadInt32LittleEndian(data.Slice(pos)); 139return BinaryPrimitives.ReadInt16LittleEndian(data.Slice(pos));

System\Reflection\Emit\FieldBuilderImpl.cs (1)

60_offset = BinaryPrimitives.ReadInt32LittleEndian(binaryAttribute.Slice(2));

System\Reflection\Emit\MethodBuilderImpl.cs (1)

178int implValue = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(2));

System\Reflection\Metadata\BlobBuilder.cs (1)

680ReadOnlySpan<byte> remaining = buffer.Slice(bytesToCurrent);

System\Reflection\Metadata\TypeName.cs (2)

355name = name.Slice(_declaringType._nestedNameLength + 1); 360name = name.Slice(idx + 1);

System\Reflection\Metadata\TypeNameParser.cs (2)

86_inputString = _inputString.Slice(fullTypeNameLength); 255_inputString = _inputString.Slice(candidate.Length);

System\Reflection\Metadata\TypeNameParserHelpers.cs (4)

213ReadOnlySpan<char> trimmed = span.Slice(1).TrimStart(); 219span = trimmed.Slice(1).TrimStart(); 240int length = GetFullTypeNameLength(input.Slice(totalLength), out isNestedType); 344span = span.Slice(1).TrimStart();

System\Resources\Extensions\TypeNameComparer.cs (2)

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;

src\libraries\Common\src\System\Number.Parsing.Common.cs (1)

306return !value.Slice(index).ContainsAnyExcept(TChar.CastFrom('\0'));

System\Number.BigInteger.cs (2)

361intDigits = intDigits.Slice(leadingDigits.Length); 367intDigits = intDigits.Slice(PowersOf1e9.MaxPartialDigits);

System\Numerics\BigInteger.cs (2)

298value = value.Slice(offset); 378value.Slice(unalignedBytes).CopyTo(uintBytes);

System\Numerics\BigIntegerCalculator.AddSub.cs (1)

16source.Slice(start).CopyTo(dest.Slice(start));

System\Numerics\BigIntegerCalculator.DivRem.cs (5)

524Debug.Assert(CompareActual(left.Slice(right.Length), right) < 0); 596Debug.Assert(CompareActual(left.Slice(right.Length), right) < 0); 614BurnikelZieglerD3n2n(left.Slice(right.Length), left.Slice(halfN, halfN), right, quotient.Slice(halfN), r1); 634ReadOnlySpan<uint> a1 = left12.Slice(n); 635ReadOnlySpan<uint> b1 = right.Slice(n);

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

81left = left.Slice(k);

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

86ReadOnlySpan<uint> valueHigh = value.Slice(n); 213ReadOnlySpan<uint> leftHigh = left.Slice(n); 262ReadOnlySpan<uint> leftHigh = left.Slice(n); 266ReadOnlySpan<uint> rightHigh = right.Slice(n);

System\Numerics\BigIntegerCalculator.Utils.cs (4)

20Debug.Assert(left.Length <= right.Length || left.Slice(right.Length).ContainsAnyExcept(0u)); 21Debug.Assert(left.Length >= right.Length || right.Slice(left.Length).ContainsAnyExcept(0u)); 40if (ActualLength(right.Slice(left.Length)) > 0) 46if (ActualLength(left.Slice(right.Length)) > 0)

System\Numerics\Complex.cs (1)

2135if ((closeBracket != (s.Length - 1)) && (((style & NumberStyles.AllowTrailingWhite) == 0) || !s.Slice(closeBracket).IsWhiteSpace()))

src\libraries\Common\src\System\Security\Cryptography\Asn1Reader\AsnValueReader.cs (17)

System\Security\Cryptography\Pkcs\CmsSignature.cs (2)

196val = val.Slice(1); 208val = val.Slice(1);

System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (2)

78definedCharsBitmapAsLittleEndian = definedCharsBitmapAsLittleEndian.Slice(Vector<byte>.Count); 89thisAllowedCharactersBitmap[i] &= BinaryPrimitives.ReadUInt32LittleEndian(definedCharsBitmapAsLittleEndian.Slice(i * sizeof(uint)));

System\Text\Encodings\Web\OptimizedInboxTextEncoder.cs (3)

304OperationStatus runeDecodeStatus = Rune.DecodeFromUtf8(source.Slice(srcIdx), out Rune scalarValue, out int bytesConsumedJustNow); 377data = data.Slice(asciiBytesSkipped); 389data = data.Slice(bytesConsumed);

System\Text\Encodings\Web\TextEncoder.cs (10)

150ReadOnlySpan<char> remainingInput = value.Slice(indexOfFirstCharToEncode); 172remainingInput = remainingInput.Slice(charsConsumedJustNow); 315OperationStatus status = EncodeUtf8Core(utf8Source.Slice(idxOfFirstByteToEncode), utf8Destination.Slice(idxOfFirstByteToEncode), out int innerBytesConsumed, out int innerBytesWritten, isFinalBlock); 361utf8Source = utf8Source.Slice(bytesConsumedJustNow); 373utf8Source = utf8Source.Slice(bytesConsumedJustNow); 445OperationStatus status = EncodeCore(source.Slice(idxOfFirstCharToEncode), destination.Slice(idxOfFirstCharToEncode), out int innerCharsConsumed, out int innerCharsWritten, isFinalBlock); 477source = source.Slice(charsConsumedJustNow); 489source = source.Slice(charsConsumedJustNow); 533value = value.Slice(charsConsumedJustNow); 570utf8Text = utf8Text.Slice(bytesConsumed);

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

373return JsonReaderHelper.UnescapeAndCompare(segment.Slice(idx), otherUtf8Text.Slice(idx));

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

192JsonReaderHelper.Unescape(currentPropertyName.Slice(idx), utf8Unescaped, 0, out written); 195if (utf8Unescaped.Slice(0, written).SequenceEqual(propertyName.Slice(idx)))

System\Text\Json\JsonHelpers.cs (8)

375leftLast = leftFractional.Slice(-diff); 378rightMiddle = rightIntegral.Slice(rightOffset); 394leftMiddle = leftIntegral.Slice(leftOffset); 398rightLast = rightFractional.Slice(diff); 436span = span.Slice(1); 457span = span.Slice(i + 1); 474if (!Utf8Parser.TryParse(span.Slice(i + 1), out exp, out _)) 498frac = frac.Slice(lz + 1);

System\Text\Json\JsonHelpers.Date.cs (4)

258return ParseOffset(ref parseData, source.Slice(sourceIndex)); 291return ParseOffset(ref parseData, source.Slice(sourceIndex)); 349return ParseOffset(ref parseData, source.Slice(sourceIndex)); 374|| !TryGetNextTwoDigits(offsetData.Slice(3), ref parseData.OffsetMinutes))

System\Text\Json\Reader\JsonReaderHelper.Unescaping.cs (1)

594ReadOnlySpan<byte> remaining = source.Slice(idx);

System\Text\Json\Reader\Utf8JsonReader.cs (18)

598if (other.Slice(matchedSoFar).StartsWith(span)) 628return JsonReaderHelper.UnescapeAndCompare(localSpan.Slice(idx), other.Slice(idx)); 658if (!other.Slice(matchedSoFar).StartsWith(span.Slice(0, idx))) 664other = other.Slice(matchedSoFar); 678if (!other.Slice(matchedSoFar).StartsWith(span)) 988if (!TryGetNumber(localBuffer.Slice(_consumed), out int numberOfBytes)) 1135ReadOnlySpan<byte> span = _buffer.Slice(_consumed); 1207if (!TryGetNumber(_buffer.Slice(_consumed), out int consumed)) 1285ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2317ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2324return SkipSingleLineComment(localBuffer.Slice(1), out _); 2328return SkipMultiLineComment(localBuffer.Slice(1), out _); 2422localBuffer = localBuffer.Slice(idx + 1); 2452int foundIdx = localBuffer.Slice(idx).IndexOf(JsonConstants.Slash); 2494ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2501return ConsumeSingleLineComment(localBuffer.Slice(1), _consumed); 2505return ConsumeMultiLineComment(localBuffer.Slice(1), _consumed);

System\Text\Json\Reader\Utf8JsonReader.MultiSegment.cs (12)

360if (!TryGetNumberMultiSegment(_buffer.Slice(_consumed), out int numberOfBytes)) 512ReadOnlySpan<byte> span = _buffer.Slice(_consumed); 567ReadOnlySpan<byte> leftToMatch = literal.Slice(span.Length); 615leftToMatch = leftToMatch.Slice(span.Length); 680if (!TryGetNumberMultiSegment(_buffer.Slice(_consumed), out int consumed)) 757ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2243ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed); 2276localBuffer = localBuffer.Slice(1); 2449localBuffer = localBuffer.Slice(p); 2482localBuffer = localBuffer.Slice(1); 2540localBuffer = localBuffer.Slice(1); 2552localBuffer = localBuffer.Slice(nextIdx);

System\Text\Json\Schema\JsonSchemaExporter.cs (1)

503span = span.Slice(pos + 1);

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.cs (1)

86originalSpan.Slice(checked((int)resumptionByteIndex)),

System\Text\Json\Serialization\Converters\Value\EnumConverter.cs (1)

326rest = rest.Slice(i + 1).TrimStart();

System\Text\Json\Writer\JsonWriterHelper.Escaping.cs (5)

98ThrowHelper.ThrowArgumentException_InvalidUTF8(value.Slice(encoderBytesWritten)); 121value = value.Slice(indexOfFirstByteToEscape); 151value = value.Slice(indexOfFirstByteToEscape); 239value = value.Slice(indexOfFirstByteToEscape); 269value = value.Slice(indexOfFirstByteToEscape);

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.StringSegment.cs (8)

87value = value.Slice(charsConsumed - partialStringDataBuffer.Length); 93value = value.Slice(charsConsumed - partialStringDataBuffer.Length); 155PartialUtf16StringData = value.Slice(consumed); 255utf8Value = utf8Value.Slice(bytesConsumed - partialStringDataBuffer.Length); 261utf8Value = utf8Value.Slice(bytesConsumed - partialStringDataBuffer.Length); 321PartialUtf8StringData = utf8Value.Slice(consumed); 411bytes = bytes.Slice(3 - partialStringDataBuffer.Length); 438PartialBase64StringData = bytes.Slice(bytes.Length - leftoverSize);

src\libraries\Common\src\SourceGenerators\SourceWriter.cs (1)

99rest = remainingText.Slice(lineLength + 1);

System\Text\RegularExpressions\RegexFindOptimizations.cs (9)

543int newline = textSpan.Slice(pos).IndexOf('\n'); 619int i = textSpan.Slice(pos).IndexOf(LeadingPrefix.AsSpan()); 634int i = textSpan.Slice(pos).IndexOf(LeadingPrefix.AsSpan(), StringComparison.OrdinalIgnoreCase); 651ReadOnlySpan<char> span = textSpan.Slice(pos); 695int i = textSpan.Slice(pos + FixedDistanceLiteral.Distance).IndexOf(FixedDistanceLiteral.Char); 710int i = textSpan.Slice(pos + FixedDistanceLiteral.Distance).IndexOf(FixedDistanceLiteral.String.AsSpan()); 727int i = textSpan.Slice(pos).IndexOfAny(LeadingStrings); 752ReadOnlySpan<char> textSpanAtOffset = textSpan.Slice(offset); 828ReadOnlySpan<char> slice = textSpan.Slice(startingPos);

System\Text\RegularExpressions\RegexParser.cs (2)

173input = input.Slice(indexOfMetachar); 200input = input.Slice(1);

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexParser.cs (2)

173input = input.Slice(indexOfMetachar); 200input = input.Slice(1);

System\Web\Util\HttpEncoder.cs (2)

152chars = chars.Slice(i + 1); 448foreach (byte b in bytes.Slice(i))

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\ReflectionUtils.cs (5)

61nameSlice = nameSlice.Slice(escapedComma + 2); 107int tokenEnding = assemblyName.Slice(versionIndex + 1).IndexOf(',') + 1; 108int tokenLength = tokenEnding == 0 ? assemblyName.Slice(versionIndex).Length : tokenEnding; 117int tokenEnding = assemblyName.Slice(tokenIndex + 1).IndexOf(',') + 1; 118int tokenLength = tokenEnding == 0 ? assemblyName.Slice(tokenIndex).Length : tokenEnding;

System\Xaml\Parser\GenericTypeNameScanner.cs (1)

161subscript = typeName.Slice(openBracketNdx);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

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

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

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

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);