SequenceEqual

247 references to SequenceEqual

Aspire.Dashboard (3)

Components\Controls\AspireMenuButton.razor.cs (1)

55if (Items != null && !_items.SequenceEqual(Items))

Components\Controls\Chart\ChartBase.cs (1)

95_renderedDimensionAttributes is null || !_renderedDimensionAttributes.SequenceEqual(dimensionAttributes) ||

Otlp\Model\MetricValues\DimensionScope.cs (1)

98explicitBounds = lastHistogramValue.ExplicitBounds.SequenceEqual(h.ExplicitBounds)

Aspire.Dashboard.Tests (1)

TelemetryRepositoryTests\MetricsTests.cs (1)

1247Assert.True(Enumerable.SequenceEqual(MemoryMarshal.ToEnumerable(key), scope.Attributes), "Key and attributes don't match.");

Aspire.Hosting (2)

Dcp\Model\Container.cs (2)

332&& (Entries ?? Enumerable.Empty<ContainerFileSystemEntry>()).SequenceEqual(other.Entries ?? Enumerable.Empty<ContainerFileSystemEntry>()); 423&& (Entries ?? Enumerable.Empty<ContainerFileSystemEntry>()).SequenceEqual(other.Entries ?? Enumerable.Empty<ContainerFileSystemEntry>());

Extensibility.MessageEncoder.IntegrationTests (1)

TextTests.4.1.0.cs (1)

117Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes");

GenerateDocumentationAndConfigFiles (6)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

IOperationGenerator (1)

IOperationClassWriter.cs (1)

406bool hasSkippedProperties = !GetAllProperties(type, includeSkipGenerationProperties: true).SequenceEqual(allProps);

Metrics (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Metrics.Legacy (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.AspNetCore.Components.Endpoints.Tests (1)

Binding\FormDataMapperTests.cs (1)

1281Assert.True(((IEnumerable<TElement>)expected).SequenceEqual((IEnumerable<TElement>)list));

Microsoft.AspNetCore.Rewrite.Tests (1)

ApacheModRewrite\FlagParserTest.cs (1)

81.SequenceEqual((dictionary ?? new Dictionary<TKey, TValue>())

Microsoft.AspNetCore.Routing.Tests (2)

Matching\MatcherAssert.cs (2)

19!expectedValues.OrderBy(kvp => kvp.Key).SequenceEqual(actualValues.OrderBy(kvp => kvp.Key))) 85!values.OrderBy(kvp => kvp.Key).SequenceEqual(actualValues.OrderBy(kvp => kvp.Key)))

Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (2)

InMemoryTransportBenchmark.cs (1)

77if (!Enumerable.SequenceEqual(expectedResponseLines, responseLines))

NamedPipesTransportBenchmark.cs (1)

79if (!Enumerable.SequenceEqual(expectedResponseLines, responseLines))

Microsoft.AspNetCore.SignalR.Common.Tests (1)

Internal\Protocol\CustomObject.cs (1)

42System.Linq.Enumerable.SequenceEqual(ByteArrProp, right.ByteArrProp);

Microsoft.AspNetCore.TestHost.Tests (2)

TestClientTests.cs (2)

628Assert.True(hello.SequenceEqual(buffer.Take(hello.Length))); 633Assert.True(world.SequenceEqual(buffer.Take(world.Length)));

Microsoft.Cci.Extensions (3)

Differs\Rules\TokenListDiffer.cs (1)

67return list1.SequenceEqual(list2);

HostEnvironment.cs (2)

355!assemblyIdentity.PublicKeyToken.SequenceEqual(this.CoreAssemblySymbolicIdentity.PublicKeyToken)) 365if (assemblyIdentity.PublicKeyToken == null || !assemblyIdentity.PublicKeyToken.SequenceEqual(s_ecmaKey))

Microsoft.CodeAnalysis (1)

Diagnostic\DiagnosticWithInfo.cs (1)

172this.AdditionalLocations.SequenceEqual(other.AdditionalLocations);

Microsoft.CodeAnalysis.Analyzers (6)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.AnalyzerUtilities (4)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\ThrownExceptionInfo.cs (1)

101InterproceduralCallStack.SequenceEqual(other.InterproceduralCallStack) &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.BannedApiAnalyzers (6)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.CodeStyle (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.CodeStyle.Fixes (5)

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

221constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes))

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

64if (constraints.SequenceEqual(typeParameter.ConstraintTypes))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.CSharp (4)

Binder\Binder_InterpolatedString.cs (1)

669Debug.Assert(appendCallsArray.Select(a => a.Length).SequenceEqual(partsArray.Select(a => a.Length)));

Compilation\SyntaxAndDeclarationManager.cs (1)

476var loadDirectivesHaveChanged = !oldTree.GetCompilationUnitRoot().GetLoadDirectives().SequenceEqual(newLoadDirectivesSyntax);

FlowAnalysis\FlowAnalysisPass.cs (1)

95Debug.Assert(getErrorsOnly(flowAnalysisDiagnostics.ToReadOnly()).SequenceEqual(getErrorsOnly(diagnostics.ToReadOnly().Diagnostics.Skip(initialDiagnosticCount))));

Symbols\NamespaceOrTypeSymbol.cs (1)

224Debug.Assert(memberT.MergedDeclaration.Declarations.SelectAsArray(decl => decl.NameLocation).SequenceEqual(memberT.Locations));

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (1)

135if (!finalList.SequenceEqual(initialList))

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (2)

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (2)

174.SequenceEqual(propertiesToAssign.Select(property => property.Type))) 360if (!orderedParameterTypes.SequenceEqual(orderedPropertyTypesToAssign))

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (2)

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (1)

714Assert.True(expectedSymbolKinds.SequenceEqual(result.PossibleSymbolKinds));

Completion\CompletionServiceTests.cs (1)

182Assert.True(performSort == completionList.ItemsList.SequenceEqual(completionListManuallySorted));

Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (2)

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (2)

168Assert.True(regex.GetGroupNumbers().OrderBy(v => v).SequenceEqual( 171Assert.True(regex.GetGroupNames().Where(v => !int.TryParse(v, out _)).OrderBy(v => v).SequenceEqual(

Microsoft.CodeAnalysis.CSharp.Features (5)

Organizing\Organizers\MemberDeclarationsOrganizer.cs (2)

32if (sortedGroups.SequenceEqual(members)) 118if (!finalList.SequenceEqual(initialList))

Organizing\Organizers\ModifiersOrganizer.cs (1)

26if (!initialList.SequenceEqual(finalList))

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (2)

174.SequenceEqual(propertiesToAssign.Select(property => property.Type))) 360if (!orderedParameterTypes.SequenceEqual(orderedPropertyTypesToAssign))

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (7)

DeclarationTests.cs (7)

129Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "C", "D" })); 160Assert.True(table.TypeNames.Distinct().OrderBy(s => s).SequenceEqual(new[] { "C", "D" })); 236Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B" })); 239Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B", "C", "D" })); 242Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B" })); 245Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B", "C", "D" })); 248Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "C", "D" }));

Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (11)

Parsing\ParsingErrorRecoveryTests.cs (7)

7399Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7418Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7451Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7476Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7501Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7527Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7551Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[]

Syntax\SyntaxNodeTests.cs (4)

1565Assert.True(related.SequenceEqual(related2)); 1569Assert.True(related.SequenceEqual(related3)); 2046Assert.True(expectedTokenKinds.SequenceEqual(actualTokens.Select(t => t.Kind()))); 2067Assert.True(expectedTokenKinds.SequenceEqual(actualTokens.Select(t => (SyntaxKind)t.RawKind)));

Microsoft.CodeAnalysis.CSharp.Workspaces (1)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (1)

135if (!finalList.SequenceEqual(initialList))

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (3)

Utilities\PatternMatcherTests.cs (3)

320Assert.True(match.Select(m => m.Kind).SequenceEqual(new[] { PatternMatchKind.StartOfWordSubstring, PatternMatchKind.StartOfWordSubstring })); 328Assert.True(match.Select(m => m.Kind).SequenceEqual(new[] { PatternMatchKind.StartOfWordSubstring, PatternMatchKind.StartOfWordSubstring })); 387Assert.True(match.Select(m => m.Kind).SequenceEqual(new[] { PatternMatchKind.StartOfWordSubstring, PatternMatchKind.StartOfWordSubstring }));

Microsoft.CodeAnalysis.Extensions.Package (3)

Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.Features (8)

AddImport\References\Reference.cs (1)

71SearchResult.NameParts.SequenceEqual(other.SearchResult.NameParts);

CodeFixes\RoslynAssemblyHelper.cs (1)

15=> source.GetType().GetTypeInfo().Assembly.GetName().GetPublicKey().SequenceEqual(

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.ProjectStates.cs (1)

49entry.AnalyzerReferences.SequenceEqual(project.AnalyzerReferences))

EditAndContinue\EditSession.cs (2)

1074oldProject.MetadataReferences.SequenceEqual(newProject.MetadataReferences) && 1075oldProject.ProjectReferences.SequenceEqual(newProject.ProjectReferences))

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (1)

120=> parameters.Select(p => p.Type).SequenceEqual(constructor.Parameters.Select(p => p.Type));

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

221constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes))

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

64if (constraints.SequenceEqual(typeParameter.ConstraintTypes))

Microsoft.CodeAnalysis.LanguageServer.Protocol (4)

Protocol\Converters\SumConverter.cs (2)

138.SequenceEqual(expressionLambdaMethodTypes)) 149.SequenceEqual(jsonSerializerDeserializeMethodTypes))

Protocol\Diagnostic.cs (1)

152: this.Tags.Equals(other.Tags) || this.Tags.SequenceEqual(other.Tags))

Protocol\SymbolInformation.cs (1)

120: (this.Tags.Equals(other.Tags) || this.Tags.SequenceEqual(other.Tags)))

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (6)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.PublicApiAnalyzers (4)

DeclarePublicApiAnalyzer.Impl.cs (1)

340overload.Parameters.Select(p => p.Type).SequenceEqual(method.Parameters.Select(p => p.Type)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.ResxSourceGenerator (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.Test.Utilities (5)

Assert\AssertEx.cs (1)

728=> expected.Where(c => !char.IsWhiteSpace(c)).SequenceEqual(actual.Where(c => !char.IsWhiteSpace(c)));

CompilationVerifier.cs (1)

687if (!expected.SequenceEqual(actual))

Diagnostics\DiagnosticDescription.cs (1)

332if (!args1.SequenceEqual(args2))

Diagnostics\DiagnosticsHelper.cs (1)

28Assert.True(expectedDiagnosticIds.SequenceEqual(actualDiagnosticIds),

Diagnostics\TrackingDiagnosticAnalyzer.cs (1)

166Assert.True(expected.SequenceEqual(actual),

Microsoft.CodeAnalysis.UnitTests (19)

Collections\Extensions\EnumerableExtensionsTests.cs (3)

105Assert.True(elements.SequenceEqual(result)); 112Assert.True(MakeEnumerable(1, 2, 3, 4).SequenceEqual(elements.Concat(4))); 139Assert.True(sequence.Flatten().SequenceEqual(MakeEnumerable("a", "b", "c", "d", "e", "f")));

Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (3)

284Assert.True(arr1.SequenceEqual(arr2)); 348Assert.False(noComparerSet.SequenceEqual(set)); 350Assert.False(comparerSet.SequenceEqual(set));

Collections\IdentifierCollectionTests.cs (4)

41Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), idcol.OrderBy(x => x))); 50Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), copy.OrderBy(x => x))); 58Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), idcol.OrderBy(x => x))); 67Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), copy.OrderBy(x => x)));

Collections\ImmutablesTestBase.nonnetstandard.cs (1)

60bool expectedResult = value != null && Enumerable.SequenceEqual(objectUnderTest, value);

Collections\List\ICollection.Generic.Tests.cs (2)

536Assert.True(Enumerable.SequenceEqual(collection, array)); 546Assert.True(Enumerable.SequenceEqual(collection, array.Take(count)));

InternalUtilities\ConcurrentLruCacheTests.cs (2)

62Assert.True(clc.TestingEnumerable.SequenceEqual(expected)); 75Assert.True(clc.TestingEnumerable.SequenceEqual(expected));

MetadataReferences\FusionAssemblyPortabilityPolicy.cs (1)

98Enumerable.SequenceEqual(_fileHash, other._fileHash);

Text\CompositeTextTests.cs (1)

39Assert.True(sourceLinesText.SequenceEqual(compositeLinesText));

Text\SourceTextStreamTests.cs (2)

55Assert.True(buffer.Take(baseText.Length).SequenceEqual(encoding.GetBytes(baseText))); 58Assert.True(buffer.Take(3).SequenceEqual(encoding.GetBytes(new[] { '\u2019' })));

Microsoft.CodeAnalysis.Workspaces (16)

Rename\Renamer.cs (1)

121if (newDocumentFolders != null && !newDocumentFolders.SequenceEqual(document.Folders))

Rename\Renamer.RenameDocumentActionSet.cs (1)

141return project.Documents.FirstOrDefault(d => d.Name == _documentName && d.Folders.SequenceEqual(_documentFolders))

Shared\Extensions\IMethodSymbolExtensions.cs (1)

68!method1.Parameters.Select(p => p.Name).SequenceEqual(method2.Parameters.Select(p => p.Name)))

Shared\Extensions\INamespaceSymbolExtensions.Comparer.cs (1)

16=> GetNameParts(x).SequenceEqual(GetNameParts(y));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Workspace\Solution\DocumentInfo.cs (1)

214newFolders.SequenceEqual(Folders) &&

Workspace\Solution\ProjectState.cs (1)

1040if (documentIds.SequenceEqual(DocumentStates.Ids))

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker.cs (1)

576if (!Enumerable.SequenceEqual(compilationWithoutGeneratedDocuments.ExternalReferences, newReferences))

Workspace\Solution\SolutionState.cs (1)

195var analyzerReferencesEqual = AnalyzerReferences.SequenceEqual(analyzerReferences);

Workspace\Solution\TextDocumentStates.cs (1)

276=> !States.Values.SequenceEqual(oldStates.States.Values);

Workspace\Workspace.cs (1)

1632if (!CurrentSolution.AnalyzerReferences.SequenceEqual(newSolution.AnalyzerReferences))

Microsoft.CodeAnalysis.Workspaces.UnitTests (6)

ObjectSerializationTests.cs (1)

268Assert.True(Enumerable.SequenceEqual(expected, (byte[])reader.ReadByteArray()));

SolutionTests\SourceGeneratorExecutionVersionMapTests.cs (3)

28Assert.True(map1.Map.SequenceEqual(map2.Map)); 60Assert.True(rehydrated1.Map.SequenceEqual(rehydrated2.Map)); 61Assert.True(rehydrated1.Map.SequenceEqual(map1.Map));

UtilityTest\IntervalTreeTests.cs (1)

440Assert.True(tree.SequenceEqual(allInts));

UtilityTest\NameGeneratorTests.cs (1)

107Assert.True(Enumerable.SequenceEqual(expectedResult, namesBuilder));

Microsoft.Data.Analysis.Tests (1)

DataFrameJoinExtensionsTests.cs (1)

151Assert.True(expected.SequenceEqual(intersection));

Microsoft.DotNet.Build.Tasks.Feed (5)

src\AzureStorageExtensions.cs (1)

70if (!remoteBuffer.SequenceEqual(localBuffer))

src\model\TargetChannelConfig.cs (1)

112if (!left.SequenceEqual(right))

src\model\TargetFeedConfig.cs (3)

103LatestLinkShortUrlPrefixes.SequenceEqual(other.LatestLinkShortUrlPrefixes) && 111(AkaMSCreateLinkPatterns.Select(p => p.ToString()).SequenceEqual(other.AkaMSCreateLinkPatterns.Select(p => p.ToString())))) && 113(AkaMSDoNotCreateLinkPatterns.Select(p => p.ToString()).SequenceEqual(other.AkaMSDoNotCreateLinkPatterns.Select(p => p.ToString()))));

Microsoft.DotNet.SignTool.Tests (1)

SignToolTests.cs (1)

363beforeSigningEngineFilesList.SequenceEqual(afterSigningEngineFilesList).Should().BeTrue();

Microsoft.Extensions.AI.Abstractions.Tests (1)

Embeddings\GeneratedEmbeddingsTests.cs (1)

84Assert.True(embeddings.SequenceEqual(generatedEmbeddings));

Microsoft.Extensions.AI.Evaluation.NLP (1)

Common\NGram.cs (1)

35=> Values.SequenceEqual(other.Values);

Microsoft.Extensions.AI.Evaluation.Reporting.Tests (15)

ResponseCacheTester.cs (14)

ScenarioRunResultTests.cs (1)

105Assert.True(entry.Tags!.SequenceEqual(deserialized.Tags!));

Microsoft.Extensions.Caching.Hybrid.Tests (8)

DistributedCacheTests.cs (4)

76Assert.True(expected.SequenceEqual(actual)); 84Assert.True(expected.SequenceEqual(actual)); 122Assert.True(expected.SequenceEqual(actual)); 130Assert.True(expected.SequenceEqual(actual));

PayloadTests.cs (4)

59Assert.True(payload.SequenceEqual(bytes)); 87Assert.True(payload.SequenceEqual(bytes)); 153Assert.True(payload.SequenceEqual(bytes)); 191Assert.True(payload.SequenceEqual(bytes));

Microsoft.Interop.ComInterfaceGenerator (2)

ComClassInfo.cs (1)

76&& ImplementedInterfacesNames.SequenceEqual(other.ImplementedInterfacesNames);

ComInterfaceGenerator.cs (1)

511if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))

Microsoft.Maui.Controls.Foldable (1)

DualScreenInfo.cs (1)

128 !Enumerable.SequenceEqual(_spanningBounds, value))

Microsoft.Maui.Controls.SourceGen (2)

CodeBehindGenerator.cs (1)

785 return x.ExternalReferences.OfType<PortableExecutableReference>().SequenceEqual(y.ExternalReferences.OfType<PortableExecutableReference>());

src\Controls\src\Xaml\XamlNode.cs (1)

69 TypeArguments != null && other.TypeArguments != null && TypeArguments.SequenceEqual(other.TypeArguments));

Microsoft.Maui.Controls.Xaml (1)

XamlNode.cs (1)

69 TypeArguments != null && other.TypeArguments != null && TypeArguments.SequenceEqual(other.TypeArguments));

Microsoft.Maui.Essentials (1)

Connectivity\Connectivity.shared.cs (1)

117 if (currentAccess != e.NetworkAccess || !currentProfiles.SequenceEqual(e.ConnectionProfiles))

Microsoft.ML.Core (1)

ComponentModel\ComponentCatalog.cs (1)

1124return assembly.GetName().GetPublicKey().SequenceEqual(

Microsoft.ML.Tests (3)

OnnxConversionTest.cs (1)

1145return Enumerable.SequenceEqual(MissingIndicator, other.MissingIndicator);

Scenarios\Api\TestApi.cs (2)

257Assert.True(retrievedFloatVBuffer.Items().SequenceEqual(valueFloatVBuffer.Items())); 261Assert.True(retrievedVBuffer.Items().SequenceEqual(valueVBuffer.Items()));

Microsoft.ML.Tokenizers (1)

Model\EnglishRobertaTokenizer.cs (1)

1219public bool Equals(HighestOccurrenceMapping other) => _idToIndex.SequenceEqual(other._idToIndex);

Microsoft.ML.TorchSharp (2)

NasBert\Modules\MultiHeadAttention.cs (2)

265Debug.Assert(attentionWeights.size().SequenceEqual(new[] { batchSize * _numHeads, tgtLen, srcLen })); 294Debug.Assert(attention.size().SequenceEqual(new[] { batchSize * _numHeads, tgtLen, _headDim }));

Microsoft.Net.Http.Headers.Tests (1)

StringWithQualityHeaderValueComparerTest.cs (1)

57Assert.True(expectedSortedValues.SequenceEqual(actualSorted));

Microsoft.VisualStudio.LanguageServices (5)

ChangeSignature\ChangeSignatureDialogViewModel.cs (2)

480!_parametersWithoutDefaultValues.OfType<ExistingParameterViewModel>().Select(p => p.ParameterSymbol).SequenceEqual(_originalParameterConfiguration.ParametersWithoutDefaultValues.Cast<ExistingParameter>().Select(p => p.Symbol)) || 481!_parametersWithDefaultValues.OfType<ExistingParameterViewModel>().Select(p => p.ParameterSymbol).SequenceEqual(_originalParameterConfiguration.RemainingEditableParameters.Cast<ExistingParameter>().Select(p => p.Symbol));

GenerateType\GenerateTypeDialogViewModel.cs (1)

359this.SelectedProject.Documents.Where(n => n.Name != null && n.Folders.Count > 0 && n.Name == this.FileName && this.Folders.SequenceEqual(n.Folders)).Any()) ||

ProjectSystem\Legacy\AbstractLegacyProject.cs (1)

359if (!Enumerable.SequenceEqual(folderNames, newFolderNames))

ProjectSystem\VisualStudioWorkspaceImpl.cs (1)

1336if (document.Folders != updatedInfo.Folders && !document.Folders.SequenceEqual(updatedInfo.Folders))

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (1)

DocumentOutline\DocumentOutlineTests.cs (1)

114Assert.True(expected.SequenceEqual(actual));

Roslyn.Diagnostics.Analyzers (6)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Roslyn.Diagnostics.CSharp.Analyzers (1)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (1)

135if (!finalList.SequenceEqual(initialList))

Roslyn.VisualStudio.Next.UnitTests (5)

Services\AssetProviderTests.cs (1)

183Assert.True(documents.Select(d => d.ContentChecksum).SequenceEqual(documentsReversed.Reverse().Select(d => d.ContentChecksum)));

UnifiedSettings\TestModel\EnumIntegerToString.cs (1)

27return Input.Equals(other.Input) && Map.SequenceEqual(other.Map);

UnifiedSettings\TestModel\UnifiedSettingBase.cs (1)

55return Messages.SequenceEqual(other.Messages);

UnifiedSettings\TestModel\UnifiedSettingsEnumOption.cs (2)

28return base.Equals(other) && @Enum.SequenceEqual(other.@Enum) && EnumItemLabels.SequenceEqual(other.EnumItemLabels);

System.ComponentModel.Annotations (1)

System\ComponentModel\DataAnnotations\UIHintAttribute.cs (1)

152return leftParams.OrderBy(p => p.Key).SequenceEqual(rightParams.OrderBy(p => p.Key));

System.Composition.Runtime (1)

System\Composition\Hosting\Core\CompositionContract.cs (1)

201if (secondEnumerable == null || !Enumerable.SequenceEqual(firstEnumerable.Cast<object>(), secondEnumerable.Cast<object>()))

System.Composition.TypedParts (1)

System\Composition\TypedParts\Discovery\DiscoveredPart.cs (1)

236if (_appliedArguments.Any(args => Enumerable.SequenceEqual(args, typeArguments)))

System.Text.Json.SourceGeneration (1)

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

45MessageArgs.SequenceEqual(other.MessageArgs) &&

Test.Utilities (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Text.Analyzers (6)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))