Span

Otlp\Model\OtlpHelpers.cs (1)

Otlp\Model\OtlpInstrument.cs (3)

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

Otlp\Storage\TelemetryRepository.cs (2)

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

RabbitMQFunctionalTests.cs (2)

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

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

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

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

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

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

96int index = IndexOfExtension(path.Span);

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

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

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\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

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

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

130DecodeInternal(segment.Span, handler);

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

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

130DecodeInternal(segment.Span, handler);

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

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

130DecodeInternal(segment.Span, handler);

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

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

130DecodeInternal(segment.Span, handler);

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

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

130DecodeInternal(segment.Span, handler);

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

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

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

130DecodeInternal(segment.Span, handler);

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

src\Servers\Kestrel\shared\test\CertificateAuthority.cs (4)

561writer.WriteEncodedValue(certId.Span); 605writer.WriteEncodedValue(nonceExtension.Span); 703if (!reqDn.Span.SequenceEqual(_dnHash)) 723ReadOnlySpan<byte> reqSerialSpan = reqSerial.Span;

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

96int index = IndexOfExtension(path.Span);

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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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

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

WebApiAgentTemplateExecutionTests.cs (1)

114var first = 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\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);

Routing\QueryParameterValueSupplier.cs (1)

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

Routing\SupplyParameterFromQueryValueProvider.cs (2)

78if (!query.Span.SequenceEqual(GetQueryString(_lastUri).Span))

Routing\UrlValueConstraint.cs (1)

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

src\Shared\QueryStringEnumerable.cs (4)

94ReadOnlySpan<char> source = chars.Span; 117_query = query.IsEmpty || query.Span[0] != '?' 137var delimiterIndex = _query.Span.IndexOf('&'); 150var 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)

137var startIndex = key.Value.Span.IndexOf('['); 140var endIndex = key.Value.Span[startIndex..].IndexOf(']') + startIndex; 158var nextOpenBracket = key.Value.Span[(endIndex + 1)..].IndexOf('['); 175if (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\Components\Shared\src\ArrayBuilderMemoryStream.cs (1)

72ArrayBuilder.Append(memory.Span);

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

79return lengthPrefixBuffer.First.Span;

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

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

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\Components\Shared\src\ArrayBuilderMemoryStream.cs (1)

72ArrayBuilder.Append(memory.Span);

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

930return 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')

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\Components\Endpoints\src\FormMapping\FormDataReader.cs (4)

137var startIndex = key.Value.Span.IndexOf('['); 140var endIndex = key.Value.Span[startIndex..].IndexOf(']') + startIndex; 158var nextOpenBracket = key.Value.Span[(endIndex + 1)..].IndexOf('['); 175if (CurrentPrefix.Span.Length == 0)

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

79CommonWrite(buffer.Span);

PasskeyHandler.cs (4)

327if (!credential.Id.AsSpan().SequenceEqual(attestedCredentialData.CredentialId.Span)) 575clientData = JsonSerializer.Deserialize(utf8Json.Span, IdentityJsonSerializerContext.Default.CollectedClientData) 591if (!CryptographicOperations.FixedTimeEquals(clientData.Challenge.AsSpan(), originalChallenge.Span)) 624if (!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;

Passkeys\CredentialHelpers.cs (8)

19args.Aaguid.Span.CopyTo(result.AsSpan(offset, AaguidLength)); 25args.CredentialId.Span.CopyTo(result.AsSpan(offset)); 28args.CredentialPublicKey.Span.CopyTo(result.AsSpan(offset)); 53args.RpIdHash.Span.CopyTo(result.AsSpan(offset, RpIdHashLength)); 64attestedCredentialData.Span.CopyTo(result.AsSpan(offset)); 70extensions.Span.CopyTo(result.AsSpan(offset)); 94writer.WriteEncodedValue(attestationStatement.Span); 99writer.WriteByteString(authenticatorData.Span);

Passkeys\JsonHelpers.cs (1)

17=> !bytes.HasValue ? "null" : $"\"{Base64Url.EncodeToString(bytes.Value.Span)}\"";

Passkeys\PasskeyHandlerAssertionTest.cs (5)

392var invalidSignature = (byte[])[.. signature.Span, 0xFF, 0xFF, 0xFF, 0xFF]; 791return (byte[])[.. authenticatorData.Span, 0xFF, 0xFF, 0xFF, 0xFF]; 1034DoesCredentialExistOnUser && user == User && CredentialId.Span.SequenceEqual(credentialId) 1077var dataToSign = (byte[])[.. authenticatorData.Span, .. clientDataHash.Span];

Passkeys\PasskeyHandlerAttestationTest.cs (2)

852return (byte[])[.. attestedCredentialData.Span, 0xFF, 0xFF, 0xFF, 0xFF]; 1016if (CredentialId.Span.SequenceEqual(credentialId))

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

EndToEndBenchmarks.cs (4)

92var value = source.Span; 124WriteInRandomChunks(Payload.Span, oc); 200if (!Payload.Span.SequenceEqual(body.FirstSpan)) 209if (!Payload.Span.SequenceEqual(new(oversized, 0, PayloadLength)))

RedisOutputCacheStore.cs (1)

280var tag = tags.Span[i];

OutputCacheEntryFormatterTests.cs (4)

169Assert.True(expected.Headers.Span.SequenceEqual(actual.Headers.Span), "Headers"); 179var result = xLinear.Span.SequenceEqual(yLinear.Span);

src\Shared\SegmentWriteStream.cs (1)

159Write(buffer.Span);

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\Shared\runtime\Http2\Hpack\HPackDecoder.cs (1)

130DecodeInternal(segment.Span, handler);

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

Core\OutputProducer.cs (1)

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

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

357index = memory.Span.IndexOfAny(ByteCR, ByteLF); 381if (memory.Span[index] == ByteCR) 399if (memory.Span[index] == ByteCR)

Internal\Http\HttpProtocol.cs (6)

1613return Output.WriteChunkAsync(data.Span, cancellationToken); 1616return Output.WriteDataToPipeAsync(data.Span, cancellationToken: cancellationToken); 1663return Output.FirstWriteChunkedAsync(StatusCode, ReasonPhrase, responseHeaders, _responseBodyMode, data.Span, cancellationToken); 1666return Output.FirstWriteAsync(StatusCode, ReasonPhrase, responseHeaders, _responseBodyMode, data.Span, cancellationToken); 1710return await Output.WriteChunkAsync(data.Span, cancellationToken); 1713return 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)

952RequestBodyPipe.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\Shared\CertificateGeneration\CertificateManager.cs (2)

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

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

130DecodeInternal(segment.Span, handler);

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

170DecodeInternal(segment.Span, handler);

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

src\Servers\Kestrel\shared\test\CertificateAuthority.cs (4)

561writer.WriteEncodedValue(certId.Span); 605writer.WriteEncodedValue(nonceExtension.Span); 703if (!reqDn.Span.SequenceEqual(_dnHash)) 723ReadOnlySpan<byte> reqSerialSpan = reqSerial.Span;

Buffers\PooledArrayBufferWriterTests.cs (2)

134Assert.Equal(42, writtenMemory.Span[0]); 135Assert.Equal(99, writtenMemory.Span[1]);

CertificateManagerTests.cs (7)

36Assert.True(authorityKeyIdentifier.KeyIdentifier?.Span.SequenceEqual(subjectKeyIdentifier.SubjectKeyIdentifierBytes.Span)); 60Assert.True(subjectKeyIdentifier.SubjectKeyIdentifierBytes.Span.SequenceEqual(testSubjectKeyId)); 85Assert.True(subjectKeyIdentifier.SubjectKeyIdentifierBytes.Span.SequenceEqual(testSubjectKeyId)); 111Assert.True(authorityKeyIdentifier.KeyIdentifier?.Span.SequenceEqual(testSubjectKeyId)); 131Assert.True(authorityKeyIdentifier.KeyIdentifier?.Span.SequenceEqual(subjectKeyIdentifier.SubjectKeyIdentifierBytes.Span));

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

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

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\Shared\QueryStringEnumerable.cs (4)

94ReadOnlySpan<char> source = chars.Span; 117_query = query.IsEmpty || query.Span[0] != '?' 137var delimiterIndex = _query.Span.IndexOf('&'); 150var equalIndex = segment.Span.IndexOf('=');

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

130DecodeInternal(segment.Span, handler);

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

170DecodeInternal(segment.Span, handler);

src\Shared\SegmentWriteStream.cs (1)

159Write(buffer.Span);

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

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

17var span = buffer.First.Span;

Protocol\HandshakeProtocol.cs (1)

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

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

17var span = buffer.First.Span;

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

72var source = _utf8Buffer.First.Span;

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

79return lengthPrefixBuffer.First.Span;

src\SignalR\common\Http.Connections\src\ServerSentEventsMessageFormatter.cs (1)

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

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

79return lengthPrefixBuffer.First.Span;

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

17var span = buffer.First.Span;

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

17var span = buffer.First.Span;

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

72var source = _utf8Buffer.First.Span;

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

79return lengthPrefixBuffer.First.Span;

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

17var span = buffer.First.Span;

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

72var source = _utf8Buffer.First.Span;

DummyHubProtocol.cs (1)

44output.Write(GetMessageBytes(message).Span);

HttpResponseStreamWriter.cs (3)

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

src\Shared\QueryStringEnumerable.cs (4)

94ReadOnlySpan<char> source = chars.Span; 117_query = query.IsEmpty || query.Span[0] != '?' 137var delimiterIndex = _query.Span.IndexOf('&'); 150var equalIndex = segment.Span.IndexOf('=');

CommandLine\CommandLineParser.cs (5)

86IsOptionName(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)

327hashCode = 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)

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

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

96int index = IndexOfExtension(path.Span);

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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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\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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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(); 1800var valueSpan = valueMemory.Span; 1954var valueSpan = value.Span; 2108if (part.Span.Equals(nullableSpan, StringComparison.OrdinalIgnoreCase))

Symbols\NamespaceOrTypeSymbol.cs (1)

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

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

899=> 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))

Symbols\MockNamedTypeSymbol.cs (2)

135where sym is NamedTypeSymbol namedType && sym.Name.AsSpan().SequenceEqual(name.Span) && namedType.Arity == arity 142where sym is NamedTypeSymbol && sym.Name.AsSpan().SequenceEqual(name.Span)

Symbols\MockNamespaceSymbol.cs (2)

57return _children.Where(ns => ns.Name.AsSpan().SequenceEqual(name.Span)).ToArray().AsImmutableOrNull(); 70where c is NamedTypeSymbol && c.Name.AsSpan().SequenceEqual(name.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\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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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

96int index = IndexOfExtension(path.Span);

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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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

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

Host\AssetProvider.cs (1)

302Contract.ThrowIfTrue(missingChecksumsMemory.Span.Contains(Checksum.Null));

SolutionAssetStorage.Scope.cs (1)

63foreach (var checksum in checksums.Span)

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

96int index = IndexOfExtension(path.Span);

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\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (1)

96int index = IndexOfExtension(path.Span);

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

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

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\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

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

src\Compilers\Core\Portable\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);

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

96int index = IndexOfExtension(path.Span);

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

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

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\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

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

Fakes\SimpleAssetSource.cs (1)

23foreach (var checksum in checksums.Span)

ReadOnlyDataFrameBuffer.cs (1)

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

ToolReduction\EmbeddingToolReductionStrategy.cs (2)

77private Func<ReadOnlyMemory<float>, ReadOnlyMemory<float>, float> _similarity = static (a, b) => TensorPrimitives.CosineSimilarity(a.Span, b.Span);

ChatCompletion\ChatResponseExtensions.cs (1)

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

Contents\DataContent.cs (1)

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

Contents\DataUriParser.cs (5)

29if (!dataUri.Span.StartsWith(Scheme.AsSpan(), StringComparison.OrdinalIgnoreCase)) 37int commaPos = dataUri.Span.IndexOf(','); 51if (metadata.Span.EndsWith(";base64".AsSpan(), StringComparison.OrdinalIgnoreCase)) 55if (!IsValidBase64Data(data.Span)) 62ReadOnlySpan<char> span = metadata.Span.Trim();

Functions\AIFunctionFactory.cs (1)

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

ResponseContinuationToken.cs (1)

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

Utilities\AIJsonUtilities.cs (1)

233Write(buffer.Span);

ChatCompletion\ChatMessageTests.cs (1)

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

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;

ToolReductionTests.cs (1)

OpenAIResponsesChatClient.cs (3)

217Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 427Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 1262Arguments = JsonSerializer.Deserialize(mtci.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!,

OpenAIResponsesContinuationToken.cs (1)

70Utf8JsonReader reader = new(data.Span);

OpenAIConversionTests.cs (4)

488}), JsonElement.Parse(tc.FunctionArguments.ToMemory().Span))); 544}), JsonElement.Parse(m3.FunctionArguments.ToMemory().Span))); 874var deserializedArgs = JsonSerializer.Deserialize<Dictionary<string, object?>>(toolCall.FunctionArguments.ToMemory().Span); 1070toolCallUpdate.FunctionArgumentsUpdate.ToMemory().Span);

OpenAIResponseClientTests.cs (2)

3700JsonObject rcoJsonObject = Assert.IsType<JsonObject>(JsonNode.Parse(rcoJsonBinaryData.ToMemory().Span)); 5524Utf8JsonReader reader = new(data.Span);

AIChatWebExecutionTests.cs (1)

193var first = options.Span[0];

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

98addresses.Add(new AddressResult(response.CreatedAt.AddSeconds(additional.Ttl), new IPAddress(additional.Data.Span))); 337target = 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))

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;

OrderProcessingWorker.cs (1)

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

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

96int index = IndexOfExtension(path.Span);

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

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

Services\AssetProviderTests.cs (1)

201if (checksums.Span.IndexOf(checksum) >= 0)

ServerSentEvents\SseFormatter.cs (1)

86data: userDataBufferWriter.WrittenMemory.Span,

src\Servers\Kestrel\test\FunctionalTests\Http2\HandshakeTests.cs (4)

73Assert.True(SslApplicationProtocol.Http2.Protocol.Span.SequenceEqual(tlsFeature.ApplicationProtocol.Span), 101Assert.True(SslApplicationProtocol.Http2.Protocol.Span.SequenceEqual(tlsFeature.ApplicationProtocol.Span),

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\Drawing\Imaging\Effects\EffectsTests.cs (16)

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)

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

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

138ReadOnlySpan<byte> buffer = _data.Span; 210return _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)

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

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

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

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

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

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

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

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

337hash.Append(buffer.Span);

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

1087WriteMultiSegment(source.Span);

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

115this.Write(source.Span);

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

397InnerStream.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\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;

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

88ReadOnlySpan<byte> s = _content.Span; 114_content.Span.Slice(_position).CopyTo(buffer); 120_content.Span.Slice(_position, buffer.Length).CopyTo(buffer); 161destination.Write(_content.Span.Slice(_position));

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\libraries\Common\src\System\IO\ReadOnlyMemoryStream.cs (4)

88ReadOnlySpan<byte> s = _content.Span; 114_content.Span.Slice(_position).CopyTo(buffer); 120_content.Span.Slice(_position, buffer.Length).CopyTo(buffer); 161destination.Write(_content.Span.Slice(_position));

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

130DecodeInternal(segment.Span, handler);

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

170DecodeInternal(segment.Span, handler);

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

1122Write(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)

1675current.Span.CopyTo(span); 1687current.Span.CopyTo(span);

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

1419WriteToBuffer(source.Span); 1426WriteToBuffer(source.Span.Slice(0, remaining)); 1437WriteToBuffer(source.Span); 1458WriteToBuffer(source.Span); 1505WriteToBuffer(source.Span); 1584_stream.Write(source.Span); 1874destination.Write(source.Span);

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

49stream.Write(buffer.Span);

System\Net\Base64Stream.cs (1)

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

System\Net\BufferBuilder.cs (1)

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

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

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

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)

76if (!CertificateThumbprints.Span.SequenceEqual(other.CertificateThumbprints.Span)) 104hash.AddBytes(CertificateThumbprints.Span); 110hash.AddBytes(protocol.Protocol.Span);

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

80CertificateThumbprints.Span.SequenceEqual(other.CertificateThumbprints.Span) && 88hash.AddBytes(CertificateThumbprints.Span); 901if (clientProto.SequenceEqual(protocolList[i].Protocol.Span))

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

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

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

49stream.Write(buffer.Span);

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

529_context.ComputeIntegrityCheck(bufferToWrap.Span, _writeBuffer); 530_writeBuffer.Write(bufferToWrap.Span); 535statusCode = _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)

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

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

1006if (NetEventSource.Log.IsEnabled()) NetEventSource.DumpBuffer(this, buffer.Span); 1062certificate.RawDataMemory.Span.SequenceEqual(_remoteCertificate.RawDataMemory.Span))

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

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

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

707if (protocol.SequenceEqual(SslApplicationProtocol.Http2.Protocol.Span)) 717protocol.SequenceEqual(SslApplicationProtocol.Http11.Protocol.Span))

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

83data: userDataBufferWriter.WrittenMemory.Span,

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

81Write(buffer.Span);

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

504int sendBytes = WriteFrameToSendBuffer(opcode, endOfMessage, disableCompression, payloadBuffer.Span); 600int sendBytes = WriteFrameToSendBuffer(opcode, endOfMessage, disableCompression, payloadBuffer.Span);

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

75buffer.Span.CopyTo(array);

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

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

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

1034int bytesWritten = WriteToBuffer(buffer.Span); 1086buffer = buffer.Slice(WriteToBuffer(buffer.Span)); 1101int bytesWritten = WriteToBuffer(buffer.Span); 1119buffer.Span.CopyTo(new Span<byte>(_buffer, _writePos, buffer.Length));

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

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

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

703Write(buffer.Span);

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

638buffer.Span.CopyTo(_buffer.AsSpan(_writePos)); 702source.Span.CopyTo(_buffer.AsSpan(_writePos)); 708source.Span.Slice(0, spaceLeft).CopyTo(_buffer.AsSpan(_writePos)); 732source.Span.CopyTo(_buffer.AsSpan(_writePos));

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

738buffer.Span.CopyTo(sharedBuffer);

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

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

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

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

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

314Write(chunk.Span); 670t.Item1.Write(t.Item2.Span); 756t.Item1.WriteLine(t.Item2.Span); 1091Write(buffer.Span); 1103WriteLine(buffer.Span);

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

739Write(buffer.Span);

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\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\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\MemoryMarshal.cs (1)

433yield return memory.Span[i];

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

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

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

573bytes: remainingOuterEncodedBytes.Span,

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

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

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

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

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

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

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

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

src\libraries\Common\src\System\Security\Cryptography\Asn1\CurveAsn.xml.cs (5)

27writer.WriteOctetString(A.Span); 28writer.WriteOctetString(B.Span); 32writer.WriteBitString(Seed.Value.Span, 0); 47AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 80ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

71if (!Asn1Tag.TryDecode(UniversalString.Value.Span, out Asn1Tag validateTag, out _) || 80writer.WriteEncodedValue(UniversalString.Value.Span); 117AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 145ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

42AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

75AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

29writer.WriteOctetString(PrivateKey.Span); 42writer.WriteBitString(PublicKey.Value.Span, 0); 58AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 92ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

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

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

88if (!Asn1Tag.TryDecode(X400Address.Value.Span, out Asn1Tag validateTag, out _) || 97writer.WriteEncodedValue(X400Address.Value.Span); 114writer.WriteEncodedValue(DirectoryName.Value.Span); 147writer.WriteOctetString(IPAddress.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 7)); 177AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 206ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

47writer.WriteOctetString(Seed.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 56writer.WriteOctetString(ExpandedKey.Value.Span); 79AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 107ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

26writer.WriteOctetString(Seed.Span); 27writer.WriteOctetString(ExpandedKey.Span); 40AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

47writer.WriteOctetString(Seed.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 56writer.WriteOctetString(ExpandedKey.Value.Span); 79AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 107ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

26writer.WriteOctetString(Seed.Span); 27writer.WriteOctetString(ExpandedKey.Span); 40AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

26writer.WriteOctetString(Salt.Span); 40AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

75AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

45writer.WriteOctetString(Specified.Value.Span); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

47writer.WriteOctetString(MacSalt.Span); 73AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 107ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

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

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

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

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

53if (!Asn1Tag.TryDecode(Certificate.Value.Span, out Asn1Tag validateTag, out _) || 62writer.WriteEncodedValue(Certificate.Value.Span); 78if (!Asn1Tag.TryDecode(ExtendedCertificate.Value.Span, out Asn1Tag validateTag, out _) || 87writer.WriteEncodedValue(ExtendedCertificate.Value.Span); 103if (!Asn1Tag.TryDecode(AttributeCertificateV1.Value.Span, out Asn1Tag validateTag, out _) || 112writer.WriteEncodedValue(AttributeCertificateV1.Value.Span); 128if (!Asn1Tag.TryDecode(AttributeCertificateV2.Value.Span, out Asn1Tag validateTag, out _) || 137writer.WriteEncodedValue(AttributeCertificateV2.Value.Span); 165AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 193ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

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

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

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

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); 56AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 89ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

54writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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); 84AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 118ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

141AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

src\libraries\Common\src\System\Security\Cryptography\Asn1\RSAPrivateKeyAsn.xml.cs (10)

34writer.WriteInteger(Modulus.Span); 35writer.WriteInteger(PublicExponent.Span); 36writer.WriteInteger(PrivateExponent.Span); 37writer.WriteInteger(Prime1.Span); 38writer.WriteInteger(Prime2.Span); 39writer.WriteInteger(Exponent1.Span); 40writer.WriteInteger(Exponent2.Span); 41writer.WriteInteger(Coefficient.Span); 54AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 87ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

26writer.WriteInteger(Modulus.Span); 27writer.WriteInteger(PublicExponent.Span); 40AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

34writer.WriteOctetString(Base.Span); 35writer.WriteInteger(Order.Span); 39writer.WriteInteger(Cofactor.Value.Span); 67AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 100ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

62writer.WriteOctetString(ExtnValue.Span); 75AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 109ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

682dsa = CompositeMLDsaImplementation.ImportCompositeMLDsaPublicKeyImpl(algorithm, key.Span); 875dsa = CompositeMLDsaImplementation.ImportCompositeMLDsaPrivateKeyImpl(algorithm, privateKeyContents.Span);

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

33xBytes.Span, 99yBytes.Span,

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

13if (memory.Length > 1 && memory.Span[0] == 0) 27memory.Span.CopyTo(destination); 33if (memory.Span[0] == 0) 35memory.Span.Slice(1).CopyTo(destination); 46memory.Span.CopyTo(destination.Slice(length - memory.Length));

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

43AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.DER); 74AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.DER); 115AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); 142AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER);

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

107AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); 127epki.EncryptedData.Span, 350AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); 369epki.EncryptedData.Span,

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

1389ReadOnlySpan<byte> publicKey = spki.SubjectPublicKey.Span; 1396return MLDsaImplementation.ImportPublicKey(algorithm, spki.SubjectPublicKey.Span); 2225dsa = MLDsaImplementation.ImportMLDsaPrivateSeed(algorithm, seed.Span); 2234dsa = MLDsaImplementation.ImportPrivateKey(algorithm, expandedKey.Span); 2246MLDsa key = MLDsaImplementation.ImportMLDsaPrivateSeed(algorithm, both.Seed.Span); 2254if (CryptographicOperations.FixedTimeEquals(buffer, both.ExpandedKey.Span))

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

1219kem = MLKemImplementation.ImportEncapsulationKeyImpl(algorithm, key.Span); 1737kem = MLKemImplementation.ImportPrivateSeedImpl(algorithm, seed.Span); 1746kem = MLKemImplementation.ImportDecapsulationKeyImpl(algorithm, expandedKey.Span); 1758MLKem key = MLKemImplementation.ImportPrivateSeedImpl(algorithm, both.Seed.Span); 1766if (CryptographicOperations.FixedTimeEquals(buffer, both.ExpandedKey.Span))

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

662rc2Parameters.Iv.Span.CopyTo(iv); 698ReadOnlySpan<byte> source = encryptionSchemeParameters.Value.Span; 839Pbkdf1(hasher, password, pbeParameters.Salt.Span, iterationCount, dk); 888ReadOnlySpan<byte> saltSpan = pbeParameters.Salt.Span;

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

362_sealedData.Span.CopyTo(destination);

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

104encodedCertificate.Span,

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

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

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

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

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

175PkcsHelpers.EnsureSingleBerValue(secretValue.Span); 247encryptedData.EncryptedContentInfo.EncryptedContent.Value.Span, 286AsnValueReader reader = new AsnValueReader(serialized.Span, AsnEncodingRules.BER); 438writer.WriteEncodedValueForCrypto(_encrypted.Span);

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

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

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

47AsnValueReader reader = new AsnValueReader(keyData.Span, AsnEncodingRules.DER);

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

311return selected.Span.TryCopyToDestination(destination, out bytesWritten); 355return data.Span.TryCopyToDestination(destination, out bytesWritten); 439spki.Span,

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

1238slhDsa = SlhDsaImplementation.ImportPublicKey(algorithm, key.Span); 1294ReadOnlySpan<byte> privateKey = key.Span; 1301ret = ImportSlhDsaPrivateKey(info, key.Span);

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

142AsnDecoder.ReadSequence(data.Span, AsnEncodingRules.BER, out _, out _, out int trimLength); 154ReadOnlySpan<byte> authSafeContents = authSafeMemory.Span; 279AsnValueReader outer = new AsnValueReader(contentData.Span, AsnEncodingRules.BER); 549encryptedContent.Span); 781return HasCapiValue(attr.AttrValues[0].Span, out isRsa);

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

711return LiteHashProvider.HmacStreamAsync(hashAlgorithm.Name, key.Span, source, destination, cancellationToken); 756return LiteHashProvider.HmacStreamAsync(hashAlgorithm.Name, key.Span, source, cancellationToken); 1006key.Span, 1012return CryptographicOperations.FixedTimeEquals(mac, hash.Span);

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

132ReadOnlySpan<byte> publicKeyBytes = key.PublicKey.Value.Span; 193ReadOnlySpan<byte> publicKeyBytes = key.Span; 243ReadOnlySpan<byte> algIdParameters = algId.Parameters.Value.Span; 317ReadOnlySpan<byte> primeValue = primeReader.ReadIntegerBytes().Span; 435ReadOnlySpan<byte> baseSpan = specifiedParameters.Base.Span;

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

164ReadOnlySpan<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)

17ReadOnlySpan<byte> span = memory.Span;

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\RSA.cs (2)

885ImportRSAPublicKey(pkcs1.Span, out _); 958ImportRSAPrivateKey(pkcs1.Span, out _);

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

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

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

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

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

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

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

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

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

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

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

29writer.WriteBitString(SignatureValue.Span, 0); 42AsnValueReader reader = new AsnValueReader(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); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 102ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

67AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

64if (!Asn1Tag.TryDecode(NameRelativeToCRLIssuer.Value.Span, out Asn1Tag validateTag, out _) || 73writer.WriteEncodedValue(NameRelativeToCRLIssuer.Value.Span); 92AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 121ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

69writer.WriteInteger(SerialNumber.Span); 73if (!Asn1Tag.TryDecode(Issuer.Span, out Asn1Tag validateTag, out _) || 82writer.WriteEncodedValue(Issuer.Span); 91if (!Asn1Tag.TryDecode(Subject.Span, out Asn1Tag validateTag, out _) || 100writer.WriteEncodedValue(Subject.Span); 110writer.WriteBitString(IssuerUniqueId.Value.Span, 0, new Asn1Tag(TagClass.ContextSpecific, 1)); 116writer.WriteBitString(SubjectUniqueId.Value.Span, 0, new Asn1Tag(TagClass.ContextSpecific, 2)); 146AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 182ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

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

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

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

203X500DistinguishedName subject = new X500DistinguishedName(requestInfo.Subject.Span); 234attr.AttrValues[0].Span, 249extAsn.ExtnValue.Span, 277new AsnEncodedData(attr.AttrType, val.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\OpenSslX509ChainProcessor.cs (3)

835return string.Concat(baseUri, resource.Span); 838return string.Concat(baseUri, "/", resource.Span); 1222AsnValueReader reader = new AsnValueReader(authorityInformationAccess.Span, AsnEncodingRules.DER);

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

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

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

501keyValue = new AsnEncodedData(spki.SubjectPublicKey.Span); 504ReadOnlyMemory<byte> algParameters => new AsnEncodedData(algParameters.Span),

System\Security\Cryptography\X509Certificates\X500NameEncoder.ManagedDecode.cs (1)

191HexConverter.EncodeToUtf16(state.Span, buff.Slice(1));

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

30ReadOnlySpan<byte> rawDataSpan = rawData.Span; 130AsnValueReader reader = new AsnValueReader(_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 (4)

1584X509Certificate2 ret = X509CertificateLoader.LoadCertificate(certData.Span); 1617return PemEncoding.WriteString(PemLabels.X509Certificate, RawDataMemory.Span); 1646return PemEncoding.TryWrite(PemLabels.X509Certificate, RawDataMemory.Span, destination, out charsWritten); 1860AsnValueReader reader = new AsnValueReader(rdn.RawData.Span, AsnEncodingRules.DER);

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

123if (OpenSslX509CertificateReader.TryReadX509Der(data.Span, out ICertificatePal? ret))

System\Security\Cryptography\X509Certificates\X509CertificateLoader.Unix.cs (9)

134AsnValueReader reader = new AsnValueReader(memory.Span, AsnEncodingRules.BER); 160AsnValueReader reader = new AsnValueReader(memory.Span, AsnEncodingRules.BER); 263key = CreateKey(privateKeyInfo.PrivateKeyAlgorithm.Algorithm, safeBag.BagValue.Span); 323Helpers.DecodeOctetStringAsMemory(attr.AttrValues[0]).Span); 377Pkcs12Key? key = CreateKey(cert.KeyAlgorithm, keyBag.BagValue.Span); 421if (curKeyId.Span.SequenceEqual(localKeyId)) 467if (!publicKeyInfo.SubjectPublicKey.Span.SequenceEqual(certEncodedKeyValue)) 489publicKeyInfo.Algorithm.Parameters.Value.Span.SequenceEqual(certKeyParameters); 501publicKeyInfo.Algorithm.Parameters.Value.Span.SequenceEqual(certKeyParameters);

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); 256hashCode.AddBytes(EncodedValue.Span);

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

306CoseHeaderValue value = CoseHeaderValue.FromEncodedValue(reader.ReadEncodedValue().Span); 462int 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)

1028CoseHelpers.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); 659CoseMessage.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.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\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\libraries\Common\src\System\Security\Cryptography\Asn1\AlgorithmIdentifierAsn.manual.cs (3)

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

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

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

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

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

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

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

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

71if (!Asn1Tag.TryDecode(UniversalString.Value.Span, out Asn1Tag validateTag, out _) || 80writer.WriteEncodedValue(UniversalString.Value.Span); 117AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 145ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

88if (!Asn1Tag.TryDecode(X400Address.Value.Span, out Asn1Tag validateTag, out _) || 97writer.WriteEncodedValue(X400Address.Value.Span); 114writer.WriteEncodedValue(DirectoryName.Value.Span); 147writer.WriteOctetString(IPAddress.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 7)); 177AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 206ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

108AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

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

26writer.WriteOctetString(Salt.Span); 40AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 73ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

75AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

45writer.WriteOctetString(Specified.Value.Span); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

47writer.WriteOctetString(MacSalt.Span); 73AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 107ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

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

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

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

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

53if (!Asn1Tag.TryDecode(Certificate.Value.Span, out Asn1Tag validateTag, out _) || 62writer.WriteEncodedValue(Certificate.Value.Span); 78if (!Asn1Tag.TryDecode(ExtendedCertificate.Value.Span, out Asn1Tag validateTag, out _) || 87writer.WriteEncodedValue(ExtendedCertificate.Value.Span); 103if (!Asn1Tag.TryDecode(AttributeCertificateV1.Value.Span, out Asn1Tag validateTag, out _) || 112writer.WriteEncodedValue(AttributeCertificateV1.Value.Span); 128if (!Asn1Tag.TryDecode(AttributeCertificateV2.Value.Span, out Asn1Tag validateTag, out _) || 137writer.WriteEncodedValue(AttributeCertificateV2.Value.Span); 165AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 193ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

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

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

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

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); 56AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 89ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

54writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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); 84AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 118ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

141AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

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

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

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

62writer.WriteOctetString(ExtnValue.Span); 75AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 109ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

43AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.DER); 74AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.DER); 115AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); 142AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER);

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

107AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); 127epki.EncryptedData.Span, 350AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); 369epki.EncryptedData.Span,

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

662rc2Parameters.Iv.Span.CopyTo(iv); 698ReadOnlySpan<byte> source = encryptionSchemeParameters.Value.Span; 839Pbkdf1(hasher, password, pbeParameters.Salt.Span, iterationCount, dk); 888ReadOnlySpan<byte> saltSpan = pbeParameters.Salt.Span;

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

362_sealedData.Span.CopyTo(destination);

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

104encodedCertificate.Span,

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

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

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

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

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

175PkcsHelpers.EnsureSingleBerValue(secretValue.Span); 247encryptedData.EncryptedContentInfo.EncryptedContent.Value.Span, 286AsnValueReader reader = new AsnValueReader(serialized.Span, AsnEncodingRules.BER); 438writer.WriteEncodedValueForCrypto(_encrypted.Span);

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

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

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

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

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

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

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

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

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

54writer.WriteOctetString(Hash.Span); 73AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 107ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

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

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

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

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

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

56writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 79AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 107ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

39writer.WriteEncodedValue(KeyAttr.Value.Span); 59AsnValueReader reader = new AsnValueReader(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); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 101ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

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

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

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

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

54writer.WriteOctetString(SubjectKeyIdentifier.Value.Span, new Asn1Tag(TagClass.ContextSpecific, 0)); 68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 96ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

68AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

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

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

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

63writer.WriteInteger(Nonce.Value.Span); 104AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 139ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

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

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

59writer.WriteInteger(SerialNumber.Span); 83writer.WriteInteger(Nonce.Value.Span); 119AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet); 155ReadOnlySpan<byte> rebindSpan = rebind.Span;

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

65AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);

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

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

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

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

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

194ReadOnlySpan<byte> val = sequence.ReadIntegerBytes().Span; 206val = sequence.ReadIntegerBytes().Span;

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

63signature.Span

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

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

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

77signature.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)

87AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.DER); 180signerInfo.GetSignatureMemory().Span, 267ReadOnlySpan<byte> nonceSpan = nonceMemory.Span; 356AsnValueReader reader = new AsnValueReader(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) && 297AsnValueReader reader = new AsnValueReader(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)); 364writer.WriteOctetString(content.Span); 436content.Span, 680if (cert.Certificate is not null && cert.Certificate.Value.Span.SequenceEqual(rawData)) 720if (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; 765ReadOnlySpan<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)

1232return _parent.GetRawValue(_idx, includeQuotes: false).Span; 1279return 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)

424valueSequence.First.Span[0] == (byte)'"', 425$"Calculated sequence starts with {valueSequence.First.Span[0]}"); 436? 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)

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

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

1633vsb.Append(chunk.Span); 1767vsb.Append(chunk.Span);

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

1633vsb.Append(chunk.Span); 1767vsb.Append(chunk.Span);

Infra\ScreenRecordService.cs (12)

166Write(fileStream, buffer, crc: null, firstEncoded.ihdr.Span); 175Write(fileStream, buffer, crc: null, idat.Span); 341Write(stream, buffer, crc: null, s_pngHeader.Span); 374WriteFdat(stream, buffer, crc, sequenceNumber++, idat.Span[8..^4]); 415if (!signature.Span.SequenceEqual(s_pngHeader.Span)) 425if (chunkType.Span.SequenceEqual(Ihdr)) 430else if (chunkType.Span.SequenceEqual(Srgb) 431|| chunkType.Span.SequenceEqual(Gama) 432|| chunkType.Span.SequenceEqual(Phys)) 437else if (chunkType.Span.SequenceEqual(Idat)) 441else if (chunkType.Span.SequenceEqual(Iend)) 463=> (int)BinaryPrimitives.ReadUInt32BigEndian(memory.Span);

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

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

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

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

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

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

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

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

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

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

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

96int index = IndexOfExtension(path.Span);

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

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

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\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

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

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

96int index = IndexOfExtension(path.Span);

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

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

MemoryAsserts.cs (10)

101 if (actualMemory.Span.IndexOf(expectedSubMemory.Span) < 0) 103 CollectionTracker<T>.FormatStart(expectedSubMemory.Span), 104 CollectionTracker<T>.FormatStart(actualMemory.Span) 177 var expectedSpan = expectedSubMemory.Span; 178 var actualSpan = actualMemory.Span; 240 if (!expectedMemory.Span.SequenceEqual(actualMemory.Span)) 241 Equal<object>(expectedMemory.Span.ToArray(), actualMemory.Span.ToArray());

StringAsserts.cs (10)

168 Contains(expectedSubstring.Span, actualString.Span, comparisonType); 415 DoesNotContain(expectedSubstring.Span, actualString.Span, comparisonType); 731 EndsWith(expectedEndString.Span, actualString.Span, comparisonType); 1092 expected.Span, 1093 actual.Span, 1524 StartsWith(expectedStartString.Span, actualString.Span, comparisonType);