Slice

ConsoleLogs\AnsiParser.cs (8)

47if (IsConEmuSequence(span[currentPos..], ref currentPos) || 48IsControlSequence(span[currentPos..], ref currentPos, out _, out _) || 49IsLinkControlSequence(span[currentPos..], ref currentPos, out _)) 86if (IsConEmuSequence(span[i..], ref i)) 106if (IsLinkControlSequence(span[i..], ref i, out var url)) 129if (IsControlSequence(span[i..], ref i, out var finalByte, out var parameters)) 313span[currentParamStartPosition..i], 851var indexInSlice = span[startIndex..].IndexOf(value);

EnvVarEscaper.cs (1)

72i += ProcessVariable(input[i..], result, depth + 1);

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

509if (!chunk.Span.Equals(array.AsSpan().Slice(chunkOffset, chunk.Length), StringComparison.Ordinal))

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

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

146source.Slice(0, writable).CopyTo(_span);

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

Linker\TypeReferenceExtensions.cs (1)

401return name.Slice(0, name.Length - type.Name.Length - 1).Equals(type.Namespace, StringComparison.Ordinal);

INamedTypeSymbolExtensions.cs (1)

29roSpan = roSpan.Slice(0, dot > 0 ? dot : 0);

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

349name = name.Slice(0, _nestedNameLength); 395rootFullName = rootFullName.Slice(0, rootTypeName._nestedNameLength); 399rootTypeName._namespace = rootFullName.Slice(0, idx).ToString();

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

85ReadOnlySpan<char> fullTypeName = _inputString.Slice(0, fullTypeNameLength);

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

149return offset < 0 ? input : input.Slice(0, offset);

BadHttpRequestTests.cs (2)

594line = line.AsSpan().Slice(0, nullIndex + 2).ToString(); 606var printableTarget = target.AsSpan().Slice(0, target.IndexOf('\0') + 1).ToString();

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

NavigationManager.cs (1)

297return uri[_baseUri.OriginalString.Length..];

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

381indexOfLiteral = requestSegment.Slice(0, startIndex).LastIndexOf( 388indexOfLiteral = requestSegment.Slice(0, startIndex).LastIndexOf( 462var parameterValueSpan = requestSegment.Slice(parameterStartIndex, parameterTextLength);

FormMapping\FormDataReader.cs (1)

140var endIndex = key.Value.Span[startIndex..].IndexOf(']') + startIndex;

FormMapping\PrefixResolver.cs (10)

59separatorX = x.Value.Span[currentXPos..].IndexOfAny('.', '['); 60separatorY = y.Value.Span[currentYPos..].IndexOfAny('.', '['); 66return MemoryExtensions.CompareTo(x.Value.Span[currentXPos..], y.Value.Span[currentYPos..], StringComparison.Ordinal); 71compare = MemoryExtensions.CompareTo(x.Value.Span[currentXPos..], y.Value.Span[currentYPos..][..separatorY], StringComparison.Ordinal); 81compare = MemoryExtensions.CompareTo(x.Value.Span[currentXPos..][..separatorX], y.Value.Span[currentYPos..], StringComparison.Ordinal); 89compare = MemoryExtensions.CompareTo(x.Value.Span[currentXPos..][..separatorX], y.Value.Span[currentYPos..][..separatorY], StringComparison.Ordinal);

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

77span[remainingLength..].CopyTo(_currentBuffer);

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

240source.Slice(copiedBytes, writable).CopyTo(_span);

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

738span = this.reader.CurrentSpan.Slice(this.reader.CurrentSpanIndex, length); 774string value = StringEncoding.UTF8.GetString(unreadSpan.Slice(0, byteLength)); 1113initializedChars += decoder.GetChars(this.reader.UnreadSpan.Slice(0, bytesRead), charArray.AsSpan(initializedChars), flush);

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

459firstSpan.Slice(0, destination.Length).CopyTo(destination); 485nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));

Routing\NavLink.cs (2)

179return uri.Slice(0, minPos); 202currentUriAbsolute.SequenceEqual(hrefAbsolute.Slice(0, hrefAbsolute.Length - 1), CaseInsensitiveComparer))

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

77span[remainingLength..].CopyTo(_currentBuffer);

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

140var endIndex = key.Value.Span[startIndex..].IndexOf(']') + startIndex;

src\Components\Endpoints\src\FormMapping\PrefixResolver.cs (10)

59separatorX = x.Value.Span[currentXPos..].IndexOfAny('.', '['); 60separatorY = y.Value.Span[currentYPos..].IndexOfAny('.', '['); 66return MemoryExtensions.CompareTo(x.Value.Span[currentXPos..], y.Value.Span[currentYPos..], StringComparison.Ordinal); 71compare = MemoryExtensions.CompareTo(x.Value.Span[currentXPos..], y.Value.Span[currentYPos..][..separatorY], StringComparison.Ordinal); 81compare = MemoryExtensions.CompareTo(x.Value.Span[currentXPos..][..separatorX], y.Value.Span[currentYPos..], StringComparison.Ordinal); 89compare = MemoryExtensions.CompareTo(x.Value.Span[currentXPos..][..separatorX], y.Value.Span[currentYPos..][..separatorY], StringComparison.Ordinal);

RequestBufferingStream.cs (2)

97if (span.Slice(0, innerCount).TryCopyTo(_tailMemory.Span)) 105BuffersExtensions.Write(this, span.Slice(0, innerCount));

ResponseBufferingStream.cs (1)

91var slice = span.Slice(0, innerCount);

IPNetwork.cs (1)

196if (!IPAddress.TryParse(networkSpan.Slice(0, forwardSlashIndex), out prefix))

CookieRequestCultureProvider.cs (2)

79var potentialCultureName = valueSpan[parts[0]]; 80var potentialUICultureName = valueSpan[parts[1]];

Rendering\TagBuilder.cs (1)

191stringBuffer.Append(remainingName.Slice(0, indexOfInvalidCharacter));

FormatterBinaryWriter.cs (1)

201value.Slice(start: 0, length: toWrite).CopyTo(available);

RecyclableSequenceBuilder.cs (1)

105buffer.Slice(0, toWrite).CopyTo(available);

EndToEndBenchmarks.cs (2)

84destination.Write(value.Slice(0, bytes)); 99value.Slice(0, bytes).CopyTo(span);

src\Shared\SegmentWriteStream.cs (1)

146buffer = buffer[bytesWritten..];

ApacheModRewrite\FlagParser.cs (3)

77if (!_ruleFlagLookup.TryGetValue(tokenSpan[hasPayload[0]].ToString(), out flag)) 79throw new FormatException($"Unrecognized flag: '{tokenSpan[hasPayload[0]]}'"); 84flags.SetFlag(flag, tokenSpan[hasPayload[1]].ToString());

Matching\HostMatcherPolicy.cs (8)

102host = host.Slice(0, pivot); 162if (!hostSpan[hostParts[0]].IsEmpty) 164return new EdgeKey(hostSpan[hostParts[0]].ToString(), null); 169if (!hostSpan[hostParts[0]].IsEmpty) 171if (int.TryParse(hostSpan[hostParts[1]], out var port)) 173return new EdgeKey(hostSpan[hostParts[0]].ToString(), port); 175else if (hostSpan[hostParts[1]].Equals(WildcardHost, StringComparison.Ordinal)) 177return new EdgeKey(hostSpan[hostParts[0]].ToString(), null);

Patterns\RoutePatternMatcher.cs (3)

381indexOfLiteral = requestSegment.Slice(0, startIndex).LastIndexOf( 388indexOfLiteral = requestSegment.Slice(0, startIndex).LastIndexOf( 462var parameterValueSpan = requestSegment.Slice(parameterStartIndex, parameterTextLength);

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

113ref Unsafe.As<byte, long>(ref MemoryMarshal.GetReference(timingInfo.Span[sizeof(long)..])),

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

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

113ref Unsafe.As<byte, long>(ref MemoryMarshal.GetReference(timingInfo.Span[sizeof(long)..])),

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

146source.Slice(0, writable).CopyTo(_span);

Internal\Http\Http1Connection.cs (1)

863var clientPrefaceRequestLine = Http2.Http2Connection.ClientPreface.Slice(0, PrefaceLineLength);

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

14818output.Write(HeaderBytes.Slice(640, 18)); 15174var headerKey = HeaderBytes.Slice(keyStart, keyLength);

Internal\Http\HttpParser.cs (5)

227span = span.Slice(0, crIndex); 233span = span.Slice(0, span.Length - 1); 283span = span.Slice(0, lfIndex); 549handler.OnHeader(name: headerLine.Slice(0, nameEnd), value: headerLine[valueStart..valueEnd]);

Internal\Http2\Http2Connection.cs (1)

643httpVersion = HttpUtilities.GetKnownVersion(requestLine.Slice(requestLine.Length - 9, 8));

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

249ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 310data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 394data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 595: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 605: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

146source.Slice(0, writable).CopyTo(_span);

HttpParserTests.cs (2)

94line = line.AsSpan().Slice(0, nullIndex + 2).ToString(); 146var line = method.AsSpan().Slice(0, nullIndex + 1).ToString();

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

113ref Unsafe.As<byte, long>(ref MemoryMarshal.GetReference(timingInfo.Span[sizeof(long)..])),

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

249ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 310data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 394data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 595: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 605: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

src\Shared\SegmentWriteStream.cs (1)

146buffer = buffer[bytesWritten..];

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

146source.Slice(0, writable).CopyTo(_span);

FormPipeReader.cs (2)

174keyValuePair = span.Slice(0, ampersand); 213key = keyValuePair.Slice(0, equals);

HttpResponseStreamWriter.cs (1)

662var source = value.Slice(0, remaining);

QueryHelpers.cs (1)

90uriToBeAppended = uriToBeAppended.Slice(0, anchorIndex);

Hashing\XxHashShared.cs (3)

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

InternalUtilities\LittleEndianReader.cs (1)

46var result = _span.Slice(0, byteCount);

InternalUtilities\StringTable.cs (1)

509if (!chunk.Span.Equals(array.AsSpan().Slice(chunkOffset, chunk.Length), StringComparison.Ordinal))

MetadataReader\MetadataHelpers.cs (1)

522if (tryScanArity(emittedTypeName[indexOfManglingChar..]) is not short arity)

Syntax\SyntaxTriviaListBuilder.cs (1)

101items.Slice(offset, length).CopyTo(_nodes.AsSpan().Slice(_count, length));

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

CSharpParseOptions.cs (1)

224singleNamespaceBuilder.Add(@namespace.Slice(currentIndex, dotIndex - currentIndex).ToString());

Parser\LanguageParser_InterpolatedString.cs (6)

109originalTextSpan[currentContentStart..interpolation.OpenBraceRange.Start])); 126originalTextSpan[currentContentStart..closeQuoteRange.Start])); 139var closeQuoteText = originalTextSpan[closeQuoteRange]; 148return closeQuoteText[afterNewLine..afterWhitespace]; 185var currentLineWhitespace = text[lineStartPosition..currentIndex]; 347var slice = text[start..currentIndex];

Attributes\AttributeTests_WellKnownAttributes.cs (1)

39var typeName = spanName.Slice(0, lastDotIndex);

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (1)

199foreach (var c in span.Slice(0, end))

EditAndContinue\SourceMarkers.cs (1)

133var regionText = plainSource.AsSpan().Slice(exceptionRegion.Index, exceptionRegion.Length);

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

TestHelpers.cs (1)

165bytes[i] = parseByte(input.Slice(i << 1, 2), NumberStyles.HexNumber);

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

509if (!chunk.Span.Equals(array.AsSpan().Slice(chunkOffset, chunk.Length), StringComparison.Ordinal))

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

46var result = _span.Slice(0, byteCount);

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

509if (!chunk.Span.Equals(array.AsSpan().Slice(chunkOffset, chunk.Length), StringComparison.Ordinal))

XxHash128Tests.cs (1)

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

DataFrameColumns\ArrowStringDataFrameColumn.cs (1)

246return _dataBuffers[offsetsBufferIndex].ReadOnlySpan.Slice(currentOffset, numberOfBytes);

PrimitiveColumnContainer.BinaryOperations.cs (3)

136arithmetic.HandleOperation(operation, leftSpan.Slice(0, availableInRetSpan), rightSpan.Slice(0, availableInRetSpan), retSpan.Slice(retOffset)); 178arithmetic.HandleOperation(operation, leftSpan.Slice(0, availableInRetSpan), right, retSpan.Slice(retOffset));

ReadOnlyDataFrameBuffer.cs (1)

44get => (MemoryMarshal.Cast<byte, T>(ReadOnlyBuffer.Span)).Slice(0, Length);

ArrayComparer.cs (6)

99Assert.True(expectedArray.Values.Slice(0, expectedArray.Length).SequenceEqual(actualArray.Values.Slice(0, actualArray.Length))); 113Assert.True(expectedArray.Values.Slice(0, booleanByteCount).SequenceEqual(actualArray.Values.Slice(0, booleanByteCount))); 126Assert.True(expectedArray.Values.Slice(0, expectedArray.Length).SequenceEqual(actualArray.Values.Slice(0, actualArray.Length)));

Helpers.cs (2)

32return value.Slice(wordStart.Value, idx - wordStart.Value); 53return value.Slice(0, 0);

AzureAIInferenceEmbeddingGenerator.cs (1)

133base64 = base64.Slice(1, base64.Length - 2);

Common\NGramExtensions.cs (3)

35ReadOnlySpan<T> next = input.Slice(0, Math.Min(n, input.Length)); 42next = input.Slice(0, Math.Min(n, input.Length)); 78nGrams.Add(new NGram<T>(input.Slice(i, s)));

Utilities\JsonOutputFixer.cs (1)

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

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

161ReadOnlySpan<byte> nextLine = data.Slice(0, lineLength);

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

364fieldName = line.Slice(0, colonPos);

Classification\DataClassificationTypeConverter.cs (1)

103taxonomyName = valueSpan.Slice(0, index).ToString();

ConfigurationKeyComparer.cs (2)

45xDelimiterIndex == -1 ? xSpan : xSpan.Slice(0, xDelimiterIndex), 46yDelimiterIndex == -1 ? ySpan : ySpan.Slice(0, yDelimiterIndex));

Http\DownstreamDependencyMetadataManager.cs (3)

114routeSpan = routeSpan.Slice(0, routeSpan.Length - 1); 370requestRouteAsSpan = requestRouteAsSpan.Slice(0, requestRouteAsSpan.Length - 1); 404var nextDelimiterIndex = requestRouteAsSpan.Slice(i, requestPathEndIndex - i).IndexOf(trieCurrent.Delimiter) + i;

Http\HttpRouteFormatter.cs (5)

206_ = outputBuffer.AppendRedacted(redactor, httpPath.Slice(startIndex, length)); 213_ = outputBuffer.Append(httpPath.Slice(startIndex, length).ToString()); 222_ = outputBuffer.Append(httpPath.Slice(startIndex, length).ToString()); 247_ = outputBuffer.AppendRedacted(redactor, httpPath.Slice(startIndex, length)); 254_ = outputBuffer.Append(httpPath.Slice(startIndex, length).ToString());

Http\HttpRouteParser.cs (6)

257HttpRouteParameterRedactionMode.None => httpPath.Slice(startIndex, length).ToString(), 279return redactor.Redact(httpPathAsSpan.Slice(startIndex, length)); 282return httpPathAsSpan.Slice(startIndex, length).ToString(); 287return httpPathAsSpan.Slice(startIndex, length).ToString(); 309return redactor.Redact(httpPathAsSpan.Slice(startIndex, length)); 312return httpPathAsSpan.Slice(startIndex, length).ToString();

XamlLoader.cs (1)

431 var slice = xaml.AsSpan().Slice(index, fullName.Length);

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

41 segment = query.Slice(0, delimeterIndex); 58 name = segment.Slice(0, equalIndex).ToString();

Color.cs (19)

Data\ReadOnlyMemoryUtils.cs (2)

226sb.AppendSpan(span.Slice(min, j - min)).Append(ch); 233sb.AppendSpan(span.Slice(min, j - min));

Utilities\BigArray.cs (5)

346src.Slice(0, firstSubArrayCapacity).CopyTo(_entries[maMin].AsSpan(miMin)); 349src.Slice(firstSubArrayCapacity, miLim).CopyTo(_entries[maMax]); 358src.Slice(0, srcSoFar).CopyTo(_entries[maMin].AsSpan(miMin)); 364src.Slice(srcSoFar, BlockSize).CopyTo(_entries[major]); 372src.Slice(srcSoFar, miLim).CopyTo(_entries[maMax]);

Utilities\DoubleParser.cs (2)

143if (!DoubleParser.TryParse(span.Slice(ich, span.Length - ich), out value, out ichEnd, flags)) 195if (!DoubleParser.TryParse(span.Slice(ich, span.Length - ich), out value, out ichEnd, flags))

Utilities\LineParser.cs (3)

33if (DoubleParser.TryParse(valuesToParse.Slice(toParseStartIndex, i - toParseStartIndex), out float parsed)) 40if (float.TryParse(valuesToParse.Slice(toParseStartIndex, i - toParseStartIndex).ToString(), out float parsed)) 50return (true, trimmedLine.Slice(0, firstSeparatorIndex).ToString(), values);

CpuMathUtils.cs (9)

56TensorPrimitives.Multiply(source.Slice(0, count), value, destination); 75TensorPrimitives.MultiplyAdd(source.Slice(0, count), scale, destination.Slice(0, count), destination); 97TensorPrimitives.MultiplyAdd(source.Slice(0, count), scale, destination.Slice(0, count), result.Slice(0, count)); 115TensorPrimitives.Add(source.Slice(0, count), destination.Slice(0, count), destination.Slice(0, count)); 136TensorPrimitives.Multiply(left.Slice(0, count), right.Slice(0, count), destination.Slice(0, count)); 194return TensorPrimitives.Dot(left.Slice(0, count), right.Slice(0, count));

CpuMathUtils.netcoreapp.cs (2)

443var value = TensorPrimitives.Distance(left.Slice(0, count), right.Slice(0, count));

DataLoadSave\Text\TextLoaderParser.cs (3)

1232_sb.AppendSpan(span.Slice(ichRun, ichCur - ichRun)); 1266_sb.AppendSpan(span.Slice(ichRun, ichCur - ichRun - 1)); 1276_sb.AppendSpan(span.Slice(ichRun, ichCur - ichRun));

DataLoadSave\Text\TextSaver.cs (2)

841sb.AppendSpan(span.Slice(ichRun, ichCur - ichRun)); 848sb.AppendSpan(span.Slice(ichRun, ichCur - ichRun));

DataView\Transposer.cs (3)

1191_inputValue.GetValues().Slice(min, len).CopyTo(editor.Values); 1209_inputValue.GetIndices().Slice(smin, scount).CopyTo(editor.Indices); 1217_inputValue.GetValues().Slice(smin, scount).CopyTo(editor.Values);

PcaTrainer.cs (2)

538writer.WriteSinglesNoCount(_mean.GetValues().Slice(0, _dimension)); 544writer.WriteSinglesNoCount(_eigenVectors[i].GetValues().Slice(0, _dimension));

Model\BPETokenizer.cs (10)

461EncodeWithCache(textSpanToEncode.Slice(split.Offset, split.Length), tokens, split.Offset, ref priorityQueue); 522EncodeToIdsWithCache(textSpanToEncode.Slice(split.Offset, split.Length), ids, maxTokenCount - ids.Count, out int length, ref priorityQueue); 583count += EncodeToIdsWithCache(textSpanToEncode.Slice(split.Offset, split.Length), null, maxTokenCount - count, out int length, ref priorityQueue); 663count += EncodeToIdsWithCache(textSpanToEncode.Slice(split.Offset, split.Length), null, maxTokenCount - count, out int length, ref priorityQueue); 717tokenCount += EncodeToIdsFromEndWithCache(textSpanToEncode.Slice(split.Offset, split.Length), null, maxTokenCount - tokenCount, out int textIndex, ref priorityQueue); 856span = span.Slice(0, span.Length - EndOfWordSuffix.Length); 953sSpan = sSpan.Slice(0, sSpan.Length - EndOfWordSuffix!.Length); 1032span = span.Slice(0, span.Length - EndOfWordSuffix.Length); 1202s = w.Slice(i, 2); 1207s = w.Slice(i, 1);

Model\CodeGenTokenizer.cs (6)

391EncodeInternal(null, textSpanToEncode.Slice(split.Offset, split.Length), tokens, addPrefixSpace, split.Offset, agenda); 632EncodeToIdsInternal(null, textSpanToEncode.Slice(split.Offset, split.Length), ids, agenda, out int length, maxTokenCount - ids.Count); 844count += EncodeToIdsInternal(null, textSpanToEncode.Slice(split.Offset, split.Length), null, agenda, out int length, maxTokenCount - count); 983tokenCount += EncodeToIdsFromEndInternal(null, textSpanToEncode.Slice(split.Offset, split.Length), null, agenda, out int textIndex, maxTokenCount - tokenCount); 1693if (!_mergeRanks.TryGetValue(textSpan.Slice(symbols[left].pieceSpan.Index, symbols[left].pieceSpan.Length), textSpan.Slice(symbols[right].pieceSpan.Index, symbols[right].pieceSpan.Length), out int rank))

Model\EnglishRobertaTokenizer.cs (4)

337foreach (EncodedToken t in EncodeInternal(textSpanToEncode.Slice(split.Offset, split.Length))) 441EncodeToIdsInternal(textSpanToEncode.Slice(split.Offset, split.Length), ids, out int length, maxTokenCount - ids.Count); 525count += EncodeToIdsInternal(textSpanToEncode.Slice(split.Offset, split.Length), null, out int length, maxTokenCount - count); 572tokenCount += EncodeToIdsFromEndInternal(textSpanToEncode.Slice(split.Offset, split.Length), null, out int textIndex, maxTokenCount - tokenCount);

Model\SentencePieceBpeModel.cs (28)

Model\SentencePieceUnigramModel.cs (14)

Model\TiktokenTokenizer.cs (6)

282EncodeToTokens(textSpanToEncode.Slice(split.Offset, split.Length), tokens, split.Offset); 309value[i].TokenLength == 0 ? string.Empty : text.Slice(value[i].TokenIndex, value[i].TokenLength).ToString(), 350encodedTokens[i].TokenLength == 0 ? string.Empty : text.Slice(encodedTokens[i].TokenIndex, encodedTokens[i].TokenLength).ToString(), 393EncodeToIds(textSpanToEncode.Slice(split.Offset, split.Length), ids, out int length, maxTokenCount - ids.Count); 560count += CountTokens(textSpanToEncode.Slice(split.Offset, split.Length), out int length, maxTokenCount - count); 687tokenCount += CountTokensFromEnd(textSpanToEncode.Slice(split.Offset, split.Length), out int textIndex, maxTokenCount - tokenCount);

Model\WordPieceTokenizer.cs (6)

296EncodeToTokens(textSpanToEncode.Slice(split.Offset, split.Length), tokens, split.Offset); 341scoped ReadOnlySpan<char> subStr = text.Slice(start, end - start); 420EncodeToIds(textSpanToEncode.Slice(split.Offset, split.Length), ids, out int length, maxTokenCount - ids.Count); 482scoped ReadOnlySpan<char> subStr = text.Slice(start, end - start); 570count += EncodeToIds(textSpanToEncode.Slice(split.Offset, split.Length), accumulatedIds: null, out int length, maxTokenCount - count); 649int count = EncodeToIds(textSpanToEncode.Slice(split.Offset, split.Length), accumulatedIds: null, out charsConsumed, settings.MaxTokenCount - tokenCount);

Normalizer\BertNormalizer.cs (1)

85int length = original.AsSpan().Slice(i, inc + 1).ToLowerInvariant(casingBuffer);

Normalizer\SentencePieceNormalizer.cs (4)

213if (startIndex + tokenLength <= endIndex && original.Slice(startIndex, tokenLength).SequenceEqual(token.AsSpan())) 358ReadOnlySpan<byte> normalizedByte = normalizedPrefix.Length == 0 ? input.Slice(0, p) : normalizedPrefix.Span; 389ReadOnlySpan<byte> sp = normalizedPrefix.Length == 0 ? input.Slice(0, p) : normalizedPrefix.Span; 526fixed (byte* pBlob = blob.Slice(0, (int)trieBlobSize))

UnigramTests.cs (1)

551Assert.Equal(decodedString.AsSpan().Slice(0, charsWritten).ToString(), buffer.AsSpan().Slice(0, charsWritten).ToString());

Text\LdaSingleBox.cs (2)

206termID.Slice(0, termNum).CopyTo(pID); 273termID.Slice(0, termNum).CopyTo(pID);

Text\TextNormalizing.cs (4)

404buffer.AppendSpan(span.Slice(min, i - min)); 414buffer.AppendSpan(span.Slice(min, i - min)); 431buffer.AppendSpan(span.Slice(min, i - min)).Append(ch); 447buffer.AppendSpan(span.Slice(min, len));

MediaTypeHeaderValue.cs (2)

647mediaType = string.Concat(input.AsSpan().Slice(startIndex, typeLength), "/", input.AsSpan().Slice(current, subtypeLength));

SpanBasedStringBuilder.cs (1)

180if (!MemoryExtensions.Equals(other.Slice(otherIndex, internalSpan.Length), internalSpan.Span, comparison))

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

66fullName = fullName.Slice(0, fullName.Length - nameSlice.Length + commaIndex); 110assemblyVersion = assemblyName.Slice(versionIndex + Version.Length, tokenLength - Version.Length); 122assemblyToken = assemblyName.Slice(tokenIndex + PublicKeyToken.Length, tokenLength - PublicKeyToken.Length);

MS\Internal\FontCache\FamilyCollection.cs (1)

494faceName = faceName.Slice(0, indexOfSpace);

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

790int lastByteOffset = Int32.Parse(contentRangeSpan.Slice(0, index), NumberStyles.None, NumberFormatInfo.InvariantInfo);

System\Windows\TextDecorationCollectionConverter.cs (1)

94ReadOnlySpan<char> decoration = decorationsSpan[segment].Trim();

Microsoft\Win32\FileDialog.cs (2)

729int i = exts[ext].LastIndexOf('.'); 735extensions.Add(exts[ext].Slice(i + 1).ToString());

MS\Internal\Annotations\Anchoring\FixedTextSelectionProcessor.cs (4)

505start = GetPoint(segmentValueSpan[splitRegions[0]], segmentValueSpan[splitRegions[1]]); 506end = GetPoint(segmentValueSpan[splitRegions[2]], segmentValueSpan[splitRegions[3]]);

MS\Internal\Annotations\Anchoring\TextSelectionProcessor.cs (2)

444startOffset = int.Parse(segmentString[splitRegions[0]], NumberFormatInfo.InvariantInfo); 445endOffset = int.Parse(segmentString[splitRegions[1]], NumberFormatInfo.InvariantInfo);

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

104stringBuilder.Append(contentSpan.Slice(0, firstEscapeToken)); 133if (contentSpan.Slice(0, 6).SequenceEqual(""")) 139else if (contentSpan.Slice(0, 6).SequenceEqual("'")) 148if (contentSpan.Slice(0, 5).SequenceEqual("&")) 157if (contentSpan.Slice(0, 4).SequenceEqual("<")) 163else if (contentSpan.Slice(0, 4).SequenceEqual(">"))

System\Windows\Annotations\Annotation.cs (3)

636ReadOnlySpan<char> name = typeName[segments[0]]; 646ReadOnlySpan<char> @namespace = typeName[segments[0]]; 647ReadOnlySpan<char> name = typeName[segments[1]];

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

258ReadOnlySpan<char> valueString = valueSpan.Slice(0, valueSpan.Length - strLenUnit);

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

12001_fileName = traceSplits[splitRegions[0]].ToString(); 12005if (int.TryParse(traceSplits[splitRegions[1]], NumberStyles.Integer, CultureInfo.InvariantCulture, out int flushDepth)) 12013if (int.TryParse(traceSplits[splitRegions[2]], NumberStyles.Integer, CultureInfo.InvariantCulture, out int luThreshold))

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

444return new string[] { attrValueSpan.Slice(0, spacePos).ToString() };

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

416ReadOnlySpan<char> characterClusterSpec = valueSpec.Slice(firstBracket + 1, secondBracket - (firstBracket + 1)); 424ReadOnlySpan<char> characterClusterSpec = valueSpec.Slice(firstBracket + 1, colon - (firstBracket + 1)); 426ReadOnlySpan<char> glyphClusterSpec = valueSpec.Slice(colon + 1, secondBracket - (colon + 1));

System\Windows\Documents\TextStore.cs (2)

4666_fileName = traceSplits[splitRegions[0]].ToString(); 4670if (int.TryParse(traceSplits[splitRegions[1]], NumberStyles.Integer, CultureInfo.InvariantCulture, out int flushDepth))

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

3561s = s.Slice(0, n + 1); 3823ReadOnlySpan<char> onenum = thickness.Slice(s, e - s);

System\Windows\LengthConverter.cs (1)

204valueSpan = valueSpan.Slice(0, valueSpan.Length - pixelUnit.Name.Length);

System\Windows\Markup\XamlFigureLengthSerializer.cs (1)

240ReadOnlySpan<char> valueString = valueSpan.Slice(0, valueSpan.Length - strLenUnit);

System\Windows\Markup\XamlGridLengthSerializer.cs (1)

240ReadOnlySpan<char> valueString = valueSpan.Slice(0, valueSpan.Length - strLenUnit);

System\Windows\ThemeDictionaryExtension.cs (1)

138return GenerateUri(info.AssemblyName, resourceName, nameSpan[splitRegions[1]]);

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

1872zoomString = zoomString.Slice(0, zoomString.Length - 1);

Replay.cs (1)

260var argName = line.AsSpan().Slice(0, index).ToString();

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

ServerSentEvents\SseFormatter.cs (1)

161ReadOnlySpan<byte> nextLine = data.Slice(0, lineLength);

ServerSentEvents\SseParser_1.cs (1)

364fieldName = line.Slice(0, colonPos);

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

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(HashIndex, HashCount));

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

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(HashIndex, HashCount));

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

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinal(s.Slice(HashIndex, HashCount));

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_RightJustifiedSubstring.cs (1)

28private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinal(s.Slice(s.Length + HashIndex, HashCount));

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

27private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(HashIndex, HashCount));

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

27private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(HashIndex, HashCount));

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

25private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinal(s.Slice(HashIndex, HashCount));

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_RightJustifiedSubstring.cs (1)

25private protected override int GetHashCode(ReadOnlySpan<char> s) => Hashing.GetHashCodeOrdinal(s.Slice(s.Length + HashIndex, HashCount));

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

275Node left = NodeTreeFromList(items.Slice(0, leftCount));

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

76return potentialPhoneNumber.Slice(0, lastIndexOfExtension); 88return potentialPhoneNumber.Slice(0, lastIndexOfExtension); 100return potentialPhoneNumber.Slice(0, lastIndexOfExtension);

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

641 => PossibleKnownColor(Color.FromArgb(IntFromString(textSpan[tokens[0]], culture))), 653 => PossibleKnownColor(Color.FromArgb(IntFromString(textSpan[tokens[0]], culture), IntFromString(textSpan[tokens[1]], culture), IntFromString(textSpan[tokens[2]], culture))), 664 => PossibleKnownColor(Color.FromArgb(IntFromString(textSpan[tokens[0]], culture), IntFromString(textSpan[tokens[1]], culture), IntFromString(textSpan[tokens[2]], culture), IntFromString(textSpan[tokens[3]], culture))),

System\ComponentModel\Design\Serialization\RootDesignerSerializerAttribute.cs (1)

86baseType = baseType.Slice(0, comma);

System\ConsolePal.Unix.cs (1)

648dst.AppendExtraBuffer(src.Slice(i, 1));

System\IO\KeyParser.cs (2)

134key = MapEscapeSequenceNumber(byte.Parse(input.Slice(SequencePrefixLength, digitCount))); 165? MapEscapeSequenceNumber(byte.Parse(input.Slice(SequencePrefixLength, digitCount)))

System\Diagnostics\Activity.cs (2)

1967if (!Utf8Parser.TryParse(idData.Slice(0, 16), out span[0], out _, 'x')) 1974if (!Utf8Parser.TryParse(idData.Slice(16, 16), out span[1], out _, 'x'))

System\Diagnostics\DsesFilterAndTransform.cs (5)

229activitySourceName = entry.Slice(0, eventNameIndex).Trim(); 236eventName = suffixPart.Slice(0, samplingResultIndex).Trim(); 256|| !double.TryParse(suffixPart.Slice(c_ParentRatioSamplerPrefix.Length, endingLocation - c_ParentRatioSamplerPrefix.Length), NumberStyles.Float, CultureInfo.InvariantCulture, out double ratio)) 274suffixPart.Slice(c_ParentRateLimitingSamplerPrefix.Length, endingLocation - c_ParentRateLimitingSamplerPrefix.Length), 332activitySourceName = activitySourceName.Slice(0, plusSignIndex).Trim();

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

276tags = tags.Slice(0, _tagsCount); 305((ReadOnlySpan<KeyValuePair<string, object?>>)_tags).Slice(0, _tagsCount);

System\Diagnostics\W3CPropagator.cs (4)

100ReadOnlySpan<char> currentEntry = entrySeparator >= 0 ? baggageSpan.Slice(0, entrySeparator) : baggageSpan; 108ReadOnlySpan<char> keySpan = currentEntry.Slice(0, keyValueSeparator); 151ReadOnlySpan<char> entry = commaIndex >= 0 ? traceStateSpan.Slice(0, commaIndex) : traceStateSpan; 165if (IsInvalidTraceStateKey(Trim(entry.Slice(0, equalIndex))) || IsInvalidTraceStateValue(TrimSpaceOnly(entry.Slice(equalIndex + 1))))

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

209major = ParseUInt16UntilNonDigit(versionSpan[parts[0]], out bool endedEarly); 212minor = ParseUInt16UntilNonDigit(versionSpan[parts[1]], out endedEarly); 215build = ParseUInt16UntilNonDigit(versionSpan[parts[2]], out endedEarly); 218priv = ParseUInt16UntilNonDigit(versionSpan[parts[3]], out _);

src\libraries\Common\src\Interop\Linux\cgroups\Interop.cgroups.cs (2)

421if (lineSpan[lineParts[0]] is "0" && lineSpan[lineParts[1]].IsEmpty)

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

88switch (line.Slice(0, startIndex)) // name

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

43ReadOnlySpan<char> root = line[fields.Current]; 50ReadOnlySpan<char> mountPoint = line[fields.Current]; 67ReadOnlySpan<char> fileSystemType = line[fields.Current]; 80ReadOnlySpan<char> superOptions = line[fields.Current];

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

310string? name = GetUntruncatedNameFromArg(argRemainder.Slice(0, argEnd), prefix: stat.comm); 321name = GetUntruncatedNameFromArg(argRemainder.Slice(0, argEnd), prefix: stat.comm);

System\Drawing\Icon.cs (1)

541ReadOnlySpan<byte> bestImage = reader.Span.Slice((int)_bestImageOffset, (int)_bestBytesInRes);

System\Drawing\Imaging\ColorPalette.cs (1)

70new((int)buffer[0], ARGB.ToColorArray(buffer.Slice(2, (int)buffer[1])));

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

641 => PossibleKnownColor(Color.FromArgb(IntFromString(textSpan[tokens[0]], culture))), 653 => PossibleKnownColor(Color.FromArgb(IntFromString(textSpan[tokens[0]], culture), IntFromString(textSpan[tokens[1]], culture), IntFromString(textSpan[tokens[2]], culture))), 664 => PossibleKnownColor(Color.FromArgb(IntFromString(textSpan[tokens[0]], culture), IntFromString(textSpan[tokens[1]], culture), IntFromString(textSpan[tokens[2]], culture), IntFromString(textSpan[tokens[3]], culture))),

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

382bytes.Slice(i, 2).ToArray(),

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

524ReadOnlySpan<byte> topSpan = source.Slice(topOffset, topLength); 574ReadOnlySpan<byte> tmpSpan = source.Slice(topOffset, topLength);

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

642return source.Slice(0, len); 654return source.Slice(offset, length); 673return source.Slice(offset, lengthVal);

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

389ReadOnlySpan<byte> topSpan = source.Slice(topOffset, topLength); 438ReadOnlySpan<byte> topSpan = source.Slice(topOffset, topLength);

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

111ReadOnlySpan<byte> current = remaining.Slice(0, consumed);

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

174remainingData.Slice(0, MaxCERContentSize).CopyTo(dest);

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

151remainingData.Slice(0, MaxCERSegmentSize).CopyTo(dest);

System\Formats\Asn1\WellKnownOids.cs (99)

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

139ReadOnlySpan<byte> previousKeyEncoding = buffer.Slice(previousKeyEncodingRange.Offset, previousKeyEncodingRange.Length); 140ReadOnlySpan<byte> currentKeyEncoding = buffer.Slice(currentKeyEncodingRange.Offset, currentKeyEncodingRange.Length); 210return _reader._data.Span.Slice(range.Offset, range.Length);

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

45buffer.Slice(bytesRead, length).CopyTo(result); 86buffer.Slice(bytesRead, length).CopyTo(destination); 189ReadOnlySpan<byte> encodedString = buffer.Slice(bytesRead, length); 237ReadOnlySpan<byte> encodedSlice = buffer.Slice(bytesRead, byteLength); 340source.Slice(o, l).CopyTo(target); 365source.Slice(o, l).CopyTo(destination); 386concatenatedStringSize += ValidateUtf8AndGetCharCount(buffer.Slice(o, l), utf8Encoding); 403int charsWritten = CborHelpers.GetChars(input.utf8Encoding, source.Slice(o, l), target); 421concatenatedStringSize += ValidateUtf8AndGetCharCount(buffer.Slice(o, l), utf8Encoding); 432CborHelpers.GetChars(utf8Encoding, buffer.Slice(o, l), destination); 497ReadOnlySpan<byte> encodedSlice = buffer.Slice(bytesRead, byteLength);

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

44&& bytes.Slice(SerializedStreamHeaderRecord.Size - HeaderSuffix.Length, HeaderSuffix.Length).SequenceEqual(HeaderSuffix);

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

139sb.Append(path.Slice(0, skip)); 235path.Slice(0, path.Length - 1) :

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

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

571name = name.Slice(0, utf16NameTruncatedLength); 613prefix = pathNameBytes.Slice(0, lastIdx); 627prefix = pathNameBytes.Slice(0, lastIdx); 691linkName = linkName.Slice(0, truncatedLength); 749uName = uName.Slice(0, truncatedLength); 767gName = gName.Slice(0, truncatedLength); 1063bytesToWrite = bytesToWrite.Slice(0, numToCopy); 1080bytesToWrite = bytesToWrite.Slice(0, numToCopy);

System\IO\Compression\ZipBlocks.Async.cs (1)

188dynamicHeader = buffer.Span[FieldLocations.DynamicData..];

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

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

43ReadOnlySpan<char> root = line[fields.Current]; 50ReadOnlySpan<char> mountPoint = line[fields.Current]; 67ReadOnlySpan<char> fileSystemType = line[fields.Current]; 80ReadOnlySpan<char> superOptions = line[fields.Current];

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

139sb.Append(path.Slice(0, skip)); 235path.Slice(0, path.Length - 1) :

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

99source.Slice(0, remain).CopyTo(_holdback.AsSpan(held));

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

40source = source.Slice(0, StripeSize);

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

99source.Slice(0, remain).CopyTo(_holdback.AsSpan(held));

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

51source = source.Slice(0, StripeSize);

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

266source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 305source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 318source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

293_type = ValidateToken(typeAndSubType.Slice(0, forwardSlashPos).ToString()); 336ValidateToken(parameterAndValue.Slice(0, equalSignIndex).ToString()), 337ValidateQuotedStringOrToken(parameterAndValue.Slice(parameterStartIndex, parameterValueLength).ToString()));

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

357pieceStream.Write(buffer.Slice(totalBytesWritten, numBytesToWriteInCurrentPiece));

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

1105source.Slice(0, writable).CopyTo(destination);

System\Linq\SegmentedArrayBuilder.cs (3)

71foreach (T[] segment in segments.Slice(0, segmentsCount)) 145ReadOnlySpan<T> sourceSlice = sourceSpan.Slice(0, Math.Min(availableSpaceInCurrentSpan, sourceSpan.Length)); 318foreach (T[] arr in ((ReadOnlySpan<T[]>)_segments).Slice(0, segmentsCount))

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

151sourceSpan.Slice(sourceIndex, destination.Length).CopyTo(destination); 172return span.Slice(minInclusive, GetAdjustedCount(minInclusive, _maxIndexInclusive, span.Length)).IndexOf(item);

System\Buffers\BuffersExtensions.cs (1)

138input.Slice(0, writeSize).CopyTo(destination);

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

189return span.Slice(startIndex, endIndex - startIndex); 213return span.Slice(startIndex, (endIndex & ReadOnlySequence.IndexBitMask) - startIndex); 224return memory.Span.Slice(startIndex & ReadOnlySequence.IndexBitMask, endIndex - startIndex); 656first = first.Slice(startIndex, endIndex - startIndex);

System\Buffers\SequenceReader.cs (2)

419firstSpan.Slice(0, destination.Length).CopyTo(destination); 445nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));

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

25span = index == 0 ? default : remaining.Slice(0, index); 61span = remaining.Slice(0, index); 337span = remaining.Slice(0, index); 422span = remaining.Slice(0, index); 841currentSpan = currentSpan.Slice(0, next.Length);

System\Text\EncodingExtensions.cs (2)

434: encoder.GetByteCount(chars.Slice(0, MaxInputElementsPerIteration), flush: false /* this isn't the end of the data */); 527: decoder.GetCharCount(bytes.Slice(0, MaxInputElementsPerIteration), flush: false /* this isn't the end of the data */);

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

120_content.Span.Slice(_position, buffer.Length).CopyTo(buffer);

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

120_content.Span.Slice(_position, buffer.Length).CopyTo(buffer);

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

198ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 448data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 479data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 508: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 523: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackDecoder.cs (5)

249ReadOnlySpan<byte> headerBytes = data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length); 310data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 394data.Slice(currentIndex, count).CopyTo(_stringOctets.AsSpan(_stringIndex)); 595: data.Slice(_headerValueRange.GetValueOrDefault().start, _headerValueRange.GetValueOrDefault().length); 605: data.Slice(_headerNameRange.GetValueOrDefault().start, _headerNameRange.GetValueOrDefault().length);

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

419source.Slice(0, block.Length).CopyTo(block.Span);

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

77builder.Append(escapedChars.Slice(0, indexOfEscapedSpace));

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

259builder.Append(value.Slice(0, idx)); 328else if (!TryReadQuotedValue(quoted.Slice(0, idx), out host)) 368builder.Append(value.Slice(0, idx));

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

289dateString = dateString.Slice(1, dateString.Length - 2); 461processedInputSpan[parts[0]] is not "\"=" || 462processedInputSpan[parts[4]] is not "=\"" || 463!processedInputSpan[parts[2]].Equals("b", StringComparison.OrdinalIgnoreCase))

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

85Encoding.ASCII.GetChars(utf8.Slice(0, length), builder.AppendSpan(length)); 100foreach (byte b in utf8.Slice(0, length))

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

170return encoding.GetString(firstBuffer[bomLength..]); 1002buffer.Slice(0, remainingInCurrentBuffer.Length).CopyTo(remainingInCurrentBuffer);

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

166slice = slice.Slice(0, index);

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

431sb.Append(valueSpan.Slice(0, i)).Append('\\').Append(valueSpan[i]);

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

726frameData = frameData.Slice(0, frameData.Length - padLength); 765if ((frameHeader.StreamId != 0 && originLength == 0) || (frameHeader.StreamId == 0 && span.Length >= originLength && span.Slice(0, originLength).SequenceEqual(_pool.Http2AltSvcOriginUri)))

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

1226throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_line, Encoding.ASCII.GetString(buffer.Slice(0, newLineIndex)))); 1244name = name.Slice(0, spIdx); 1270value = value.Slice(0, spIdx); 1395WriteToBuffer(source.Slice(0, remaining)); 1426WriteToBuffer(source.Span.Slice(0, remaining)); 1615line = buffer.Slice(0, length); 1751available.Slice(0, toCopy).CopyTo(buffer);

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

240uri = new Uri($"{uriSpan[tokens[0]]}//:@{uriSpan[tokens[2]]}");

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

261if ((proxyType & wantedFlag) != 0 && Uri.TryCreate(string.Concat("http://", proxyString.Slice(0, iter)), UriKind.Absolute, out uri))

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\ChunkStream.cs (1)

310return idx >= 0 ? input.Slice(0, idx) : input;

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

166host = host.Slice(0, colon);

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

103valueSpan[subStrings[0]] is not "=" || 104valueSpan[subStrings[4]] is not "=")

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

279timeZoneSpan = timeZoneSpan.Slice(0, endOfTimeZoneOffset);

System\Net\NetworkInformation\StringParsingHelpers.Statistics.cs (17)

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

344scopeId = address.Slice(scopeStart, i - scopeStart);

System\Net\IPEndPoint.cs (2)

108else if (s.Slice(0, lastColonPos).LastIndexOf(':') == -1) 114if (IPAddress.TryParse(s.Slice(0, addressLength), out IPAddress? address))

System\Net\IPNetwork.cs (2)

184ReadOnlySpan<char> ipAddressSpan = s.Slice(0, separatorIndex); 212ReadOnlySpan<byte> ipAddressSpan = utf8Text.Slice(0, separatorIndex);

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

344scopeId = address.Slice(scopeStart, i - scopeStart);

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

419source.Slice(0, block.Length).CopyTo(block.Span);

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

115_buffer.AvailableMemory.CopyFrom(buffer.Slice(0, bytesWritten));

System\Net\FtpControlStream.cs (8)

927ReadOnlySpan<char> dateTimeLine = strSpan[parts[1]]; 932int year = int.Parse(dateTimeLine.Slice(0, 4), NumberFormatInfo.InvariantInfo); 933int month = short.Parse(dateTimeLine.Slice(4, 2), NumberFormatInfo.InvariantInfo); 934int day = short.Parse(dateTimeLine.Slice(6, 2), NumberFormatInfo.InvariantInfo); 935int hour = short.Parse(dateTimeLine.Slice(8, 2), NumberFormatInfo.InvariantInfo); 936int minute = short.Parse(dateTimeLine.Slice(10, 2), NumberFormatInfo.InvariantInfo); 937int second = short.Parse(dateTimeLine.Slice(12, 2), NumberFormatInfo.InvariantInfo); 941millisecond = short.Parse(strSpan[parts[2]], NumberFormatInfo.InvariantInfo);

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

344scopeId = address.Slice(scopeStart, i - scopeStart);

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

116input.Slice(0, partLen).CopyTo(buffer.Slice(index));

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

46return _span.Slice(contentOffset, contentLength); 52return _span.Slice(0, consumed); 171ReadOnlySpan<byte> content = _span.Slice(contentOffset, contentLength); 187ReadOnlySpan<byte> content = _span.Slice(contentOffset, contentLength);

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

47source.Slice(0, pos).CopyTo(dest);

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

331return payload.Slice(GetFieldOffset(field), GetFieldLength(field)); 489time = DateTime.FromFileTimeUtc(BitConverter.ToInt64(info.Slice(4, 8))); 507info.Slice(0, length + 4).CopyTo(targetInfoBuffer.AsSpan(targetInfoOffset, length + 4)); 567ref readonly ChallengeMessage challengeMessage = ref MemoryMarshal.AsRef<ChallengeMessage>(blob.Slice(0, sizeof(ChallengeMessage))); 571!NtlmHeader.SequenceEqual(blob.Slice(0, NtlmHeader.Length))) 648ReadOnlySpan<byte> serverChallenge = blob.Slice(24, 8); 796if (!VerifyMIC(output.Slice(0, input.Length - SignatureLength), input.Slice(0, SignatureLength)))

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

537tokenBytes = tokenBytes.Slice(0, length - 1);

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

542ProtocolToken token = NextMessage(availableData.Slice(0, chunkSize), out int consumed);

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

404TryParseClientHello(helloData.Slice(0, helloLength), ref info, options, callback) : 405TryParseServerHello(helloData.Slice(0, helloLength), ref info, options, callback); 506ReadOnlySpan<byte> extensionData = extensions.Slice(0, extensionLength); 576ReadOnlySpan<byte> serverName = serverNameList.Slice(0, serverNameListLength); 704ReadOnlySpan<byte> protocol = alpnList.Slice(1, protocolLength);

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

210host = hostAndPort.Slice(0, colonIndex); // Excludes colon

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

158ReadOnlySpan<byte> nextLine = data.Slice(0, lineLength);

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

347fieldName = line.Slice(0, colonPos);

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\IO\ChunkedMemoryStream.cs (1)

51buffer.Slice(0, toCopy).CopyTo(new Span<byte>(_currentChunk._buffer, _currentChunk._freeOffset, toCopy));

System\Net\HeaderInfoTable.cs (1)

77return lastElement.Slice(0, equalsPos).Trim().Equals("Expires", StringComparison.OrdinalIgnoreCase);

System\Numerics\Tensors\netcore\ReadOnlyTensorDimensionSpan_1.cs (2)

33_sliceShape = TensorShape.Create((dimension != tensor.Rank) ? tensor.Lengths[dimension..] : [1], tensor.Strides[dimension..], tensor.IsPinned);

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

1557span.Slice(0, ospan.Length).CopyTo(ospan); 1597span.Slice(0, ospan.Length).CopyTo(ospan); 2298tensor.Lengths.Slice(0, dimension).CopyTo(newLengths); 2310tensor.Strides.Slice(0, dimension).CopyTo(newStrides); 2335tensor.Lengths.Slice(0, dimension).CopyTo(newLengths); 2347tensor.Strides.Slice(0, dimension).CopyTo(newStrides); 2372tensor.Lengths.Slice(0, dimension).CopyTo(newLengths); 2384tensor.Strides.Slice(0, dimension).CopyTo(newStrides);

System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs (2)

30_sliceShape = TensorShape.Create((dimension != tensor.Rank) ? tensor.Lengths[dimension..] : [1], tensor.Strides[dimension..], tensor.IsPinned);

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

593ReadOnlySpan<nint> lengths1 = shape1.Lengths[rankDelta..]; 623ReadOnlySpan<nint> strides1 = shape1.Strides[rankDelta..]; 664ReadOnlySpan<nint> lengths1 = shape1Lengths[rankDelta..];

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

88switch (line.Slice(0, startIndex)) // name

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

43ReadOnlySpan<char> root = line[fields.Current]; 50ReadOnlySpan<char> mountPoint = line[fields.Current]; 67ReadOnlySpan<char> fileSystemType = line[fields.Current]; 80ReadOnlySpan<char> superOptions = line[fields.Current];

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (1)

84return buffer.Slice(0, length).ToString();

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

139sb.Append(path.Slice(0, skip)); 235path.Slice(0, path.Length - 1) :

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (1)

266attributeValueSpan[parts[i]],

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

314return value.Slice(start, end - start + 1);

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

63if (!TryParseUInt32X(text.Slice(0, 8), out uint i1, out int justConsumed) || justConsumed != 8) 70if (!TryParseUInt16X(text.Slice(8, 4), out ushort i2, out justConsumed) || justConsumed != 4) 77if (!TryParseUInt16X(text.Slice(12, 4), out ushort i3, out justConsumed) || justConsumed != 4) 84if (!TryParseUInt16X(text.Slice(16, 4), out ushort i4, out justConsumed) || justConsumed != 4)

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

114source.Slice(startIndexNonLeadingDigitsBeforeDecimal, numNonLeadingDigitsBeforeDecimalToCopy).CopyTo(digits); 178source.Slice(startIndexOfDigitsAfterDecimalToCopy, numDigitsAfterDecimalToCopy).CopyTo(digits.Slice(dstIndex));

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

345if ((source.Length > sizeof(byte)) && (source[sizeof(byte)..].ContainsAnyExcept((byte)0x00)))

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

1276if ((source.Length > sizeof(char)) && (source[sizeof(char)..].ContainsAnyExcept((byte)0x00)))

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

3028source = source.Slice(0, destination.Length * 2); 3036source = source.Slice(0, source.Length - 1); 3084utf8Source = utf8Source.Slice(0, destination.Length * 2); 3092utf8Source = utf8Source.Slice(0, utf8Source.Length - 1);

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

95decodedFields[i] = new Guid(payload.Slice(0, sizeOfGuid)); 126charPayload = MemoryMarshal.Cast<byte, char>(payload.Slice(0, byteCount - 2));

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

1069subvalue = value.Slice(0, endIndex).Trim();

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

109string key = new string(variable.Slice(0, i));

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

198: source.Slice(0, startIndex);

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

329span = span.Slice(0, span.IndexOf('\0'));

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

2361Culture.CompareInfo.Compare(str.Value.Slice(str.Index, value.tokenString.Length), value.tokenString, CompareOptions.IgnoreCase) == 0))

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

416if (str.CompareInfo.Compare(str.Value.Slice(str.Index, target.Length), target, CompareOptions.IgnoreCase) != 0) 5581m_info.Compare(Value.Slice(Index, target.Length), target, CompareOptions.IgnoreCase) == 0; 5588if (matchLength > valueRemaining || m_info.Compare(Value.Slice(Index, matchLength), target, CompareOptions.IgnoreCase) != 0) 5620if (m_info.CompareOptionIgnoreCase(Value.Slice(thisPosition, segmentLength), target.AsSpan(targetPosition, segmentLength)) != 0) 5653if (m_info.CompareOptionIgnoreCase(Value.Slice(thisPosition, segmentLength), target.AsSpan(targetPosition, segmentLength)) != 0) 5848Value = Value.Slice(0, i + 1); 5873Value.Slice(0, i).CopyTo(result);

src\libraries\System.Private.CoreLib\src\System\Globalization\IcuLocaleData.cs (5)

3708indices = indices[start..end]; 3727return GetString(CultureNames.Slice(start, length)); 3751ReadOnlySpan<byte> numericData = NameIndexToNumericData.Slice(index * NumericLocaleDataBytesPerRow, NumericLocaleDataBytesPerRow); 3780return GetString(ThreeLetterWindowsLanguageName.Slice(index * 3, 3)); 3858return CultureNames.Slice(start, length);

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

59src.Slice(0, i).CopyTo(destination); 105src.Slice(0, i).CopyTo(destination);

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

175if (!int.TryParse(valueSpan.Slice(0, 4), NumberStyles.None, NumberFormatInfo.InvariantInfo, out int year) || 176!int.TryParse(valueSpan.Slice(5, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out int month) || 177!int.TryParse(valueSpan.Slice(8, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out int day)) 196ReadOnlySpan<char> eraName = dataSpan[names[0]]; 197ReadOnlySpan<char> abbreviatedEraName = dataSpan[names[1]]; 198ReadOnlySpan<char> englishEraName = dataSpan[names[2]]; 199ReadOnlySpan<char> abbreviatedEnglishEraName = dataSpan[names[3]];

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

83else if (!spanA.Slice(0, bytesConsumedA).SequenceEqual(spanB.Slice(0, bytesConsumedB))) 393else if (!spanA.Slice(0, bytesConsumedA).SequenceEqual(spanB.Slice(0, bytesConsumedB)))

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

255return new TimeSpanToken(TTT.Sep, 0, 0, _value.Slice(startPos, length));

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

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

859if (source[Size..].ContainsAnyExcept((byte)sign))

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

400if (source[sizeof(short)..].ContainsAnyExcept((byte)sign))

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

427if (source[sizeof(int)..].ContainsAnyExcept((byte)sign))

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

424if (source[sizeof(long)..].ContainsAnyExcept((byte)sign))

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

447if (source[sizeof(nint_t)..].ContainsAnyExcept((byte)sign))

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

787buffer.Slice(0, bytesToWrite).CopyTo(new Span<byte>(_buffer, _writePos, bytesToWrite));

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

1540ReadOnlySpan<char> toEncode = contents.Slice(0, Math.Min(contents.Length, ChunkSize));

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

155return end >= 0 ? path.Slice(0, end) : ReadOnlySpan<char>.Empty; 205return path.Slice(i, length - i); 272fileName.Slice(0, lastPeriod);

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

507source.Slice(0, numBytes).CopyTo(_buffer!.AsSpan(_writePos)); 708source.Span.Slice(0, spaceLeft).CopyTo(_buffer.AsSpan(_writePos));

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

819retVal = new string(charBufferSpan.Slice(0, idxOfNewline)); 823retVal = string.Concat(vsb.AsSpan(), charBufferSpan.Slice(0, idxOfNewline));

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

792source.Span.Slice(copied, n).CopyTo(new Span<char>(_charBuffer, _charPos, n));

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

2564pos = span.Slice(0, pos).LastIndexOf(value[0], comparer); 3585SequenceEqual(span.Slice(0, value.Length), value, comparer); 4961other = other.Slice(0, span.Length); 4965span = span.Slice(0, other.Length);

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

106return span.Slice(start, length); 123=> span.Slice(0, ClampEnd(span, 0, trimElement)); 414return span.Slice(start, length); 458return span.Slice(0, ClampEnd(span, 0, trimElements)); 600return span.Slice(start, end - start + 1); 637return span.Slice(0, end + 1); 665return span.Slice(start, end - start + 1); 703return span.Slice(0, end + 1); 779return span.Slice(0, end + 1);

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

31span = span[firstBytesConsumed..]; 57span = span[bytesConsumed..];

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

42sb.Append(valueSpan.Slice(0, index)); 71sb.Append(valueSpan.Slice(0, index)); 171sb.Append(valueSpan.Slice(0, index)); 196sb.Append(valueSpan.Slice(0, index)); 227? uint.TryParse(inputSlice.Slice(2, entityLength - 2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out uint parsedValue) 228: uint.TryParse(inputSlice.Slice(1, entityLength - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out parsedValue); 251ReadOnlySpan<char> entity = inputSlice.Slice(0, entityLength);

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

367vsb.Append(stringToEscape.Slice(0, charsToCopy));

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

127_identifier = frameworkNameSpan[components[0]].Trim().ToString(); 143ReadOnlySpan<char> component = frameworkNameSpan[components[i]]; 152ReadOnlySpan<char> key = component.Slice(0, separatorIndex).Trim();

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

381if (source[sizeof(sbyte)..].ContainsAnyExcept((byte)sign))

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

181span = span.Slice(0, offset + 1); 209span = span.Slice(0, offset + 1);

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

268Ordinal.ToUpperOrdinal(span.Slice(i, i + 1 == span.Length ? 1 : 2), destination);

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

334sb.Append(span.Slice(0, pos)).Append(GetEscapeSequence(span[pos]));

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

1243result.Append(searchSpace.Slice(0, index)); 1536builder.Append(remaining.Slice(0, idx)); 1626builder.Append(remaining.Slice(0, idx)); 2192if (currentSepLength == 1 || source.Slice(i, currentSepLength).SequenceEqual(separator))

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

145vsb.Append(remainder.Slice(0, countUntilNextBrace)); 312itemFormat = format.Slice(startingPos, pos - startingPos).ToString();

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

206MemoryMarshal.AsBytes(new ReadOnlySpan<int>(in _leftoverBytes)).Slice(0, _leftoverByteCount);

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

66_current = remaining.Slice(0, idx);

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

1555Append(remainder.Slice(0, countUntilNextBrace)); 2040if (!chunk.EqualsOrdinal(span.Slice(span.Length - offset, chunk_length)))

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

50Append(remainder.Slice(0, countUntilNextBrace));

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

980if (int.TryParse(dateRule.Slice(1, monthWeekDotIndex - 1), out month) && 981int.TryParse(weekDaySpan.Slice(0, weekDayDotIndex), out week) && 1099return posixFormat.Slice(startIndex, index - startIndex);

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

513str = str.Slice(0, str.Length - 1);

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

895if ((source.Length > Size) && (source[Size..].ContainsAnyExcept((byte)0x00)))

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

359if ((source.Length > sizeof(ushort)) && (source[sizeof(ushort)..].ContainsAnyExcept((byte)0x00)))

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

387if ((source.Length > sizeof(uint)) && (source[sizeof(uint)..].ContainsAnyExcept((byte)0x00)))

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

386if ((source.Length > sizeof(ulong)) && (source[sizeof(ulong)..].ContainsAnyExcept((byte)0x00)))

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

408if ((source.Length > sizeof(nuint_t)) && (source[sizeof(nuint_t)..].ContainsAnyExcept((byte)0x00)))

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

390if (!TryParseComponent(input.Slice(0, majorEnd), nameof(input), throwOnFailure, out int major)) 398if (!TryParseComponent(input.Slice(majorEnd + 1, minorEnd - majorEnd - 1), nameof(input), throwOnFailure, out minor)) 407TryParseComponent(input.Slice(minorEnd + 1, buildEnd - minorEnd - 1), nameof(build), throwOnFailure, out build) &&

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

349name = name.Slice(0, _nestedNameLength); 395rootFullName = rootFullName.Slice(0, rootTypeName._nestedNameLength); 399rootTypeName._namespace = rootFullName.Slice(0, idx).ToString();

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

85ReadOnlySpan<char> fullTypeName = _inputString.Slice(0, fullTypeNameLength);

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

149return offset < 0 ? input : input.Slice(0, offset); 254if (length > 1 && input[0] == '.' && input.Slice(0, length).LastIndexOf('.') == 0)

src\System\Reflection\RuntimeCustomAttributeData.cs (1)

925private ReadOnlySpan<byte> PeekData(int size) => _blob.Slice(_curr, size);

src\System\StubHelpers.cs (1)

454managed.Slice(0, numChars).CopyTo(native);

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

267int charCount = _dec!.GetChars(buffer.Slice(0, size), _chars, false);

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

169ticksvalue = ticksvalue.Slice(0, indexOfTimeZoneOffset + 1); // +1 for Slice above

System\Xml\XmlBufferReader.cs (8)

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

344scopeId = address.Slice(scopeStart, i - scopeStart);

System\DomainNameHelper.cs (3)

112hostname = hostname.Slice(0, invalidCharOrDelimiterIndex); 152ReadOnlySpan<char> label = hostname.Slice(0, labelLength); 239label = label.Slice(0, dotIndex);

System\Uri.cs (2)

4382str.Slice(_info.Offset.Path, _info.Offset.Query - _info.Offset.Path), 4656share = share.Slice(0, i + 1);

System\UriExt.cs (2)

611string result = string.Concat(charsToUnescape.Slice(0, indexOfFirstToUnescape), vsb.AsSpan()); 666charsToUnescape.Slice(0, indexOfFirstToUnescape).CopyTo(destination);

System\UriHelper.cs (4)

176charsToEscape.Slice(0, indexOfFirstToEscape).CopyTo(destination); 227string result = string.Concat(charsToEscape.Slice(0, indexOfFirstToEscape), vsb.AsSpan()); 245dest.Append(stringToEscape.Slice(0, indexOfFirstToEscape)); 316vsb.Append(stringToEscape.Slice(0, charsToCopy));

System\SpanReader.cs (2)

31set => _unread = Span[value..]; 240public void Advance(int count) => _unread = _unread[count..];

System\Xml\Core\XmlTextEncoder.cs (1)

293_textWriter.Write(text.Slice(startPos, i - startPos));

System\Xml\Serialization\XmlSerializationWriter.cs (1)

416Debug.Assert(!span.Slice(0, charsWritten).ContainsAny(escapeChars), "Primitive value contains illegal xml char.");

System\Xml\XPath\Internal\XPathScanner.cs (1)

343return span.Slice(0, i).ToString();

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

97return Text.Encoding.UTF8.GetString(data.Slice(pos, len));

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (1)

266attributeValueSpan[parts[i]],

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

676buffer.Slice(0, bytesToCurrent).CopyTo(_buffer.AsSpan(Length));

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

349name = name.Slice(0, _nestedNameLength); 395rootFullName = rootFullName.Slice(0, rootTypeName._nestedNameLength); 399rootTypeName._namespace = rootFullName.Slice(0, idx).ToString();

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

85ReadOnlySpan<char> fullTypeName = _inputString.Slice(0, fullTypeNameLength);

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

149return offset < 0 ? input : input.Slice(0, offset);

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

34return comma == -1 ? assemblyQualifiedTypeName : assemblyQualifiedTypeName.Slice(0, comma); 42return comma == -1 ? assemblyName : assemblyName.Slice(0, comma).TrimEnd(s_whiteSpaceChars);

System\Number.BigInteger.cs (8)

155value = value[whiteIndex..]; 193value = value[leadingBitsCount..]; 203value = value[TParser.DigitsPerBlock..]; 346intDigits = intDigits.Slice(0, intDigitsEnd); 366uint.TryParse(intDigits.Slice(0, PowersOf1e9.MaxPartialDigits), out base1E9[di]); 448base1E9 = base1E9.Slice(0, BigIntegerCalculator.ActualLength(base1E9)); 473Recursive(powersOf1e9, powersOf1e9Index - 1, base1E9[multiplier1E9Length..], buffer); 1103return pow1E9.Slice(from, toExclusive - from);

System\Numerics\BigInteger.cs (1)

387value.Slice(0, wholeUInt32Count * 4).CopyTo(MemoryMarshal.AsBytes<uint>(val.AsSpan()));

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

530left = left.Slice(0, ActualLength(left)); 548Divide(left.Slice(0, quotient.Length), right[0], quotient, ref carry); 614BurnikelZieglerD3n2n(left.Slice(right.Length), left.Slice(halfN, halfN), right, quotient.Slice(halfN), r1); 615BurnikelZieglerD3n2n(r1.Slice(0, right.Length), left.Slice(0, halfN), right, quotient.Slice(0, halfN), remainder); 636ReadOnlySpan<uint> b2 = right.Slice(0, n); 655ReadOnlySpan<uint> a2 = left12.Slice(0, n); 687left = left.Slice(0, ActualLength(left)); 688right = right.Slice(0, ActualLength(right));

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

112right = right.Slice(0, k);

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

85ReadOnlySpan<uint> valueLow = value.Slice(0, n); 212ReadOnlySpan<uint> leftLow = left.Slice(0, n); 261ReadOnlySpan<uint> leftLow = left.Slice(0, n); 265ReadOnlySpan<uint> rightLow = right.Slice(0, n);

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

42right = right.Slice(0, left.Length); 48left = left.Slice(0, right.Length);

System\Numerics\Complex.cs (3)

2107if ((openBracket != 0) && (((style & NumberStyles.AllowLeadingWhite) == 0) || !s.Slice(0, openBracket).IsWhiteSpace())) 2116if (!double.TryParse(s.Slice(openBracket + 1, semicolon - openBracket - 1), style, provider, out double real)) 2129if (!double.TryParse(s.Slice(semicolon + 1, closeBracket - semicolon - 1), style, provider, out double imaginary))

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

46return _span.Slice(contentOffset, contentLength); 52return _span.Slice(0, consumed); 171ReadOnlySpan<byte> content = _span.Slice(contentOffset, contentLength); 187ReadOnlySpan<byte> content = _span.Slice(contentOffset, contentLength);

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

40writer.WriteKeyParameterInteger(input.Slice(0, halfLength)); 41writer.WriteKeyParameterInteger(input.Slice(halfLength, halfLength));

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

165ReadOnlySpan<byte> mldsaKey = source.Slice(0, metadata.MLDsaAlgorithm.PublicKeySizeInBytes); 207ReadOnlySpan<byte> mldsaKey = source.Slice(0, metadata.MLDsaAlgorithm.PrivateSeedSizeInBytes); 336ReadOnlySpan<byte> r = signature.Slice(0, CompositeMLDsaAlgorithm.RandomizerSizeInBytes); 337ReadOnlySpan<byte> mldsaSig = signature.Slice(CompositeMLDsaAlgorithm.RandomizerSizeInBytes, AlgorithmDetails.MLDsaAlgorithm.SignatureSizeInBytes);

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

169byte[] x = source.Slice(1, fieldWidth).ToArray();

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

30x = publicKey.Slice(1, fieldWidthInBytes).ToArray();

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

26ReadOnlySpan<char> label = pem[fields.Label]; 51pem = pem[offset..]; 68ReadOnlySpan<char> base64Contents = foundSlice[foundFields.Base64Data]; 110ReadOnlySpan<char> label = pem[fields.Label]; 125pem = pem[offset..]; 133ReadOnlySpan<char> base64Contents = foundSlice[foundFields.Base64Data];

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

263bytes.Slice(0, destination.Length).CopyTo(destination); 294ReadOnlySpan<char> trimmed = password.Slice(0, destination.Length / 2);

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

503AsnWriter writer = RSAKeyFormatHelper.WriteSubjectPublicKeyInfo(source.Slice(0, read)); 544source.Slice(0, read), 591source.Slice(0, read), 619AsnWriter writer = RSAKeyFormatHelper.WritePkcs8PrivateKey(source.Slice(0, read));

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

184ReadOnlySpan<byte> noZeros = source.Slice(2, 8); 506ReadOnlySpan<byte> maskedDb = em.Slice(0, dbLen); 507ReadOnlySpan<byte> h = em.Slice(dbLen, hLen);

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

47source.Slice(0, pos).CopyTo(dest);

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

492source.Slice(0, 8).CopyTo(A);

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

253inputBuffer.Slice(0, whitespaceIndex).CopyTo(transformBuffer.Slice(index));

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

203X = publicKeyBytes.Slice(1, fieldWidth).ToArray(), 422curve.G.X = baseSpan.Slice(1, primeOrPoly.Length).ToArray();

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

171ReadOnlySpan<TChar> label = pemData[labelRange]; 206if (!TryCountBase64<TChar, T>(pemData[contentRange], out int base64start, out int base64end, out int decodedSize)) 314if (T.IsValidBase64(str.Slice(start, end + 1 - start), out base64DecodedSize)) 609charsWritten += T.WriteBase64(remainingData.Slice(0, BytesPerLine), destination, charsWritten);

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

51_contents = _contents[_pemFields.Location.End..];

System\Security\Cryptography\PemKeyHelpers.cs (6)

112ReadOnlySpan<char> label = pem[fields.Label]; 127pem = pem[offset..]; 135ReadOnlySpan<char> base64Contents = foundSlice[foundFields.Base64Data]; 173ReadOnlySpan<char> label = pem[fields.Label]; 204pem = pem[offset..]; 221ReadOnlySpan<char> base64Contents = foundSlice[foundFields.Base64Data];

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

195bufferSpan.Slice(_startIndex, size).CopyTo(destination); 201bufferSpan.Slice(_startIndex, cb).CopyTo(destination); 215bufferSpan.Slice(0, _blockSize).CopyTo(destination.Slice(offset)); 220bufferSpan.Slice(0, remainder).CopyTo(destination.Slice(offset));

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

933source.Slice(0, firstValueLength),

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

167if (block.Slice(block.Length - padBytes, padBytes - 1).ContainsAnyExcept((byte)0))

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

56inputBuffer = inputBuffer.Slice(0, inputBuffer.Length - _heldoverCipher.Length);

System\Security\Cryptography\X509Certificates\CertificateRequest.Load.cs (2)

51if (contents[fields.Label].SequenceEqual(PemLabels.Pkcs10CertificateRequest)) 55if (!Convert.TryFromBase64Chars(contents[fields.Base64Data], rented, out int bytesWritten) ||

System\Security\Cryptography\X509Certificates\CertificateRevocationListBuilder.Load.cs (2)

270if (contents[fields.Label].SequenceEqual(PemLabels.X509CertificateRevocationList)) 274if (!Convert.TryFromBase64Chars(contents[fields.Base64Data], rented, out int bytesWritten))

System\Security\Cryptography\X509Certificates\X500NameEncoder.cs (3)

289tagOid = ParseOid(chars[tagStart..tagEnd]); 394encodedSets.Add(ParseRdn(tagOid, chars[valueStart..valueEnd], hadEscapedQuote, forceUtf8Encoding)); 462encodedSets.Add(ParseRdn(tagOid, chars[valueStart..valueEnd], hadEscapedQuote, forceUtf8Encoding));

System\Security\Cryptography\X509Certificates\X509Certificate2.cs (8)

1557ReadOnlySpan<char> label = contents[fields.Label]; 1563if (!Convert.TryFromBase64Chars(contents[fields.Base64Data], certBytes, out int bytesWritten) 1798match = match.Slice(0, match.Length - 1); 1829embeddedSpan = embeddedSpan.Slice(0, embeddedSpan.Length - 1); 1926ReadOnlySpan<char> label = contents[fields.Label]; 1932using (TAlg key = factory(contents[fields.Location])) 1958ReadOnlySpan<char> label = contents[fields.Label]; 1962using (TAlg key = factory(contents[fields.Location], password))

System\Security\Cryptography\X509Certificates\X509Certificate2Collection.cs (2)

445ReadOnlySpan<char> label = contents[fields.Label]; 452if (!Convert.TryFromBase64Chars(contents[fields.Base64Data], certBytes, out int bytesWritten)

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

146if (!Convert.TryToBase64Chars(value.Slice(offset, localLength), base64, out int written))

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

46return _span.Slice(contentOffset, contentLength); 52return _span.Slice(0, consumed); 171ReadOnlySpan<byte> content = _span.Slice(contentOffset, contentLength); 187ReadOnlySpan<byte> content = _span.Slice(contentOffset, contentLength);

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

263bytes.Slice(0, destination.Length).CopyTo(destination); 294ReadOnlySpan<char> trimmed = password.Slice(0, destination.Length / 2);

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

245ieeeSignature.Slice(0, fieldSize), 253ieeeSignature.Slice(fieldSize, fieldSize),

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (1)

84return buffer.Slice(0, length).ToString();

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

179string retVal = string.Concat(value.Slice(0, indexOfFirstCharToEncode), stringBuilder.AsSpan()); 295sourceSearchSpace = utf8Source.Slice(0, utf8Destination.Length); 304utf8Source.Slice(0, idxOfFirstByteToEncode).CopyTo(utf8Destination); // memcpy data that doesn't need to be encoded 425sourceSearchSpace = source.Slice(0, destination.Length); 434source.Slice(0, idxOfFirstCharToEncode).CopyTo(destination); // memcpy data that doesn't need to be encoded

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

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

519valueSpan = reader.OriginalSpan.Slice( 591valueSpan = readerSpan.Slice((int)reader.TokenStartIndex, payloadLength);

System\Text\Json\Document\JsonDocument.PropertyNameSet.cs (1)

89ReadOnlySpan<byte> previousPropertyName = utf8Json.Span.Slice(range.Start, range.Length);

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

166ReadOnlySpan<byte> currentPropertyName = documentSpan.Slice(row.Location, row.SizeOrLength); 179currentPropertyName.Slice(0, idx).SequenceEqual(propertyName.Slice(0, idx)))

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

1474return utf8Text.Slice(0, 0) == default; 1504return text.Slice(0, 0) == default;

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

374leftMiddle = leftFractional.Slice(0, -diff); 377rightFirst = rightIntegral.Slice(0, rightOffset); 393leftFirst = leftIntegral.Slice(0, leftOffset); 397rightMiddle = rightFractional.Slice(0, diff); 453intg = span.Slice(0, i); 466frac = span.Slice(0, i); 486frac = frac.Slice(0, iz); 512intg = intg.Slice(0, fz);

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

175|| !TryGetNextTwoDigits(source.Slice(start: 5, length: 2), ref parseData.Month) 177|| !TryGetNextTwoDigits(source.Slice(start: 8, length: 2), ref parseData.Day)) 233|| !TryGetNextTwoDigits(source.Slice(start: 11, length: 2), ref parseData.Hour) 234|| !TryGetNextTwoDigits(source.Slice(start: 14, length: 2), ref parseData.Minute)) 267|| !TryGetNextTwoDigits(source.Slice(start: 17, length: 2), ref parseData.Second)) 358|| !TryGetNextTwoDigits(offsetData.Slice(0, 2), ref parseData.OffsetHours))

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

33data = data.Slice(0, lastLineFeedIndex);

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

484if (!source.Slice(0, idx).TryCopyTo(destination)) 534bool result = Utf8Parser.TryParse(source.Slice(idx + 1, 4), out int scalar, out int bytesConsumed, 'x'); 557result = Utf8Parser.TryParse(source.Slice(idx + 3, 4), out int lowSurrogate, out bytesConsumed, 'x'); 622remaining.Slice(0, nextUnescapedSegmentLength).CopyTo(destination.Slice(written));

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

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

341ValueSpan = _buffer.Slice(_consumed, 1); 351ValueSpan = _buffer.Slice(_consumed, 1); 529ValueSpan = span.Slice(0, literal.Length); 552span.Slice(0, amountToWrite).CopyTo(readSoFar); 562span.Slice(0, amountToWrite).CopyTo(readSoFar); 589span.Slice(0, amountToWrite).CopyTo(readSoFar.Slice(written)); 609span.Slice(0, amountToWrite).CopyTo(readSoFar.Slice(written)); 771ValueSpan = localBuffer.Slice(0, idx); 1100ValueSpan = data.Slice(0, idx); 1251ValueSpan = data.Slice(0, i);

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

491sb.Append(span.Slice(0, pos));

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

325next = rest.Slice(0, i).TrimEnd();

System\Text\Json\Serialization\JsonSerializer.Read.Utf8JsonReader.cs (2)

365valueSpan = reader.OriginalSpan.Slice( 414valueSpan = readerSpan.Slice((int)reader.TokenStartIndex, payloadLength);

System\Text\Json\Serialization\Metadata\PropertyRef.cs (2)

656 => MemoryMarshal.Read<uint>(name) | ((ulong)MemoryMarshal.Read<ushort>(name.Slice(4, 2)) << 32), 667 => MemoryMarshal.Read<uint>(name) | ((ulong)MemoryMarshal.Read<ushort>(name.Slice(4, 2)) << 32) | ((ulong)name[6] << 48),

System\Text\Json\ThrowHelper.Serialization.cs (1)

361str.Slice(0, MaxLength).CopyTo(builder);

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

114value.Slice(0, indexOfFirstByteToEscape).CopyTo(destination); 232value.Slice(0, indexOfFirstByteToEscape).CopyTo(destination);

System\Text\Json\Writer\Utf8JsonWriter.cs (3)

133return partialStringDataBytes.Slice(0, length); 162return MemoryMarshal.Cast<byte, char>(partialStringDataBytes.Slice(0, length)); 190return partialStringDataBytes.Slice(0, length);

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.Literal.cs (1)

31escapedPropertyNameSection.Slice(1, escapedPropertyNameSection.Length - 3);

System\Text\Json\Writer\Utf8JsonWriter.WriteProperties.String.cs (1)

27escapedPropertyNameSection.Slice(1, escapedPropertyNameSection.Length - 3);

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

439bytes = bytes.Slice(0, bytes.Length - leftoverSize);

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

108next = remainingText.Slice(0, lineLength);

System\Text\RegularExpressions\RegexCaseEquivalences.cs (1)

156equivalences = EquivalenceCasingValues.Slice(index3, count);

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

462int i = textSpan.Slice(0, pos).LastIndexOf(LeadingPrefix.AsSpan()); 477int i = textSpan.Slice(0, pos).LastIndexOf(FixedDistanceLiteral.Char); 495ReadOnlySpan<char> span = textSpan.Slice(0, pos);

System\Text\RegularExpressions\RegexInterpreter.cs (1)

978i = inputSpan.Slice(runtextpos, len).IndexOf(ch);

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

1393startingSpan = startingSpan.Slice(0, 1); 1409startingSpan = startingSpan.Slice(0, c);

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

172vsb.Append(input.Slice(0, indexOfMetachar));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCaseEquivalences.cs (1)

156equivalences = EquivalenceCasingValues.Slice(index3, count);

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

1393startingSpan = startingSpan.Slice(0, 1); 1409startingSpan = startingSpan.Slice(0, c);

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

172vsb.Append(input.Slice(0, indexOfMetachar));

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

150vsb.Append(chars.Slice(0, i));

System\Windows\Forms\Controls\ImageList\ImageListStreamer.cs (1)

60ReadOnlySpan<byte> remaining = reader.Span[reader.Position..];

System\ComponentModel\TypeConverterHelper.cs (1)

55output[i] = (T)converter.ConvertFromString(context, culture, text[tokens[i]].ToString())!;

System\Windows\Forms\Automation\UiaTextRange.cs (1)

303ReadOnlySpan<char> rangeText = _provider.Text.AsSpan().Slice(Start, Length);

Infra\ScreenRecordService.cs (3)

284ReadOnlySpan<uint> previousFrameLine = previousImageData.Slice(line * stridePixels, width); 285ReadOnlySpan<uint> currentFrameLine = currentImageData.Slice(line * stridePixels, width); 547for (ReadOnlySpan<byte> remaining = bytes; !remaining.IsEmpty; remaining = remaining[Math.Min(buffer.Length, remaining.Length)..])

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

66fullName = fullName.Slice(0, fullName.Length - nameSlice.Length + commaIndex); 110assemblyVersion = assemblyName.Slice(versionIndex + Version.Length, tokenLength - Version.Length); 122assemblyToken = assemblyName.Slice(tokenIndex + PublicKeyToken.Length, tokenLength - PublicKeyToken.Length);

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

162return typeName.Slice(0, openBracketNdx);

System\Xaml\XamlSchemaContext.cs (2)

184if (!values[segment].IsEmpty) 186sb.Append(char.ToLower(values[segment][0], TypeConverterHelper.InvariantEnglishUS));

System\Xaml\XamlType.cs (1)

1626typeName = string.Concat(typeNameSpan.Slice(0, index), subscript);

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

509if (!chunk.Span.Equals(array.AsSpan().Slice(chunkOffset, chunk.Length), StringComparison.Ordinal))

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());

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

275source.Slice(0, loadSize).CopyTo(new Span<byte>(buffer + state.BufferedCount, loadSize)); 314source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); 327source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span<byte>(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes));

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

375span.Slice(offset, segmentLength).CopyTo(buffer.AsSpan());