Span

Certificates\CertificateGeneration\CertificateManager.cs (2)

1050return cert1.RawDataMemory.Span.SequenceEqual(cert2.RawDataMemory.Span);

Mcp\Docs\LlmsTxtParser.cs (1)

103var document = ParseDocument(docContent.Span);

Otlp\Model\OtlpHelpers.cs (1)

81var data = bytes.Span;

Otlp\Model\OtlpInstrument.cs (3)

139return x.Span.SequenceEqual(y.Span); 145foreach (KeyValuePair<string, string> pair in obj.Span)

Otlp\Storage\TelemetryRepository.cs (2)

1296var s = traceId.Span; 1299if (traces[i].Key.Span.SequenceEqual(s))

DeveloperCertificateService.cs (2)

86!rootCerts.Any(rc => rc.RawDataMemory.Span.SequenceEqual(cert.RawDataMemory.Span)))

RabbitMQFunctionalTests.cs (2)

89Assert.Equal(message, Encoding.UTF8.GetString(result!.Body.Span)); 206Assert.Equal("Hello World!", Encoding.UTF8.GetString(result!.Body.Span));

ObjectFileScraper.cs (12)

74if (FindMagic(bytes.Span, out int offset, out bool isLittleEndian)) 85int start = buffer.IndexOf(MagicLE.Span); 92start = buffer.IndexOf(MagicBE.Span); 104public ulong GetUInt64(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt64LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt64BigEndian(Data.Span.Slice((int)offset)); 105public uint GetUInt32(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt32LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt32BigEndian(Data.Span.Slice((int)offset)); 106public ushort GetUInt16(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt16LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt16BigEndian(Data.Span.Slice((int)offset)); 107public byte GetByte(long offset) => Data.Span[(int)offset]; 109public ReadOnlySpan<byte> GetBytes(long offset, int length) => Data.Span.Slice((int)offset, length); 341var nameStart = NamesPool.Span.Slice((int)stringIdx);

src\aspnetcore\src\Shared\CertificateGeneration\CertificateManager.cs (2)

1053return cert1.RawDataMemory.Span.SequenceEqual(cert2.RawDataMemory.Span);

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

331hashCode = CombineFNVHash(hashCode, chunk.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 31return string.GetHashCode(obj.Span);

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

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

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\SectionData.cs (1)

141ReadOnlySpan<byte> currentBuffer = _sectionData._buffers[_bufferIndex].Span.Slice(_bufferPosition);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\SectionData.cs (1)

141ReadOnlySpan<byte> currentBuffer = _sectionData._buffers[_bufferIndex].Span.Slice(_bufferPosition);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Wasm\WasmSection.cs (1)

271ReadOnlySpan<int> functionIndices = entry.Span;

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\SimpleArrayOfTRuntimeInterfacesAlgorithm.cs (1)

36MetadataType runtimeInterface =_systemModule.GetType("System.Collections.Generic"u8, s_genericRuntimeInterfacesNames[i].Span, throwIfNotFound: false);

TemplateTestUtilities.cs (1)

77var firstOption = options.Span[0];

NavigationManagerExtensions.cs (8)

590newQueryStringBuilder.AppendParameter(pair.EncodedName.Span, pair.EncodedValue.Span); 628if (pair.EncodedName.Span.Equals(encodedName, StringComparison.OrdinalIgnoreCase)) 635newQueryStringBuilder.AppendParameter(pair.EncodedName.Span, pair.EncodedValue.Span); 667if (!pair.EncodedName.Span.Equals(encodedName, StringComparison.OrdinalIgnoreCase)) 669newQueryStringBuilder.AppendParameter(pair.EncodedName.Span, pair.EncodedValue.Span);

Routing\SupplyParameterFromQueryValueProvider.cs (2)

79if (!query.Span.SequenceEqual(QueryParameterValueSupplier.GetQueryString(_lastUri).Span))

src\aspnetcore\src\Components\Shared\src\QueryParameterNameComparer.cs (5)

13=> x.Span.CompareTo(y.Span, StringComparison.OrdinalIgnoreCase); 16=> x.Span.Equals(y.Span, StringComparison.OrdinalIgnoreCase); 19=> string.GetHashCode(obj.Span, StringComparison.OrdinalIgnoreCase);

src\aspnetcore\src\Components\Shared\src\QueryParameterValueSupplier.cs (1)

50return parser.Parse(values[0].Span, queryParameterName);

src\aspnetcore\src\Components\Shared\src\UrlValueConstraint.cs (1)

142if (!_parser(values[i].Span, out result[i]))

src\aspnetcore\src\Shared\QueryStringEnumerable.cs (4)

96ReadOnlySpan<char> source = chars.Span; 127_query = query.IsEmpty || query.Span[0] != '?' 147var delimiterIndex = _query.Span.IndexOf('&'); 160var equalIndex = segment.Span.IndexOf('=');

FormMapping\Converters\DictionaryConverter.cs (3)

61context.PushPrefix(key.Span); 64context.PopPrefix(key.Span); 66if (!TKey.TryParse(key[1..^1].Span, CultureInfo.InvariantCulture, out var keyValue))

FormMapping\FormDataReader.cs (4)

123!key.Span[..prefix.Length].Equals(prefix.Span, StringComparison.OrdinalIgnoreCase)) 129if (key.Span[prefix.Length] != '[') 136var closeIndex = remaining.Span[1..].IndexOf(']'); 168if (CurrentPrefix.Span.Length == 0)

FormMapping\FormKey.cs (3)

11private readonly int _hashCode = string.GetHashCode(value.Span, StringComparison.OrdinalIgnoreCase); 18MemoryExtensions.Equals(Value.Span, other.Value.Span, StringComparison.OrdinalIgnoreCase);

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\aspnetcore\src\Components\Shared\src\QueryParameterNameComparer.cs (5)

13=> x.Span.CompareTo(y.Span, StringComparison.OrdinalIgnoreCase); 16=> x.Span.Equals(y.Span, StringComparison.OrdinalIgnoreCase); 19=> string.GetHashCode(obj.Span, StringComparison.OrdinalIgnoreCase);

src\aspnetcore\src\Components\Shared\src\QueryParameterValueSupplier.cs (1)

50return parser.Parse(values[0].Span, queryParameterName);

src\aspnetcore\src\Components\Shared\src\UrlValueConstraint.cs (1)

142if (!_parser(values[i].Span, out result[i]))

src\aspnetcore\src\Shared\QueryStringEnumerable.cs (4)

96ReadOnlySpan<char> source = chars.Span; 127_query = query.IsEmpty || query.Span[0] != '?' 147var delimiterIndex = _query.Span.IndexOf('&'); 160var equalIndex = segment.Span.IndexOf('=');

src\aspnetcore\src\Components\Shared\src\ArrayBuilderMemoryStream.cs (1)

74ArrayBuilder.Append(memory.Span);

src\aspnetcore\src\SignalR\common\Shared\BinaryMessageParser.cs (1)

79return lengthPrefixBuffer.First.Span;

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

108this.writer.Write(segment.Span);

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

68ReadOnlySpan<T> first = sequence.First.Span; 91this.CurrentSpan = memory.Span; 289this.CurrentSpan = memory.Span; 314this.CurrentSpan = memory.Span; 483ReadOnlySpan<T> nextSpan = nextSegment.Span;

src\aspnetcore\src\Components\Shared\src\ArrayBuilderMemoryStream.cs (1)

74ArrayBuilder.Append(memory.Span);

src\aspnetcore\src\Components\Shared\src\ArrayBuilderMemoryStream.cs (1)

74ArrayBuilder.Append(memory.Span);

src\aspnetcore\src\Shared\CertificateGeneration\CertificateManager.cs (2)

1053return cert1.RawDataMemory.Span.SequenceEqual(cert2.RawDataMemory.Span);

Features\QueryFeature.cs (2)

108accumulator.Append(pair.DecodeName().Span, pair.DecodeValue().Span);

ServerSentEventsMessageFormatter.cs (1)

88if (memory.Span[memory.Length - 1] == '\r')

Internal\Utils.cs (1)

39if (pair.EncodedName.Span.SequenceEqual(key.AsSpan()))

src\aspnetcore\src\Shared\QueryStringEnumerable.cs (4)

96ReadOnlySpan<char> source = chars.Span; 127_query = query.IsEmpty || query.Span[0] != '?' 147var delimiterIndex = _query.Span.IndexOf('&'); 160var equalIndex = segment.Span.IndexOf('=');

src\aspnetcore\src\Components\Endpoints\src\FormMapping\Converters\DictionaryConverter.cs (3)

61context.PushPrefix(key.Span); 64context.PopPrefix(key.Span); 66if (!TKey.TryParse(key[1..^1].Span, CultureInfo.InvariantCulture, out var keyValue))

src\aspnetcore\src\Components\Endpoints\src\FormMapping\FormDataReader.cs (4)

123!key.Span[..prefix.Length].Equals(prefix.Span, StringComparison.OrdinalIgnoreCase)) 129if (key.Span[prefix.Length] != '[') 136var closeIndex = remaining.Span[1..].IndexOf(']'); 168if (CurrentPrefix.Span.Length == 0)

src\aspnetcore\src\Components\Endpoints\src\FormMapping\FormKey.cs (3)

11private readonly int _hashCode = string.GetHashCode(value.Span, StringComparison.OrdinalIgnoreCase); 18MemoryExtensions.Equals(Value.Span, other.Value.Span, StringComparison.OrdinalIgnoreCase);

src\aspnetcore\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);

ResponseBufferingStream.cs (1)

122CommonWrite(buffer.Span);

PasskeyHandler.cs (4)

327if (!credential.Id.AsSpan().SequenceEqual(attestedCredentialData.CredentialId.Span)) 578clientData = JsonSerializer.Deserialize(utf8Json.Span, IdentityJsonSerializerContext.Default.CollectedClientData) 594if (!CryptographicOperations.FixedTimeEquals(clientData.Challenge.AsSpan(), originalChallenge.Span)) 627if (!CryptographicOperations.FixedTimeEquals(authenticatorData.RpIdHash.Span, originalRpIdHash.AsSpan()))

Passkeys\AttestedCredentialData.cs (1)

64var credentialIdLength = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(offset, CredentialIdLengthLength).Span);

Passkeys\AuthenticatorData.cs (2)

110var flags = (AuthenticatorDataFlags)bytes.Span[offset]; 113var signCount = BinaryPrimitives.ReadUInt32BigEndian(bytes.Slice(offset, SignCountLength).Span);

Passkeys\BufferSource.cs (4)

59=> _bytes.Span; 77return other is not null && _bytes.Span.SequenceEqual(other._bytes.Span); 117var span = _bytes.Span;

CacheEntryHelpers.cs (1)

23foreach (var item in cachedResponse.Headers.Span)

FormatterBinaryReader.cs (1)

31_root = ref MemoryMarshal.GetReference(content.Span);

OutputCacheEntry.cs (2)

28foreach (var header in Headers.Span) 118foreach (var header in Headers.Span)

OutputCacheEntryFormatter.cs (2)

145foreach (var header in entry.Headers.Span) 182writer.WriteRaw(segment.Span);

Streams\OutputCacheStream.cs (1)

180_segmentWriteStream.Write(buffer.Span);

RedisOutputCacheStore.cs (1)

280var tag = tags.Span[i];

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\MemoryBuilderExtensions.cs (1)

58chunk.Span.CopyTo(destination);

src\aspnetcore\src\Shared\SegmentWriteStream.cs (1)

159Write(buffer.Span);

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (2)

108var timingCount = MemoryMarshal.Read<int>(timingInfo.Span); 113ref Unsafe.As<byte, long>(ref MemoryMarshal.GetReference(timingInfo.Span[sizeof(long)..])),

Core\OutputProducer.cs (1)

81_pipe.Writer.Write(buffer.Span);

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (2)

108var timingCount = MemoryMarshal.Read<int>(timingInfo.Span); 113ref Unsafe.As<byte, long>(ref MemoryMarshal.GetReference(timingInfo.Span[sizeof(long)..])),

src\aspnetcore\src\Shared\ServerInfrastructure\BufferExtensions.cs (3)

48pipeWriter.Write(item.Span); 74int index = source.First.Span.IndexOfAny(value0, value1); 94int index = memory.Span.IndexOfAny(value0, value1);

Internal\Http\HttpParser.cs (3)

152index = memory.Span.IndexOfAny(ByteCR, ByteLF); 176if (memory.Span[index] == ByteCR) 193if (memory.Span[index] == ByteCR)

Internal\Http\HttpProtocol.cs (6)

1640return Output.WriteChunkAsync(data.Span, cancellationToken); 1643return Output.WriteDataToPipeAsync(data.Span, cancellationToken: cancellationToken); 1690return Output.FirstWriteChunkedAsync(StatusCode, ReasonPhrase, responseHeaders, _responseBodyMode, data.Span, cancellationToken); 1693return Output.FirstWriteAsync(StatusCode, ReasonPhrase, responseHeaders, _responseBodyMode, data.Span, cancellationToken); 1737return await Output.WriteChunkAsync(data.Span, cancellationToken); 1740return await Output.WriteDataToPipeAsync(data.Span, cancellationToken: cancellationToken);

Internal\Http2\Http2FrameWriter.cs (1)

971_outputWriter.Write(segment.Span);

Internal\Http3\Http3FrameWriter.cs (3)

195_outputWriter.Write(buffer.Span); 218_outputWriter.Write(buffer.Span); 232_outputWriter.Write(buffer.Span);

Internal\Http3\Http3Stream.cs (1)

1015RequestBodyPipe.Writer.Write(segment.Span);

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

57var span = segment.Span;

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

104var span = segment.Span;

Internal\HttpConnection.cs (2)

240if (!http1Enabled && http2Enabled && hasTls && !Http2Id.SequenceEqual(applicationProtocol.Span)) 257return http2Enabled && (!hasTls || Http2Id.SequenceEqual(applicationProtocol.Span)) ? HttpProtocols.Http2 : HttpProtocols.Http1;

Internal\Infrastructure\KestrelEventSource.cs (1)

195var applicationProtocol = feature == null ? string.Empty : Encoding.UTF8.GetString(feature.ApplicationProtocol.Span);

Internal\Infrastructure\PipeWriterHelpers\ConcurrentPipeWriter.cs (1)

259_innerPipeWriter.Write(segment.Memory.Span);

Middleware\Internal\LoggingStream.cs (1)

146Log("WriteAsync", source.Span);

src\aspnetcore\src\Shared\CertificateGeneration\CertificateManager.cs (2)

1053return cert1.RawDataMemory.Span.SequenceEqual(cert2.RawDataMemory.Span);

src\aspnetcore\src\Shared\runtime\Http2\Hpack\HPackDecoder.cs (1)

130DecodeInternal(segment.Span, handler);

src\aspnetcore\src\Shared\runtime\Http3\QPack\QPackDecoder.cs (1)

170DecodeInternal(segment.Span, handler);

src\aspnetcore\src\Shared\ServerInfrastructure\BufferExtensions.cs (3)

48pipeWriter.Write(item.Span); 74int index = source.First.Span.IndexOfAny(value0, value1); 94int index = memory.Span.IndexOfAny(value0, value1);

ConnectionIoState.cs (2)

376var status = TlsWrite(_writeBuffer.Span, out var written); 430var status = TlsWrite(_writeBuffer.Span, out var written);

Protocol\HandshakeProtocol.cs (1)

49public static ReadOnlySpan<byte> GetSuccessfulHandshake(IHubProtocol protocol) => _successHandshakeData.Span;

src\aspnetcore\src\SignalR\common\Shared\TextMessageParser.cs (1)

17var span = buffer.First.Span;

src\aspnetcore\src\SignalR\common\Shared\Utf8BufferTextReader.cs (1)

72var source = _utf8Buffer.First.Span;

src\aspnetcore\src\SignalR\common\Shared\TextMessageParser.cs (1)

17var span = buffer.First.Span;

src\aspnetcore\src\SignalR\common\Shared\Utf8BufferTextReader.cs (1)

72var source = _utf8Buffer.First.Span;

src\aspnetcore\src\SignalR\common\Shared\BinaryMessageParser.cs (1)

79return lengthPrefixBuffer.First.Span;

src\aspnetcore\src\SignalR\common\Shared\TextMessageParser.cs (1)

17var span = buffer.First.Span;

src\aspnetcore\src\SignalR\common\Shared\Utf8BufferTextReader.cs (1)

72var source = _utf8Buffer.First.Span;

src\sdk\src\Dotnet.Watch\Web.Middleware\ScriptInjectingStream.cs (5)

108var sourceBuffer = new SourceBuffer(buffer.Span); 167var index = buffer.Span.LastIndexOf(s_bodyTagBytes.Span); 210var remainingBodyTagBytes = s_bodyTagBytes.Span[currentBodyTagLength..]; 247return buffer[^partialTagLength..].SequenceEqual(s_bodyTagBytes.Span[..partialTagLength]) 353public readonly void Write(ReadOnlyMemory<byte> data) => baseStream.Write(data.Span);

HttpResponseStreamWriter.cs (3)

333CopyToCharBuffer(value.Span); 355var written = CopyToCharBuffer(value.Span); 385CopyToCharBuffer(value.Span);

src\aspnetcore\src\Shared\QueryStringEnumerable.cs (4)

96ReadOnlySpan<char> source = chars.Span; 127_query = query.IsEmpty || query.Span[0] != '?' 147var delimiterIndex = _query.Span.IndexOf('&'); 160var equalIndex = segment.Span.IndexOf('=');

Evaluation\Expander.cs (1)

609ReadOnlySpan<char> argumentsSpan = argumentsMemory.Span;

Logging\TerminalLogger\TerminalLogger.cs (3)

934ReadOnlySpan<char> outputPathSpan = outputPath.Span; 951var workingDirectorySpan = workingDir.Span; 963else if (sourceRoot is { Span: var sourceRootSpan })

FileUtilities.cs (1)

760var span = value.Span;

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

CommandLine\CommandLineParser.cs (5)

85IsOptionName(optionName, value.Span); 955var arg = argMemory.Span; 1034var span = arg.Span; 1090var span = memory.Span; 1139isScriptFile = !extension.Span.Equals(RegularFileExtension.AsSpan(), StringComparison.OrdinalIgnoreCase);

InternalUtilities\CharMemoryEqualityComparer.cs (3)

19public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => x.Span.SequenceEqual(y.Span); 21public int GetHashCode(ReadOnlyMemory<char> mem) => Hash.GetFNVHashCode(mem.Span);

InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

InternalUtilities\Hash.cs (1)

331hashCode = CombineFNVHash(hashCode, chunk.Span);

InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 31return string.GetHashCode(obj.Span);

InternalUtilities\StringTable.cs (1)

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

MemoryExtensions.cs (3)

79var span = memory.Span; 91internal static bool StartsWith(this ReadOnlyMemory<char> memory, char c) => memory.Length > 0 && memory.Span[0] == c; 95var span = memory.Span;

MetadataReader\MetadataHelpers.cs (3)

580arity = InferTypeArityFromMetadataName(emittedTypeName.Span, out suffixStartsAt); 632var nameSpan = nameMemory.Span; 643return nameMemory.Span.SequenceEqual(SystemString.AsSpan()) ? splitSystemString : ImmutableArray.Create(convert(nameMemory));

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 33return Hash.GetFNVHashCode(obj.Span);

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 33return Hash.GetFNVHashCode(obj.Span);

src\roslyn\src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (2)

61var commentText = GetTextContextOfComment(trivia).Span.Trim(); 78var triviaStringParts = commentText.Span.Trim().ToString().Replace("\r\n", "\n").Split('\n');

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 33return Hash.GetFNVHashCode(obj.Span);

CommandLine\CSharpCommandLineParser.cs (5)

193string? valueMemoryString() => valueMemory is { } m ? m.Span.ToString() : null; 253string name = nameMemory.Span.ToString().ToLowerInvariant(); 1799var valueSpan = valueMemory.Span; 1953var valueSpan = value.Span; 2107if (part.Span.Equals(nullableSpan, StringComparison.OrdinalIgnoreCase))

Symbols\NamespaceOrTypeSymbol.cs (1)

352&& emittedTypeName.TypeNameMemory.Span is [GeneratedNameParser.FileTypeNameStartChar, ..]

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

956=> GetTypeMembers().WhereAsArray(static (type, name) => type.Name.AsSpan().SequenceEqual(name.Span), name);

Utilities\ContentHashComparer.cs (3)

21return x.Span.SequenceEqual(y.Span); 28return BinaryPrimitives.ReadInt32LittleEndian(obj.Span);

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

69if (textLeftOfCaret.Span.StartsWith(DirectiveKind)) 78var contentStartIndex = ClampStart(textAfterDirectiveKind.Span); 84else if (DirectiveKind.StartsWith(textLeftOfCaret.Span))

InlineHints\AbstractInlineParameterNameHintsService.cs (6)

145if (!firstPrefix.Span.Equals(nextPrefix.Span, StringComparison.Ordinal)) 163if (!firstPrefix.Span.Equals(nextPrefix.Span, StringComparison.Ordinal)) 274return char.ToLower(suffix.Span[0]) == parameterName[0] && 275suffix.Span[1..].Equals(parameterName.AsSpan()[1..], StringComparison.Ordinal);

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (3)

174var span = line.Span; 221var index = source.Span.IndexOf(separator); 228index = source.Span.IndexOf(separator);

src\roslyn\src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (2)

61var commentText = GetTextContextOfComment(trivia).Span.Trim(); 78var triviaStringParts = commentText.Span.Trim().ToString().Replace("\r\n", "\n").Split('\n');

Language\CodeGeneration\CodeWriter.cs (7)

107_lastChar = value.Span[^1]; 169return chars.Span[index]; 250var span = value.Span; 337return page.Value[chunkIndex].Span[charIndex]; 347return page.Value[chunkIndex].Span[charIndex]; 427var source = chunk.Span; 515var source = chunk.Span;

Language\CodeGeneration\CodeWriter.IndentCache.cs (1)

44: new string(chars.Span[0], length).AsMemory();

Language\CodeGeneration\CodeWriterExtensions.cs (6)

273if (literal.Length >= 256 && literal.Length <= 1500 && literal.Span.IndexOf('\0') == -1) 353var forwardSlashIndex = filePathMemory.Span.IndexOf('/'); 360forwardSlashIndex = filePathMemory.Span.IndexOf('/'); 903while ((index = literal.Span.IndexOf('"')) >= 0) 933while ((index = literal.Span.IndexOfAny(CStyleStringLiteralEscapeChars)) >= 0) 937switch (literal.Span[index])

Language\CodeGeneration\IntermediateNodeWriter.cs (2)

323htmlContent.Span.CopyTo(content.AsSpan(contentIndex)); 336var lastCharBeforeSplit = literal.Span[maxStringLiteralLength - 1];

Language\Components\ComponentMarkupEncodingPass.cs (1)

167var ampersandIndex = content.Span.IndexOf('&');

Language\Components\ComponentNodeWriter.cs (3)

548var lastColon = nonGenericTypeName.Span.LastIndexOf(':'); 560var lastDot = nonGenericTypeName.Span.LastIndexOf('.'); 569var offset = nonGenericTypeName.Span.StartsWith('@')

Language\Components\TypeNameHelper.cs (2)

97var typeNameSpan = typeName.Span; 131var index = memory.Span.IndexOf('<');

Language\Components\TypeNameHelper.NameComparer.cs (3)

21=> x.Span.Equals(y.Span, StringComparison.Ordinal); 29foreach (var ch in memory.Span)

Language\DefaultRazorTagHelperContextDiscoveryPhase.cs (4)

69if (mem.Span.StartsWith(globalPrefix.AsSpan(), StringComparison.Ordinal)) 321switch (GetMemoryWithoutGlobalPrefix(addTagHelper.TypePattern).Span) 374switch (GetMemoryWithoutGlobalPrefix(removeTagHelper.TypePattern).Span) 467if (currentNamespace is not null && IsTypeNamespaceInScope(typeNamespace.Span, currentNamespace))

Language\Intermediate\ComponentAttributeIntermediateNode.cs (9)

219if (candidate.Span.StartsWith("global::".AsSpan())) 227if (candidate.Span.Equals(eventCallbackName, StringComparison.Ordinal)) 234!candidate.Span.StartsWith(eventCallbackName, StringComparison.Ordinal)) 241if (afterCallbackName.Span is ['<', .., '>']) 256if (candidate.Span.StartsWith("global::".AsSpan())) 261if (!candidate.Span.StartsWith("System.Action".AsSpan())) 269if (candidate.Span is ['<', .., '>']) 295var genericTypeStart = actionArgument.Span.IndexOf('<'); 296var genericTypeEnd = actionArgument.Span.IndexOf('>');

Language\Legacy\ParserHelpers.cs (5)

64var span = content.Span; 100Debug.Assert(entity.Span is ['&',.., ';'], "At this point, entity must start with '&' and end with ';'."); 102if (entity.Span[1] == '#') 107var digitsSpan = entity.Span[2..^1]; 155else if (s_namedHtmlEntities.GetAlternateLookup<ReadOnlySpan<char>>().TryGetValue(entity.Span, out replacement))

Language\RazorHtmlWriter.cs (1)

248var charIsWhitespace = char.IsWhiteSpace(content.Span[i]);

Language\RazorProjectEngineBuilderExtensions.cs (1)

24if (!configurationName.StartsWith(s_prefix.Span))

Language\RazorProjectFileSystem.cs (3)

110if (pathMemory.Span[(fileNameIndex + 1)..].Equals(fileName.AsSpan(), StringComparison.Ordinal)) 119while (index > basePath.Length && (index = pathMemory.Span.LastIndexOf('/')) >= 0) 130memory.Span.CopyTo(span);

Language\ReadOnlyMemoryOfCharComparer.cs (4)

20=> x.SequenceEqual(y.Span); 23=> x.Span.SequenceEqual(y.Span); 28return string.GetHashCode(memory.Span);

Language\TagHelperCollection_Factories.cs (1)

84return segment.Span switch

Language\TagHelperCollection.cs (2)

264var span = segment.Span; 339var span = segment.Span;

Language\TagHelperCollection.Enumerator.cs (2)

31_current = _segment.Span[_index]; 43_current = _segment.Span[0];

Language\TagHelperCollection.MultiSegmentCollection.cs (1)

72return _segments[segmentIndex].Span[localIndex];

Language\TagHelperCollection.SegmentBuilder.cs (1)

66var span = segment.Span;

Language\TagHelperCollection.SegmentCollectionBase.cs (4)

33foreach (var item in segment.Span) 48foreach (var item in segment.Span) 84var index = segment.Span.IndexOf(item); 103segment.Span.CopyTo(destination);

Language\TagHelperCollection.SingleSegmentCollection.cs (1)

49return _segment.Span[index];

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 33return Hash.GetFNVHashCode(obj.Span);

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

85if (IsCandidate(state, token, expectedDocCommentId.Span, suppressMessageAttribute, cancellationToken, out var offsetOfReferenceInToken)) 125if (!docCommentId.Span.StartsWith(expectedDocCommentId)) 137if (docCommentId.Span[expectedDocCommentId.Length] != '.') 146offsetOfReferenceInToken += idPartBeforeArguments.Span.LastIndexOf('.') + 1; 279if (prefix.Span[^2] is < 'A' or > 'Z') 284if (prefix.Span[^1] is not ':') 305var indexOfArguments = id.Span.IndexOfAny(argumentSeparators);

FindSymbols\SymbolTree\SymbolTreeInfo_Serialization.cs (4)

111writer.WriteString(group.Span[0].Name); 113foreach (var item in group.Span) 176var currentName = sortedNodes.Span[0].Name; 179var node = sortedNodes.Span[i];

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

331hashCode = CombineFNVHash(hashCode, chunk.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 31return string.GetHashCode(obj.Span);

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

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

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

96int index = IndexOfExtension(path.Span);

ReadOnlyDataFrameBuffer.cs (1)

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

CatalogEntry.cs (2)

63: this(name, SHA1.HashData(content.Span), SHA256.HashData(content.Span))

ChatRouting\SemanticRoutingChatClient.cs (1)

195ReadOnlySpan<float> queryVector = generated[0].Vector.Span;

ChatCompletion\ChatResponseExtensions.cs (1)

333ms.Write(current.Data.Span);

Contents\DataContent.cs (1)

289wrote |= Convert.TryToBase64Chars(data.Span, array.AsSpan(prefixLength), out int dataLength);

Contents\DataUriParser.cs (5)

34if (!dataUri.Span.StartsWith(Scheme.AsSpan(), StringComparison.OrdinalIgnoreCase)) 42int commaPos = dataUri.Span.IndexOf(','); 56if (metadata.Span.EndsWith(";base64".AsSpan(), StringComparison.OrdinalIgnoreCase)) 60if (!IsValidBase64Data(data.Span)) 68ReadOnlySpan<char> span = metadata.Span.Trim();

Functions\AIFunctionFactory.cs (1)

1433buffer.Span.CopyTo(_buffer.AsSpan(_position));

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\JsonContext.ReadOnlyMemoryDouble.g.cs (1)

51foreach (double element in value.Span)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\JsonContext.ReadOnlyMemoryHalf.g.cs (1)

51foreach (global::System.Half element in value.Span)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\JsonContext.ReadOnlyMemoryInt32.g.cs (1)

51foreach (int element in value.Span)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\JsonContext.ReadOnlyMemorySByte.g.cs (1)

51foreach (sbyte element in value.Span)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\JsonContext.ReadOnlyMemorySingle.g.cs (1)

51foreach (float element in value.Span)

ResponseContinuationToken.cs (1)

62writer.WriteBase64StringValue(value.ToBytes().Span);

Utilities\AIJsonUtilities.cs (1)

247Write(buffer.Span);

ChatCompletion\ChatMessageTests.cs (1)

313Assert.True(dataContent.Data.Span.SequenceEqual(new BinaryData(new[] { 1, 2, 3 }, TestJsonSerializerContext.Default.Options)));

Generated\361d1da7f942c932\TestJsonSerializerContext.ReadOnlyMemoryDouble.g.cs (1)

49foreach (double element in value.Span)

Generated\361d1da7f942c932\TestJsonSerializerContext.ReadOnlyMemorySByte.g.cs (1)

49foreach (sbyte element in value.Span)

Generated\361d1da7f942c932\TestJsonSerializerContext.ReadOnlyMemorySingle.g.cs (1)

49foreach (float element in value.Span)

Common\SimpleWordTokenizer.cs (4)

60var span = text.Span; 194while (!text.IsEmpty && (char.IsNumber(text.Span[0]) || char.IsPunctuation(text.Span[0]))) 196_ = sb.Append(text.Span[0]);

Storage\AzureStorageResponseCache.CacheEntry.cs (1)

42content.Value.Content.ToMemory().Span,

QuantizationEmbeddingGenerator.cs (1)

48ReadOnlySpan<float> vector = embedding.Vector.Span;

ResponsesClientContinuationToken.cs (1)

70Utf8JsonReader reader = new(data.Span);

OpenAIConversionTests.cs (4)

776}), JsonElement.Parse(tc.FunctionArguments.ToMemory().Span))); 832}), JsonElement.Parse(m3.FunctionArguments.ToMemory().Span))); 1608var deserializedArgs = JsonSerializer.Deserialize<Dictionary<string, object?>>(toolCall.FunctionArguments.ToMemory().Span); 1804toolCallUpdate.FunctionArgumentsUpdate.ToMemory().Span);

OpenAIResponseClientTests.cs (1)

6920Utf8JsonReader reader = new(data.Span);

TemplateTestUtilities.cs (1)

77var firstOption = options.Span[0];

Generated\361d1da7f942c932\TestJsonSerializerContext.ReadOnlyMemorySingle.g.cs (1)

49foreach (float element in value.Span)

DistributedCacheTests.cs (4)

189Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 197Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 251Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 259Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span));

Chunkers\DocumentTokenChunker.cs (3)

63text: contentToProcess.Span, 71fixed (char* ptr = &MemoryMarshal.GetReference(contentToProcess.Span)) 79contentToProcessTokenCount = _tokenizer.CountTokens(contentToProcess.Span, considerNormalization: false);

Chunkers\SemanticSimilarityChunker.cs (2)

88float distance = 1 - TensorPrimitives.CosineSimilarity(embeddings[i].Vector.Span, embeddings[i + 1].Vector.Span);

Linux\Network\LinuxNetworkUtilizationParser.cs (2)

150ReadOnlySpan<char> firstLine = enumerableLines.Current.TrimStart().Span; 158UpdateTcpStateInfo(enumerableLines.Current.Span, tcpStateInfo);

Resolver\DnsDataWriter.cs (1)

53!TryWriteRawData(label.Span))

Resolver\DnsPrimitives.cs (10)

Resolver\DnsResolver.cs (2)

104addresses.Add(new AddressResult(response.CreatedAt.AddSeconds(additional.Ttl), new IPAddress(additional.Data.Span))); 318target = new IPAddress(record.Data.Span);

Resolver\EncodedDomainName.cs (4)

29sb.Append(Encoding.ASCII.GetString(label.Span)); 44if (!Ascii.EqualsIgnoreCase(Labels[i].Span, other.Labels[i].Span)) 64foreach (byte b in label.Span)

Resolver\LoopbackDnsServer.cs (1)

322!writer.TryWriteRawData(label.Span))

ModelTests\BasicModelTests.cs (2)

532Assert.Equal(Vector.Span.Length, other.Vector.Span.Length);

ModelTests\MultiVectorModelTests.cs (8)

144Assert.Equal(Vector1.Span.Length, other.Vector1.Span.Length); 145Assert.Equal(Vector2.Span.Length, other.Vector2.Span.Length); 149Assert.True(Vector1.Span.SequenceEqual(other.Vector1.Span)); 150Assert.True(Vector2.Span.SequenceEqual(other.Vector2.Span));

ModelTests\NoDataModelTests.cs (4)

99Assert.Equal(Floats.Span.Length, other.Floats.Span.Length); 103Assert.True(Floats.Span.SequenceEqual(other.Floats.Span));

Data\ModelHeader.cs (1)

163foreach (var ch in ns.Value.Span)

Data\ReadOnlyMemoryUtils.cs (14)

31return memory.Span.SequenceEqual(s.AsSpan()); 47var span = memory.Span; 64span = memory.Slice(ichCur).Span; 82span = memory.Slice(ichCur).Span; 102int index = memory.Span.IndexOf(separator); 134index = memory.Span.IndexOf(separators[0]); 136index = memory.Span.IndexOfAny(separators); 161var span = memory.Span; 182var span = memory.Span; 203var span = memory.Span; 241sb.AppendSpan(memory.Span); 263return x.Span.SequenceEqual(y.Span); 268return (int)Hashing.HashString(obj.Span);

Utilities\NormStr.cs (5)

109if (strSpan.SequenceEqual(ns.Value.Span)) 123var span = str.Span; 132if (ns.Value.Span.SequenceEqual(span)) 190if (value.Span[ich] != sb[ich]) 215Contracts.Assert(Hashing.HashString(str.Span) == hash);

UnitTests\CoreBaseTestClass.cs (4)

118return GetComparerVec<ReadOnlyMemory<char>>(r1, r2, col, size, (a, b) => a.Span.SequenceEqual(b.Span)); 161return GetComparerOne<ReadOnlyMemory<char>>(r1, r2, col, (a, b) => a.Span.SequenceEqual(b.Span));

Data\Conversion.cs (9)

1038return TryParseCore(src.Span, out dst); 1051var span = src.Span; 1150var span = src.Span; 1338var span = text.Span; 1377var span = src.Span; 1391var span = src.Span; 1532var span = src.Span; 1684var span = src.Span; 1692var span = src.Span;

DataLoadSave\Text\TextLoaderParser.cs (3)

752int srcLim = impl.GatherFields(text, text.Span); 781impl.GatherFields(textHeader, textHeader.Span); 869var span = lineSpan.Span;

DataLoadSave\Text\TextSaver.cs (1)

135TextSaverUtils.MapText(src.Span, ref sb, Sep);

Evaluators\EvaluatorUtils.cs (2)

973(slot, val1, val2) => result = result && val1.Span.SequenceEqual(val2.Span));

Transforms\Hashing.cs (6)

614=> value.IsEmpty ? 0 : (Hashing.MurmurHash(seed, value.Span.Trim(' ')) & mask) + 1; 618=> value.IsEmpty ? 0 : (Hashing.MurmurHashV2(seed, value.Span.Trim(' ')) & mask) + 1; 628hash = Hashing.MurmurHashV2(hash, value.Span.Trim(' ')); 1542public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => x.Span.SequenceEqual(y.Span); 1548return (int)Hashing.MurmurHash(_seed, obj.Span.Trim(' ')) + 1;

Transforms\InvertHashUtils.cs (1)

435var span = text.Span;

Transforms\ValueToKeyMappingTransformerImpl.cs (4)

125Comparison<int> comp = (i, j) => _pool.GetNormStrById(i).Value.Span.CompareTo(_pool.GetNormStrById(j).Value.Span, StringComparison.Ordinal); 133Contracts.Assert(i == 0 || sortedPool.GetNormStrById(i - 1).Value.Span.CompareTo(sortedPool.GetNormStrById(i).Value.Span, StringComparison.Ordinal) < 0);

ModelFiles.cs (1)

499if (value.Span.SequenceEqual(slotName.AsSpan()))

DataPipe\TestDataPipe.cs (2)

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

DataPipe\TestDataPipeBase.cs (4)

917return GetComparerOne<ReadOnlyMemory<char>>(r1, r2, col, (a, b) => a.Span.SequenceEqual(b.Span)); 968return GetComparerVec<ReadOnlyMemory<char>>(r1, r2, col, size, (a, b) => a.Span.SequenceEqual(b.Span));

TestCommon.cs (2)

264Assert.True(CompareVec(in names1, in names2, (int)size, (a, b) => a.Span.SequenceEqual(b.Span)), $"Different {kind} metadata values");

ExpressionLanguageTests\ExpressionLanguageTests.cs (2)

391TextSaverUtils.MapText(v.Span, ref sb, '\t'); 606sb.AppendFormat("{0:X4} ", (short)a.Span[ich]);

Scenarios\Api\TestApi.cs (2)

248Assert.True(retrievedReadOnlyMemory.Span.SequenceEqual(valueString.AsMemory().Span));

Transformers\CopyColumnEstimatorTests.cs (2)

156Assert.True(TestCommon.CompareVec(in names1, in names2, size, (a, b) => a.Span.SequenceEqual(b.Span)));

Model\TiktokenTokenizer.cs (4)

824tokenBytes.Span.CopyTo(utf8Bytes.Slice(utf8ByteCount)); 912if (!Helpers.ConvertUtf8ToUtf16(tokenBytes.Span, tempBuffer, out int bytesConsumed, out incompleteCharsWritten)) 936tokenBytes.Span.Slice(bytesConsumed).CopyTo(utf8Bytes); 943tokenBytes.Span.CopyTo(utf8Bytes.Slice(utf8BytesIncompleteIndex + utf8BytesIncompleteCount));

Utils\ByteArrayComparer.cs (3)

16x.Span.SequenceEqual(y.Span); 21foreach (byte b in x.Span)

Expression\BuiltinFunctions.cs (10)

712ReadOnlyMemoryUtils.AddLowerCaseToStringBuilder(a.Span, sb); 722a.Span.ToUpperInvariant(dst); 741a.Span.CopyTo(dst); 742b.Span.CopyTo(new Span<char>(dst, a.Length, b.Length)); 750a.Span.CopyTo(dst); 751b.Span.CopyTo(new Span<char>(dst, a.Length, b.Length)); 752c.Span.CopyTo(new Span<char>(dst, a.Length + b.Length, c.Length)); 769sb.AppendSpan(a[i].Span); 924return first.Span.SequenceEqual(second.Span);

Expression\LambdaBinder.cs (4)

1785(a,b) => Cast<TX>(a).Span.SequenceEqual(Cast<TX>(b).Span), 1799(a,b) => !Cast<TX>(a).Span.SequenceEqual(Cast<TX>(b).Span),

Expression\Printer.cs (1)

285foreach (var ch in str.Span)

GroupTransform.cs (2)

415result = ((ReadOnlyMemory<char>)(object)oldValue).Span.SequenceEqual(((ReadOnlyMemory<char>)(object)newValue).Span);

SvmLight\SvmLightLoader.cs (2)

117if (text.IsEmpty || text.Span[0] == '#') 253int index = memory.Span.LastIndexOf(separator);

Text\StopWordsRemovingTransformer.cs (4)

431ReadOnlyMemoryUtils.AddLowerCaseToStringBuilder(srcValues[i].Span, buffer); 852ReadOnlyMemoryUtils.AddLowerCaseToStringBuilder(stopword.Span, buffer); 884ReadOnlyMemoryUtils.AddLowerCaseToStringBuilder(src.Span, buffer); 1119ReadOnlyMemoryUtils.AddLowerCaseToStringBuilder(srcValues[i].Span, buffer);

Text\TextNormalizing.cs (2)

397var span = src.Span; 429if (ch != src.Span[i])

Text\TokenizingByCharacters.cs (3)

492var span = src.Span; 540var span = srcValues[i].Span; 595var span = srcValues[i].Span;

ResolvePackageAssets.cs (1)

988_compilerNameSearchString = string.Concat("/".AsSpan(), compilerName.Span);

src\sdk\src\StaticWebAssetsSdk\Tasks\Data\StaticWebAssetPathPattern.cs (18)

89var nextToken = MemoryExtensions.IndexOf(current.Span, PatternStart.AsSpan(), StringComparison.OrdinalIgnoreCase); 108var tokenEnd = MemoryExtensions.IndexOf(current.Span, PatternEnd); 130(current.Span[tokenEnd + 1] == PatternOptional || current.Span[tokenEnd + 1] == PatternPreferred || current.Span[tokenEnd + 1] == PatternPackOnly)) 132if (current.Span[tokenEnd + 1] == PatternPackOnly) 141if (current.Span[tokenEnd + 1] == PatternPreferred) 150nextToken = MemoryExtensions.IndexOf(current.Span, PatternStart.AsSpan(), StringComparison.OrdinalIgnoreCase); 176var nextToken = MemoryExtensions.IndexOf(current.Span, PatternParameterStart); 186var tokenEnd = MemoryExtensions.IndexOf(current.Span, PatternParameterEnd); 192var embeddedValue = MemoryExtensions.IndexOf(current.Span, PatternValueSeparator); 210nextToken = MemoryExtensions.IndexOf(current.Span, PatternParameterStart); 281if (!part.IsLiteral && part.Name.Span.SequenceEqual(tokenName.Span) && !part.Value.IsEmpty) 485if (part.Name.Span.SequenceEqual(tokenName.Span)) 539MemoryExtensions.Equals(RawPattern.Span, other.RawPattern.Span, StringComparison.Ordinal) &&

src\sdk\src\StaticWebAssetsSdk\Tasks\Data\StaticWebAssetSegmentPart.cs (4)

23Name.Span.SequenceEqual(other.Name.Span) && 24Value.Span.SequenceEqual(other.Value.Span);

Data\StaticWebAssetPathPattern.cs (18)

89var nextToken = MemoryExtensions.IndexOf(current.Span, PatternStart.AsSpan(), StringComparison.OrdinalIgnoreCase); 108var tokenEnd = MemoryExtensions.IndexOf(current.Span, PatternEnd); 130(current.Span[tokenEnd + 1] == PatternOptional || current.Span[tokenEnd + 1] == PatternPreferred || current.Span[tokenEnd + 1] == PatternPackOnly)) 132if (current.Span[tokenEnd + 1] == PatternPackOnly) 141if (current.Span[tokenEnd + 1] == PatternPreferred) 150nextToken = MemoryExtensions.IndexOf(current.Span, PatternStart.AsSpan(), StringComparison.OrdinalIgnoreCase); 176var nextToken = MemoryExtensions.IndexOf(current.Span, PatternParameterStart); 186var tokenEnd = MemoryExtensions.IndexOf(current.Span, PatternParameterEnd); 192var embeddedValue = MemoryExtensions.IndexOf(current.Span, PatternValueSeparator); 210nextToken = MemoryExtensions.IndexOf(current.Span, PatternParameterStart); 281if (!part.IsLiteral && part.Name.Span.SequenceEqual(tokenName.Span) && !part.Value.IsEmpty) 485if (part.Name.Span.SequenceEqual(tokenName.Span)) 539MemoryExtensions.Equals(RawPattern.Span, other.RawPattern.Span, StringComparison.Ordinal) &&

Data\StaticWebAssetSegmentPart.cs (4)

23Name.Span.SequenceEqual(other.Name.Span) && 24Value.Span.SequenceEqual(other.Value.Span);

FingerprintPatternMatcher.cs (6)

87if (MemoryExtensions.Contains(relativePathCandidate.Span, "#[".AsSpan(), StringComparison.Ordinal)) 96if (MemoryExtensions.Equals(name.Span, "fingerprint".AsSpan(), StringComparison.OrdinalIgnoreCase)) 124var fileName = Path.GetFileName(relativePathCandidate.Span); 125var directoryName = Path.GetDirectoryName(relativePathCandidate.Span); 126var stem = Path.GetFileNameWithoutExtension(relativePathCandidate.Span); 127var extension = Path.GetExtension(relativePathCandidate.Span);

Utils\Globbing\PathTokenizer.cs (1)

87foreach (var range in MemoryExtensions.SplitAny(_path, OSPath.DirectoryPathSeparators.Span))

Utils\Globbing\StaticWebAssetGlobMatcher.cs (4)

224if (!span.Slice(index).StartsWith(part.Value.Span, StringComparison.OrdinalIgnoreCase)) 253var nextLiteralIndex = remainingSpan.IndexOf(nextPart.Value.Span, StringComparison.OrdinalIgnoreCase); 269nextLiteralIndex = remainingSpan.IndexOf(nextPart.Value.Span, StringComparison.OrdinalIgnoreCase); 585Path = path.Span;

Utils\Globbing\StaticWebAssetGlobMatcherBuilder.cs (6)

66var tokenizer = new PathTokenizer(patternMemory.Span); 75if (patternMemory.Span.EndsWith("/".AsSpan()) || patternMemory.Span.EndsWith("\\".AsSpan())) 88var segmentSpan = segment.Span; 207if (segmentSpan.Equals("**".AsMemory().Span, StringComparison.Ordinal)) 219if (segmentSpan.Equals("*".AsMemory().Span, StringComparison.Ordinal))

InternableString.cs (5)

55return ref span.Span[_charIndex]; 198if (span.Span.SequenceCompareTo(other.AsSpan(otherStart, span.Length)) != 0) 260fixed (char* sourcePtr = span.Span) 294return _spans[0].Span == str.AsSpan(); 333fixed (char* charPtr = span.Span)

SpanBasedStringBuilder.cs (7)

55return span.Span[_charIndex]; 137return span.Span[adjustedIndex]; 180if (!MemoryExtensions.Equals(other.Slice(otherIndex, internalSpan.Length), internalSpan.Span, comparison)) 270ReadOnlySpan<char> span = _spans[spanIdx].Span; 292ReadOnlySpan<char> span = _spans[spanIdx].Span; 317ReadOnlySpan<char> span = _spans[spanIdx].Span; 339ReadOnlySpan<char> span = _spans[spanIdx].Span;

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

src\sourcelink\src\Common\Utilities\Hash.cs (1)

321hashCode = CombineFNVHash(hashCode, chunk.Span);

ContentModel\ContentItemCollection.cs (4)

306asset.Path.AsMemory().Span.StartsWith(assemblyPrefix.Span, StringComparison.Ordinal)) 339return x.Span.Equals(y.Span, StringComparison.OrdinalIgnoreCase);

ContentModel\ContentPropertyDefinition.cs (2)

105if (name.Span.EndsWith(fileExtension.AsSpan(), StringComparison.OrdinalIgnoreCase)) 137foreach (var ch in name.Span)

ContentModel\ManagedCodeConventions.cs (5)

148foreach (char c in name.Span) 192else if (name.Length >= 4 && name.Span[2] == '-') // e.g. en-US 200else if (name.Length >= 5 && name.Span[3] == '-') // e.g agq-CM 292if (MemoryExtensions.Equals(PackagingCoreConstants.EmptyFolder.AsSpan(), s.Span, StringComparison.Ordinal)) 311ReadOnlySpan<char> span = s.Span;

ContentModel\ReadOnlyMemoryCharComparerOrdinal.cs (3)

23return x.Span.Equals(y.Span, StringComparison.Ordinal); 34foreach (var character in obj.Span)

Signing\TrustStore\CertificateBundleX509ChainFactory.cs (1)

121return new string(pem.Span);

OrderProcessingWorker.cs (1)

66var order = JsonSerializer.Deserialize<Order>(message.Span) ?? new Order() { Id = "fake" };

src\aspnetcore\src\Shared\CertificateGeneration\CertificateManager.cs (2)

1053return cert1.RawDataMemory.Span.SequenceEqual(cert2.RawDataMemory.Span);

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

96int index = IndexOfExtension(path.Span);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (4)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span); 33return Hash.GetFNVHashCode(obj.Span);

ServerSentEvents\SseFormatter.cs (1)

86data: userDataBufferWriter.WrittenMemory.Span,

Parsing\CommandLineParser.cs (1)

53var c = memory.Span[pos];

System\IO\StdInReader.cs (1)

132encoder.Convert(chunk.Span, buffer, flush: false, out int charsUsed, out int bytesUsed, out bool completed);

System\Diagnostics\XmlWriterTraceListener.cs (1)

435writer.Write(chunk.Span);

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

722_data.Span, 788_data.Span, 840_data.Span,

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

114bool ret = AsnDecoder.ReadBoolean(_data.Span, RuleSet, out int bytesConsumed, expectedTag);

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

683if (bigger.Span.Overlaps(smaller, out int offset)) 827return Asn1Tag.Decode(_data.Span, out _); 846AsnDecoder.ReadEncodedValue(_data.Span, RuleSet, out _, out _, out int bytesConsumed); 865_data.Span,

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

298AsnDecoder.ReadEnumeratedBytes(_data.Span, RuleSet, out int consumed, expectedTag); 352TEnum ret = AsnDecoder.ReadEnumeratedValue<TEnum>(_data.Span, RuleSet, out int consumed, expectedTag); 406Enum ret = AsnDecoder.ReadEnumeratedValue(_data.Span, RuleSet, enumType, out int consumed, expectedTag);

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

433DateTimeOffset ret = AsnDecoder.ReadGeneralizedTime(_data.Span, RuleSet, out int consumed, expectedTag);

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

550AsnDecoder.ReadIntegerBytes(_data.Span, RuleSet, out int consumed, expectedTag); 586BigInteger ret = AsnDecoder.ReadInteger(_data.Span, RuleSet, out int consumed, expectedTag); 625bool ret = AsnDecoder.TryReadInt32(_data.Span, RuleSet, out value, out int read, expectedTag); 665bool ret = AsnDecoder.TryReadUInt32(_data.Span, RuleSet, out value, out int read, expectedTag); 704bool ret = AsnDecoder.TryReadInt64(_data.Span, RuleSet, out value, out int read, expectedTag); 744bool ret = AsnDecoder.TryReadUInt64(_data.Span, RuleSet, out value, out int read, expectedTag);

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

487_data.Span, 541_data.Span, 578BitArray ret = AsnDecoder.ReadNamedBitList(_data.Span, RuleSet, out int consumed, expectedTag);

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

92AsnDecoder.ReadNull(_data.Span, RuleSet, out int consumed, expectedTag);

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

578_data.Span, 624byte[] ret = AsnDecoder.ReadOctetString(_data.Span, RuleSet, out int consumed, expectedTag); 663_data.Span,

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

369AsnDecoder.ReadObjectIdentifier(_data.Span, RuleSet, out int consumed, expectedTag);

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

136_data.Span,

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

213_data.Span,

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

537_data.Span, 599_data.Span, 668_data.Span, 724_data.Span,

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

275_data.Span, 319AsnDecoder.ReadUtcTime(_data.Span, RuleSet, out int consumed, twoDigitYearMax, expectedTag);

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

13Compare(x.Span, y.Span);

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

162var nextByte = new CborInitialByte(_data.Span[_offset]); 295private ReadOnlySpan<byte> GetRemainingBytes() => _data.Span.Slice(_offset);

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

139ReadOnlySpan<byte> buffer = _data.Span; 211return _reader._data.Span.Slice(range.Offset, range.Length);

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

59var initialByte = new CborInitialByte(_data.Span[_offset]);

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

169byte value = _data.Span[_offset + 1];

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

283ValidateUtf8AndGetCharCount(encodedSlice.Span, encoding); 401ReadOnlySpan<byte> source = input.source.Span;

src\runtime\src\libraries\Common\src\System\ReadWriteAdapter.cs (1)

74stream.Write(buffer.Span);

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

250ReadCentralDirectoryEndOfOuterLoopWork(ref currPosition, sizedFileBuffer.Span);

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

190if (!TryReadBlockInitialize(buffer.Span, out header, out int bytesRead, out uint compressedSizeSmall, out uint uncompressedSizeSmall, out ushort diskNumberStartSmall, out uint relativeOffsetOfLocalHeaderSmall)) 208dynamicHeader = buffer.Span[FieldLocations.DynamicData..];

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

437ReadOnlySpan<byte> chunk = buffer.Span[..chunkSize];

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

449_checksum = Crc32Helper.UpdateCrc32(_checksum, buffer.Span);

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

59bufferPointer = bufferMemory.Span.LastIndexOf(signatureToFind.Span);

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

191lastResult = _encoder.Compress(buffer.Span, output.Span, out bytesConsumed, out bytesWritten, isFinalBlock);

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

131internal OperationStatus Compress(ReadOnlyMemory<byte> source, Memory<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) => Compress(source.Span, destination.Span, out bytesConsumed, out bytesWritten, isFinalBlock);

System\IO\Compression\ZipFile.Create.cs (2)

422CreateZipArchiveFromDirectory(sourceDirectoryName, archive, options.CompressionLevel, options.IncludeBaseDirectory, options.Password.Span, options.EncryptionMethod); 444CreateZipArchiveFromDirectory(sourceDirectoryName, archive, options.CompressionLevel, options.IncludeBaseDirectory, options.Password.Span, options.EncryptionMethod);

System\IO\Compression\ZipFile.Extract.cs (2)

458ExtractToDirectory(sourceArchiveFileName, destinationDirectoryName, options.EntryNameEncoding, options.OverwriteFiles, options.Password.Span); 472ExtractToDirectory(source, destinationDirectoryName, options.EntryNameEncoding, options.OverwriteFiles, options.Password.Span);

System\IO\Compression\ZipFileExtensions.ZipArchive.Create.Async.cs (1)

147(FileStream fs, ZipArchiveEntry entry) = InitializeDoCreateEntryFromFile(destination, sourceFileName, entryName, compressionLevel, useAsync: true, password.Span, encryption);

System\IO\Compression\ZipFileExtensions.ZipArchive.Extract.cs (1)

92entry.ExtractRelativeToDirectory(destinationDirectoryName, options.OverwriteFiles, options.Password.Span);

System\IO\Compression\ZipFileExtensions.ZipArchiveEntry.Extract.Async.cs (1)

118? await source.OpenAsync(password.Span, cancellationToken: cancellationToken).ConfigureAwait(false)

System\IO\Compression\ZipFileExtensions.ZipArchiveEntry.Extract.cs (1)

80ExtractToFile(source, destinationFileName, options.OverwriteFiles, options.Password.Span);

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

334hash.Append(buffer.Span);

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

1198WriteMultiSegment(source.Span);

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

115this.Write(source.Span);

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

398InnerStream.Write(returnSegment.Memory.Span);

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

813ReadOnlySpan<byte> buff = writeRequest.Buffer.Span;

System\Buffers\BuffersExtensions.cs (4)

21int index = source.First.Span.IndexOf(value); 41int index = memory.Span.IndexOf(value); 67ReadOnlySpan<T> span = source.First.Span; 86ReadOnlySpan<T> span = memory.Span;

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

184ReadOnlySpan<T> span = ((ReadOnlySequenceSegment<T>)startObject).Memory.Span; 224return memory.Span.Slice(startIndex & ReadOnlySequence.IndexBitMask, endIndex - startIndex); 648first = segment.Memory.Span;

System\Buffers\ReadOnlySequenceStream.cs (1)

145destination.Write(segment.Span);

System\Buffers\SequenceReader.cs (4)

181value = currentMemory.Span[(int)remainingOffset]; 271CurrentSpan = memory.Span; 295CurrentSpan = memory.Span; 443ReadOnlySpan<T> nextSpan = nextSegment.Span;

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

41span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray(); 79span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray(); 353span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray(); 440span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray(); 838currentSpan = nextSegment.Span;

System\BinaryData.cs (3)

419public override string ToString() => Encoding.UTF8.GetString(_bytes.Span); 465ReadOnlySpan<byte> span = _bytes.Span; 490return data._bytes.Span;

System\BinaryDataConverter.cs (1)

26writer.WriteBase64StringValue(value.ToMemory().Span);

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

130DecodeInternal(segment.Span, handler);

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

170DecodeInternal(segment.Span, handler);

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

1134Write(buffer.Span);

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

19stream.Write(_content.Span);

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

307bytesRead.Span.CopyTo(buffer);

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

1732current.Span.CopyTo(span); 1744current.Span.CopyTo(span);

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

1422WriteToBuffer(source.Span); 1429WriteToBuffer(source.Span.Slice(0, remaining)); 1440WriteToBuffer(source.Span); 1461WriteToBuffer(source.Span); 1508WriteToBuffer(source.Span); 1587_stream.Write(source.Span); 1900destination.Write(source.Span);

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

361rawCertData.AsSpan().SequenceEqual(serverCertificate.RawDataMemory.Span))

src\runtime\src\libraries\Common\src\System\ReadWriteAdapter.cs (1)

74stream.Write(buffer.Span);

System\Net\Base64Stream.cs (1)

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

System\Net\BufferBuilder.cs (1)

41value.Span.CopyTo(_buffer.AsSpan(_offset));

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

81EncodeLines(buffer.Span);

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

250written += EncodeBytes(buffer.Span.Slice(written));

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

364written += EncodeBytes(buffer.Span.Slice(written));

System\Net\DnsResolverPal.Managed.cs (2)

652socket.Send(query.Span); 743SendExactSync(socket, query.Span);

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

165(bool wait, int bytesWritten) = TryWriteToBuffer(buffer.Span);

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

58buffer.Span.CopyTo(_buffers[index].Span);

System\Net\Quic\Internal\MsQuicConfiguration.Cache.cs (4)

74if (!CertificateThumbprints.Span.SequenceEqual(other.CertificateThumbprints.Span)) 102hash.AddBytes(CertificateThumbprints.Span); 108hash.AddBytes(protocol.Protocol.Span);

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

90CertificateThumbprints.Span.SequenceEqual(other.CertificateThumbprints.Span) && 98hash.AddBytes(CertificateThumbprints.Span); 1236if (clientProto.SequenceEqual(protocolList[i].Protocol.Span))

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

355protocol.Protocol.Span.CopyTo(buffer.Slice(offset));

src\runtime\src\libraries\Common\src\System\ReadWriteAdapter.cs (1)

74stream.Write(buffer.Span);

System\Net\Security\NegotiateStream.cs (3)

534_context.ComputeIntegrityCheck(bufferToWrap.Span, _writeBuffer); 535_writeBuffer.Write(bufferToWrap.Span); 540statusCode = _context.Wrap(bufferToWrap.Span, _writeBuffer, isEncrypted, out _);

System\Net\Security\Pal.Managed\EndpointChannelBindingToken.cs (3)

43return SHA256.HashData(cert.RawDataMemory.Span); 48return SHA384.HashData(cert.RawDataMemory.Span); 53return SHA512.HashData(cert.RawDataMemory.Span);

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

384NetEventSource.Log.SentFrame(this, payload.Span);

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

1038if (NetEventSource.Log.IsEnabled()) NetEventSource.DumpBuffer(this, buffer.Span); 1225certificate.RawDataMemory.Span.SequenceEqual(remoteCertificateSlot.RawDataMemory.Span))

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

76Interop.Ssl.SslErrorCode errorCode = Interop.OpenSsl.Encrypt((SafeSslHandle)securityContext, input.Span, ref token);

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

728if (protocol.SequenceEqual(SslApplicationProtocol.Http2.Protocol.Span)) 738protocol.SequenceEqual(SslApplicationProtocol.Http11.Protocol.Span))

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

85data: userDataBufferWriter.WrittenMemory.Span,

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

81Write(buffer.Span);

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

510int sendBytes = WriteFrameToSendBuffer(opcode, endOfMessage, disableCompression, payloadBuffer.Span); 607int sendBytes = WriteFrameToSendBuffer(opcode, endOfMessage, disableCompression, payloadBuffer.Span);

System\Net\WebSockets\WebSocket.cs (1)

75buffer.Span.CopyTo(array);

src\runtime\src\libraries\System.Private.CoreLib\src\Microsoft\Win32\SafeHandles\SafeFileHandle.ThreadPoolValueTaskSource.cs (1)

102RandomAccess.WriteAtOffset(_fileHandle, _singleSegment.Span, _fileOffset);

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

1034int bytesWritten = WriteToBuffer(buffer.Span); 1087buffer = buffer.Slice(WriteToBuffer(buffer.Span)); 1102int bytesWritten = WriteToBuffer(buffer.Span); 1120buffer.Span.CopyTo(new Span<byte>(_buffer, _writePos, buffer.Length));

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

1618using SafeFileHandle fileHandle = OpenHandle(path, mode, FileAccess.Write, FileShare.Read, FileOptions.Asynchronous, GetPreallocationSize(mode, contents.Span, encoding, preambleSize)); 1649int encoded = encoder.GetBytes(toEncode.Span, bytes.AsSpan(preambleSize), flush: contents.IsEmpty);

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

699Write(buffer.Span);

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

88ReadOnlySpan<byte> span = _memory.Span; 120_memory.Span.Slice(_position, bytesToRead).CopyTo(buffer); 190destination.Write(_memory.Span.Slice(_position));

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

639buffer.Span.CopyTo(_buffer.AsSpan(_writePos)); 704source.Span.CopyTo(_buffer.AsSpan(_writePos)); 710source.Span.Slice(0, spaceLeft).CopyTo(_buffer.AsSpan(_writePos)); 734source.Span.CopyTo(_buffer.AsSpan(_writePos));

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

741buffer.Span.CopyTo(sharedBuffer);

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

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

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

131int written = _encoding.GetBytes(_text.Span, buffer); 159ReadOnlySpan<char> remaining = _text.Span.Slice(_charPosition);

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

221Write(buffer.Span); 297WriteLine(buffer.Span);

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

314Write(chunk.Span); 679t.Item1.Write(t.Item2.Span); 774t.Item1.WriteLine(t.Item2.Span); 1115Write(buffer.Span); 1127WriteLine(buffer.Span);

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

740Write(buffer.Span);

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

306Write(buffer.Span);

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

47ReadOnlySpan<T> span = memory.Span; 59=> memory.Slice(ClampStart(memory.Span, trimElement)); 67=> memory.Slice(0, ClampEnd(memory.Span, 0, trimElement)); 275ReadOnlySpan<T> span = memory.Span; 300return memory.Slice(ClampStart(memory.Span, trimElements)); 322return memory.Slice(0, ClampEnd(memory.Span, 0, trimElements)); 545ReadOnlySpan<char> span = memory.Span; 556=> memory.Slice(ClampStart(memory.Span)); 563=> memory.Slice(0, ClampEnd(memory.Span, 0));

src\runtime\src\libraries\System.Private.CoreLib\src\System\ReadOnlyMemory.cs (4)

141return (_object is string str) ? str.Substring(_index, _length) : Span.ToString(); 284public void CopyTo(Memory<T> destination) => Span.CopyTo(destination.Span); 294public bool TryCopyTo(Memory<T> destination) => Span.TryCopyTo(destination.Span); 355public T[] ToArray() => Span.ToArray();

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\MemoryMarshal.cs (1)

474yield return memory.Span[i];

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

1139public StringBuilder Append(ReadOnlyMemory<char> value) => Append(value.Span);

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

573bytes: remainingOuterEncodedBytes.Span,

src\runtime\src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (1)

87byte[] ret = AsnDecoder.ReadOctetString(encodedOctets.Span, AsnEncodingRules.BER, out int consumed);

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

32return Parameters!.Value.Span.SequenceEqual(other.Parameters!.Value.Span); 47ReadOnlySpan<byte> span = parameters.Value.Span; 69val.Parameters = parameters.Span;

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

39writer.WriteEncodedValue(Parameters.Value.Span); 59ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 92ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

41writer.WriteEncodedValue(AttrValues[i].Span); 62ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

27writer.WriteOctetString(Digest.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\DirectoryStringAsn.xml.cs (4)

86if (!Asn1Tag.TryDecode(UniversalString.Value.Span, out Asn1Tag validateTag, out _) || 95writer.WriteEncodedValue(UniversalString.Value.Span); 132ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 160ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\EdiPartyNameAsn.xml.cs (1)

49ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

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

27writer.WriteOctetString(EncryptedData.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\GeneralNameAsn.xml.cs (6)

103if (!Asn1Tag.TryDecode(X400Address.Value.Span, out Asn1Tag validateTag, out _) || 112writer.WriteEncodedValue(X400Address.Value.Span); 129writer.WriteEncodedValue(DirectoryName.Value.Span); 162writer.WriteOctetString(IPAddress.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 7)); 192ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 221ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

37writer.WriteEncodedValue(Value.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\CertBagAsn.xml.cs (3)

37writer.WriteEncodedValue(CertValue.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\MacData.xml.cs (3)

50writer.WriteOctetString(MacSalt.Span); 76ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 110ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\PfxAsn.manual.cs (2)

73MacData.Value.MacSalt.Span, 88MacData.Value.Mac.Digest.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\PfxAsn.xml.cs (1)

47ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SafeBagAsn.xml.cs (3)

39writer.WriteEncodedValue(BagValue.Span); 71ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 106ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SecretBagAsn.xml.cs (3)

37writer.WriteEncodedValue(SecretValue.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\CertificateChoiceAsn.xml.cs (10)

68if (!Asn1Tag.TryDecode(Certificate.Value.Span, out Asn1Tag validateTag, out _) || 77writer.WriteEncodedValue(Certificate.Value.Span); 93if (!Asn1Tag.TryDecode(ExtendedCertificate.Value.Span, out Asn1Tag validateTag, out _) || 102writer.WriteEncodedValue(ExtendedCertificate.Value.Span); 118if (!Asn1Tag.TryDecode(AttributeCertificateV1.Value.Span, out Asn1Tag validateTag, out _) || 127writer.WriteEncodedValue(AttributeCertificateV1.Value.Span); 143if (!Asn1Tag.TryDecode(AttributeCertificateV2.Value.Span, out Asn1Tag validateTag, out _) || 152writer.WriteEncodedValue(AttributeCertificateV2.Value.Span); 180ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 208ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\ContentInfoAsn.xml.cs (3)

37writer.WriteEncodedValue(Content.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncapsulatedContentInfoAsn.xml.cs (3)

40writer.WriteEncodedValue(Content.Value.Span); 61ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 95ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncryptedContentInfoAsn.xml.cs (3)

39writer.WriteOctetString(EncryptedContent.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 87ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncryptedDataAsn.xml.cs (1)

55ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\IssuerAndSerialNumberAsn.xml.cs (5)

28if (!Asn1Tag.TryDecode(Issuer.Span, out Asn1Tag validateTag, out _) || 37writer.WriteEncodedValue(Issuer.Span); 43writer.WriteInteger(SerialNumber.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 89ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\OtherCertificateFormat.xml.cs (3)

36writer.WriteEncodedValue(OtherCert.Span); 54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 87ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignedDataAsn.xml.cs (3)

63writer.WriteEncodedValue(Crls[i].Span); 94ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 128ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerIdentifierAsn.xml.cs (3)

69writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 83ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 111ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerInfoAsn.xml.cs (5)

40if (!Asn1Tag.TryDecode(SignedAttributes.Value.Span, out Asn1Tag validateTag, out _) || 49writer.WriteEncodedValue(SignedAttributes.Value.Span); 58writer.WriteOctetString(SignatureValue.Span); 84ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 118ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

31writer.WriteOctetString(PrivateKey.Span); 57ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 91ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

27writer.WriteOctetString(Iv.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

27writer.WriteBitString(SubjectPublicKey.Span, 0); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

65writer.WriteOctetString(ExtnValue.Span); 78ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 112ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

23return ToUnsignedIntegerBytes(memory.Span); 28ToUnsignedIntegerBytes(memory.Span, destination);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Builder.cs (1)

362_sealedData.Span.CopyTo(destination);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12CertBag.cs (1)

104encodedCertificate.Span,

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Info.cs (3)

48return _decoded.VerifyMac(password, _authSafeContents.Span); 57int firstValueLength = PkcsHelpers.FirstBerValueLength(encodedBytes.Span); 110ValueAsnReader authSafeReader = new ValueAsnReader(authSafeBytes.Span, AsnEncodingRules.BER);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12SafeBag.cs (2)

48PkcsHelpers.EnsureSingleBerValue(encodedBagValue.Span); 81writer.WriteEncodedValueForCrypto(EncodedBagValue.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12SafeContents.cs (4)

186PkcsHelpers.EnsureSingleBerValue(secretValue.Span); 258encryptedData.EncryptedContentInfo.EncryptedContent.Value.Span, 341ValueAsnReader reader = new ValueAsnReader(serialized.Span, AsnEncodingRules.BER); 499writer.WriteEncodedValueForCrypto(_encrypted.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs8PrivateKeyInfo.cs (6)

36PkcsHelpers.EnsureSingleBerValue(algorithmParameters.Value.Span); 74ValueAsnReader reader = new ValueAsnReader(source.Span, AsnEncodingRules.BER); 180source.Span, 188Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span)); 211source.Span, 219Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span));

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

142AsnDecoder.ReadSequence(data.Span, AsnEncodingRules.BER, out _, out _, out int trimLength); 154ReadOnlySpan<byte> authSafeContents = authSafeMemory.Span; 279ValueAsnReader outer = new ValueAsnReader(contentData.Span, AsnEncodingRules.BER); 549encryptedContent.Span); 581algorithmIdentifier.Parameters.Value.Span, 588algorithmIdentifier.Parameters.Value.Span, 784return HasCapiValue(attr.AttrValues[0].Span, out isRsa); 1115bag.BagValue.Span, 1143bag.BagValue.Span,

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

749return LiteHashProvider.HmacStreamAsync(hashAlgorithm.Name, key.Span, source, destination, cancellationToken); 794return LiteHashProvider.HmacStreamAsync(hashAlgorithm.Name, key.Span, source, cancellationToken); 1044key.Span, 1050return CryptographicOperations.FixedTimeEquals(mac, hash.Span);

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

165ReadOnlySpan<byte> input = encodedOctetString.Span;

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

128return LiteHashProvider.HmacStreamAsync(THMAC.HashAlgorithmName, key.Span, source, cancellationToken); 155key.Span, 228key.Span, 234return CryptographicOperations.FixedTimeEquals(mac, hash.Span);

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

12return ToUnsignedIntegerBytes(memory.Span, length);

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

559return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC128, key.Span, source, xof: false, outputLength, customizationString.Span, cancellationToken); 599return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC128, key.Span, source, xof: false, destination, customizationString.Span, cancellationToken);

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

559return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC256, key.Span, source, xof: false, outputLength, customizationString.Span, cancellationToken); 599return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC256, key.Span, source, xof: false, destination, customizationString.Span, cancellationToken);

System\Security\Cryptography\KmacStatic.cs (3)

130key.Span, 134customizationString.Span, 137return CryptographicOperations.FixedTimeEquals(mac, hash.Span);

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

559return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC128, key.Span, source, xof: true, outputLength, customizationString.Span, cancellationToken); 599return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC128, key.Span, source, xof: true, destination, customizationString.Span, cancellationToken);

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

559return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC256, key.Span, source, xof: true, outputLength, customizationString.Span, cancellationToken); 599return LiteHashProvider.KmacStreamAsync(HashAlgorithmNames.KMAC256, key.Span, source, xof: true, destination, customizationString.Span, cancellationToken);

System\Security\Cryptography\X509Certificates\Asn1\AccessDescriptionAsn.xml.cs (1)

47ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\Asn1\BasicConstraintsAsn.xml.cs (1)

74ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\Asn1\CertificateAsn.xml.cs (3)

29writer.WriteBitString(SignatureValue.Span, 0); 42ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 75ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\X509Certificates\Asn1\CertificatePolicyMappingAsn.xml.cs (1)

54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\Asn1\CertificateTemplateAsn.xml.cs (1)

54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\Asn1\CertificationRequestAsn.xml.cs (3)

29writer.WriteBitString(SignatureValue.Span, 0); 42ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 75ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\X509Certificates\Asn1\CertificationRequestInfoAsn.xml.cs (4)

32if (!Asn1Tag.TryDecode(Subject.Span, out Asn1Tag validateTag, out _) || 41writer.WriteEncodedValue(Subject.Span); 68ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 102ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\X509Certificates\Asn1\PolicyConstraintsAsn.xml.cs (1)

50ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\Asn1\PolicyInformationAsn.xml.cs (3)

39writer.WriteEncodedValue(PolicyQualifiers.Value.Span); 59ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 92ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\X509Certificates\Asn1\TbsCertificateAsn.xml.cs (9)

72writer.WriteInteger(SerialNumber.Span); 76if (!Asn1Tag.TryDecode(Issuer.Span, out Asn1Tag validateTag, out _) || 85writer.WriteEncodedValue(Issuer.Span); 94if (!Asn1Tag.TryDecode(Subject.Span, out Asn1Tag validateTag, out _) || 103writer.WriteEncodedValue(Subject.Span); 113writer.WriteBitString(IssuerUniqueId.Value.Span, 0, new Asn1Tag(TagClass.ContextSpecific, 1)); 119writer.WriteBitString(SubjectUniqueId.Value.Span, 0, new Asn1Tag(TagClass.ContextSpecific, 2)); 149ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 185ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\X509Certificates\Asn1\TimeAsn.xml.cs (1)

83ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\Asn1\ValidityAsn.xml.cs (1)

40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\X509Certificates\CertificateRequest.cs (1)

1034Helpers.ValidateDer(signatureAlgorithmAsn.Parameters.Value.Span);

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

229issuerCertificate.SerialNumberBytes.Span); 358Helpers.ValidateDer(signatureAlgorithmAsn.Parameters.GetValueOrDefault().Span);

System\Security\Cryptography\X509Certificates\CertificateRevocationListBuilder.cs (1)

70AddEntry(certificate.SerialNumberBytes.Span, revocationTime, reason);

System\Security\Cryptography\X509Certificates\Pkcs10CertificationRequestInfo.cs (1)

51Helpers.ValidateDer(signatureAlgorithmAsn.Parameters.Value.Span);

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

30ReadOnlySpan<byte> rawDataSpan = rawData.Span; 130ValueAsnReader reader = new ValueAsnReader(_singleElementValue.Span, AsnEncodingRules.DER);

System\Security\Cryptography\X509Certificates\X509AuthorityKeyIdentifierExtension.cs (5)

201subjectKeyIdentifier.SubjectKeyIdentifierBytes.Span); 477ReadOnlySpan<byte> skidBytes = skid.SubjectKeyIdentifierBytes.Span; 484certificate.SerialNumberBytes.Span); 493certificate.SerialNumberBytes.Span); 560decoded.DirectoryName.GetValueOrDefault().Span);

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

438return CryptographicOperations.HashData(hashAlgorithm, PalRawDataMemory.Span); 448return CryptographicOperations.TryHashData(hashAlgorithm, PalRawDataMemory.Span, destination, out bytesWritten); 460return GetCertHashString(hashAlgorithm, PalRawDataMemory.Span);

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

1556X509Certificate2 ret = X509CertificateLoader.LoadCertificate(certData.Span); 1589return PemEncoding.WriteString(PemLabels.X509Certificate, RawDataMemory.Span); 1618return PemEncoding.TryWrite(PemLabels.X509Certificate, RawDataMemory.Span, destination, out charsWritten); 1832ValueAsnReader reader = new ValueAsnReader(rdn.RawData.Span, AsnEncodingRules.DER); 2165ecdh.ImportPkcs8PrivateKey(privateKeyInfo.Span, out int pkcs8Read); 2182ecdsa.ImportPkcs8PrivateKey(privateKeyInfo.Span, out int pkcs8Read); 2215X509KeyUsageExtension.DecodeX509KeyUsageExtension(attrValue.Span, out X509KeyUsageFlags usages);

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

622if (!PemEncoding.TryWrite(PemLabels.X509Certificate, certData.Span, buffer, out int certWritten) || 789int bytesWritten = CryptographicOperations.HashData(hashAlgorithm, cert.RawDataMemory.Span, thumbprintBuffer);

System\Security\Cryptography\X509Certificates\X509CertificateLoader.Windows.cs (2)

51using (SafeCertStoreHandle storeHandle = ImportPfx(data.Span, password, keyStorageFlags)) 66using (SafeCertStoreHandle storeHandle = ImportPfx(data.Span, password, keyStorageFlags))

System\Security\Cryptography\X509Certificates\X509SubjectAlternativeNameExtension.cs (1)

98ReadOnlySpan<byte> value = item.IPAddress.GetValueOrDefault().Span;

System\Security\Cryptography\Cose\CoseHeaderMap.cs (1)

372writer.WriteEncodedValue(value.EncodedValue.Span);

System\Security\Cryptography\Cose\CoseHeaderValue.cs (3)

246public bool Equals(CoseHeaderValue other) => EncodedValue.Span.SequenceEqual(other.EncodedValue.Span); 255hashCode.AddBytes(EncodedValue.Span);

System\Security\Cryptography\Cose\CoseMessage.cs (4)

315CoseHeaderValue value = CoseHeaderValue.FromEncodedValue(reader.ReadEncodedValue().Span); 485int bytesWritten = CreateToBeSigned(buffer, context, bodyProtected.Span, signProtected.Span, associatedData.Span, ReadOnlySpan<byte>.Empty);

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (1)

602CoseHelpers.WriteContent(writer, Content.GetValueOrDefault().Span, !Content.HasValue);

System\Security\Cryptography\Cose\CoseSign1Message.cs (1)

1018CoseHelpers.WriteContent(writer, Content.GetValueOrDefault().Span, !Content.HasValue);

System\Security\Cryptography\Cose\CoseSignature.cs (4)

112return VerifyCore(coseKey, Message.Content.Value.Span, null, associatedData); 152return VerifyCore(key, Message.Content.Value.Span, null, associatedData); 195return VerifyCore(coseKey, Message.Content.Value.Span, null, associatedData); 662CoseMessage.AppendToBeSigned(buffer, toBeSignedBuilder, SigStructureContext.Signature, Message.RawProtectedHeaders.Span, _encodedSignProtectedHeaders, associatedData, contentBytes, contentStream);

Internal\Cryptography\Pal\AnyOS\AsnHelpers.cs (2)

29originator.IssuerAndSerialNumber.Value.SerialNumber.Span.ToBigEndianHex())); 36originator.SubjectKeyIdentifier.Value.Span.ToBigEndianHex());

Internal\Cryptography\Pal\AnyOS\ManagedPal.cs (1)

125ValueAsnReader reader = new(contentEncryptionAlgorithm.Parameters.Value.Span, AsnEncodingRules.BER);

Internal\Cryptography\Pal\AnyOS\ManagedPal.Decode.cs (1)

48originatorCerts.Add(X509CertificateLoader.LoadCertificate(certChoice.Certificate.Value.Span));

Internal\Cryptography\Pal\AnyOS\ManagedPal.Decrypt.cs (1)

171return alg.DecryptCbc(encryptedContent.Span, alg.IV);

Internal\Cryptography\Pal\AnyOS\ManagedPal.KeyAgree.cs (1)

83rawData = rid.RKeyId.Value.Other.Value.KeyAttr!.Value.Span;

Internal\Cryptography\Pal\AnyOS\ManagedPal.KeyTrans.cs (2)

45!parameters.Value.Span.SequenceEqual(s_rsaPkcsParameters)) 61return DecryptCekCore(cert, privateKey, _asn.EncryptedKey.Span, keyEncryptionAlgorithm, parameters, out exception);

Internal\Cryptography\PkcsHelpers.cs (1)

375!oaepParameters.PSourceFunc.Parameters.Value.Span.SequenceEqual(pSpecifiedDefaultParameters))

src\runtime\src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (2)

87byte[] ret = AsnDecoder.ReadOctetString(encodedOctets.Span, AsnEncodingRules.BER, out int consumed); 175ReadOnlySpan<byte> input = encodedOctetString.Span;

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

32return Parameters!.Value.Span.SequenceEqual(other.Parameters!.Value.Span); 47ReadOnlySpan<byte> span = parameters.Value.Span; 69val.Parameters = parameters.Span;

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

39writer.WriteEncodedValue(Parameters.Value.Span); 59ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 92ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

41writer.WriteEncodedValue(AttrValues[i].Span); 62ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

27writer.WriteOctetString(Digest.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\DirectoryStringAsn.xml.cs (4)

86if (!Asn1Tag.TryDecode(UniversalString.Value.Span, out Asn1Tag validateTag, out _) || 95writer.WriteEncodedValue(UniversalString.Value.Span); 132ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 160ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\EdiPartyNameAsn.xml.cs (1)

49ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

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

27writer.WriteOctetString(EncryptedData.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\GeneralNameAsn.xml.cs (6)

103if (!Asn1Tag.TryDecode(X400Address.Value.Span, out Asn1Tag validateTag, out _) || 112writer.WriteEncodedValue(X400Address.Value.Span); 129writer.WriteEncodedValue(DirectoryName.Value.Span); 162writer.WriteOctetString(IPAddress.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 7)); 192ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 221ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\OaepParamsAsn.xml.cs (1)

111ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

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

37writer.WriteEncodedValue(Value.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\CertBagAsn.xml.cs (3)

37writer.WriteEncodedValue(CertValue.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\MacData.xml.cs (3)

50writer.WriteOctetString(MacSalt.Span); 76ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 110ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\PfxAsn.manual.cs (2)

73MacData.Value.MacSalt.Span, 88MacData.Value.Mac.Digest.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\PfxAsn.xml.cs (1)

47ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SafeBagAsn.xml.cs (3)

39writer.WriteEncodedValue(BagValue.Span); 71ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 106ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SecretBagAsn.xml.cs (3)

37writer.WriteEncodedValue(SecretValue.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\CertificateChoiceAsn.xml.cs (10)

68if (!Asn1Tag.TryDecode(Certificate.Value.Span, out Asn1Tag validateTag, out _) || 77writer.WriteEncodedValue(Certificate.Value.Span); 93if (!Asn1Tag.TryDecode(ExtendedCertificate.Value.Span, out Asn1Tag validateTag, out _) || 102writer.WriteEncodedValue(ExtendedCertificate.Value.Span); 118if (!Asn1Tag.TryDecode(AttributeCertificateV1.Value.Span, out Asn1Tag validateTag, out _) || 127writer.WriteEncodedValue(AttributeCertificateV1.Value.Span); 143if (!Asn1Tag.TryDecode(AttributeCertificateV2.Value.Span, out Asn1Tag validateTag, out _) || 152writer.WriteEncodedValue(AttributeCertificateV2.Value.Span); 180ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 208ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\ContentInfoAsn.xml.cs (3)

37writer.WriteEncodedValue(Content.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 90ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncapsulatedContentInfoAsn.xml.cs (3)

40writer.WriteEncodedValue(Content.Value.Span); 61ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 95ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncryptedContentInfoAsn.xml.cs (3)

39writer.WriteOctetString(EncryptedContent.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 87ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncryptedDataAsn.xml.cs (1)

55ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\IssuerAndSerialNumberAsn.xml.cs (5)

28if (!Asn1Tag.TryDecode(Issuer.Span, out Asn1Tag validateTag, out _) || 37writer.WriteEncodedValue(Issuer.Span); 43writer.WriteInteger(SerialNumber.Span); 56ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 89ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\OtherCertificateFormat.xml.cs (3)

36writer.WriteEncodedValue(OtherCert.Span); 54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 87ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignedDataAsn.xml.cs (3)

63writer.WriteEncodedValue(Crls[i].Span); 94ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 128ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerIdentifierAsn.xml.cs (3)

69writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 83ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 111ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerInfoAsn.xml.cs (5)

40if (!Asn1Tag.TryDecode(SignedAttributes.Value.Span, out Asn1Tag validateTag, out _) || 49writer.WriteEncodedValue(SignedAttributes.Value.Span); 58writer.WriteOctetString(SignatureValue.Span); 84ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 118ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

31writer.WriteOctetString(PrivateKey.Span); 57ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 91ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

27writer.WriteOctetString(Iv.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

27writer.WriteBitString(SubjectPublicKey.Span, 0); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

65writer.WriteOctetString(ExtnValue.Span); 78ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 112ReadOnlySpan<byte> rebindSpan = rebind.Span;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Builder.cs (1)

362_sealedData.Span.CopyTo(destination);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12CertBag.cs (1)

104encodedCertificate.Span,

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Info.cs (3)

48return _decoded.VerifyMac(password, _authSafeContents.Span); 57int firstValueLength = PkcsHelpers.FirstBerValueLength(encodedBytes.Span); 110ValueAsnReader authSafeReader = new ValueAsnReader(authSafeBytes.Span, AsnEncodingRules.BER);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12SafeBag.cs (2)

48PkcsHelpers.EnsureSingleBerValue(encodedBagValue.Span); 81writer.WriteEncodedValueForCrypto(EncodedBagValue.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12SafeContents.cs (4)

186PkcsHelpers.EnsureSingleBerValue(secretValue.Span); 258encryptedData.EncryptedContentInfo.EncryptedContent.Value.Span, 341ValueAsnReader reader = new ValueAsnReader(serialized.Span, AsnEncodingRules.BER); 499writer.WriteEncodedValueForCrypto(_encrypted.Span);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs8PrivateKeyInfo.cs (6)

36PkcsHelpers.EnsureSingleBerValue(algorithmParameters.Value.Span); 74ValueAsnReader reader = new ValueAsnReader(source.Span, AsnEncodingRules.BER); 180source.Span, 188Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span)); 211source.Span, 219Debug.Assert(!ret.PrivateKeyBytes.Span.Overlaps(decryptedMemory.Span));

System\Security\Cryptography\Pkcs\Asn1\CadesIssuerSerial.xml.cs (3)

35writer.WriteInteger(SerialNumber.Span); 48ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 82ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\EnvelopedDataAsn.xml.cs (1)

71ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\EssCertId.xml.cs (3)

26writer.WriteOctetString(Hash.Span); 45ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 78ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\EssCertIdV2.xml.cs (3)

57writer.WriteOctetString(Hash.Span); 76ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 110ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\KeyAgreeRecipientIdentifierAsn.xml.cs (1)

83ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\KeyAgreeRecipientInfoAsn.xml.cs (3)

38writer.WriteOctetString(Ukm.Value.Span); 63ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 98ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\KeyTransRecipientInfoAsn.xml.cs (3)

31writer.WriteOctetString(EncryptedKey.Span); 44ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 77ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\MessageImprint.xml.cs (3)

27writer.WriteOctetString(HashedMessage.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\OriginatorIdentifierOrKeyAsn.xml.cs (3)

71writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 94ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 122ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\OriginatorInfoAsn.xml.cs (3)

49writer.WriteEncodedValue(RevocationInfoChoices[i].Span); 72ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 106ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\OriginatorPublicKeyAsn.xml.cs (3)

27writer.WriteBitString(PublicKey.Span, 0); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\OtherKeyAttributeAsn.xml.cs (3)

39writer.WriteEncodedValue(KeyAttr.Value.Span); 59ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 92ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\PkiStatusInfo.xml.cs (4)

33if (!Asn1Tag.TryDecode(StatusString.Value.Span, out Asn1Tag validateTag, out _) || 42writer.WriteEncodedValue(StatusString.Value.Span); 68ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 101ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\PolicyInformation.xml.cs (1)

60ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\PolicyQualifierInfo.xml.cs (3)

36writer.WriteEncodedValue(Qualifier.Span); 54ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 87ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\RecipientEncryptedKeyAsn.xml.cs (3)

27writer.WriteOctetString(EncryptedKey.Span); 40ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\RecipientIdentifierAsn.xml.cs (3)

69writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 83ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 111ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\RecipientInfoAsn.xml.cs (1)

83ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\RecipientKeyIdentifier.xml.cs (3)

27writer.WriteOctetString(SubjectKeyIdentifier.Span); 52ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 85ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\Rfc3161Accuracy.xml.cs (1)

57ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TimeStampReq.xml.cs (3)

66writer.WriteInteger(Nonce.Value.Span); 107ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 142ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TimeStampResp.xml.cs (3)

32writer.WriteEncodedValue(TimeStampToken.Value.Span); 52ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 85ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TstInfo.xml.cs (4)

62writer.WriteInteger(SerialNumber.Span); 86writer.WriteInteger(Nonce.Value.Span); 122ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet); 158ReadOnlySpan<byte> rebindSpan = rebind.Span;

System\Security\Cryptography\Pkcs\Asn1\SignedAttributesSet.xml.cs (1)

80ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\SigningCertificateAsn.xml.cs (1)

60ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

System\Security\Cryptography\Pkcs\Asn1\SigningCertificateV2Asn.xml.cs (1)

60ValueAsnReader reader = new ValueAsnReader(encoded.Span, ruleSet);

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

181ValueAsnReader reader = new(derSignature.Span, AsnEncodingRules.DER);

System\Security\Cryptography\Pkcs\CmsSignature.MLDsa.cs (1)

68signature.Span

System\Security\Cryptography\Pkcs\CmsSignature.RSA.cs (3)

86signature.Span, 201if (expectedParameters.SequenceEqual(signatureParameters.Value.Span)) 315signatureParameters.Value.Span,

System\Security\Cryptography\Pkcs\CmsSignature.SlhDsa.cs (1)

82signature.Span

System\Security\Cryptography\Pkcs\CmsSigner.cs (3)

299hasher.AppendData(data.Span); 315hasher.AppendData(data.Span); 414messageToSign.Span,

System\Security\Cryptography\Pkcs\Rfc3161TimestampRequest.cs (7)

87ValueAsnReader reader = new ValueAsnReader(source.Span, AsnEncodingRules.DER); 180signerInfo.GetSignatureMemory().Span, 267ReadOnlySpan<byte> nonceSpan = nonceMemory.Span; 356ValueAsnReader reader = new ValueAsnReader(encodedBytes.Span, RuleSet); 392if (!token.VerifyHash(GetMessageHash().Span, HashAlgorithmId.Value)) 428!requestNonce.Value.Span.SequenceEqual(responseNonce.Value.Span))

System\Security\Cryptography\Pkcs\Rfc3161TimestampToken.cs (9)

159signerInfo.GetSignatureMemory().Span, 167hash.SequenceEqual(TokenInfo.GetMessageHash().Span) && 297ValueAsnReader reader = new ValueAsnReader(encodedBytes.Span, AsnEncodingRules.BER); 319cms.Decode(encodedBytes.Span); 448return serialNumber == issuerSerial.SerialNumber.Span.ToBigEndianHex(); 470if (!requiredName.DirectoryName.Value.Span.SequenceEqual(issuerDirectoryName)) 475return serialNumber.SequenceEqual(issuerSerial.SerialNumber.Span); 490!thumbprint.SequenceEqual(certId.Value.Hash.Span)) 537if (!thumbprint.SequenceEqual(certId2.Value.Hash.Span))

System\Security\Cryptography\Pkcs\SignedCms.cs (5)

95coll.Add(X509CertificateLoader.LoadCertificate(choice.Certificate.Value.Span)); 352writer.WriteOctetString(content.Span); 424content.Span, 668if (cert.Certificate is not null && cert.Certificate.Value.Span.SequenceEqual(rawData)) 708if (cert.Certificate is not null && cert.Certificate.Value.Span.SequenceEqual(rawData))

System\Security\Cryptography\Pkcs\SignerInfo.cs (7)

499static (signature, contentToVerify) => signature.Span.SequenceEqual(contentToVerify)); 602hasher.AppendData(additionalContent.Value.Span); 605hasher.AppendData(content.Span); 786return verify(state, content.Span); 794additionalContent.Value.Span.CopyTo(rented); 795content.Span.CopyTo(rented.AsSpan(additionalContent.Value.Length)); 983ReadOnlySpan<byte> data = attributeValues[i].Span;

System\Security\Cryptography\Pkcs\SubjectIdentifier.cs (3)

56ReadOnlySpan<byte> issuerNameSpan = issuerAndSerialNumber.Value.Issuer.Span; 57ReadOnlySpan<byte> serial = issuerAndSerialNumber.Value.SerialNumber.Span; 89Value = subjectKeyIdentifier.Value.Span.ToBigEndianHex();

System\Runtime\InteropServices\JsonMarshal.cs (1)

27return element.GetRawValue().Span;

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

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

284ReadOnlySpan<char> jsonChars = json.Span; 608valueSequence.First.Span[0] == (byte)'"', 609$"Calculated sequence starts with {valueSequence.First.Span[0]}"); 723ReadOnlySpan<byte> utf8JsonSpan = utf8Json.Span; 763ReadOnlySpan<byte> utf8JsonSpan = utf8Json.Span;

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

81propertyName = JsonReaderHelper.GetUnescaped(propertyName.Span); 89ReadOnlySpan<byte> previousPropertyName = utf8Json.Span.Slice(range.Start, range.Length); 91if (previousPropertyName.SequenceEqual(propertyName.Span)) 93ThrowHelper.ThrowJsonException_DuplicatePropertyNotAllowed(propertyName.Span); 106ThrowHelper.ThrowJsonException_DuplicatePropertyNotAllowed(propertyName.Span); 149left.Length == right.Length && left.Span.SequenceEqual(right.Span); 156return Marvin.ComputeHash32(name.Span, Marvin.DefaultSeed);

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

141ReadOnlySpan<byte> documentSpan = _utf8Json.Span;

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

1233return _parent.GetRawValue(_idx, includeQuotes: false).Span; 1280return JsonHelpers.AreEqualJsonNumbers(element1.GetRawValue().Span, element2.GetRawValue().Span);

System\Text\Json\Nodes\JsonValueOfJsonPrimitive.cs (7)

53writer.WriteStringValue(_value.Span); 71value = (T)(object)JsonWriterHelper.WriteString(_value.Span, static serialized => JsonElement.Parse(serialized)); 77string? result = JsonReaderHelper.TranscodeHelper(_value.Span); 88success = JsonReaderHelper.TryGetValue(_value.Span, isEscaped: false, out DateTime result); 95success = JsonReaderHelper.TryGetValue(_value.Span, isEscaped: false, out DateTimeOffset result); 102success = JsonReaderHelper.TryGetValue(_value.Span, isEscaped: false, out Guid result); 109string? result = JsonReaderHelper.TranscodeHelper(_value.Span);

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

596ReadOnlySpan<byte> span = memory.Span; 652ReadOnlySpan<byte> span = memory.Span; 669result = JsonReaderHelper.UnescapeAndCompare(localSequence.First.Span, other);

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

26_buffer = jsonData.First.Span; 80_buffer = memory.Span; 328_buffer = memory.Span; 2211ValueSpan = commentSequence.First.Span;

System\Text\Json\Serialization\Converters\Collection\ReadOnlyMemoryConverter.cs (1)

49return OnWriteResume(writer, value.Span, options, ref state);

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

20writer.WriteBase64StringValue(value.Span);

System\Text\Json\Serialization\JsonSerializer.Read.Document.cs (5)

36ReadOnlySpan<byte> utf8Json = document.GetRootRawValue().Span; 65ReadOnlySpan<byte> utf8Json = document.GetRootRawValue().Span; 92ReadOnlySpan<byte> utf8Json = document.GetRootRawValue().Span; 115ReadOnlySpan<byte> utf8Json = document.GetRootRawValue().Span; 162ReadOnlySpan<byte> utf8Json = document.GetRootRawValue().Span;

System\Text\Json\Serialization\JsonSerializer.Read.Element.cs (5)

31ReadOnlySpan<byte> utf8Json = element.GetRawValue().Span; 59ReadOnlySpan<byte> utf8Json = element.GetRawValue().Span; 85ReadOnlySpan<byte> utf8Json = element.GetRawValue().Span; 103ReadOnlySpan<byte> utf8Json = element.GetRawValue().Span; 145ReadOnlySpan<byte> utf8Json = element.GetRawValue().Span;

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

442valueSequence.First.Span[0] == (byte)'"', 443$"Calculated sequence starts with {valueSequence.First.Span[0]}"); 457? reader.ValueSequence.First.Span[0]

System\Text\Json\Serialization\PipeReadBufferState.cs (2)

107if (_sequence.First.Span.StartsWith(JsonConstants.Utf8Bom)) 119ReadOnlySpan<byte> span = mem.Span;

System\Text\RegularExpressions\Regex.Replace.cs (1)

688ReadOnlySpan<char> segment = span[i].Span;

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

1671vsb.Append(chunk.Span); 1808vsb.Append(chunk.Span);

src\runtime\src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (2)

1671vsb.Append(chunk.Span); 1808vsb.Append(chunk.Span);