Contains

129 references to Contains

aspire (6)

Commands\InitCommand.cs (1)

199.FirstOrDefault(f => DotNetAppHostProject.ProjectExtensions.Contains(f.Extension, StringComparer.OrdinalIgnoreCase));

Projects\DotNetBasedAppHostServerProject.cs (2)

307if (!atsAssemblies.Contains(integration.Name, StringComparer.OrdinalIgnoreCase)) 363if (!channelSources.Contains(mapping.Source, StringComparer.OrdinalIgnoreCase))

Projects\PrebuiltAppHostServer.cs (3)

388if (!sources.Contains(mapping.Source, StringComparer.OrdinalIgnoreCase)) 542if (!atsAssemblies.Contains(pkg.Name, StringComparer.OrdinalIgnoreCase)) 550if (!atsAssemblies.Contains(name, StringComparer.OrdinalIgnoreCase))

Aspire.Cli.Tests (2)

Commands\NewCommandTests.cs (1)

66Assert.DoesNotContain(command.Options, option => option.Aliases.Contains("--language", StringComparer.OrdinalIgnoreCase));

tests\Shared\Logging\LogValuesAssert.cs (1)

41if (!actualValues.Contains(expectedPair, comparer))

Aspire.Dashboard.Components.Tests (1)

tests\Shared\Logging\LogValuesAssert.cs (1)

41if (!actualValues.Contains(expectedPair, comparer))

Aspire.Dashboard.Tests (1)

tests\Shared\Logging\LogValuesAssert.cs (1)

41if (!actualValues.Contains(expectedPair, comparer))

Aspire.Hosting (3)

ApplicationModel\ResourceNotificationService.cs (1)

130re => re.Snapshot.State?.Text is { Length: > 0 } stateText && targetStates.Contains(stateText, StringComparers.ResourceState),

DistributedApplication.cs (1)

641if (KnownResourceStates.TerminalStates.Contains(Snapshot?.State?.Text, StringComparers.ResourceState))

ResourceBuilderExtensions.cs (1)

2927if (!s_httpSchemes.Contains(matchingEndpoint.Scheme, StringComparers.EndpointAnnotationUriScheme))

Aspire.Hosting.CodeGeneration.Go (2)

AtsGoCodeGenerator.cs (2)

773if (_structNames.Values.Contains(name, StringComparer.Ordinal)) 782while (_structNames.Values.Contains(candidate, StringComparer.Ordinal))

Aspire.Hosting.CodeGeneration.Java (2)

AtsJavaCodeGenerator.cs (2)

729if (_classNames.Values.Contains(name, StringComparer.Ordinal)) 738while (_classNames.Values.Contains(candidate, StringComparer.Ordinal))

Aspire.Hosting.CodeGeneration.Python (2)

AtsPythonCodeGenerator.cs (2)

713if (_classNames.Values.Contains(name, StringComparer.Ordinal)) 722while (_classNames.Values.Contains(candidate, StringComparer.Ordinal))

Aspire.Hosting.CodeGeneration.Rust (2)

AtsRustCodeGenerator.cs (2)

913if (_structNames.Values.Contains(name, StringComparer.Ordinal)) 922while (_structNames.Values.Contains(candidate, StringComparer.Ordinal))

Aspire.Hosting.Testing.Tests (1)

tests\Shared\Logging\LogValuesAssert.cs (1)

41if (!actualValues.Contains(expectedPair, comparer))

Aspire.Hosting.Tests (1)

tests\Shared\Logging\LogValuesAssert.cs (1)

41if (!actualValues.Contains(expectedPair, comparer))

Aspire.Playground.Tests (2)

Infrastructure\DistributedApplicationExtensions.cs (1)

107return Task.WhenAll(applicationModel.Resources.Select(r => app.ResourceNotifications.WaitForResourceAsync(r.Name, r => targetStates?.Contains(r.Snapshot.State?.Text, StringComparer.OrdinalIgnoreCase) is true || r.Snapshot.IsHidden, cancellationToken)));

tests\Shared\Logging\LogValuesAssert.cs (1)

41if (!actualValues.Contains(expectedPair, comparer))

dotnet (3)

Commands\New\MSBuildEvaluation\CapabilityExpressionEvaluator.cs (1)

137bool isPresent = _presentTerms.Contains(ident, StringComparer.OrdinalIgnoreCase);

Commands\Tool\Install\ProjectRestorer.cs (1)

68&& _additionalRestoreArguments.Contains(Constants.RestoreInteractiveOption, StringComparer.Ordinal))

NugetPackageDownloader\NuGetPackageDownloader.cs (1)

437allowListNuspec.Contains(Path.GetFileName(f), comparer: StringComparer.OrdinalIgnoreCase)))

dotnet-svcutil (2)

GlobalTool.cs (2)

20if (!arguments.Contains("--toolContext", StringComparer.InvariantCultureIgnoreCase) && !arguments.Contains("-tc", StringComparer.InvariantCultureIgnoreCase))

GenerateAnalyzerNuspec (1)

Program.cs (1)

213if (fileNamesToExclude.Contains(fileName, StringComparer.OrdinalIgnoreCase))

GenerateDocumentationAndConfigFiles (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

138=> GenerateUniqueName(baseName, x => !names.Contains(x, comparer));

Microsoft.AspNetCore.Authorization (1)

ClaimsAuthorizationRequirement.cs (1)

72&& requirement.AllowedValues!.Contains(claim.Value, StringComparer.Ordinal))

Microsoft.AspNetCore.Cors (1)

Infrastructure\CorsPolicy.cs (1)

177return Origins.Contains(origin, StringComparer.Ordinal);

Microsoft.AspNetCore.HostFiltering (1)

MiddlewareConfigurationManager.cs (1)

75if (!results.Contains(host, StringSegmentComparer.OrdinalIgnoreCase))

Microsoft.AspNetCore.Http.Extensions (2)

RequestDelegateFactory.cs (2)

732if (factoryContext.RouteParameters is { } routeParams && !routeParams.Contains(routeName, StringComparer.OrdinalIgnoreCase)) 889if (routeParams.Contains(parameter.Name, StringComparer.OrdinalIgnoreCase))

Microsoft.AspNetCore.HttpOverrides (1)

ForwardedHeadersMiddleware.cs (1)

90if (!allowedHosts.Contains(host, StringSegmentComparer.OrdinalIgnoreCase))

Microsoft.AspNetCore.Routing (2)

Constraints\HttpMethodRouteConstraint.cs (2)

49return AllowedMethods.Contains(httpContext.Request.Method, StringComparer.OrdinalIgnoreCase); 70return AllowedMethods.Contains(Convert.ToString(obj, CultureInfo.InvariantCulture), StringComparer.OrdinalIgnoreCase);

Microsoft.AspNetCore.SignalR.Core (1)

Internal\DefaultHubProtocolResolver.cs (1)

36if (_availableProtocols.TryGetValue(protocolName, out var protocol) && (supportedProtocols == null || supportedProtocols.Contains(protocolName, StringComparer.OrdinalIgnoreCase)))

Microsoft.AspNetCore.WebSockets (2)

WebSocketMiddleware.cs (2)

43_anyOriginAllowed = _options.AllowedOrigins.Count == 0 || _options.AllowedOrigins.Contains("*", StringComparer.Ordinal); 73if (!_allowedOrigins.Contains(originHeader.ToString(), StringComparer.Ordinal))

Microsoft.Build (1)

Instance\ProjectInstance.cs (1)

892if (!itemFilter.Value.Contains(metadataName, StringComparer.OrdinalIgnoreCase))

Microsoft.Build.Tasks.Core (1)

CultureInfoCache.cs (1)

78return pseudoLocales.Contains(name, StringComparer.OrdinalIgnoreCase);

Microsoft.CodeAnalysis (1)

Operations\ControlFlowGraphBuilder.cs (1)

8129Debug.Assert(properties.Contains(propertyReference.Property, SymbolEqualityComparer.IgnoreAll));

Microsoft.CodeAnalysis.Analyzers (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

138=> GenerateUniqueName(baseName, x => !names.Contains(x, comparer));

Microsoft.CodeAnalysis.CodeStyle.Fixes (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

138=> GenerateUniqueName(baseName, x => !names.Contains(x, comparer));

Microsoft.CodeAnalysis.Razor.Compiler (1)

Language\Components\ComponentGenericTypePass.cs (1)

212.Contains(typeName, StringComparer.Ordinal);

Microsoft.CodeAnalysis.Workspaces (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

138=> GenerateUniqueName(baseName, x => !names.Contains(x, comparer));

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

HarvestPackage.cs (1)

605return extension != null && extension.Length > 0 && s_includedExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.ServiceDiscovery (1)

Http\ResolvingHttpDelegatingHandler.cs (1)

115if (options.AllowAllSchemes || options.AllowedSchemes.Contains(scheme, StringComparer.OrdinalIgnoreCase))

Microsoft.Extensions.ServiceDiscovery.Yarp (1)

ServiceDiscoveryDestinationResolver.cs (1)

115if (_options.AllowAllSchemes || _options.AllowedSchemes.Contains(scheme, StringComparer.OrdinalIgnoreCase))

Microsoft.Gen.Logging (3)

Parsing\Parser.cs (3)

160bool parameterInTemplate = lm.Templates.Contains(lp.TagName, StringComparer.OrdinalIgnoreCase) || 161lm.Templates.Contains(lp.ParameterNameWithAtIfNeeded, StringComparer.OrdinalIgnoreCase) || 162lm.Templates.Contains($"@{lp.ParameterName}", StringComparer.OrdinalIgnoreCase);

Microsoft.Maui.Controls.Build.Tasks (5)

NodeILExtensions.cs (5)

Microsoft.Maui.Controls.SourceGen (1)

CodeBehindGenerator.cs (1)

592 if (type.DeclaredAccessibility == Accessibility.Internal && internalsVisible.Contains(type.ContainingAssembly, SymbolEqualityComparer.Default))

Microsoft.TemplateEngine.Cli (6)

Commands\create\InstantiateCommand.Help.cs (1)

114if (languages.Contains(defaultLanguage, StringComparer.OrdinalIgnoreCase))

Commands\Extensions.cs (1)

71var invalidArguments = optionResult.Tokens.Where(token => !allowedValues.Append(allowedHiddenValue).Contains(token.Value, StringComparer.OrdinalIgnoreCase)).ToList();

TemplatePackageCoordinator.cs (2)

789return template.ShortNameList.Contains(sourceIdentifier, StringComparer.OrdinalIgnoreCase); 811return template.ShortNameList.Contains(sourceIdentifier, StringComparer.OrdinalIgnoreCase);

TemplateResolution\CliFilters.cs (2)

111if (templateLanguages.Contains(language, StringComparer.OrdinalIgnoreCase)) 123if (templateLanguages.Contains(defaultLanguage, StringComparer.OrdinalIgnoreCase))

Microsoft.TemplateEngine.Edge (4)

Constraints\HostConstraint.cs (1)

48foreach (HostInformation hostInfo in supportedHosts.Where(h => EnvironmentSettings.Host.FallbackHostTemplateConfigNames.Contains(h.HostName, StringComparer.OrdinalIgnoreCase)))

Settings\TemplateCache.cs (1)

162if (availableLocalizations.Contains(currentCulture.Name, StringComparer.OrdinalIgnoreCase))

Template\WellKnownSearchFilters.cs (2)

94if (template.Classifications?.Contains(tagFilter, StringComparer.OrdinalIgnoreCase) ?? false) 164if (!template.Classifications.Contains(part, StringComparer.OrdinalIgnoreCase))

Microsoft.TemplateEngine.Utils (1)

WellKnownSearchFilters.cs (1)

124if (template.Classifications?.Contains(classification, StringComparer.CurrentCultureIgnoreCase) ?? false)

Microsoft.TestPlatform.CrossPlatEngine (3)

Discovery\DiscovererEnumerator.cs (2)

294if (Constants.DefaultAdapters.Contains(discoverer.Metadata.DefaultExecutorUri.ToString(), StringComparer.OrdinalIgnoreCase)) 407discovererFileExtensions!.Contains(

Execution\BaseRunTests.cs (1)

487if (!CrossPlatEngine.Constants.DefaultAdapters.Contains(executor.Metadata.ExtensionUri, StringComparer.OrdinalIgnoreCase))

Microsoft.TestPlatform.Filter.Source (1)

Condition.cs (1)

242if (properties.Contains(Name, StringComparer.OrdinalIgnoreCase))

Microsoft.VisualStudio.TestPlatform.Common (1)

src\vstest\src\Microsoft.TestPlatform.Filter.Source\Condition.cs (1)

242if (properties.Contains(Name, StringComparer.OrdinalIgnoreCase))

Microsoft.VisualStudio.TestPlatform.ObjectModel (2)

Nuget.Frameworks\FrameworkReducer.cs (1)

400if (pair.Value.Contains(nearestForSub, NuGetFrameworkFullComparer.Instance))

TraitCollection.cs (1)

68if (!_testObject.Properties.Contains(TraitsProperty, EqualityComparer<TestProperty>.Default))

NuGet.CommandLine.XPlat (1)

Commands\Package\Update\PackageUpdateIO.cs (1)

354sourceMappedSources.AddRange(_enabledSources.Where(ps => allowedSources.Contains(ps.Name, StringComparer.OrdinalIgnoreCase)));

NuGet.Commands (5)

RestoreCommand\Diagnostics\UnexpectedDependencyMessages.cs (2)

78.Where(e => !ignoreIds.Contains(e.Child.Name, StringComparer.OrdinalIgnoreCase) 149if (ignoreIds.Contains(dependency.Name, StringComparer.OrdinalIgnoreCase)

RestoreCommand\Utility\MSBuildRestoreUtility.cs (3)

380return (values?.Contains(Clear, StringComparer.OrdinalIgnoreCase) == true); 625.Contains(dependency.Name, StringComparer.OrdinalIgnoreCase)) 855.Contains(frameworkReference, ComparisonUtility.FrameworkReferenceNameComparer))

NuGet.Frameworks (1)

FrameworkReducer.cs (1)

400if (pair.Value.Contains(nearestForSub, NuGetFrameworkFullComparer.Instance))

NuGet.PackageManagement (3)

PackageDownloader.cs (1)

134!configuredPackageSources.Contains(source.PackageSource.Name, StringComparer.OrdinalIgnoreCase))

Projects\MSBuildNuGetProject.cs (1)

626Constants.AssemblyReferencesExtensions.Contains(Path.GetExtension(filePath), StringComparer.OrdinalIgnoreCase);

Resolution\ResolverGather.cs (1)

570!configuredPackageSources.Contains(source.Source.PackageSource.Name, StringComparer.OrdinalIgnoreCase))

NuGet.Packaging (7)

PackageCreation\Authoring\ManifestSchemaUtility.cs (1)

120return VersionToSchemaMappings.Contains(schemaNamespace, StringComparer.OrdinalIgnoreCase);

PackageFileExtractor.cs (3)

47if (refAndLibFiles.Contains(dllFile, StringComparer.OrdinalIgnoreCase)) 55if (refAndLibFiles.Contains(resourceDll, StringComparer.OrdinalIgnoreCase)) 63if (languageDllFile != null && refAndLibFiles.Contains(languageDllFile, StringComparer.Ordinal))

PackageReaderExtensions.cs (1)

41.Contains(packageLanguage, StringComparer.OrdinalIgnoreCase));

Signing\Utility\SignatureUtility.cs (1)

524if (!signingSpecifications.AllowedHashAlgorithmOids.Contains(

Signing\Verification\IntegrityVerificationProvider.cs (1)

28if (validHashOids.Contains(signatureHashOid, StringComparer.InvariantCultureIgnoreCase))

NuGet.ProjectModel (1)

LockFile\LockFileExtensions.cs (1)

36return assetsFile.Targets.Where(target => message.TargetGraphs.Contains(target.TargetAlias + (string.IsNullOrEmpty(target.RuntimeIdentifier) ? "" : "/" + target.RuntimeIdentifier), StringComparer.OrdinalIgnoreCase));

NuGet.Protocol (20)

ProviderComparer.cs (20)

NuGet.Resolver (7)

PackageResolver.cs (1)

134if (!context.RequiredPackageIds.Contains(group.Key, StringComparer.OrdinalIgnoreCase))

ResolverComparer.cs (3)

76var xInstalled = _preferredVersions.Contains(x, _identityComparer); 77var yInstalled = _preferredVersions.Contains(y, _identityComparer); 106if (_targetIds.Contains(x.Id, StringComparer.OrdinalIgnoreCase))

ResolverInputSort.cs (2)

113if (context.TargetIds.Contains(id, StringComparer.OrdinalIgnoreCase)) 119if (context.PackagesConfig.Select(package => package.PackageIdentity.Id).Contains(id, StringComparer.OrdinalIgnoreCase))

ResolverUtility.cs (1)

314var dependencyPackages = packages.Where(package => dependencyIds.Contains(package.Id, StringComparer.OrdinalIgnoreCase));

Roslyn.Diagnostics.Analyzers (2)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

138=> GenerateUniqueName(baseName, x => !names.Contains(x, comparer));

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

159namedType.GetBaseTypesAndThis().Any(b => SymbolTypesWithExpectedSymbolDeclaredEvent.Contains(b.Name, StringComparer.Ordinal)))

System.CommandLine (1)

ArgumentValidation.cs (1)

167if (!values.Contains(token.Value, comparer))

System.Text.Json.SourceGeneration (1)

Helpers\RoslynExtensions.cs (1)

134if (type.AllInterfaces.Contains(baseType, SymbolEqualityComparer.Default))