SequenceEqual

Backchannel\ExtensionBackchannel.cs (1)

182return GetCertificate().RawData.SequenceEqual(c.GetRawCertData());

Model\DebugSessionHelpers.cs (1)

33return cert.RawData.SequenceEqual(c.RawData);

Otlp\Storage\TelemetryRepository.cs (1)

1062if (traces[i].Key.Span.SequenceEqual(s))

ApplicationModel\ResourceNotificationService.cs (1)

758return publicKey is not null && microsoftOpenPublicKey.SequenceEqual(publicKey);

Dcp\DcpHost.cs (5)

296if (level.SequenceEqual("info"u8)) 300else if (level.SequenceEqual("error"u8)) 304else if (level.SequenceEqual("warning"u8)) 308else if (level.SequenceEqual("debug"u8)) 312else if (level.SequenceEqual("trace"u8))

CompilationDiff.cs (1)

159if (originalBytes.SequenceEqual(rebuildBytes))

RuntimeSource\SourceGenerators\ImmutableEquatableArray.cs (1)

28=> other != null && ((ReadOnlySpan<T>)_values).SequenceEqual(other._values);

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

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

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

InMemoryUserStore.cs (4)

41=> Task.FromResult(_users.Values.FirstOrDefault(u => u.Passkeys.Any(p => p.CredentialId.SequenceEqual(credentialId)))); 44=> Task.FromResult(ToUserPasskeyInfo(user.Passkeys.FirstOrDefault(p => p.CredentialId.SequenceEqual(credentialId)))); 75var passkeyEntity = user.Passkeys.FirstOrDefault(p => p.CredentialId.SequenceEqual(passkey.CredentialId)); 95var passkey = user.Passkeys.SingleOrDefault(p => p.CredentialId.SequenceEqual(credentialId));

InMemoryUserStore.cs (4)

41=> Task.FromResult(_users.Values.FirstOrDefault(u => u.Passkeys.Any(p => p.CredentialId.SequenceEqual(credentialId)))); 44=> Task.FromResult(ToUserPasskeyInfo(user.Passkeys.FirstOrDefault(p => p.CredentialId.SequenceEqual(credentialId)))); 75var passkeyEntity = user.Passkeys.FirstOrDefault(p => p.CredentialId.SequenceEqual(passkey.CredentialId)); 95var passkey = user.Passkeys.SingleOrDefault(p => p.CredentialId.SequenceEqual(credentialId));

Http2\Http2ConnectionTests.cs (19)

Http2\Http2StreamTests.cs (8)

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

134if (!certificate.IssuerName.RawData.SequenceEqual(_cert.SubjectName.RawData)) 205if (!subjectName.RawData.SequenceEqual(_cert.IssuerName.RawData)) 703if (!reqDn.Span.SequenceEqual(_dnHash)) 727if (reqSerialSpan.SequenceEqual(serial))

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

X509CertificateExtensions.cs (1)

23return subject.SequenceEqual(issuer);

Routing\SupplyParameterFromQueryValueProvider.cs (1)

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

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

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

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

391Assert.True(originalBytes.SequenceEqual(outBytes)); 416Assert.True(originalBytes.SequenceEqual(outBytes));

DefaultPasskeyHandler.cs (1)

239if (!credential.Id.AsSpan().SequenceEqual(attestedCredentialData.CredentialId.Span))

Passkeys\BufferSource.cs (1)

77return other is not null && _bytes.Span.SequenceEqual(other._bytes.Span);

UserOnlyStore.cs (2)

592userPasskey => userPasskey.UserId.Equals(userId) && userPasskey.CredentialId.SequenceEqual(credentialId), 604return UserPasskeys.SingleOrDefaultAsync(userPasskey => userPasskey.CredentialId.SequenceEqual(credentialId), cancellationToken);

UserStore.cs (2)

728userPasskey => userPasskey.UserId.Equals(userId) && userPasskey.CredentialId.SequenceEqual(credentialId), 740return UserPasskeys.SingleOrDefaultAsync(userPasskey => userPasskey.CredentialId.SequenceEqual(credentialId), cancellationToken);

Passkeys\DefaultPasskeyHandlerAssertionTest.cs (1)

1294DoesCredentialExistOnUser && user == User && CredentialId.Span.SequenceEqual(credentialId)

Passkeys\DefaultPasskeyHandlerAttestationTest.cs (1)

1289if (CredentialId.Span.SequenceEqual(credentialId))

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

391Assert.True(originalBytes.SequenceEqual(outBytes)); 416Assert.True(originalBytes.SequenceEqual(outBytes));

Cache\DistributedCacheTagHelperService.cs (1)

192if (serializedKeyBuffer.SequenceEqual(expectedKey))

EndToEndBenchmarks.cs (2)

200if (!Payload.Span.SequenceEqual(body.FirstSpan)) 209if (!Payload.Span.SequenceEqual(new(oversized, 0, PayloadLength)))

OutputCacheEntryFormatterTests.cs (2)

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

Internal\Http\Http1Connection.cs (1)

865if (currentRequestLine.SequenceEqual(clientPrefaceRequestLine))

Internal\Http2\Http2Connection.cs (11)

668if (!span.SequenceEqual(ClientPreface)) 1743_isMethodConnect = value.SequenceEqual(ConnectBytes); 1786else if (name.SequenceEqual(PathBytes)) 1790else if (name.SequenceEqual(MethodBytes)) 1794else if (name.SequenceEqual(SchemeBytes)) 1798else if (name.SequenceEqual(StatusBytes)) 1802else if (name.SequenceEqual(AuthorityBytes)) 1806else if (name.SequenceEqual(ProtocolBytes)) 1818return name.SequenceEqual(ConnectionBytes) || (name.SequenceEqual(TeBytes) && !value.SequenceEqual(TrailersBytes));

Internal\Http3\Http3Stream.cs (10)

457_isMethodConnect = value.SequenceEqual(ConnectBytes); 511else if (name.SequenceEqual(PathBytes)) 515else if (name.SequenceEqual(MethodBytes)) 519else if (name.SequenceEqual(SchemeBytes)) 523else if (name.SequenceEqual(StatusBytes)) 527else if (name.SequenceEqual(AuthorityBytes)) 531else if (name.SequenceEqual(ProtocolBytes)) 543return name.SequenceEqual(ConnectionBytes) || (name.SequenceEqual(TeBytes) && !value.SequenceEqual(TrailersBytes));

Internal\HttpConnection.cs (2)

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

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

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

HttpRequestHeadersTests.cs (2)

567Assert.False(nextSpan.SequenceEqual(Encoding.ASCII.GetBytes(headerValueUtf16Latin1CrossOver))); 612Assert.False(latinValueSpan.SequenceEqual(Encoding.ASCII.GetBytes(headerValueUtf16Latin1CrossOver)));

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

134if (!certificate.IssuerName.RawData.SequenceEqual(_cert.SubjectName.RawData)) 205if (!subjectName.RawData.SequenceEqual(_cert.IssuerName.RawData)) 703if (!reqDn.Span.SequenceEqual(_dnHash)) 727if (reqSerialSpan.SequenceEqual(serial))

src\Shared\test\Shared.Tests\runtime\Http2\DynamicTableTest.cs (4)

157Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Name)); 158Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Value)); 195Assert.True(headers[i].Name.AsSpan().SequenceEqual(dynamicTable[i].Name)); 196Assert.True(headers[i].Value.AsSpan().SequenceEqual(dynamicTable[i].Value));

src\Shared\test\Shared.Tests\runtime\Http2\HPackIntegerTest.cs (1)

21Assert.True(actualResult.Slice(0, bytesWritten).SequenceEqual(expectedResult));

runtime\Http2\DynamicTableTest.cs (4)

157Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Name)); 158Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Value)); 195Assert.True(headers[i].Name.AsSpan().SequenceEqual(dynamicTable[i].Name)); 196Assert.True(headers[i].Value.AsSpan().SequenceEqual(dynamicTable[i].Value));

runtime\Http2\HPackIntegerTest.cs (1)

21Assert.True(actualResult.Slice(0, bytesWritten).SequenceEqual(expectedResult));

SegmentWriteStreamTests.cs (2)

69Assert.True(expectedSegment.SequenceEqual(segment)); 102Assert.True(expectedSegment.SequenceEqual(segment));

UrlDecoderTests.cs (9)

Internal\Utf8HashLookup.cs (1)

64if (_slots[i].caseSensitiveHashCode == caseSensitiveHashCode && encodedValue.SequenceEqual(_slots[i].encodedValue.AsSpan()))

FallbackStaticFileTest.cs (1)

132Assert.True(responseContent.SequenceEqual(fileContents));

StaticFileMiddlewareTests.cs (1)

171Assert.True(responseContent.SequenceEqual(fileContents));

StaticFileMiddlewareTests.cs (5)

199Assert.True(responseContent.SequenceEqual(fileContents)); 238Assert.True(responseContent.SequenceEqual(fileContents)); 280Assert.True(responseContent.SequenceEqual(fileContents)); 330Assert.True(responseContent.SequenceEqual(fileContents)); 373Assert.True(responseContent.SequenceEqual(fileContents));

HandshakeHelpers.cs (2)

102if (value.SequenceEqual(WebSocketDeflateConstants.ClientNoContextTakeover)) 119else if (value.SequenceEqual(WebSocketDeflateConstants.ServerNoContextTakeover))

NativeMethods.cs (1)

1573return s.AsSpan().SequenceEqual(new ReadOnlySpan<char>(buffer, len));

Extensions\CSharp\CSharpCciExtensions.cs (1)

920return actual.SequenceEqual(other);

InternalUtilities\CharMemoryEqualityComparer.cs (1)

19public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => x.Span.SequenceEqual(y.Span);

InternalUtilities\ReadOnlyMemoryOfCharComparer.cs (2)

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

MetadataReader\MetadataHelpers.cs (1)

633return nameMemory.Span.SequenceEqual(SystemString.AsSpan()) ? splitSystemString : ImmutableArray.Create(convert(nameMemory));

SourceGeneration\GlobalAliases.cs (1)

90return this.AliasAndSymbolNames.AsSpan().SequenceEqual(aliases.AliasAndSymbolNames.AsSpan());

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

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

Utilities\ContentHashComparer.cs (1)

21return x.Span.SequenceEqual(y.Span);

Attributes\AttributeTests_Nullable.cs (1)

4219if (!expectedPreviously.SequenceEqual(expectedNow))

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)

DiagnosticTestUtilities.cs (1)

160Assert.True(experr.Parameters.SequenceEqual(acterr.Parameters), String.Format("Param: {0}!={1}", experr.Parameters.Count(), acterr.Parameters.Count()));

Protocol\Internal\Converters\ImageElementConverter.cs (1)

50if (!typePropertyValue.SequenceEqual(nameof(ImageElement).AsSpan()))

Protocol\Internal\Converters\ImageIdConverter.cs (1)

51if (!typePropertyValue.SequenceEqual(nameof(ImageId).AsSpan()))

Workspaces\LspWorkspaceManager.cs (1)

513return lspText.GetContentHash().AsSpan().SequenceEqual(documentText.GetContentHash().AsSpan());

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

19public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

XxHash128Tests.cs (1)

123Assert.True(destination.SequenceEqual(destination2));

DataFrameColumns\ArrowStringDataFrameColumn.cs (2)

615ret[i] = strBytes.SequenceEqual(bytes); 656ret[i] = !strBytes.SequenceEqual(bytes);

ArrayComparer.cs (6)

87Assert.True(expectedArray.NullBitmapBuffer.Span.SequenceEqual(actualArray.NullBitmapBuffer.Span)); 99Assert.True(expectedArray.Values.Slice(0, expectedArray.Length).SequenceEqual(actualArray.Values.Slice(0, actualArray.Length))); 111Assert.True(expectedArray.NullBitmapBuffer.Span.SequenceEqual(actualArray.NullBitmapBuffer.Span)); 113Assert.True(expectedArray.Values.Slice(0, booleanByteCount).SequenceEqual(actualArray.Values.Slice(0, booleanByteCount))); 125Assert.True(expectedArray.NullBitmapBuffer.Span.SequenceEqual(actualArray.NullBitmapBuffer.Span)); 126Assert.True(expectedArray.Values.Slice(0, expectedArray.Length).SequenceEqual(actualArray.Values.Slice(0, actualArray.Length)));

ChatCompletion\ChatMessageTests.cs (1)

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

Utilities\JsonOutputFixer.cs (1)

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

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

381if (fieldName.SequenceEqual("data"u8)) 423else if (fieldName.SequenceEqual("event"u8)) 428else if (fieldName.SequenceEqual("id"u8)) 437else if (fieldName.SequenceEqual("retry"u8))

Internal\HybridCachePayload.cs (1)

253if (!stringSpan.SequenceEqual(key.AsSpan()))

Internal\TagSet.cs (2)

181case string single when span.SequenceEqual(single.AsSpan()): 187if (span.SequenceEqual(test.AsSpan()))

DependencyContextJsonReader.cs (1)

93utf8Bom.SequenceEqual(rented.AsSpan(0, utf8Bom.Length)))

PollingWildCardChangeToken.cs (1)

142else if (!_previousHash.AsSpan().SequenceEqual(currentHash))

SystemdHelpers.cs (1)

58return comm.AsSpan().SequenceEqual("systemd\n"u8);

EquatableArray.cs (1)

37 return AsSpan().SequenceEqual(array.AsSpan());

Data\ReadOnlyMemoryUtils.cs (2)

31return memory.Span.SequenceEqual(s.AsSpan()); 263return x.Span.SequenceEqual(y.Span);

Utilities\NormStr.cs (2)

109if (strSpan.SequenceEqual(ns.Value.Span)) 132if (ns.Value.Span.SequenceEqual(span))

UnitTests\CoreBaseTestClass.cs (2)

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

Transforms\Hashing.cs (1)

1542public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y) => x.Span.SequenceEqual(y.Span);

ModelFiles.cs (1)

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

TensorflowTests.cs (16)

DataPipe\TestDataPipe.cs (1)

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

DataPipe\TestDataPipeBase.cs (2)

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

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

Scenarios\Api\TestApi.cs (1)

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

Transformers\CopyColumnEstimatorTests.cs (1)

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

Transformers\ValueMappingTests.cs (2)

123Assert.True(dValue.GetValues().SequenceEqual(new int[] { 2, 3, 1 })); 158Assert.True(dValue.GetValues().SequenceEqual(new uint[] { 2, 3, 1 }));

Normalizer\SentencePieceNormalizer.cs (1)

213if (startIndex + tokenLength <= endIndex && original.Slice(startIndex, tokenLength).SequenceEqual(token.AsSpan()))

Utils\ByteArrayComparer.cs (1)

16x.Span.SequenceEqual(y.Span);

Utils\StringSpanOrdinalKey.cs (1)

44Span.SequenceEqual(other.Span);

Expression\BuiltinFunctions.cs (1)

924return first.Span.SequenceEqual(second.Span);

Expression\LambdaBinder.cs (2)

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

GroupTransform.cs (1)

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

EditorConfigSettings\NamingStyle\ViewModel\ColumnViewModels\NamingStylesStyleViewModel.cs (1)

36if (value is not null && !_styleValues.SequenceEqual(value))

System\Windows\Media\PixelFormat.cs (1)

160if (pGuidPixelFormat.SequenceEqual(pGuidBuiltIn) && ((byte*)&guidPixelFormat)[15] <= (byte)PixelFormatEnum.Cmyk32)

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

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

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

ServerSentEvents\SseParser_1.cs (4)

381if (fieldName.SequenceEqual("data"u8)) 423else if (fieldName.SequenceEqual("event"u8)) 428else if (fieldName.SequenceEqual("id"u8)) 437else if (fieldName.SequenceEqual("retry"u8))

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

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

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

312public override bool Equals(string? x, string? y) => x.AsSpan(IsLeft ? Index : (x!.Length + Index), Count).SequenceEqual(y.AsSpan(IsLeft ? Index : (y!.Length + Index), Count));

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

28private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.SequenceEqual(y.AsSpan());

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

25private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.SequenceEqual(y.AsSpan());

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

26private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.SequenceEqual(y.AsSpan());

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

25private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.SequenceEqual(y.AsSpan());

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

26private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.SequenceEqual(y.AsSpan());

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

102(!x.IsEmpty || y is not null) && x.SequenceEqual(y.AsSpan());

System\Diagnostics\Metrics\StringSequence.cs (1)

91_values.AsSpan().SequenceEqual(other._values.AsSpan());

System\Drawing\FontConverterTests.cs (1)

111Assert.True(propNames.SequenceEqual(expectedPropNames));

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

361return EncodeAsSpan().SequenceEqual(other); 383return EncodeAsSpan().SequenceEqual(other.EncodeAsSpan());

System\Formats\Cbor\CborConformanceLevel.cs (1)

229return left.SequenceEqual(right);

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

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

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

441if (magic.SequenceEqual(GnuMagicBytes)) 446else if (magic.SequenceEqual(UstarMagicBytes)) 475if (!version.SequenceEqual(UstarVersionBytes)) 478if (!version.SequenceEqual(GnuVersionBytes)) 493if (!version.SequenceEqual(GnuVersionBytes)) 496if (!version.SequenceEqual(UstarVersionBytes))

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

117Debug.Assert(new Span<byte>(secret, SecretLengthBytes).SequenceEqual(DefaultSecret));

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

628|| !name.AsSpan().SequenceEqual(typeValue.AsSpan(index + 1)))

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

138return buffer.SequenceEqual("\r\n"u8);

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

86return addressBuffer1.SequenceEqual(addressBuffer2);

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

364if (fieldName.SequenceEqual("data"u8)) 405else if (fieldName.SequenceEqual("event"u8)) 410else if (fieldName.SequenceEqual("id"u8)) 419else if (fieldName.SequenceEqual("retry"u8))

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

321if (value.SequenceEqual(ClientWebSocketDeflateConstants.ClientNoContextTakeover)) 325else if (value.SequenceEqual(ClientWebSocketDeflateConstants.ServerNoContextTakeover))

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

1412if (tensor.Lengths.SequenceEqual(lengths)) 1485if (tensor.Lengths.SequenceEqual(lengths)) 1561if (tensor.Lengths.SequenceEqual(lengths)) 1777&& tensor.Lengths.SequenceEqual(other.Lengths) 1778&& MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor._shape.LinearLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other._shape.LinearLength)); 1789&& tensor.Lengths.SequenceEqual(other.Lengths) 1790&& MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor._shape.LinearLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other._shape.LinearLength)); 2096if (!tensors[0].Lengths.SequenceEqual(tensors[i].Lengths)) 2136if (!tensors[0].Lengths.SequenceEqual(tensors[i].Lengths))

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

699return lengths1.SequenceEqual(lengths2);

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

77_publicKeyToken.AsSpan().SequenceEqual(other._publicKeyToken);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\EqualityComparer.cs (1)

310return span.SequenceEqual(target);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\NonRandomizedStringEqualityComparer.cs (1)

102return span.SequenceEqual(target);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\RandomizedStringEqualityComparer.cs (1)

70return alternate.SequenceEqual(other);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

3340startEventMetadata.Name.AsSpan()[..^ActivityStartSuffix.Length].SequenceEqual(

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (1)

790Debug.Assert(ProviderMetadata.SequenceEqual(m_providerMetadata));

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

1097if (subvalue.SequenceEqual(enumNames[i]))

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

451if (calendarStringSpan.SequenceEqual(existingResult))

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

542return (!monthNames.AsSpan().SequenceEqual(genitiveMonthNames) || !abbrevMonthNames.AsSpan().SequenceEqual(genitiveAbbrevMonthNames))

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

4418if (((result.flags & ParseFlags.Rfc1123Pattern) != 0 && quotedSpan.SequenceEqual(GMTName)) || 4419((result.flags & ParseFlags.UtcSortPattern) != 0 && quotedSpan.SequenceEqual(ZuluName)))

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

90return result.SequenceEqual(strInput)

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

73return result.SequenceEqual(strInput)

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

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

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

63value is SortKey other && new ReadOnlySpan<byte>(_keyData).SequenceEqual(other._keyData);

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

41Path.GetFileName(srcNoDirectorySeparator).SequenceEqual(Path.GetFileName(destNoDirectorySeparator)))

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

432Path.GetFileName(srcNoDirectorySeparator).SequenceEqual(Path.GetFileName(destNoDirectorySeparator))) // same names.

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

2167SequenceEqual((ReadOnlySpan<T>)span, other);

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

76return span.SequenceEqual(value);

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

60if (EcmaKey.SequenceEqual(publicKeyBlob))

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

566return (uint)offset <= (uint)this.Length && this.AsSpan(offset).SequenceEqual(value);

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

2192if (currentSepLength == 1 || source.Slice(i, currentSepLength).SequenceEqual(separator))

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

400span.SequenceEqual(target); 464return span.SequenceEqual(target);

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

92if (invariantName.SequenceEqual(EncodingNames.AsSpan(EncodingNameIndices[left], EncodingNameIndices[left + 1] - EncodingNameIndices[left])))

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

964return currentRules.AsSpan().SequenceEqual(otherRules);

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

284if (!buffer.AsSpan(index, n).SequenceEqual(rawData.AsSpan(index, n)))

src\System\Reflection\Emit\SignatureHelper.cs (1)

847m_signature.AsSpan(0, m_currSig).SequenceEqual(other.m_signature.AsSpan(0, m_currSig));

System\Runtime\Serialization\DataContract.cs (1)

1662formatted.SequenceEqual(Globals.SerializationNamespace))

System\TypeExtensions.cs (2)

256return publicKey1.SequenceEqual(publicKey2); 276return publicKeyToken.SequenceEqual(name.GetPublicKeyToken());

System\Private\Windows\Ole\BinaryFormatUtilitiesTests.cs (1)

1123&& info1.PublicKeyOrToken.AsSpan().SequenceEqual(info2.PublicKeyOrToken.AsSpan()))

System\Xml\NameTable.cs (2)

103if (e.hashCode == hashCode && e.str.AsSpan().SequenceEqual(key.AsSpan(start, len))) 163if (e.hashCode == hashCode && e.str.AsSpan().SequenceEqual(key.AsSpan(start, len)))

System\Xml\Schema\DataTypeImplementation.cs (1)

876value1.AsSpan().SequenceEqual(value2) ? 0 : -1;

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

4469if (choiceName.SequenceEqual(element.Name)) 4471if ((element.Form == XmlSchemaForm.Unqualified && choiceNs.IsEmpty) || choiceNs.SequenceEqual(element.Namespace))

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

237if (!left._buffer.AsSpan(leftStart, minLength).SequenceEqual(right._buffer.AsSpan(rightStart, minLength)))

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

57return Length == other.Length && _buffer.AsSpan(_start, Length).SequenceEqual(other._buffer.AsSpan(other._start, other.Length));

System\Reflection\Metadata\Ecma335\BlobDictionary.cs (2)

31if (!exists || entry.Key.AsSpan().SequenceEqual(key)) 58Debug.Assert(immutableKey.AsSpan().SequenceEqual(key));

System\Reflection\PathAssemblyResolver.cs (1)

72if (pktFromName.SequenceEqual(pktFromAssembly))

System\Reflection\TypeLoading\General\Ecma\MetadataExtensions.cs (1)

88return utf8.SequenceEqual(actual);

System\Reflection\TypeLoading\General\RoAssemblyName.cs (1)

61if (!(((ReadOnlySpan<byte>)PublicKeyToken).SequenceEqual(other.PublicKeyToken)))

System\Reflection\TypeLoading\Types\RoExceptionType.cs (2)

25internal sealed override bool IsTypeNameEqual(ReadOnlySpan<byte> ns, ReadOnlySpan<byte> name) => name.SequenceEqual(_name) && ns.SequenceEqual(_ns);

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

117return pkt1.AsSpan().SequenceEqual(pkt2);

System\Numerics\BigInteger.cs (1)

1145return _sign == other._sign && _bits.AsSpan().SequenceEqual(other._bits);

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

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

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

45!parameters.Value.Span.SequenceEqual(s_rsaPkcsParameters))

Internal\Cryptography\PkcsHelpers.cs (2)

216ba1.AsSpan().SequenceEqual(ba2.AsSpan()); 375!oaepParameters.PSourceFunc.Parameters.Value.Span.SequenceEqual(pSpecifiedDefaultParameters))

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

32return Parameters!.Value.Span.SequenceEqual(other.Parameters!.Value.Span);

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

201if (expectedParameters.SequenceEqual(signatureParameters.Value.Span))

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

500cert.SubjectName.RawData.AsSpan().SequenceEqual(cert.IssuerName.RawData))

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

428!requestNonce.Value.Span.SequenceEqual(responseNonce.Value.Span))

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

167hash.SequenceEqual(TokenInfo.GetMessageHash().Span) && 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 (2)

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

499static (signature, contentToVerify) => signature.Span.SequenceEqual(contentToVerify)); 648if (!digest.SequenceEqual(digestAttr.MessageDigest)) 984if (data.SequenceEqual(asnEncodedData))

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

73DummySignerEncodedValue.AsSpan().SequenceEqual(issuerNameSpan))

System\Security\Cryptography\Xml\SignedXml.cs (1)

1068return m_signature.SignatureValue.AsSpan().SequenceEqual(hashValue.AsSpan(0, m_signature.SignatureValue.Length));

System\Security\Cryptography\Xml\SymmetricKeyWrap.cs (1)

240if (!rgbA.AsSpan().SequenceEqual(s_rgbAES_KW_IV.AsSpan()))

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

376return segment.SequenceEqual(otherUtf8Text);

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

838utf8Bom.SequenceEqual(rented.AsSpan(0, utf8Bom.Length))) 918JsonConstants.Utf8Bom.SequenceEqual(rented.AsSpan(0, utf8BomLength)))

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

91if (previousPropertyName.SequenceEqual(propertyName.Span)) 149left.Length == right.Length && left.Span.SequenceEqual(right.Span);

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

179currentPropertyName.Slice(0, idx).SequenceEqual(propertyName.Slice(0, idx))) 195if (utf8Unescaped.Slice(0, written).SequenceEqual(propertyName.Slice(idx))) 213else if (currentPropertyName.SequenceEqual(propertyName))

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

405return leftFirst.SequenceEqual(rightFirst) && 406leftMiddle.SequenceEqual(rightMiddle) && 407leftLast.SequenceEqual(rightLast);

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

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

110bool result = other.SequenceEqual(utf8Unescaped); 148bool result = other.SequenceEqual(utf8Unescaped); 189bool result = utf8Unescaped1.SequenceEqual(utf8Unescaped2);

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

501return otherUtf8Text.SequenceEqual(ValueSpan);

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

640if (Kind is EnumFieldNameKind.Default || input.SequenceEqual(JsonName.AsSpan())) 651if (matchingField.Kind is EnumFieldNameKind.Default || input.SequenceEqual(matchingField.JsonName.AsSpan()))

System\Text\Json\Serialization\Converters\Value\HalfConverter.cs (3)

203(!Half.IsNaN(result) || buffer.SequenceEqual(JsonConstants.NaNValue)) && 204(!Half.IsPositiveInfinity(result) || buffer.SequenceEqual(JsonConstants.PositiveInfinityValue)) && 205(!Half.IsNegativeInfinity(result) || buffer.SequenceEqual(JsonConstants.NegativeInfinityValue));

System\Text\Json\Serialization\JsonSerializer.Read.HandleMetadata.cs (6)

317(resolver?.CustomTypeDiscriminatorPropertyNameUtf8?.AsSpan().SequenceEqual(propertyName) == true); 326case 3 when propertyName.SequenceEqual("$id"u8): 329case 4 when propertyName.SequenceEqual("$ref"u8): 332case 5 when resolver?.CustomTypeDiscriminatorPropertyNameUtf8 is null && propertyName.SequenceEqual("$type"u8): 335case 7 when propertyName.SequenceEqual("$values"u8): 341propertyName.SequenceEqual(customTypeDiscriminator))

System\Text\Json\Serialization\Metadata\JsonTypeInfo.Cache.cs (1)

146(!Options.PropertyNameCaseInsensitive || propertyName.SequenceEqual(info.NameAsUtf8Bytes)))

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

45return key == Key && (propertyName.Length <= PropertyNameKeyLength || propertyName.SequenceEqual(Utf8PropertyName));

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

28=> other != null && ((ReadOnlySpan<T>)_values).SequenceEqual(other._values);

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

529Debug.Assert(inputString is null || inputSpan.SequenceEqual(inputString));

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

909return !set1.AsSpan(1).SequenceEqual(set2.AsSpan(1)); 1999bool equalsGroup = group.SequenceEqual(kvp.Value.AsSpan()); 2000if (equalsGroup || invertedGroup.SequenceEqual(kvp.Value.AsSpan()))

System\Text\RegularExpressions\Symbolic\BitVector.cs (1)

191MemoryExtensions.SequenceEqual(new ReadOnlySpan<ulong>(_blocks), new ReadOnlySpan<ulong>(other._blocks));

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

909return !set1.AsSpan(1).SequenceEqual(set2.AsSpan(1)); 1999bool equalsGroup = group.SequenceEqual(kvp.Value.AsSpan());

Interop\Richedit\CHARFORMAT2WTests.cs (1)

33Assert.True(charFormat.FaceName.SequenceEqual(bigString.AsSpan()[1..]));

Interop\User32\LOGFONTWTests.cs (1)

30Assert.True(logFont.FaceName.SequenceEqual(bigString.AsSpan()[1..]));

Extensions\AssertExtensions.cs (2)

400if (!expected.AsSpan().SequenceEqual(actual.AsSpan())) 479if (!expected.SequenceEqual(actual))

SpanHelpersTests.cs (3)

24Assert.True(destination.SequenceEqual(expected)); 39Assert.True(source.AsSpan().SliceAtFirstNull().SequenceEqual(expected)); 42Assert.True(copy.SliceAtFirstNull().SequenceEqual(expected));

System\Windows\Forms\FileDialogTests.cs (2)

659Assert.True(filter.SequenceEqual(" \0*.*")); 755Assert.True(filter.SequenceEqual(" \0*.*"));

Infra\ScreenRecordService.cs (7)

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

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

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

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

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

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

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

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

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

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

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

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

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

23=> x.SequenceEqual(y.Span); 26=> x.Span.SequenceEqual(y.Span);

MemoryAsserts.cs (1)

240 if (!expectedMemory.Span.SequenceEqual(actualMemory.Span))

SpanAsserts.cs (1)

249 if (!expectedSpan.SequenceEqual(actualSpan))