OrderBy

833 references to OrderBy

AnalyzerRunner (2)

DiagnosticAnalyzerRunner.cs (2)

134var slowestFiles = documentPerformance.OrderBy(pair => pair.Value.EditsPerSecond).GroupBy(pair => pair.Key.ProjectId); 204.OrderBy(tuple => tuple.Item2.Id)

Aspire.Dashboard (6)

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

168foreach (var trace in traces.OrderBy(kvp => kvp.Key))

Otlp\Storage\TelemetryRepository.cs (4)

100var applications = results.OrderBy(a => a.ApplicationKey).ToList(); 448return keys.OrderBy(k => k).ToList(); 475return keys.OrderBy(k => k).ToList(); 1017foreach (var e in span.Events.OrderBy(e => e.TimeUnixNano))

ResourceService\Partials.cs (1)

51HealthReports = HealthReports.Select(ToHealthReportViewModel).OrderBy(vm => vm.Name).ToImmutableArray(),

Aspire.Dashboard.Tests (5)

Model\ResourceViewModelTests.cs (1)

102viewModel.Properties.OrderBy(p => p.Key),

TelemetryRepositoryTests\MetricsTests.cs (2)

372Assert.Collection(instrumentData.KnownAttributeValues.OrderBy(kvp => kvp.Key), 594Assert.Collection(instrument.Dimensions.OrderBy(d => d.Name),

TelemetryRepositoryTests\TraceTests.cs (2)

952var expectedOrder = traces.PagedResult.Items.OrderBy(t => t.FirstSpan.StartTime).Select(t => t.TraceId).ToList(); 1482var views = application.GetViews().OrderBy(v => v.Properties.Length).ToList();

Aspire.Hosting.Azure.AppContainers (1)

AzureContainerAppsInfrastructure.cs (1)

383var httpOnlyEndpoints = endpointsByTargetPort.Where(g => g.IsHttpOnly).OrderBy(g => g.Index).ToArray();

Aspire.Hosting.PostgreSQL.Tests (1)

AddPostgresTests.cs (1)

518var bookMarkFiles = Directory.GetFiles(volume.Source!).OrderBy(f => f).ToArray();

Aspire.Hosting.Tests (1)

ResourceLoggerServiceTests.cs (1)

240var sortedLogs = allLogs.OrderBy(l => l.LineNumber).ToList();

BuildActionTelemetryTable (1)

Program.cs (1)

499.OrderBy(info => info.TypeName)

BuildBoss (3)

CompilerNuGetCheckerUtil.cs (1)

285foreach (var packageFolder in packageInputs.Select(x => x.PackageFolderRelativePath).Distinct().OrderBy(x => x))

SolutionCheckerUtil.cs (2)

62foreach (var data in map.Values.OrderBy(x => x.ProjectEntry.Name)) 149foreach (var projectKey in map.Keys.OrderBy(x => x.FileName))

ClientSample (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

CodeGenerator (19)

src\Servers\Kestrel\shared\KnownHeaders.cs (19)

ConfigurationSchemaGenerator (1)

RuntimeSource\Configuration.Binder\ConfigurationBindingGenerator.Parser.cs (1)

57ConfigTypes = _createdTypeSpecs.Values.OrderBy(s => s.TypeRef.FullyQualifiedName).ToImmutableEquatableArray(),

dotnet-dev-certs (2)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

dotnet-getdocument (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

dotnet-openapi (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

dotnet-sql-cache (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

dotnet-svcutil-lib (5)

Metadata\MetadataDocumentLoader.cs (1)

723var orderedFileNames = this.metadataSourceFiles.Select(u => u.ToString().ToUpperInvariant()).OrderBy(u => u);

Metadata\MetadataDocumentSaver.cs (1)

63DocumentSaveErrors = metadataDocumentSaver.UnresolvedReferences.Distinct().OrderBy(ur => ur.Uri).Select(ur => string.Format(CultureInfo.CurrentCulture, MetadataResources.ErrUnableToResolveSchemaReferenceFormat, ur.Uri))

Shared\Options\OptionsSerializer.cs (2)

170o.Name != ApplicationOptions.VersionKey).OrderBy(o => o.SerializationName); 216o.Name != ApplicationOptions.VersionKey).OrderBy(o => o.SerializationName);

Shared\ProjectPropertyResolver.cs (1)

208var depsFileInfo = depsFiles.OrderBy(f => f.CreationTimeUtc).LastOrDefault();

dotnet-user-jwts (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

dotnet-user-secrets (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

GetDocument.Insider (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

illink (1)

Linker.Steps\OutputStep.cs (1)

150 var values = Context.PInvokes.Distinct ().OrderBy (l => l);

installer.tasks (4)

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (4)

109foreach (var r in results.Where(r => r.Content != null).OrderBy(r => r.Repo)) 135foreach (var s in existingTpn.Sections.OrderBy(s => s.Header.SingleLineName)) 150.OrderBy(s => s.Header.Name) 156.OrderBy(s => s.Header.Name))

Microsoft.AspNetCore.Analyzer.Testing (2)

DiagnosticAnalyzerRunner.cs (1)

113return diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();

DiagnosticVerifier.cs (1)

131return diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();

Microsoft.AspNetCore.Analyzers.Test (3)

ConfigureMethodVisitorTest.cs (1)

87.OrderBy(s => s)

StartupAnalyzerTest.cs (2)

111ConfigureServicesMethods.OrderBy(m => m.Name), 115ConfigureMethods.OrderBy(m => m.Name),

Microsoft.AspNetCore.App.Analyzers.Test (1)

RouteEmbeddedLanguage\RoutePatternClassifierTests.cs (1)

32var actualOrdered = actual.OrderBy(t1 => t1.TextSpan.Start).ToList();

Microsoft.AspNetCore.App.UnitTests (15)

SharedFxTests.cs (8)

TargetingPackTests.cs (7)

44_output.WriteLine(string.Join('\n', actualAssemblies.OrderBy(i => i))); 46_output.WriteLine(string.Join('\n', listedTargetingPackAssemblies.OrderBy(i => i))); 241_output.WriteLine(string.Join('\n', expectedAssemblies.OrderBy(i => i))); 318_output.WriteLine(string.Join('\n', actualElements.Select(i => i.Attribute("AssemblyName").Value).OrderBy(i => i))); 320_output.WriteLine(string.Join('\n', expectedAssemblyNames.OrderBy(i => i))); 381_output.WriteLine(string.Join('\n', actualPaths.OrderBy(i => i))); 383_output.WriteLine(string.Join('\n', expectedPaths.OrderBy(i => i)));

Microsoft.AspNetCore.Components (1)

src\Http\Routing\src\Tree\TreeRouteBuilder.cs (1)

292trees.Values.OrderBy(tree => tree.Order).ToArray(),

Microsoft.AspNetCore.Components.Analyzers (1)

ComponentParameterAnalyzer.cs (1)

133captureUnmatchedValuesParameters.Select(p => p.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)).OrderBy(n => n))));

Microsoft.AspNetCore.Components.Analyzers.Tests (3)

Helpers\CodeFixVerifier.Helper.cs (2)

43var oldArray = diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray(); 44var newArray = newDiagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();

Helpers\DiagnosticVerifier.Helper.cs (1)

97return diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();

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

Binding\FormDataMapperTests.cs (8)

953Assert.Equal(expected.OrderBy(o => o.Key).ToArray(), dictionary.OrderBy(o => o.Key).ToArray()); 1007Assert.Equal(expected.OrderBy(o => o.Key).ToArray(), dictionary.OrderBy(o => o.Key).ToArray()); 1037Assert.Equal(expected.OrderBy(o => o.Key).ToArray(), dictionary.OrderBy(o => o.Key).ToArray()); 1248Assert.Equal(expected.OrderBy(o => o.Key).ToArray(), dictionary.OrderBy(o => o.Key).ToArray());

Microsoft.AspNetCore.Components.Forms.Tests (2)

EditContextTest.cs (2)

145}, editContext.GetValidationMessages(field).OrderBy(x => x)); // Sort because the order isn't defined 176}, editContext.GetValidationMessages().OrderBy(x => x)); // Sort because the order isn't defined

Microsoft.AspNetCore.Components.SdkAnalyzers (1)

ComponentParameterAnalyzer.cs (1)

120captureUnmatchedValuesParameters.Select(p => p.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)).OrderBy(n => n))));

Microsoft.AspNetCore.Components.SdkAnalyzers.Tests (3)

Helpers\CodeFixVerifier.Helper.cs (2)

43var oldArray = diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray(); 44var newArray = newDiagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();

Helpers\DiagnosticVerifier.Helper.cs (1)

97return diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();

Microsoft.AspNetCore.Components.Server (2)

Circuits\CircuitFactory.cs (1)

94.OrderBy(h => h.Order)

Circuits\CircuitHost.cs (1)

766_circuitHandlers = [.. _scope.ServiceProvider.GetServices<CircuitHandler>().OrderBy(h => h.Order)];

Microsoft.AspNetCore.Components.Tests (1)

ParameterViewTest.Assignment.cs (1)

355target.CaptureUnmatchedValues.OrderBy(kvp => kvp.Key),

Microsoft.AspNetCore.Cors.Test (6)

CorsMiddlewareTests.cs (6)

201response.Headers.OrderBy(h => h.Key), 267response.Headers.OrderBy(h => h.Key), 488response.Headers.OrderBy(h => h.Key), 545response.Headers.OrderBy(o => o.Key), 623response.Headers.OrderBy(o => o.Key), 668response.Headers.OrderBy(o => o.Key),

Microsoft.AspNetCore.DataProtection (3)

Repositories\EphemeralXmlRepository.cs (1)

78.OrderBy(e => e.DeletionOrder.GetValueOrDefault());

Repositories\FileSystemXmlRepository.cs (1)

197.OrderBy(e => e.DeletionOrder.GetValueOrDefault());

Repositories\RegistryXmlRepository.cs (1)

179.OrderBy(e => e.DeletionOrder.GetValueOrDefault());

Microsoft.AspNetCore.DataProtection.Tests (4)

Repositories\FileSystemXmlRepositoryTests.cs (1)

136var orderedNames = allElements.Select(el => el.Name.LocalName).OrderBy(name => name);

Repositories\RegistryXmlRepositoryTests.cs (1)

123var orderedNames = allElements.Select(el => el.Name.LocalName).OrderBy(name => name);

XmlAssert.cs (2)

87.OrderBy(attr => attr.Name.ToString()) 92.OrderBy(attr => attr.Name.ToString())

Microsoft.AspNetCore.DeveloperCertificates.XPlat (1)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

Microsoft.AspNetCore.Diagnostics (4)

DeveloperExceptionPage\Views\ErrorPage.Designer.cs (4)

897foreach (var kv in Model.Query.OrderBy(kv => kv.Key)) 984foreach (var kv in Model.Cookies.OrderBy(kv => kv.Key)) 1068foreach (var kv in Model.Headers.OrderBy(kv => kv.Key)) 1421foreach (var kv in Model.RouteValues.OrderBy(kv => kv.Key))

Microsoft.AspNetCore.Grpc.Swagger.Tests (3)

Binding\ResponseBodyTests.cs (1)

67var enumValues = enumSchema.Enum.Select(e => ((OpenApiString)e).Value).OrderBy(s => s).ToList();

SchemaGeneratorIntegrationTests.cs (2)

47var enumValues = enumSchema.Enum.Select(e => ((OpenApiString)e).Value).OrderBy(s => s).ToList(); 67var enumValues = schema.Enum.Select(e => ((OpenApiString)e).Value).OrderBy(s => s).ToList();

Microsoft.AspNetCore.Hosting.Tests (4)

StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (4)

439Assert.Equal(new[] { (true, "_content") }, contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray()); 472contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray()); 490contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray()); 606contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray());

Microsoft.AspNetCore.Http.Abstractions.Tests (19)

HttpValidationProblemDetailsJsonConverterTest.cs (3)

79problemDetails.Errors.OrderBy(kvp => kvp.Key), 120problemDetails.Errors.OrderBy(kvp => kvp.Key), 159problemDetails.Errors.OrderBy(kvp => kvp.Key),

RouteValueDictionaryTests.cs (16)

Microsoft.AspNetCore.HttpLogging.Tests (6)

FileLoggerProcessorTests.cs (6)

188.OrderBy(f => f) 311.OrderBy(f => f) 335.OrderBy(f => f) 395.OrderBy(f => f) 461.OrderBy(f => f) 531.OrderBy(f => f)

Microsoft.AspNetCore.Mvc.Api.Analyzers (1)

AddResponseTypeAttributeCodeFixAction.cs (1)

67foreach (var item in results.OrderBy(s => s.statusCode))

Microsoft.AspNetCore.Mvc.ApiExplorer (1)

ApiDescriptionGroupCollectionProvider.cs (1)

33_apiDescriptionProviders = [.. apiDescriptionProviders.OrderBy(item => item.Order)];

Microsoft.AspNetCore.Mvc.ApiExplorer.Test (30)

ApiResponseTypeProviderTest.cs (17)

DefaultApiDescriptionProviderTest.cs (9)

EndpointMetadataApiDescriptionProviderTest.cs (4)

927context.Results.SelectMany(r => r.SupportedResponseTypes).OrderBy(r => r.StatusCode), 977context.Results.SelectMany(r => r.SupportedResponseTypes).OrderBy(r => r.StatusCode), 1077context.Results.SelectMany(r => r.SupportedResponseTypes).OrderBy(r => r.StatusCode), 1519.OrderBy(format => format.MediaType)

Microsoft.AspNetCore.Mvc.Core (6)

ActionConstraints\ActionConstraintCache.cs (1)

25_actionConstraintProviders = actionConstraintProviders.OrderBy(item => item.Order).ToArray();

ApplicationModels\ApplicationModelFactory.cs (1)

29_applicationModelProviders = applicationModelProviders.OrderBy(p => p.Order).ToArray();

Infrastructure\ActionInvokerFactory.cs (1)

17_actionInvokerProviders = actionInvokerProviders.OrderBy(item => item.Order).ToArray();

Infrastructure\ControllerActionInvokerCache.cs (1)

35_filterProviders = filterProviders.OrderBy(item => item.Order).ToArray();

Infrastructure\DefaultActionDescriptorCollectionProvider.cs (1)

34.OrderBy(p => p.Order)

ModelBinding\Metadata\DefaultModelMetadata.cs (1)

367properties = properties.OrderBy(p => p.Order);

Microsoft.AspNetCore.Mvc.Core.Test (79)

ApiExplorer\ApiConventionResultTest.cs (7)

42conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode), 82conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode), 107conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode), 127conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode), 150conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode), 174conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode), 198conventionResult.ResponseMetadataProviders.OrderBy(o => o.StatusCode),

ApplicationModels\DefaultApplicationModelProviderTest.cs (3)

55context.Result.Controllers.OrderBy(c => c.ControllerType.Name), 77controllerModel.ControllerProperties.OrderBy(p => p.PropertyName), 129controllerModel.ControllerProperties.OrderBy(p => p.PropertyName),

Builder\MvcAreaRouteBuilderExtensionsTest.cs (14)

ConsumesAttributeTests.cs (1)

398contentTypes.OrderBy(t => t),

DependencyInjection\ApiBehaviorOptionsSetupTest.cs (3)

42Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, badRequest.ContentTypes.OrderBy(c => c)); 64Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, badRequest.ContentTypes.OrderBy(c => c)); 88Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, objectResult.ContentTypes.OrderBy(c => c));

Formatters\InputFormatterTest.cs (1)

360results.OrderBy(c => c.ToString()),

Formatters\JsonInputFormatterTestBase.cs (9)

Formatters\SystemTextJsonInputFormatterTest.cs (1)

80formatterContext.ModelState.OrderBy(k => k),

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (3)

45problemDetails.Errors.OrderBy(kvp => kvp.Key), 85problemDetails.Errors.OrderBy(kvp => kvp.Key), 123problemDetails.Errors.OrderBy(kvp => kvp.Key),

ModelBinding\Binders\DictionaryModelBinderTest.cs (1)

373}.OrderBy(kvp => kvp.Key),

ModelBinding\EnumerableValueProviderTest.cs (1)

100Assert.Equal(expected, result.OrderBy(kvp => kvp.Key));

ModelBinding\Metadata\DefaultModelMetadataProviderTest.cs (2)

289metadata.Properties.OrderBy(p => p.Name), 373metadata.Properties.OrderBy(p => p.Name),

ModelBinding\Validation\DefaultCollectionValidationStrategyTest.cs (3)

24BufferEntries(enumerator).OrderBy(e => e.Key), 64BufferEntries(enumerator).OrderBy(e => e.Key), 99BufferEntries(enumerator).OrderBy(e => e.Key),

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (4)

31BufferEntries(enumerator).OrderBy(e => e.Key), 71BufferEntries(enumerator).OrderBy(e => e.Key), 105BufferEntries(enumerator).OrderBy(e => e.Key), 140BufferEntries(enumerator).OrderBy(e => e.Key),

ModelBinding\Validation\DefaultObjectValidatorTests.cs (2)

1483Assert.Equal<string>(keys.OrderBy(k => k).ToList(), modelState.Keys.OrderBy(k => k).ToList());

ModelBinding\Validation\ExplicitIndexCollectionValidationStrategyTest.cs (5)

24BufferEntries(enumerator).OrderBy(e => e.Key), 64BufferEntries(enumerator).OrderBy(e => e.Key), 99BufferEntries(enumerator).OrderBy(e => e.Key), 135BufferEntries(enumerator).OrderBy(e => e.Key), 165BufferEntries(enumerator).OrderBy(e => e.Key),

ModelBinding\Validation\ShortFormDictionaryValidationStrategyTest.cs (3)

35BufferEntries(enumerator).OrderBy(e => e.Key), 82BufferEntries(enumerator).OrderBy(e => e.Key), 123BufferEntries(enumerator).OrderBy(e => e.Key),

Routing\AttributeRouteTest.cs (1)

441e.Defaults.OrderBy(kvp => kvp.Key),

Routing\ControllerActionEndpointDataSourceTest.cs (11)

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (3)

191candidates[0].Values.OrderBy(kvp => kvp.Key), 269candidates[0].Values.OrderBy(kvp => kvp.Key), 369candidates[0].Values.OrderBy(kvp => kvp.Key),

Routing\UrlHelperExtensionsTest.cs (1)

587Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values).OrderBy(v => v.Key),

Microsoft.AspNetCore.Mvc.DataAnnotations (1)

DataAnnotationsMetadataProvider.cs (1)

186.OrderBy(field => field.GetCustomAttribute<DisplayAttribute>(inherit: false)?.GetOrder() ?? 1000);

Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (4)

ProblemDetailsWrapperTest.cs (1)

38problemDetails.Extensions.OrderBy(kvp => kvp.Key),

ValidationProblemDetailsWrapperTest.cs (2)

42problemDetails.Extensions.OrderBy(kvp => kvp.Key), 55problemDetails.Errors.OrderBy(kvp => kvp.Key),

XmlAssert.cs (1)

72element.Attributes().OrderBy(a => a.Name.ToString()),

Microsoft.AspNetCore.Mvc.FunctionalTests (28)

ApiBehaviorTest.cs (3)

74problemDetails.Errors.OrderBy(kvp => kvp.Key), 332Assert.Equal(expected, json.Properties().OrderBy(p => p.Name).Select(p => p.Name)); 348Assert.Equal(expected, json.Properties().OrderBy(p => p.Name).Select(p => p.Name));

ApiExplorerTest.cs (19)

629responseType.ResponseFormats.Select(responseFormat => responseFormat.MediaType).OrderBy(o => o).ToArray()); 635responseType.ResponseFormats.Select(responseFormat => responseFormat.MediaType).OrderBy(o => o).ToArray()); 693responseType.ResponseFormats.Select(responseFormat => responseFormat.MediaType).OrderBy(o => o).ToArray()); 699responseType.ResponseFormats.Select(responseFormat => responseFormat.MediaType).OrderBy(o => o).ToArray()); 751description.SupportedResponseTypes.OrderBy(responseType => responseType.StatusCode), 788description.SupportedResponseTypes.OrderBy(responseType => responseType.StatusCode), 823description.SupportedResponseTypes.OrderBy(responseType => responseType.StatusCode), 1246description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1275description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1309description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1314var actualMediaTypes = responseType.ResponseFormats.Select(r => r.MediaType).OrderBy(r => r); 1335description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1366description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1401description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1436description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1476description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1517description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1546description.SupportedResponseTypes.OrderBy(r => r.StatusCode), 1571.OrderBy(format => format.MediaType)

BasicTests.cs (1)

632problem.Errors.OrderBy(e => e.Key),

CorsTestsBase.cs (1)

133response.Headers.OrderBy(h => h.Key),

JsonInputFormatterTestBase.cs (1)

163problem.Errors.OrderBy(e => e.Key),

LinkParserTest.cs (2)

47values.Properties().OrderBy(p => p.Name), 77values.Properties().OrderBy(p => p.Name),

src\Mvc\Mvc.Formatters.Xml\test\XmlAssert.cs (1)

72element.Attributes().OrderBy(a => a.Name.ToString()),

Microsoft.AspNetCore.Mvc.IntegrationTests (23)

DictionaryModelBinderIntegrationTest.cs (6)

1257model.OrderBy(kvp => kvp.Key), 1265modelState.OrderBy(kvp => kvp.Key), 1311model.OrderBy(kvp => kvp.Key), 1328modelState.OrderBy(kvp => kvp.Key), 1464model.OrderBy(kvp => kvp.Key), 1481modelState.OrderBy(kvp => kvp.Key),

FormFileModelBindingIntegrationTest.cs (7)

114modelState.OrderBy(kvp => kvp.Key), 165modelState.OrderBy(kvp => kvp.Key), 228modelState.OrderBy(kvp => kvp.Key), 318modelState.OrderBy(kvp => kvp.Key), 384modelState.OrderBy(kvp => kvp.Key), 446modelState.OrderBy(kvp => kvp.Key), 1231container.Dictionary.OrderBy(kvp => kvp.Key),

HeaderModelBinderIntegrationTest.cs (1)

360modelState.OrderBy(kvp => kvp.Key),

NullableReferenceTypeIntegrationTest.cs (3)

50modelState.OrderBy(kvp => kvp.Key), 137modelState.OrderBy(kvp => kvp.Key), 192modelState.OrderBy(kvp => kvp.Key),

SimpleTypeModelBinderIntegrationTest.cs (1)

696Assert.Equal(new[] { "Address.Lines", "Address.Zip", "Name" }, modelState.Keys.OrderBy(p => p).ToArray());

TryUpdateModelIntegrationTest.cs (1)

1252modelState.OrderBy(kvp => kvp.Key),

ValidationIntegrationTests.cs (2)

2233model.OrderBy(k => k.Key), 2280model.OrderBy(k => k.Key),

ValidationWithRecordIntegrationTests.cs (2)

2024model.OrderBy(k => k.Key), 2071model.OrderBy(k => k.Key),

Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (10)

NewtonsoftJsonInputFormatterTest.cs (1)

272formatterContext.ModelState.OrderBy(k => k.Key),

src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (9)

Microsoft.AspNetCore.Mvc.Razor (1)

TagHelpers\TagHelperComponentTagHelper.cs (1)

39_components = manager.Components.OrderBy(p => p.Order).ToArray();

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.Test (4)

CSharpCompilerTest.cs (1)

98Assert.Collection(compilationOptions.SpecificDiagnosticOptions.OrderBy(d => d.Key),

FileProviderRazorProjectFileSystemTest.cs (3)

48razorFiles.OrderBy(f => f.FilePath), 99Assert.Collection(razorFiles.OrderBy(f => f.FilePath), 164Assert.Collection(razorFiles.OrderBy(f => f.FilePath),

Microsoft.AspNetCore.Mvc.RazorPages (2)

Infrastructure\CompiledPageActionDescriptorFactory.cs (1)

28_applicationModelProviders = applicationModelProviders.OrderBy(a => a.Order).ToArray();

Infrastructure\PageActionDescriptorProvider.cs (1)

33_routeModelProviders = pageRouteModelProviders.OrderBy(p => p.Order).ToArray();

Microsoft.AspNetCore.Mvc.RazorPages.Test (32)

ApplicationModels\CompiledPageRouteModelProviderTest.cs (9)

46result.RouteValues.OrderBy(k => k.Key), 61result.RouteValues.OrderBy(k => k.Key), 108result.RouteValues.OrderBy(k => k.Key), 128result.RouteValues.OrderBy(k => k.Key), 148result.RouteValues.OrderBy(k => k.Key), 196result.RouteValues.OrderBy(k => k.Key), 216result.RouteValues.OrderBy(k => k.Key), 418result.RouteValues.OrderBy(k => k.Key), 433result.RouteValues.OrderBy(k => k.Key),

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (11)

148propertiesOnPage.OrderBy(p => p.PropertyName), 201context.PageApplicationModel.HandlerProperties.OrderBy(p => p.PropertyName), 244context.PageApplicationModel.HandlerProperties.OrderBy(p => p.PropertyName).Where(p => p.BindingInfo != null), 298context.PageApplicationModel.HandlerMethods.OrderBy(p => p.Name), 341context.PageApplicationModel.HandlerProperties.OrderBy(p => p.PropertyName), 383context.PageApplicationModel.HandlerProperties.OrderBy(p => p.PropertyName), 430context.PageApplicationModel.HandlerMethods.OrderBy(p => p.Name), 632propertiesOnPage.OrderBy(p => p.PropertyName), 682handlerMethods.OrderBy(h => h.MethodInfo.DeclaringType.Name).ThenBy(h => h.MethodInfo.Name), 872handlerMethods.OrderBy(h => h.MethodInfo.Name), 983properties.OrderBy(p => p.PropertyName),

ApplicationModels\PageRouteModelFactoryTest.cs (2)

118routeModel.RouteValues.OrderBy(kvp => kvp.Key), 153routeModel.RouteValues.OrderBy(kvp => kvp.Key),

Filters\PageViewDataAttributeFilterTest.cs (1)

79viewData.OrderBy(kvp => kvp.Key),

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (3)

207candidates[0].Values.OrderBy(kvp => kvp.Key), 248candidates[0].Values.OrderBy(kvp => kvp.Key), 375candidates[0].Values.OrderBy(kvp => kvp.Key),

Infrastructure\PageActionDescriptorProviderTest.cs (2)

103descriptor.RouteValues.OrderBy(kvp => kvp.Key), 153descriptor.RouteValues.OrderBy(kvp => kvp.Key),

Infrastructure\PageActionEndpointDataSourceTest.cs (4)

84endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText), 154endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText), 204endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText), 252endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText),

Microsoft.AspNetCore.Mvc.TagHelpers.Test (3)

AnchorTagHelperTest.cs (1)

451Assert.Collection(rvd.OrderBy(item => item.Key),

FormActionTagHelperTest.cs (1)

462rvd.OrderBy(item => item.Key),

FormTagHelperTest.cs (1)

930rvd.OrderBy(item => item.Key),

Microsoft.AspNetCore.Mvc.Testing (1)

WebApplicationFactory.cs (1)

310.OrderBy(a => a.Priority)

Microsoft.AspNetCore.Mvc.ViewFeatures.Test (2)

Filters\ControllerSaveTempDataPropertyFilterTest.cs (1)

186tempData.OrderBy(i => i.Key),

Filters\ControllerViewDataAttributeFilterTest.cs (1)

74viewData.OrderBy(kvp => kvp.Key),

Microsoft.AspNetCore.OpenApi (1)

Transformers\Implementations\OpenApiSchemaReferenceTransformer.cs (1)

25foreach (var (schema, referenceId) in schemasByReference.Where(kvp => kvp.Value is not null).OrderBy(kvp => kvp.Value))

Microsoft.AspNetCore.OpenApi.Tests (28)

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Paths.cs (10)

23Assert.Collection(document.Paths.OrderBy(p => p.Key), 27Assert.Collection(path.Value.Operations.OrderBy(o => o.Key), 36Assert.Collection(path.Value.Operations.OrderBy(o => o.Key), 61Assert.Collection(document.Paths.OrderBy(p => p.Key), 83Assert.Collection(document.Paths.OrderBy(p => p.Key), 87Assert.Collection(path.Value.Operations.OrderBy(o => o.Key), 115Assert.Collection(document.Paths.OrderBy(p => p.Key), 119Assert.Collection(path.Value.Operations.OrderBy(o => o.Key), 154Assert.Collection(document.Paths.OrderBy(p => p.Key), 158Assert.Collection(path.Value.Operations.OrderBy(o => o.Key),

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Responses.cs (6)

28Assert.Collection(operation.Responses.OrderBy(r => r.Key), 131Assert.Collection(response.Value.Content.OrderBy(c => c.Key), 161Assert.Collection(response.Value.Content.OrderBy(c => c.Key), 204Assert.Collection(response.Value.Content.OrderBy(c => c.Key), 328Assert.Collection(operation.Responses.OrderBy(r => r.Key), 359Assert.Collection(operation.Responses.OrderBy(r => r.Key),

Services\OpenApiGeneratorTests.cs (2)

596responses.OrderBy(response => response.Key), 638responses.OrderBy(response => response.Key),

Transformers\OperationTransformerTests.cs (10)

Microsoft.AspNetCore.Owin.Tests (1)

OwinEnvironmentTests.cs (1)

158var orderedEnvironment = owinEnvironment.OrderBy(kv => kv.Key).ToList();

Microsoft.AspNetCore.Rewrite.Tests (2)

ApacheModRewrite\FlagParserTest.cs (2)

80.OrderBy(kvp => kvp.Key) 82.OrderBy(kvp => kvp.Key));

Microsoft.AspNetCore.Routing (4)

DefaultLinkGenerator.cs (1)

450foreach (var kvp in values.OrderBy(kvp => kvp.Key))

Matching\DfaMatcherBuilder.cs (1)

47var (nodeBuilderPolicies, endpointComparerPolicies, endpointSelectorPolicies) = ExtractPolicies(policies.OrderBy(p => p.Order));

Matching\EndpointMetadataComparer.cs (1)

38.OrderBy(p => p.Order)

Tree\TreeRouteBuilder.cs (1)

283trees.Values.OrderBy(tree => tree.Order).ToArray(),

Microsoft.AspNetCore.Routing.Microbenchmarks (2)

src\Http\Routing\test\UnitTests\Matching\RouteMatcherBuilder.cs (1)

36.OrderBy(g => g.Key.Order)

src\Http\Routing\test\UnitTests\Matching\TreeRouterMatcherBuilder.cs (1)

43.OrderBy(g => g.Key.Order)

Microsoft.AspNetCore.Routing.Tests (49)

DefaultLinkGeneratorProcessTemplateTest.cs (6)

814Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key)); 847Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key)); 913Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key));

Matching\AcceptsMatcherPolicyTest.cs (2)

178edges.OrderBy(e => e.State), 236edges.OrderBy(e => e.State),

Matching\DfaMatcherBuilderTest.cs (1)

2915var comparer = new EndpointComparer(policies.OrderBy(p => p.Order).OfType<IEndpointComparerPolicy>().ToArray());

Matching\DfaMatcherTest.cs (4)

158httpContext.Request.RouteValues.OrderBy(kvp => kvp.Key), 223httpContext.Request.RouteValues.OrderBy(kvp => kvp.Key), 341httpContext.Request.RouteValues.OrderBy(kvp => kvp.Key), 601httpContext.Request.RouteValues.OrderBy(kvp => kvp.Key),

Matching\HostMatcherPolicyTest.cs (1)

216var data = edges.OrderBy(e => e.State).ToList();

Matching\HttpMethodMatcherPolicyTest.cs (4)

198edges.OrderBy(e => e.State), 243edges.OrderBy(e => e.State), 306edges.OrderBy(e => e.State), 350edges.OrderBy(e => e.State),

Matching\MatcherAssert.cs (4)

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

Matching\RouteMatcherBuilder.cs (1)

36.OrderBy(g => g.Key.Order)

Matching\TreeRouterMatcherBuilder.cs (1)

43.OrderBy(g => g.Key.Order)

Patterns\DefaultRoutePatternTransformerTest.cs (12)

Patterns\RoutePatternFactoryTest.cs (11)

RouteTest.cs (2)

1105Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key));

Microsoft.AspNetCore.Server.Kestrel.Core (1)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (19)

src\Servers\Kestrel\shared\KnownHeaders.cs (19)

Microsoft.AspNetCore.Shared.Tests (6)

AdaptiveCapacityDictionaryTests.cs (5)

216dict.OrderBy(kvp => kvp.Key), 389dict.OrderBy(kvp => kvp.Key), 411dict.OrderBy(kvp => kvp.Key), 432dict.OrderBy(kvp => kvp.Key), 451dict.OrderBy(kvp => kvp.Key),

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

Microsoft.Build (8)

BackEnd\Components\Caching\ConfigCache.cs (1)

215return _configurations.OrderBy(kvp => kvp.Key).First().Key;

BackEnd\Components\SdkResolution\SdkResolverLoader.cs (1)

72return resolvers.OrderBy(t => t.Priority).ToList();

Definition\Project.cs (1)

2786.OrderBy(pair => pair.Index)

Evaluation\LazyItemEvaluator.cs (1)

503.OrderBy(itemData => itemData.ElementOrder);

Evaluation\Profiler\ProfilerResultPrettyPrinter.cs (1)

50.OrderBy(l => l.Key.EvaluationPass);

Graph\ProjectGraph.cs (1)

521node.ProjectInstance.GlobalProperties.OrderBy(kvp => kvp.Key)

Instance\TaskRegistry.cs (1)

674.OrderBy(r => r.RegistrationOrderId);

Logging\ProfilerLogger.cs (1)

148foreach (var pair in profiledResult.ProfiledLocations.OrderBy(p => p.Key.Id))

Microsoft.Build.Engine.OM.UnitTests (1)

Instance\ProjectItemInstance_Tests.cs (1)

480itemMetadata = itemMetadata.OrderBy(pmi => pmi.Name).ToList();

Microsoft.Build.Engine.UnitTests (8)

BackEnd\SdkResolverService_Tests.cs (2)

689return _resolvers.OrderBy(i => i.Priority).ToList(); 732return resolvers.OrderBy(t => t.Priority).ToList();

Definition\ProjectEvaluationContext_Tests.cs (4)

119fileSystem.ExistenceChecks.OrderBy(kvp => kvp.Key) 125}.OrderBy(kvp => kvp.Key)); 178directoryCache.ExistenceChecks.OrderBy(kvp => kvp.Key).ShouldBe( 183}.OrderBy(kvp => kvp.Key));

FileMatcher_Tests.cs (2)

128.OrderBy(i => i) 130.ShouldBe(info.ExpectedMatches.OrderBy(i => i), caseSensitivity: Case.Insensitive, customMessage: customMessage);

Microsoft.Build.Tasks.Core (1)

WriteCodeFragment.cs (1)

517.OrderBy(c => string.Join(",", c.Select(t => t.FullName)))

Microsoft.Build.Utilities.Core (1)

ToolLocationHelper.cs (1)

478.OrderBy<TargetPlatformSDK, Version>(platform => platform.TargetPlatformVersion);

Microsoft.Build.Utilities.UnitTests (2)

TaskItem_Tests.cs (2)

341var actualMetadata = metadataContainer.EnumerateMetadata().OrderBy(metadata => metadata.Key).ToList(); 342var expectedMetadata = metadata.OrderBy(metadata => metadata.Value).ToList();

Microsoft.Cci.Extensions (1)

Traversers\SimpleTypeMemberTraverser.cs (1)

113fields = fields.OrderBy((fieldDefinition) => fieldDefinition.Constant.Value);

Microsoft.CodeAnalysis (15)

CodeGen\PrivateImplementationDetails.cs (4)

173_orderedSynthesizedMethods = _synthesizedMethods.OrderBy(kvp => kvp.Key).Select(kvp => kvp.Value).AsImmutable(); 176_orderedTopLevelTypes = _synthesizedTopLevelTypes.OrderBy(kvp => kvp.Key).Select(kvp => (Cci.INamespaceTypeDefinition)kvp.Value).AsImmutable(); 179_orderedProxyTypes = _proxyTypes.OrderBy(kvp => kvp.Key.Size).ThenBy(kvp => kvp.Key.Alignment).Select(kvp => kvp.Value).AsImmutable(); 340return _instrumentationPayloadRootFields.OrderBy(analysis => analysis.Key);

CommandLine\CommonCompiler.cs (3)

626foreach (var assembly in currentAssembly.Modules.First().ReferencedAssemblySymbols.OrderBy(a => a.Name)) 641foreach (var simpleName in enumerable.OrderBy<string, string>(n => n)) 646foreach (var key in assemblyInternal.GetInternalsVisibleToPublicKeys(simpleName).Select(k => AssemblyIdentity.PublicKeyToString(k)).OrderBy(k => k))

CommandLine\ReportAnalyzerUtil.cs (1)

96var analyzerIds = string.Join(", ", GetSupportedIds(kvp.Key).Distinct().OrderBy(id => id));

CommandLine\SarifV2ErrorLogger.cs (2)

90.OrderBy(suppression => suppression.Descriptor.Id) 122foreach (var (descriptor, info) in descriptors.OrderBy(d => d.Descriptor.Id))

DiagnosticAnalyzer\AnalyzerAssemblyLoader.Core.cs (1)

95return _loadContextByDirectory.Values.OrderBy(v => v.Directory).ToArray();

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

393.OrderBy(x => x.Key)

InternalUtilities\ImmutableSetWithInsertionOrder`1.cs (1)

61get { return _map.OrderBy(kv => kv.Value).Select(kv => kv.Key); }

NativePdbWriter\PdbWriter.cs (1)

783.OrderBy(kvp => kvp.Key))

PEWriter\MetadataWriter.PortablePdb.cs (1)

796.OrderBy(kvp => kvp.Key))

Microsoft.CodeAnalysis.CodeStyle (6)

src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

147foreach (var node in nodes.OrderBy(n => n.SpanStart))

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (1)

49.OrderBy(t => t.Start)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigFile.cs (2)

46.OrderBy(x => x.matchKind) 84.OrderBy(x => x.matchKind) // Sort by best match kind

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamedTypeSymbolExtensions.cs (1)

563return [.. result.Keys.OrderBy(s => result[s])];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (1)

221var orderedTokens = tokens.Distinct().OrderBy(t => t.SpanStart);

Microsoft.CodeAnalysis.CodeStyle.Fixes (2)

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

193foreach (var method in methodCandidates.OrderBy(m => m.Parameters.Length))

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

373diagnostics.OrderBy(d => d.Location.SourceSpan.Start),

Microsoft.CodeAnalysis.CSharp (4)

BoundTree\UnboundLambda.cs (1)

1255.OrderBy(lambda => GetLambdaSortString(lambda.Value.Symbol))

Compiler\MethodCompiler.cs (1)

1234foreach (var (parameter, field) in capturedParameters.OrderBy(pair => pair.Key.Ordinal))

Symbols\Synthesized\Records\SynthesizedPrimaryConstructor.cs (1)

120return capturedParameters.OrderBy(static pair => pair.Key.Ordinal).Select(static pair => pair.Value);

Utilities\ValueSetFactory.EnumeratedValueSet.cs (1)

54return _tc.ToConstantValue(_membersIncludedOrExcluded.OrderBy(k => k).First());

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

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

110.OrderBy(n => n.SpanStart).ToList();

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

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (1)

215.OrderBy(property => parameters.IndexOf(assignmentValues[property]))

src\Analyzers\CSharp\CodeFixes\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)

50.OrderBy(d => d.Location.SourceSpan.End)

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider_DocComments.cs (1)

175var orderedKVPs = properties.OrderBy(kvp => constructor.Parameters.FirstOrDefault(p => p.Name == kvp.Value)?.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\AttributeGenerator.cs (2)

29attributes.OrderBy(a => a.AttributeClass?.Name) 41attributes.OrderBy(a => a.AttributeClass?.Name)

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

TouchedFileLoggingTests.cs (2)

234var expected = expectedReads.Select(s => s.ToUpperInvariant()).OrderBy(s => s); 238expected = expectedWrites.Select(s => s.ToUpperInvariant()).OrderBy(s => s);

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

Interactive\BraceMatching\InteractiveBraceHighlightingTests.cs (4)

171AssertEx.Equal(Enumerable(new Span(62, 1), new Span(71, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 183AssertEx.Equal(Enumerable(new Span(62, 1), new Span(71, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 187AssertEx.Equal(Enumerable(new Span(82, 1), new Span(138, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 199AssertEx.Equal(Enumerable(new Span(82, 1), new Span(138, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start));

SymbolKey\SymbolKeyCompilationsTests.cs (8)

SymbolKey\SymbolKeyMetadataVsSourceTests.cs (1)

66var originalSymbols = GetSourceSymbols(comp1, SymbolCategory.DeclaredType).OrderBy(s => s.Name).ToList();

SymbolKey\SymbolKeyTestBase.cs (2)

43var newlist = newSymbols.OrderBy(s => s.Name).ToList(); 44var origlist = originalSymbols.OrderBy(s => s.Name).ToList();

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

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (2)

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

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (5)

Diagnostics\GetDiagnosticsTests.cs (2)

301], declaredSymbolNames.OrderBy(name => name)); 303AssertEx.Equal(["file1"], completedCompilationUnits.OrderBy(name => name));

FlowAnalysis\FlowTestBase.cs (1)

231symbols = symbols.OrderBy(n => n.Name);

FlowAnalysis\RegionAnalysisTests.cs (2)

1372string.Join(", ", new string[] { "f" }.Concat((results2.ReadOutside).Select(symbol => symbol.Name)).OrderBy(name => name))); 1376string.Join(", ", new string[] { "f" }.Concat((results2.WrittenOutside).Select(symbol => symbol.Name)).OrderBy(name => name)));

Microsoft.CodeAnalysis.CSharp.Features (5)

src\Analyzers\CSharp\CodeFixes\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs (1)

224.OrderBy(section => section.Labels.Any(label => IsDefaultSwitchLabel(label)))

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (1)

215.OrderBy(property => parameters.IndexOf(assignmentValues[property]))

src\Analyzers\CSharp\CodeFixes\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)

50.OrderBy(d => d.Location.SourceSpan.End)

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider_DocComments.cs (1)

175var orderedKVPs = properties.OrderBy(kvp => constructor.Parameters.FirstOrDefault(p => p.Name == kvp.Value)?.Ordinal);

Structure\Providers\NamespaceDeclarationStructureProvider.cs (1)

39.OrderBy(node => node.SpanStart)

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

Symbols\AnonymousTypesSemanticsTests.cs (1)

2099).OrderBy(value => value.offset).ToList();

Symbols\Metadata\PE\TypeForwarders.cs (1)

1502Assert.Equal(topLevelTypes.OrderBy(s => s), GetNamesOfForwardedTypes(assembly));

Symbols\Source\EventTests.cs (1)

43var actual = string.Join(", ", actualSymbols.Where(s => !s.IsImplicitlyDeclared).Select(symbol => symbol.Name).OrderBy(name => name));

Symbols\TypeTests.cs (1)

1681var locals = localvars.OrderBy(s => s.Name).Select(s => s).ToArray();

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

LexicalAndXml\RawStringLiteralLexingTests.cs (2)

223var expectedDiagnosticSpans = spans.Single().Value.OrderBy(d => d.Start); 224var actualDiagnosticsSpans = diagnostics.Select(d => d.Location.SourceSpan).OrderBy(d => d.Start);

Syntax\SyntaxAnnotationTests.cs (4)

351var annotatedNodesOrTokens = newRoot.GetAnnotatedNodesAndTokens(annotation).OrderBy(t => t.SpanStart).ToList(); 352var actualNodesOrTokens = GetAllNodesAndTokens(oldRoot).OrderBy(t => t.SpanStart).ToList(); 366var annotatedTrivia = newRoot.GetAnnotatedTrivia(annotation).OrderBy(t => t.SpanStart); 367var actualTrivia = GetAllTrivia(oldRoot).OrderBy(t => t.SpanStart);

Microsoft.CodeAnalysis.CSharp.Test.Utilities (1)

AttributeValidation.cs (1)

30var isUnmanagedTypeAttributes = attributeType.GetAttributes().OrderBy(attribute => attribute.AttributeClass.Name).ToArray();

Microsoft.CodeAnalysis.CSharp.Workspaces (3)

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

110.OrderBy(n => n.SpanStart).ToList();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\AttributeGenerator.cs (2)

29attributes.OrderBy(a => a.AttributeClass?.Name) 41attributes.OrderBy(a => a.AttributeClass?.Name)

Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (7)

LanguageServer\AbstractLspBuildOnlyDiagnosticsTests.cs (1)

28var missing = ExpectedDiagnosticCodes.Except(actualDiagnosticCodes).OrderBy(k => k).ToList();

NavigateTo\AbstractNavigateToTests.cs (2)

166expecteditems = [.. expecteditems.OrderBy(i => i.Name)]; 167items = items.OrderBy(i => i.Name).ToList();

ObsoleteSymbol\AbstractObsoleteSymbolTests.cs (1)

40var expectedSpans = workspace.Documents[i].SelectedSpans.OrderBy(s => s.Start);

ReassignedVariable\AbstractReassignedVariableTests.cs (1)

39var expectedSpans = workspace.Documents[i].SelectedSpans.OrderBy(s => s.Start);

Workspaces\EditorTestWorkspace.cs (2)

275mappedSpans[string.Empty] = mappedSpans[string.Empty].OrderBy(s => s.End).ThenBy(s => -s.Start).ToImmutableArray(); 324var sortedAndNamedSpans = namedSpans.OrderBy(kvp => kvp.Value.Single().Start)

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (7)

CodeFixes\ExtensionOrderingTests.cs (1)

137var actualOrder = codeFixPriorityMap.OrderBy(kvp => kvp.Value).Select(kvp => kvp.Key).ToImmutableArray();

Diagnostics\IDEDiagnosticIDConfigurationTests.cs (2)

161foreach (var kvp in expectedMap.OrderBy(kvp => kvp.Key)) 737foreach (var entry in expectedMap.OrderBy(kvp => kvp.Key))

FindReferences\FindReferencesCommandHandlerTests.cs (1)

88definitions.OrderBy(a => a));

InheritanceMargin\InheritanceMarginTests.cs (2)

115var sortedExpectedItems = memberItems.OrderBy(item => item.LineNumber).ToImmutableArray(); 132.OrderBy(target => target.TargetSymbolName)

Utilities\PatternMatcherTests.cs (1)

494var actualSpans = flattened.OrderBy(s => s.Start).ToList();

Microsoft.CodeAnalysis.Features (12)

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (1)

305var orderedDocuments = changedDocuments.OrderBy(t => codeActionToDiagnosticLocation[t.action])

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (1)

215return builder.OrderBy(kvp => kvp.Key.GetDocumentationCommentId() ?? string.Empty);

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (1)

136.OrderBy(change => change.NewText);

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

42foreach (var name in preprocessorNames.OrderBy(a => a))

EditAndContinue\EmitSolutionUpdateResults.cs (1)

264.OrderBy(static id => id)

InheritanceMargin\InheritanceMarginItem.cs (1)

77=> [.. targetItems.OrderBy(t => t.DisplayName).ThenByDescending(t => t.LanguageGlyph).ThenBy(t => t.ProjectName ?? "")];

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (1)

200foreach (var (namedType, _) in transitiveReferences.OrderBy(kvp => kvp.Value.order))

RelatedDocuments\AbstractRelatedDocumentsService.cs (1)

97IteratePotentialTypeNodes(root).OrderBy(t => Math.Abs(t.expression.SpanStart - position)),

src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

147foreach (var node in nodes.OrderBy(n => n.SpanStart))

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (1)

49.OrderBy(t => t.Start)

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

193foreach (var method in methodCandidates.OrderBy(m => m.Parameters.Length))

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

373diagnostics.OrderBy(d => d.Location.SourceSpan.Start),

Microsoft.CodeAnalysis.Features.Test.Utilities (4)

EditAndContinue\EditAndContinueTestVerifier.cs (1)

514.OrderBy(partners => partners.Key.GetLocation().SourceSpan.Start)

EditAndContinue\SourceMarkers.cs (1)

78foreach (var (id, (start, end)) in tagMap.OrderBy(k => k.Key))

RelatedDocuments\AbstractRelatedDocumentsTests.cs (2)

47var actualSortedResults = results.OrderBy(d => d.Id); 48var expectedSortedResults = workspace.Documents.Where(d => d.SelectedSpans.Count > 0).Select(d => d.Id).OrderBy(d => d.Id);

Microsoft.CodeAnalysis.Features.UnitTests (2)

FindUsages\DefinitionItemFactoryTests.cs (2)

65actual.Select(item => (key: item.Key, value: item.Value)).OrderBy(item => item.key), 72actual.OrderBy(item => item.key),

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (1)

SpellCheck\SpellCheckTests.cs (1)

566.OrderBy(t => t.textSpan.Start))

Microsoft.CodeAnalysis.Test.Utilities (12)

Assert\AssertEx.cs (1)

394SetEqual<string>(expected, actual.OrderBy(e => getIndex(e)), comparer, message, itemSeparator, itemInspector);

Diagnostics\CommonDiagnosticAnalyzers.cs (2)

86foreach (var kvp in s_properties.OrderBy(kvp => kvp.Key)) 1258return _controlFlowGraphMapOpt.Values.OrderBy(flowGraphAndSymbol => flowGraphAndSymbol.Graph.OriginalOperation.Syntax.SpanStart).ToImmutableArray();

Diagnostics\TrackingDiagnosticAnalyzer.cs (3)

151AssertSequenceEqual(expectedArguments, actualOnCodeBlockStartedArguments, items => items.OrderBy(p => p.SymbolKind).ThenBy(p => p.MethodKind).ThenBy(p => p.ReturnsVoid)); 152AssertSequenceEqual(expectedArguments, actualOnCodeBlockEndedArguments, items => items.OrderBy(p => p.SymbolKind).ThenBy(p => p.MethodKind).ThenBy(p => p.ReturnsVoid)); 163sorter = sorter ?? new Func<IEnumerable<T>, IOrderedEnumerable<T>>(items => items.OrderBy(i => i));

Platform\Custom\MetadataSignatureHelper.cs (5)

672foreach (var constructor in type.GetConstructors(BINDING_FLAGS).OrderBy((member) => member.Name)) 678foreach (var method in type.GetMethods(BINDING_FLAGS).OrderBy((member) => member.Name)) 684foreach (var property in type.GetProperties(BINDING_FLAGS).OrderBy((member) => member.Name)) 690foreach (var @event in type.GetEvents(BINDING_FLAGS).OrderBy((member) => member.Name)) 696foreach (var field in type.GetFields(BINDING_FLAGS).OrderBy((member) => member.Name))

ReflectionAssert.cs (1)

21OrderBy(s => s);

Microsoft.CodeAnalysis.UnitTests (10)

AnalyzerAssemblyLoaderTests.cs (2)

414.OrderBy(static x => x) 417.OrderBy(static x => x)

Collections\IdentifierCollectionTests.cs (8)

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

Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests (4)

Syntax\SyntaxAnnotationTests.vb (4)

326Dim annotatedNodesOrTokens = newRoot.GetAnnotatedNodesAndTokens(annotation).OrderBy(Function(x) x.SpanStart) 327Dim actualNodesOrTokens = GetAllNodesAndTokens(oldRoot).OrderBy(Function(x) x.SpanStart) 340Dim annotatedTrivia = newRoot.GetAnnotatedTrivia(annotation).OrderBy(Function(x) x.SpanStart) 341Dim actualTrivia = GetAllTrivia(oldRoot).OrderBy(Function(x) x.SpanStart)

Microsoft.CodeAnalysis.Workspaces (12)

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (1)

119.OrderBy(d => d.Location.SourceTree!.FilePath)

CodeFixes\FixAllOccurrences\TextChangeMerger.cs (1)

72var changesToApply = _totalChangesIntervalTree.Distinct().OrderBy(tc => tc.Span.Start);

Rename\ConflictEngine\ConflictResolver.cs (1)

412.OrderBy(l => l.IsInSource ? solution.GetDocumentId(l.SourceTree)!.Id : Guid.Empty)

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

106.OrderBy(g => topologicallySortedProjects.IndexOf(g.Key));

Serialization\AbstractOptionsSerializationService.cs (2)

55foreach (var kv in options.SpecificDiagnosticOptions.OrderBy(o => o.Key)) 199foreach (var kv in options.Features.OrderBy(o => o.Key))

src\Compilers\Core\Portable\DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

393.OrderBy(x => x.Key)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigFile.cs (2)

46.OrderBy(x => x.matchKind) 84.OrderBy(x => x.matchKind) // Sort by best match kind

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamedTypeSymbolExtensions.cs (1)

563return [.. result.Keys.OrderBy(s => result[s])];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (1)

221var orderedTokens = tokens.Distinct().OrderBy(t => t.SpanStart);

Workspace\Solution\SolutionState_Checksum.cs (1)

40=> s_projectIdToSortedProjectsMap.GetValue(unorderedList, projectIds => projectIds.OrderBy(id => id.Id).ToImmutableArray());

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (1)

src\Compilers\Core\Portable\InternalUtilities\ImmutableSetWithInsertionOrder`1.cs (1)

61get { return _map.OrderBy(kv => kv.Value).Select(kv => kv.Key); }

Microsoft.CodeAnalysis.Workspaces.UnitTests (10)

CodeStyle\NamingStylePreferencesUpgradeTests.cs (1)

201.OrderBy(name => name);

FindAllDeclarationsTests.TestSolutionsAndProject.cs (2)

64declarations = declarations.OrderBy(d => d.ToString()); 65expectedResults = [.. expectedResults.OrderBy(r => r)];

FindReferencesTests.cs (2)

496var refsFromVirtualSorted = refsFromVirtual.Select(r => r.Definition).OrderBy(r => r.ContainingType.Name).ToArray(); 497var refsFromOverrideSorted = refsFromOverride.Select(r => r.Definition).OrderBy(r => r.ContainingType.Name).ToArray();

SolutionTests\ProjectDependencyGraphTests.cs (4)

285expectedResults.OrderBy(n => n), 302expectedResults.OrderBy(n => n), 653expectedResults.OrderBy(n => n), 666expectedResults.OrderBy(n => n),

XxHash128Tests.cs (1)

89foreach ((ulong HashHigh, ulong HashLow, long Seed, string Ascii) test in TestCases().OrderBy(t => t.Seed))

Microsoft.DotNet.Arcade.Sdk (1)

src\GenerateResxSource.cs (1)

511arguments = arguments.OrderBy(Convert.ToInt32);

Microsoft.DotNet.Build.Tasks.Packaging (7)

GeneratePackageReport.cs (1)

92foreach (var framework in _frameworks.OrderBy(f => f.Key.ToString()))

GetMinimumNETStandard.cs (1)

33.OrderBy(fx => fx.Version)

NuGetUtility.cs (1)

68return result.OrderBy(v => v);

SplitDependenciesBySupport.cs (1)

46.OrderBy(fx => fx.Version)

ValidatePackage.cs (3)

363AllSupportedFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null).Select(fx => fx.ToItem()).OrderBy(i => i.ItemSpec).ToArray(); 561IEnumerable<ValidationFramework> higherFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == fx.Framework && vf.Framework.Version > fx.Version).OrderBy(vf => vf.Framework.Version); 566var uapFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == FrameworkConstants.FrameworkIdentifiers.UAP).OrderBy(vf => vf.Framework.Version);

Microsoft.DotNet.Build.Tasks.Workloads (2)

CreateVisualStudioWorkload.wix.cs (1)

289string uniquePackGroupKey = string.Join("\r\n", kvp.Value.Select(p => p.PackagePath).OrderBy(p => p));

WorkloadPackGroupPackage.wix.cs (1)

37var manifestPackage = ManifestsPerPlatform.First().Value.OrderBy(m => m.Version).Last();

Microsoft.DotNet.GenFacades (2)

SourceGenerator.cs (2)

58foreach (string type in typesToForward.OrderBy(s => s)) 99foreach (string alias in externAliases.OrderBy(s => s))

Microsoft.DotNet.Internal.DependencyInjection.Testing (1)

DependencyInjectionValidation.cs (1)

98.OrderBy(c => c.GetParameters().Length)

Microsoft.DotNet.NuGetRepack.Tasks (1)

src\ReplacePackageParts.cs (1)

225foreach (var partName in replacementMap.Keys.OrderBy(k => k))

Microsoft.DotNet.PackageTesting (1)

GetCompatiblePackageTargetFrameworks.cs (1)

36.OrderBy(t => t.Version)

Microsoft.DotNet.SharedFramework.Sdk (1)

src\CreateFrameworkListFile.cs (1)

254?.Keys.Except(usedFileClasses).OrderBy(p => p)

Microsoft.DotNet.SignTool (2)

src\BatchSignUtil.cs (1)

473foreach (var fileName in _batchData.FilesToSign.OrderBy(x => x.FullPath))

src\SignToolTask.cs (1)

255ItemsToSign.OrderBy(i => i.GetMetadata(SignToolConstants.CollisionPriorityId)).ToArray(),

Microsoft.DotNet.SourceBuild.Tasks (6)

src\UsageReport\UsageData.cs (2)

30.OrderBy(id => id) 39.OrderBy(u => u.PackageIdentity)

src\UsageReport\WriteUsageReports.cs (1)

181.OrderBy(snapshot =>

src\WriteBuildOutputProps.cs (3)

63.Select(g => g.OrderBy(id => id.Version).Last()) 64.OrderBy(id => id.Id) 72Version = new DirectoryInfo(Directory.EnumerateDirectories(dir).OrderBy(s => s).Last()).Name

Microsoft.DotNet.SwaggerGenerator.CodeGenerator (5)

Modeler\MethodModel.cs (4)

48Parameters.Where(p => p.Type is TypeReference.ConstantTypeReference).OrderBy(p => p.Name); 51Parameters.Where(p => !(p.Type is TypeReference.ConstantTypeReference)).OrderBy(p => p.Name); 53public IEnumerable<ParameterModel> FormalParameters => NonConstantParameters.OrderBy(p => p.Required ? 0 : 1).ThenBy(p => p.Name); 55public IEnumerable<ParameterModel> FormalParametersNoPaging => NonConstantParameters.OrderBy(p => p.Required ? 0 : 1).ThenBy(p => p.Name).Where(p => Paginated == null || (p.Name != Paginated.PageParameterName && p.Name != Paginated.PageSizeParameterName));

Modeler\ServiceClientModelFactory.cs (1)

133_types.Values?.Concat(_enumTypeModels.Values).OrderBy(m => m.Name),

Microsoft.DotNet.VersionTools (5)

Automation\DependencyUpdateResults.cs (1)

26var orderedInfos = UsedInfos.OrderBy(info => info.SimpleName).ToArray();

Automation\PullRequestCreator.cs (1)

183.OrderBy(s => s.State)

Automation\VersionsRepoUpdater.cs (1)

41.OrderBy(t => t.Key)

Automation\VstsApi\VstsAdapterClient.cs (1)

243return prs.OrderBy(pr => pr.Number).Last();

BuildManifest\Model\XElementParsingExtensions.cs (1)

35.OrderBy(pair => keySortOrder.TakeWhile(o => pair.Key != o).Count())

Microsoft.Extensions.Diagnostics.HealthChecks.Tests (9)

DefaultHealthCheckServiceTest.cs (2)

84results.Entries.OrderBy(kvp => kvp.Key), 138results.Entries.OrderBy(kvp => kvp.Key),

DependencyInjection\ServiceCollectionExtensionsTest.cs (2)

26Assert.Collection(services.OrderBy(s => s.ServiceType.FullName), 56Assert.Collection(services.OrderBy(s => s.ServiceType.FullName).ThenBy(s => s.ImplementationType!.FullName),

HealthCheckPublisherHostedServiceTest.cs (5)

211Assert.Equal(new[] { "one", "two", }, report.Entries.Keys.OrderBy(k => k)); 386var entries = publisher.Entries.SelectMany(e => e.report.Entries.Select(e2 => e2.Key)).OrderBy(k => k).ToArray(); 435Assert.Equal(new[] { "one", "two", }, report.Entries.Keys.OrderBy(k => k)); 641var entries = publishers[i].Entries.SelectMany(e => e.report.Entries.Select(e2 => e2.Key)).OrderBy(k => k).ToArray(); 657var entries = publishers[i].Entries.SelectMany(e => e.report.Entries.Select(e2 => e2.Key)).OrderBy(k => k).ToArray();

Microsoft.Extensions.Options.SourceGeneration (3)

Emitter.cs (3)

64foreach (var vt in validatorTypes.OrderBy(static lt => lt.Namespace + "." + lt.Name)) 158.OrderBy(x => x.FieldOrder) 783.OrderBy(p => p.Key)

Microsoft.Gen.ComplianceReports (5)

Emitter.cs (5)

32foreach (var classifiedType in classifiedTypes.OrderBy(ct => ct.TypeName)) 42foreach (var member in classifiedType.Members.OrderBy(m => m.Name)) 55foreach (var c in member.Classifications.OrderBy(c => c.Name)) 78foreach (var method in classifiedType.LogMethods.OrderBy(m => m.MethodName)) 99foreach (var c in p.Classifications.OrderBy(c => c.Name))

Microsoft.Gen.ContextualOptions (2)

ContextualOptionsGenerator.cs (1)

61context.AddSource($"ContextualOptions.g.cs", emitter.Emit(list.OrderBy(x => x.Namespace + "." + x.Name)));

Emitter.cs (1)

38{{{string.Concat(optionsContextType.OptionsContextProperties.OrderBy(x => x).Select(property => $@"

Microsoft.Gen.Logging (1)

Emission\Emitter.cs (1)

23foreach (var lt in logTypes.OrderBy(static lt => lt.Namespace + "." + lt.Name))

Microsoft.Gen.Metrics (4)

Emitter.cs (2)

35foreach (var entry in metricClassesDict.OrderBy(static x => x.Key)) 59foreach (var metricClass in metricTypes.OrderBy(static x => x.Name))

MetricFactoryEmitter.cs (2)

31foreach (var entry in metricClassesDict.OrderBy(static x => x.Key)) 73foreach (var metricClass in metricClasses.OrderBy(static x => x.Name))

Microsoft.Interop.ComInterfaceGenerator (1)

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (1)

89foreach (var option in options.OrderBy(item => item.Key))

Microsoft.Interop.LibraryImportGenerator (2)

Analyzers\ConvertToLibraryImportFixer.cs (1)

556attribute.ArgumentList.Arguments.OrderBy(arg =>

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (1)

89foreach (var option in options.OrderBy(item => item.Key))

Microsoft.ML.AutoML (8)

AutoMLExperiment\ITrialResultManager.cs (1)

100foreach (var trialResult in _newTrialResults.OrderBy(res => res.TrialSettings.TrialId))

ColumnInference\TextFileSample.cs (1)

143.OrderBy(x => x)

PipelineSuggesters\PipelineSuggester.cs (2)

101IEnumerable<SuggestedPipelineRunDetail> sortedHistory = history.OrderBy(r => r.Score); 116.OrderBy(x => x.Count())

Tuner\PipelineProposer.cs (1)

97schema = _eci.OrderBy(kv => kv.Value).First().Key;

Tuner\SmacTuner.cs (1)

172var bestKParamSets = _histories.OrderBy(i => i.Loss).Take(_localSearchParentCount).Select(r => r.TrialSettings.Parameter);

Utils\ArrayMath.cs (1)

36return Enumerable.Range(0, array.Length).OrderBy(index => array[index]).ToArray();

Utils\BestResultUtil.cs (1)

88orderedResults = indexedValues.OrderBy(t => metricsAgent.GetScore(t.Item1.ValidationMetrics));

Microsoft.ML.Core (4)

ComponentModel\ComponentCatalog.cs (3)

909return _components.Select(x => x.Kind).Distinct().OrderBy(x => x); 920return _components.Where(x => x.Kind == kind).OrderBy(x => x.Name); 930return _components.Where(x => x.InterfaceType == interfaceType).OrderBy(x => x.Name);

Data\ProgressReporter.cs (1)

183foreach (var subChannel in _subChannels.Values.ToArray().OrderBy(x => x.Level))

Microsoft.ML.Core.Tests (4)

UnitTests\TestVBuffer.cs (4)

327int[] indices = aIndices.Union(b.Items().Select(iv => iv.Key)).OrderBy(i => i).ToArray(); 372int[] indices = a.Items().Select(iv => iv.Key).Union(b.Items().Select(iv => iv.Key)).OrderBy(i => i).ToArray(); 420indices = indices.Distinct().OrderBy(x => x); 504.Union(b.Items().Select(iv => iv.Key)).Distinct().OrderBy(x => x).ToArray();

Microsoft.ML.Data (15)

Commands\ShowSchemaCommand.cs (1)

191foreach (var metaColumn in schema[col].Annotations.Schema.OrderBy(mcol => mcol.Name))

Commands\TypeInfoCommand.cs (5)

71foreach (var kind in obj.OrderBy(x => x)) 87var kinds = Enum.GetValues(typeof(InternalDataKind)).Cast<InternalDataKind>().Distinct().OrderBy(k => k).ToArray(); 126string srcStrings = string.Join(", ", srcs.OrderBy(k => k).Select(k => '`' + k.GetString() + '`')); 127string dstStrings = string.Join(", ", dsts.OrderBy(k => k).Select(k => '`' + k.GetString() + '`')); 135string.Join(", ", nonIdentity.OrderBy(k => k).Select(InternalDataKindExtensions.GetString)));

DataLoadSave\Binary\BinaryLoader.cs (1)

2166.Where(t => !t.Value.IsGenerated).OrderBy(t => t.Value.ColumnIndex);

DataLoadSave\Text\TextLoader.cs (1)

242var sortedRanges = Source.OrderBy(x => x.Min).ToList();

DataView\Transposer.cs (1)

98IEnumerable<int> columnSet = columns.Distinct().OrderBy(c => c);

Evaluators\ClusteringEvaluator.cs (3)

453foreach (var index in Enumerable.Range(0, _scoresArr.Length).OrderBy(i => _scoresArr[i])) 479foreach (var index in Enumerable.Range(0, _scoresArr.Length).OrderBy(i => _scoresArr[i])) 672foreach (var index in Enumerable.Range(0, scoresArr.Length).OrderBy(i => scoresArr[i]))

Utilities\StreamUtils.cs (3)

102var files = Directory.GetFiles(dir, right).OrderBy(f => f).ToArray(); 112var subs = Directory.GetDirectories(dir).OrderBy(f => f).ToArray(); 133var files = Directory.GetFiles(path, Path.GetFileName(currentPattern)).OrderBy(f => f).ToArray();

Microsoft.ML.Ensemble (2)

EntryPoints\CreateEnsemble.cs (2)

334var entries = zip.Entries.OrderBy(e => e.FullName).ToArray(); 382var entries = zip.Entries.OrderBy(e => e.FullName).ToArray();

Microsoft.ML.EntryPoints (3)

JsonUtils\JsonManifestUtils.cs (3)

60foreach (var epKind in kinds.Distinct().OrderBy(k => k.Name)) 276return new JArray(inputs.OrderBy(x => x.Key).Select(x => x.Value).ToArray()); 304return new JArray(outputs.OrderBy(x => x.Key).Select(x => x.Value).ToArray());

Microsoft.ML.FastTree (3)

Dataset\Dataset.cs (1)

845IEnumerable<string> typeNameEnumerable = arrays.Select(x => x.GetType().GetElementType()).Distinct().Select(x => x.Name).OrderBy(n => n);

Dataset\DatasetUtils.cs (2)

49foreach (uint uintQid in skel.QueryIds.Select(qid => (uint)qid).Distinct().OrderBy(x => x)) 57uint[] valueMap = uvalToOrder.Keys.OrderBy(x => x).ToArray(uvalToOrder.Count);

Microsoft.ML.SearchSpace (8)

Option\NestOption.cs (4)

31return this.OrderBy(kv => kv.Key) 42return this.OrderBy(kv => kv.Key) 53foreach (var kv in this.OrderBy(kv => kv.Key)) 68foreach (var key in _options.Keys.OrderBy(k => k))

SearchSpace.cs (4)

59return this.OrderBy(kv => kv.Key) 99return this.OrderBy(kv => kv.Key) 115foreach (var key in _options.Keys.OrderBy(k => k)) 136foreach (var key in _options.Keys.OrderBy(k => k))

Microsoft.ML.TestFramework (2)

DataPipe\TestDataPipeBase.cs (2)

157var promisedCols = promised.OrderBy(x => x.Name); 158var deliveredCols = delivered.OrderBy(x => x.Name);

Microsoft.ML.Tests (2)

PermutationFeatureImportanceTests.cs (1)

961var min = metricsDelta.OrderBy(m => metricSelector(m)).First();

Transformers\NormalizerTests.cs (1)

1083var sortedNumbers = numbers.OrderBy(n => n);

Microsoft.ML.TimeSeries (1)

RootCauseAnalyzer.cs (1)

205anomalyPoints = anomalyPoints.OrderBy(x => x.Delta).ToList();

Microsoft.ML.Transforms (2)

Expression\LambdaBinder.cs (1)

1351var arities = candidates.Select(c => c.Arity).Distinct().OrderBy(x => x).ToArray();

Text\WordEmbeddingsExtractor.cs (1)

694foreach (var parsedLine in parsedData.OrderBy(parsedLine => parsedLine.lineNumber))

Microsoft.VisualBasic.Tests (1)

Microsoft\VisualBasic\ApplicationServices\ApplicationBaseTests.cs (1)

72return [.. pairs.OrderBy(pair => pair.Item1)];

Microsoft.VisualStudio.LanguageServices (1)

CommonControls\MemberSelectionViewModel.cs (1)

37Members = members.OrderBy(s => s.SymbolName).ToImmutableArray();

Microsoft.VisualStudio.LanguageServices.LiveShare (1)

Client\LanguageServiceUtils.cs (1)

26public static string GetContentTypesName(string[] contentTypes) => string.Join("-", [.. contentTypes.OrderBy(c => c)]);

RunTests (1)

Program.cs (1)

271foreach (var proc in ProcessUtil.GetProcessTree(Process.GetCurrentProcess()).OrderBy(x => x.ProcessName))

SemanticSearch.BuildTask (3)

GenerateFilteredReferenceAssembliesTask.cs (3)

305types.OrderBy(t => t.MetadataToken).ToImmutableArray(), 312methods.OrderBy(t => t.MetadataToken).ToImmutableArray(), 319fields.OrderBy(t => t.MetadataToken).ToImmutableArray(),

Swaggatherer (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

System.ComponentModel.Annotations (2)

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

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

System.Composition.Hosting (1)

System\Composition\Hosting\Util\Formatters.cs (1)

18string reply = string.Join(SR.Formatter_ListSeparatorWithSpace, items.OrderBy(t => t));

System.Data.Common (1)

System\Data\EnumerableRowCollectionExtensions.cs (1)

32IEnumerable<TRow> ie = Enumerable.OrderBy(source, keySelector);

System.Text.Json.SourceGeneration (1)

JsonSourceGenerator.Parser.cs (1)

156GeneratedTypes = _generatedTypes.Values.OrderBy(t => t.TypeRef.FullyQualifiedName).ToImmutableEquatableArray(),

System.Text.RegularExpressions.Generator (3)

RegexGenerator.Emitter.cs (3)

156AppendHashtableContents(writer, rm.Tree.CaptureNumberSparseMapping.Cast<DictionaryEntry>().OrderBy(de => de.Key as int?)); 1557foreach (KeyValuePair<string, string[]> localFunctions in additionalLocalFunctions.OrderBy(k => k.Key)) 5399foreach (string decl in declarations.OrderBy(s => s))

System.Windows.Forms.Design.Tests (2)

System\Drawing\Design\ToolboxItemTests.cs (2)

1368Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f)); 1376Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f));

System.Windows.Forms.PrivateSourceGenerators (1)

System\Windows\Forms\SourceGenerators\EnumValidationInfo.cs (1)

12var values = GetElementValues(enumType).OrderBy(e => e).Distinct().ToImmutableArray();

System.Windows.Forms.Tests (6)

System\Windows\Forms\DataObjectTests.cs (6)

549dataObject.GetFormats().OrderBy(s => s).Should().Equal(["format1", "format2", "UnicodeText"]); 553dataObject.GetFormats().OrderBy(s => s).Should().Equal(["Bitmap", "format1", "format2", "System.Drawing.Bitmap", "UnicodeText", "WindowsForms10PersistentObject"]); 623dataObject.GetFormats(autoConvert: true).OrderBy(s => s).Should().Equal(["format1", "format2", "UnicodeText"]); 624dataObject.GetFormats(autoConvert: false).OrderBy(s => s).Should().Equal(["format1", "format2", "UnicodeText"]); 628dataObject.GetFormats(autoConvert: true).OrderBy(s => s).Should().Equal(["Bitmap", "format1", "format2", "System.Drawing.Bitmap", "UnicodeText", "WindowsForms10PersistentObject"]); 629dataObject.GetFormats(autoConvert: false).OrderBy(s => s).Should().Equal(["format1", "format2", "System.Drawing.Bitmap", "UnicodeText", "WindowsForms10PersistentObject"]);

Templates.Blazor.Tests (2)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

Templates.Blazor.WebAssembly.Auth.Tests (3)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

src\Shared\E2ETesting\CaptureSeleniumLogsAttribute.cs (1)

35foreach (var kind in logs.AvailableLogTypes.OrderBy(k => k == LogType.Browser ? 0 : 1))

Templates.Blazor.WebAssembly.Tests (3)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

src\Shared\E2ETesting\CaptureSeleniumLogsAttribute.cs (1)

35foreach (var kind in logs.AvailableLogTypes.OrderBy(k => k == LogType.Browser ? 0 : 1))

Templates.Mvc.Tests (3)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

src\Shared\E2ETesting\CaptureSeleniumLogsAttribute.cs (1)

35foreach (var kind in logs.AvailableLogTypes.OrderBy(k => k == LogType.Browser ? 0 : 1))

Templates.Tests (3)

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

853var description = list.OrderBy(c => c.Thumbprint).Select((c, i) => $" {i + 1}) " + GetDescription(c)).Prepend(certificatesDescription);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

src\Shared\E2ETesting\CaptureSeleniumLogsAttribute.cs (1)

35foreach (var kind in logs.AvailableLogTypes.OrderBy(k => k == LogType.Browser ? 0 : 1))

VBCSCompiler.UnitTests (2)

TouchedFileLoggingTests.cs (2)

186var expected = expectedReads.Select(s => s.ToUpperInvariant()).OrderBy(s => s); 190expected = expectedWrites.Select(s => s.ToUpperInvariant()).OrderBy(s => s);

Wasm.Performance.ConsoleHost (1)

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (1)

514foreach (var cmd in commands.OrderBy(c => c.Name))

xunit.assert (1)

Sdk\ArgumentFormatter.cs (1)

348 .OrderBy(p => p.name)

xunit.console (2)

ConsoleRunner.cs (2)

249foreach (var reporter in switchableReporters.OrderBy(r => r.RunnerSwitch)) 309reporterMessageHandler.OnMessage(new TestExecutionSummary(clockTime.Elapsed, completionMessages.OrderBy(kvp => kvp.Key).ToList()));