new

src\Shared\ColorGenerator.cs (1)

65_colorIndexByKey = new ConcurrentDictionary<string, Lazy<int>>(StringComparer.OrdinalIgnoreCase);

Components\Dialogs\ManageDataDialog.razor.cs (1)

59private readonly ConcurrentDictionary<string, ResourceViewModel> _resourceByName = new(StringComparers.ResourceName);

Components\Pages\ConsoleLogs.razor.cs (2)

145private readonly ConcurrentDictionary<string, ResourceViewModel> _resourceByName = new(StringComparers.ResourceName); 155private readonly ConcurrentDictionary<string, ConsoleLogsSubscription> _consoleLogsSubscriptions = new(StringComparers.ResourceName);

Components\Pages\Resources.razor.cs (4)

117private readonly ConcurrentDictionary<string, ResourceViewModel> _resourceByName = new(StringComparers.ResourceName); 925public ConcurrentDictionary<string, bool> ResourceTypesToVisibility { get; } = new(StringComparers.ResourceName); 926public ConcurrentDictionary<string, bool> ResourceStatesToVisibility { get; } = new(StringComparers.ResourceState); 927public ConcurrentDictionary<string, bool> ResourceHealthStatusesToVisibility { get; } = new(StringComparer.Ordinal);

Model\ResourceOutgoingPeerResolver.cs (1)

21private readonly ConcurrentDictionary<string, ResourceViewModel> _resourceByName = new(StringComparers.ResourceName);

Otlp\Model\OtlpResource.cs (1)

50private readonly ConcurrentDictionary<KeyValuePair<string, string>[], OtlpResourceView> _resourceViews = new(ResourceViewKeyComparer.Instance);

src\Shared\ColorGenerator.cs (1)

65_colorIndexByKey = new ConcurrentDictionary<string, Lazy<int>>(StringComparer.OrdinalIgnoreCase);

ApplicationModel\RequiredCommandValidator.cs (1)

25private readonly ConcurrentDictionary<string, CommandValidationState> _commandStates = new(StringComparer.OrdinalIgnoreCase);

Dashboard\DashboardEventHandlers.cs (1)

790var loggerCache = new ConcurrentDictionary<string, ILogger>(StringComparer.Ordinal);

AspireExportAnalyzer.cs (1)

110var reportedParameters = new ConcurrentDictionary<string, byte>(StringComparer.Ordinal);

Utilities\ProjectFileReader.cs (1)

16private static readonly ConcurrentDictionary<string, Dictionary<string, string?>> s_projectCache = new(StringComparer.OrdinalIgnoreCase);

AtsCapabilityScanner.cs (1)

2654private static readonly ConcurrentDictionary<string, XDocument?> s_xmlDocCache = new(StringComparer.Ordinal);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (1)

30: base(keyComparer)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(StringComparer.Ordinal);

Compiler\DependencyAnalysis\NodeFactory.cs (1)

167_cache = new ConcurrentDictionary<TKey, TValue>(comparer);

Compiler\DependencyAnalysis\ReadyToRunCodegenNodeFactory.cs (1)

37_cache = new ConcurrentDictionary<TKey, TValue>(comparer);

Reflection\ComponentProperties.cs (1)

295_referenceEqualityWritersCache = new ConcurrentDictionary<string, PropertySetter?>(ReferenceEqualityComparer.Instance);

StateHasChangedAnalyzer.cs (2)

52var eventHandlerMethods = new ConcurrentDictionary<IMethodSymbol, byte>(SymbolEqualityComparer.Default); 53var redundantCallLocationsByMethod = new ConcurrentDictionary<IMethodSymbol, ImmutableArray<Location>>(SymbolEqualityComparer.Default);

CacheView\CacheViewKeyResolver.cs (1)

18private static readonly ConcurrentDictionary<string, string[]> _sortedNamesByRawValue = new(StringComparer.Ordinal);

CacheView\MemoryCacheViewStore.cs (1)

15private readonly ConcurrentDictionary<string, Task<SerializedRenderFragment>> _pending = new(StringComparer.Ordinal);

ProtectedBrowserStorage\ProtectedBrowserStorage.cs (1)

21= new ConcurrentDictionary<string, IDataProtector>(StringComparer.Ordinal);

Internal\HttpConnectionManager.cs (1)

23new ConcurrentDictionary<string, HttpConnectionContext>(StringComparer.Ordinal);

Compilation\DefaultViewCompiler.cs (1)

32_normalizedPathCache = new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

RuntimeViewCompiler.cs (1)

53_normalizedPathCache = new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

JavaScriptResources.cs (1)

18new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

CachedExpressionCompiler.cs (1)

38new ConcurrentDictionary<MemberExpressionCacheKey, Func<TModel, object>>(MemberExpressionCacheKeyComparer.Instance);

ModelExpressionProvider.cs (1)

27_expressionTextCache = new ConcurrentDictionary<LambdaExpression, string>(LambdaExpressionComparer.Instance);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

HubConnection.cs (1)

86private readonly ConcurrentDictionary<string, InvocationHandlerList> _handlers = new ConcurrentDictionary<string, InvocationHandlerList>(StringComparer.Ordinal);

HubConnectionContext.cs (1)

249internal ConcurrentDictionary<string, CancellationTokenSource> ActiveRequestCancellationSources { get; } = new ConcurrentDictionary<string, CancellationTokenSource>(StringComparer.Ordinal);

HubConnectionStore.cs (1)

18new ConcurrentDictionary<string, HubConnectionContext>(StringComparer.Ordinal);

Internal\HubGroupList.cs (1)

12new ConcurrentDictionary<string, GroupConnectionList>(StringComparer.Ordinal);

Internal\RedisSubscriptionManager.cs (1)

10private readonly ConcurrentDictionary<string, HubConnectionStore> _subscriptions = new ConcurrentDictionary<string, HubConnectionStore>(StringComparer.Ordinal);

BackEnd\BuildManager\BuildManager.cs (1)

57internal static ConcurrentDictionary<ProjectCacheDescriptor, ProjectCacheDescriptor> ProjectCacheDescriptors { get; } = new(ProjectCacheDescriptorEqualityComparer.Instance);

BackEnd\Components\ProjectCache\ProjectCacheService.cs (1)

51private readonly ConcurrentDictionary<ProjectCacheDescriptor, Lazy<Task<ProjectCachePlugin>>> _projectCachePlugins = new(ProjectCacheDescriptorEqualityComparer.Instance);

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

55_ => new ConcurrentDictionary<string, Lazy<SdkResult>>(MSBuildNameIgnoreCaseComparer.Default));

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

32private readonly ConcurrentDictionary<string, Lazy<SdkResult>> _responseCache = new ConcurrentDictionary<string, Lazy<SdkResult>>(MSBuildNameIgnoreCaseComparer.Default);

BuildCheck\Infrastructure\ConfigurationProvider.cs (3)

23private readonly ConcurrentDictionary<string, CheckConfiguration> _checkConfiguration = new ConcurrentDictionary<string, CheckConfiguration>(StringComparer.InvariantCultureIgnoreCase); 28private readonly ConcurrentDictionary<string, Dictionary<string, string>> _editorConfigData = new ConcurrentDictionary<string, Dictionary<string, string>>(StringComparer.InvariantCultureIgnoreCase); 33private readonly ConcurrentDictionary<string, CustomConfigurationData> _customConfigurationData = new ConcurrentDictionary<string, CustomConfigurationData>(StringComparer.InvariantCultureIgnoreCase);

BuildCheck\Infrastructure\EditorConfig\EditorConfigParser.cs (1)

25private readonly ConcurrentDictionary<string, EditorConfigFile> _editorConfigFileCache = new ConcurrentDictionary<string, EditorConfigFile>(StringComparer.InvariantCultureIgnoreCase);

Definition\ProjectCollection.cs (1)

129private readonly ConcurrentDictionary<string, LockType> _loadProjectLocks = new(StringComparer.OrdinalIgnoreCase);

Evaluation\ConditionEvaluator.cs (3)

243_ => new ExpressionTreeForCurrentOptionsWithSize(new ConcurrentDictionary<string, Stack<GenericExpressionNode>>(StringComparer.Ordinal))); 327new ConcurrentDictionary<string, Stack<GenericExpressionNode>>(StringComparer.Ordinal)), 334new ConcurrentDictionary<string, Stack<GenericExpressionNode>>(StringComparer.Ordinal));

Evaluation\ParserIgnoreConfiguration.cs (1)

54private readonly ConcurrentDictionary<string, int> _skippedItems = new(StringComparer.OrdinalIgnoreCase);

Evaluation\ProjectRootElementCache.cs (1)

156_fileLoadLocks = new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase);

Evaluation\SimpleProjectRootElementCache.cs (1)

32_cache = new ConcurrentDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase);

Graph\ParallelWorkSet.cs (1)

88_inProgressOrCompletedWork = new ConcurrentDictionary<TKey, WorkItem>(comparer);

Instance\TaskRegistry.cs (3)

130new(RegisteredTaskIdentity.RegisteredTaskIdentityComparer.Exact); 138private readonly ConcurrentDictionary<string, ConcurrentDictionary<RegisteredTaskIdentity, RegisteredTaskRecord>> _cachedTaskRecordsWithFuzzyMatch = new(StringComparer.OrdinalIgnoreCase); 629_ => new(RegisteredTaskIdentity.RegisteredTaskIdentityComparer.Exact));

Resources\Constants.cs (1)

313var availableStaticMethods = new ConcurrentDictionary<string, Tuple<string, Type>>(StringComparer.OrdinalIgnoreCase);

src\msbuild\src\Shared\TypeLoader.cs (2)

450_typeNameToType = new(StringComparer.OrdinalIgnoreCase); 452_publicTypeNameToLoadedType = new(StringComparer.OrdinalIgnoreCase);

Utilities\EngineFileUtilities.cs (1)

593private static readonly Lazy<ConcurrentDictionary<string, bool>> _regexMatchCache = new Lazy<ConcurrentDictionary<string, bool>>(() => new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase));

FileUtilities.cs (1)

141private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

ImmutableFilesTimestampCache.cs (1)

17private readonly ConcurrentDictionary<string, DateTime> _cache = new(StringComparer.OrdinalIgnoreCase);

ItemSpecModifiers.cs (1)

98new(StringComparer.OrdinalIgnoreCase);

TaskClassRegistry.cs (1)

45private static readonly ConcurrentDictionary<string, TaskClassRegistration> s_tasksByName = new(StringComparer.OrdinalIgnoreCase);

TaskParameterTypeRegistry.cs (1)

49private static readonly ConcurrentDictionary<string, Type> s_typesByName = new(StringComparer.OrdinalIgnoreCase);

Utilities\FileMatcher.cs (3)

147private static readonly Lazy<ConcurrentDictionary<string, IReadOnlyList<string>>> s_cachedGlobExpansions = new(() => new ConcurrentDictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal)); 148private static readonly Lazy<ConcurrentDictionary<string, object>> s_cachedGlobExpansionsLock = new(() => new ConcurrentDictionary<string, object>(StringComparer.Ordinal)); 154private readonly Lazy<ConcurrentDictionary<string, object>> _cachedGlobExpansionsLock = new(() => new ConcurrentDictionary<string, object>(StringComparer.Ordinal));

GlobalJsonReader.cs (1)

36private static readonly ConcurrentDictionary<FileInfo, (DateTime LastWriteTime, Lazy<Dictionary<string, string>> Lazy)> FileCache = new ConcurrentDictionary<FileInfo, (DateTime, Lazy<Dictionary<string, string>>)>(FileSystemInfoFullNameEqualityComparer.Instance);

BootstrapperUtil\Util.cs (1)

33private static readonly ConcurrentDictionary<string, string> s_defaultPathByVersion = new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

GetSDKReferenceFiles.cs (3)

54private readonly ConcurrentDictionary<string, SDKInfo> _cacheFileForSDKs = new ConcurrentDictionary<string, SDKInfo>(StringComparer.OrdinalIgnoreCase); 995var references = new ConcurrentDictionary<string, SdkReferenceInfo>(StringComparer.OrdinalIgnoreCase); 996var directoryToFileList = new ConcurrentDictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

RedistList.cs (5)

52private readonly ConcurrentDictionary<AssemblyNameExtension, bool> _assemblyNameInRedist = new ConcurrentDictionary<AssemblyNameExtension, bool>(AssemblyNameComparer.GenericComparer); 57private readonly ConcurrentDictionary<string, AssemblyEntry> _assemblyNameToUnifiedAssemblyName = new ConcurrentDictionary<string, AssemblyEntry>(StringComparer.OrdinalIgnoreCase); 62private readonly ConcurrentDictionary<string, AssemblyNameExtension> _assemblyNameToAssemblyNameExtension = new ConcurrentDictionary<string, AssemblyNameExtension>(StringComparer.OrdinalIgnoreCase); 68private readonly ConcurrentDictionary<AssemblyNameExtension, AssemblyNameExtension> _remappingCache = new ConcurrentDictionary<AssemblyNameExtension, AssemblyNameExtension>(AssemblyNameComparer.GenericComparerConsiderRetargetable); 71private readonly ConcurrentDictionary<string, Dictionary<string, string>> _cachedDenyList = new ConcurrentDictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);

SystemState.cs (1)

73private static readonly ConcurrentDictionary<string, FileState> s_processWideFileStateCache = new ConcurrentDictionary<string, FileState>(StringComparer.OrdinalIgnoreCase);

CodeGen\ItemTokenMap.cs (1)

21private readonly ConcurrentDictionary<T, uint> _itemToToken = new ConcurrentDictionary<T, uint>(ReferenceEqualityComparer.Instance);

CodeGen\PrivateImplementationDetails.cs (3)

72new ConcurrentDictionary<(ImmutableArray<byte> Data, ushort Alignment), MappedField>(DataAndUShortEqualityComparer.Instance); 76new ConcurrentDictionary<(ImmutableArray<byte> Data, ushort ElementType), CachedArrayField>(DataAndUShortEqualityComparer.Instance); 80new ConcurrentDictionary<(ImmutableArray<ConstantValue> Constants, ushort ElementType), CachedArrayField>(ConstantValueAndUShortEqualityComparer.Instance);

CodeGen\StringTokenMap.cs (1)

20private readonly ConcurrentDictionary<string, uint> _valueToToken = new ConcurrentDictionary<string, uint>(StringComparer.Ordinal);

CommandLine\AnalyzerConfigSet.cs (1)

48new ConcurrentDictionary<ReadOnlyMemory<char>, string>(CharMemoryEqualityComparer.Instance);

DiagnosticAnalyzer\ShadowCopyAnalyzerPathResolver.cs (3)

32private static readonly ConcurrentDictionary<string, DirectoryCleanupState> s_directoryCleanupStates = new(AnalyzerAssemblyLoader.OriginalPathComparer); 77private ConcurrentDictionary<string, int> OriginalDirectoryMap { get; } = new(AnalyzerAssemblyLoader.OriginalPathComparer); 84private ConcurrentDictionary<string, Task<string>> CopyMap { get; } = new(AnalyzerAssemblyLoader.OriginalPathComparer);

DiagnosticAnalyzer\SuppressMessageAttributeState.cs (1)

49private readonly ConcurrentDictionary<string, FrozenDictionary<ISymbol, SuppressMessageInfo>> _lazyResolvedSuppressionsById = new ConcurrentDictionary<string, FrozenDictionary<ISymbol, SuppressMessageInfo>>(StringComparer.Ordinal);

Emit\CommonPEModuleBuilder.cs (2)

72_methodBodyMap = new ConcurrentDictionary<IMethodSymbolInternal, Cci.IMethodBody>(ReferenceEqualityComparer.Instance); 950new ConcurrentDictionary<TNamedTypeSymbol, SynthesizedDefinitions>(ReferenceEqualityComparer.Instance);

Emit\DebugDocumentsBuilder.cs (1)

28_debugDocuments = new ConcurrentDictionary<string, Cci.DebugSourceDocument>(

Emit\NoPia\EmbeddedTypesManager.cs (5)

69public readonly ConcurrentDictionary<TNamedTypeSymbol, TEmbeddedType> EmbeddedTypesMap = new ConcurrentDictionary<TNamedTypeSymbol, TEmbeddedType>(ReferenceEqualityComparer.Instance); 70public readonly ConcurrentDictionary<TFieldSymbol, TEmbeddedField> EmbeddedFieldsMap = new ConcurrentDictionary<TFieldSymbol, TEmbeddedField>(ReferenceEqualityComparer.Instance); 71public readonly ConcurrentDictionary<TMethodSymbol, TEmbeddedMethod> EmbeddedMethodsMap = new ConcurrentDictionary<TMethodSymbol, TEmbeddedMethod>(ReferenceEqualityComparer.Instance); 72public readonly ConcurrentDictionary<TPropertySymbol, TEmbeddedProperty> EmbeddedPropertiesMap = new ConcurrentDictionary<TPropertySymbol, TEmbeddedProperty>(ReferenceEqualityComparer.Instance); 73public readonly ConcurrentDictionary<TEventSymbol, TEmbeddedEvent> EmbeddedEventsMap = new ConcurrentDictionary<TEventSymbol, TEmbeddedEvent>(ReferenceEqualityComparer.Instance);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (1)

30: base(keyComparer)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(StringComparer.Ordinal);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (1)

30: base(keyComparer)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(StringComparer.Ordinal);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

Compilation\CSharpCompilation.cs (1)

2561() => new ConcurrentDictionary<(ImmutableArray<byte> ContentHash, int Position), OneOrMany<(Location AttributeLocation, MethodSymbol Interceptor)>>(comparer: InterceptorKeyComparer.Instance));

Compiler\ClsComplianceChecker.cs (1)

52_declaredOrInheritedCompliance = new ConcurrentDictionary<Symbol, Compliance>(Symbols.SymbolEqualityComparer.ConsiderEverything);

Compiler\MethodCompiler.cs (1)

2152identifierMap = new ConcurrentDictionary<IdentifierNameSyntax, int>(ReferenceEqualityComparer.Instance);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

121private readonly ConcurrentDictionary<Symbol, Symbol?> _matches = new(ReferenceEqualityComparer.Instance); 129private readonly ConcurrentDictionary<ISymbolInternal, IReadOnlyDictionary<string, ImmutableArray<ISymbolInternal>>> _otherMembers = new(ReferenceEqualityComparer.Instance); 858_matches = new ConcurrentDictionary<Symbol, Symbol>(ReferenceEqualityComparer.Instance);

Emitter\Model\PEModuleBuilder.cs (2)

32private readonly ConcurrentDictionary<Symbol, object> _genericInstanceMap = new ConcurrentDictionary<Symbol, object>(Symbols.SymbolEqualityComparer.ConsiderEverything); 34new ConcurrentDictionary<ImportChain, ImmutableArray<Cci.UsedNamespaceOrType>>(ReferenceEqualityComparer.Instance);

Emitter\NoPia\EmbeddedTypesManager.cs (2)

38private readonly ConcurrentDictionary<AssemblySymbol, string> _assemblyGuidMap = new ConcurrentDictionary<AssemblySymbol, string>(ReferenceEqualityComparer.Instance); 39private readonly ConcurrentDictionary<Symbol, bool> _reportedSymbolsMap = new ConcurrentDictionary<Symbol, bool>(ReferenceEqualityComparer.Instance);

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

494Interlocked.CompareExchange(ref uncommon.LazyImplementationMap, new ConcurrentDictionary<MethodSymbol, MethodSymbol?>(ReferenceEqualityComparer.Instance), null);

Symbols\Source\SourceAssemblySymbol.cs (1)

2309new ConcurrentDictionary<string, ConcurrentDictionary<ImmutableArray<byte>, Tuple<Location, String>>>(StringComparer.OrdinalIgnoreCase), null);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (1)

49private readonly ConcurrentDictionary<string, (MetadataAsSourceGeneratedFileInfo Metadata, DocumentId DocumentId)> _generatedFilenameToInformation = new(StringComparer.OrdinalIgnoreCase);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

67private readonly ConcurrentDictionary<string, SourceDocumentInfo> _fileToDocumentInfoMap = new(StringComparer.OrdinalIgnoreCase);

Microsoft.NetCore.Analyzers\Performance\PreferReadOnlySpanOverSpan.cs (2)

74ConcurrentDictionary<IParameterSymbol, int> parameterReferenceCounts = new(SymbolEqualityComparer.Default); 79candidateParameters ??= new ConcurrentDictionary<IParameterSymbol, INamedTypeSymbol>(SymbolEqualityComparer.Default);

Microsoft.NetCore.Analyzers\Performance\UseConcreteTypeAnalyzer.Collector.cs (10)

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (1)

28: base(keyComparer)

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(StringComparer.Ordinal);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (1)

30: base(keyComparer)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(StringComparer.Ordinal);

Symbols\EmbeddedSymbols\EmbeddedSymbolManager.SymbolsCollection.vb (1)

45_symbols = New ConcurrentDictionary(Of Symbol, Boolean)(ReferenceEqualityComparer.Instance)

FindSymbols\FindReferences\FindReferenceCache.cs (1)

85_identifierCache = new(comparer: semanticModel.Language switch

src\roslyn\src\Compilers\Core\Portable\DiagnosticAnalyzer\ShadowCopyAnalyzerPathResolver.cs (3)

32private static readonly ConcurrentDictionary<string, DirectoryCleanupState> s_directoryCleanupStates = new(AnalyzerAssemblyLoader.OriginalPathComparer); 77private ConcurrentDictionary<string, int> OriginalDirectoryMap { get; } = new(AnalyzerAssemblyLoader.OriginalPathComparer); 84private ConcurrentDictionary<string, Task<string>> CopyMap { get; } = new(AnalyzerAssemblyLoader.OriginalPathComparer);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

Workspace\Solution\SolutionState.cs (1)

73private readonly ConcurrentDictionary<string, ImmutableArray<DocumentId>> _lazyFilePathToRelatedDocumentIds = new(FilePathComparer);

BuildService.cs (1)

78private readonly ConcurrentDictionary<string, Microsoft.Build.Construction.ProjectRootElement> _projectRootElements = new(StringComparer.OrdinalIgnoreCase);

PhysicalFilesWatcher.cs (2)

31private readonly ConcurrentDictionary<string, ChangeTokenInfo> _filePathTokenLookup = new(StringComparer.OrdinalIgnoreCase); 32private readonly ConcurrentDictionary<string, ChangeTokenInfo> _wildcardTokenLookup = new(StringComparer.OrdinalIgnoreCase);

DefaultHttpClientFactory.cs (1)

79_activeHandlers = new ConcurrentDictionary<string, Lazy<ActiveHandlerTrackingEntry>>(StringComparer.Ordinal);

LoggerFactory.cs (1)

23private readonly ConcurrentDictionary<string, Logger> _loggers = new ConcurrentDictionary<string, Logger>(StringComparer.Ordinal);

ConsoleLoggerProvider.cs (1)

100var cd = new ConcurrentDictionary<string, ConsoleFormatter>(StringComparer.OrdinalIgnoreCase);

TraceSourceLoggerProvider.cs (1)

20private readonly ConcurrentDictionary<string, DiagnosticsTraceSource> _sources = new ConcurrentDictionary<string, DiagnosticsTraceSource>(StringComparer.OrdinalIgnoreCase);

Analyzers\ValidationsDiagnosticAnalyzer.cs (2)

178var topLevelValidatableTypes = new ConcurrentDictionary<ITypeSymbol, byte>(SymbolEqualityComparer.Default); 179var endpointParameters = new ConcurrentDictionary<IParameterSymbol, byte>(SymbolEqualityComparer.Default);

Analyzers\ComInterfaceGeneratorDiagnosticsAnalyzer.cs (1)

85var interfaceInfoCache = new ConcurrentDictionary<INamedTypeSymbol, DiagnosticOr<(ComInterfaceInfo, INamedTypeSymbol)>>(SymbolEqualityComparer.Default);

BaseTestClassAnalyzer.cs (1)

55private readonly ConcurrentDictionary<INamedTypeSymbol, bool> _knownTestAttributes = new ConcurrentDictionary<INamedTypeSymbol, bool>(SymbolEqualityComparer.Default);

RelaxTestNamingSuppressor.cs (1)

31var knownTestAttributes = new ConcurrentDictionary<INamedTypeSymbol, bool>(SymbolEqualityComparer.Default);

Model\TiktokenTokenizer.cs (1)

1291private static readonly ConcurrentDictionary<string, (Dictionary<ReadOnlyMemory<byte>, int> encoder, Dictionary<StringSpanOrdinalKey, (int Id, string Token)> vocab, Dictionary<int, ReadOnlyMemory<byte>> decoder)> _tiktokenCache = new(StringComparer.OrdinalIgnoreCase);

LocalDaemons\ContainerRuntimeOperations.cs (1)

20private readonly ConcurrentDictionary<string, string> _commandPaths = new(StringComparer.Ordinal);

src\sdk\src\Tasks\Common\FileUtilities.cs (1)

13= new(StringComparer.OrdinalIgnoreCase);

src\sdk\src\Tasks\Common\FileUtilities.MetadataReader.cs (1)

23private static readonly ConcurrentDictionary<string, (DateTime LastKnownWriteTimeUtc, Version? Version)> s_versionCache = new(StringComparer.OrdinalIgnoreCase /* Not strictly correct on *nix. Fix? */);

src\sdk\src\Tasks\Common\FileUtilities.cs (1)

13= new(StringComparer.OrdinalIgnoreCase);

src\sdk\src\Tasks\Common\FileUtilities.MetadataReader.cs (1)

23private static readonly ConcurrentDictionary<string, (DateTime LastKnownWriteTimeUtc, Version? Version)> s_versionCache = new(StringComparer.OrdinalIgnoreCase /* Not strictly correct on *nix. Fix? */);

ReflectionLoadProbingPath.cs (1)

15private static readonly ConcurrentDictionary<string, Assembly?> LoadedAssemblies = new ConcurrentDictionary<string, Assembly?>(StringComparer.OrdinalIgnoreCase);

Helpers\MicrosoftTestingPlatformDetector.cs (1)

31private static readonly ConcurrentDictionary<string, bool> Cache = new(StringComparer.OrdinalIgnoreCase);

src\msbuild\src\Shared\TypeLoader.cs (2)

450_typeNameToType = new(StringComparer.OrdinalIgnoreCase); 452_publicTypeNameToLoadedType = new(StringComparer.OrdinalIgnoreCase);

MSBuildStaticGraphRestore.cs (2)

986var projectPathLookup = new ConcurrentDictionary<string, string>(uniqueNameComparer); 1286var projects = new ConcurrentDictionary<string, TProject>(PathUtility.GetStringComparerBasedOnOS());

RestoreProjectAdapter.cs (1)

22_targetFrameworks = new(StringComparer.OrdinalIgnoreCase);

RestoreCommand\DependencyGraphResolver.DependencyGraphItemIndexer.cs (2)

60private readonly ConcurrentDictionary<string, LibraryDependencyIndex> _libraryDependencyTable = new ConcurrentDictionary<string, LibraryDependencyIndex>(StringComparer.OrdinalIgnoreCase); 65private readonly ConcurrentDictionary<LibraryRange, LibraryRangeIndex> _libraryRangeTable = new(LibraryRangeComparer.Instance);

RestoreCommand\RequestFactory\RestoreArgs.cs (2)

75= new ConcurrentDictionary<string, ISettings>(StringComparer.Ordinal); 79= new ConcurrentDictionary<string, List<SourceRepository>>(StringComparer.Ordinal);

RestoreCommand\RestoreCommand.cs (1)

35private static readonly ConcurrentDictionary<NuGetFramework, string> _frameworkShortNameCache = new(NuGetFrameworkFullComparer.Instance);

RestoreCommand\RestoreCommandProvidersCache.cs (2)

24= new ConcurrentDictionary<string, IRemoteDependencyProvider>(PathUtility.GetStringComparerBasedOnOS()); 27= new ConcurrentDictionary<string, NuGetv3LocalRepository>(PathUtility.GetStringComparerBasedOnOS());

src\nuget-client\build\Shared\TaskResultCache.cs (2)

36_cache = new(comparer); 37_perTaskLock = new(comparer);

Settings\SettingsLoadingContext.cs (1)

17private readonly ConcurrentDictionary<string, Lazy<SettingsFile>> _cache = new ConcurrentDictionary<string, Lazy<SettingsFile>>(PathUtility.GetStringComparerBasedOnOS());

src\nuget-client\build\Shared\TaskResultCache.cs (2)

36_cache = new(comparer); 37_perTaskLock = new(comparer);

LibraryType.cs (1)

11private static ConcurrentDictionary<string, LibraryType> _knownLibraryTypes = new ConcurrentDictionary<string, LibraryType>(StringComparer.OrdinalIgnoreCase);

Resolution\ResolverGather.cs (1)

35private readonly ConcurrentDictionary<string, TimeSpan> _timeTaken = new ConcurrentDictionary<string, TimeSpan>(StringComparer.OrdinalIgnoreCase);

RuntimeModel\RuntimeGraph.cs (1)

72_expandCache = new(StringComparer.Ordinal);

LockFile\BuildAction.cs (1)

13private static ConcurrentDictionary<string, BuildAction> _knownBuildActions = new ConcurrentDictionary<string, BuildAction>(StringComparer.OrdinalIgnoreCase);

CachingSourceProvider.cs (1)

25= new ConcurrentDictionary<string, SourceRepository>(StringComparer.Ordinal);

LegacyFeed\ODataServiceDocumentResourceV2Provider.cs (1)

30_cache = new ConcurrentDictionary<string, ODataServiceDocumentCacheInfo>(StringComparer.OrdinalIgnoreCase);

LocalRepositories\LocalV2FindPackageByIdResource.cs (1)

31= new ConcurrentDictionary<string, IReadOnlyList<LocalPackageInfo>>(StringComparer.OrdinalIgnoreCase);

LocalRepositories\LocalV3FindPackageByIdResource.cs (1)

31= new ConcurrentDictionary<string, List<NuGetVersion>>(StringComparer.OrdinalIgnoreCase);

PackagesFolder\LocalPackageFileCache.cs (6)

25= new ConcurrentDictionary<string, Lazy<NuspecReader>>(PathUtility.GetStringComparerBasedOnOS()); 29= new ConcurrentDictionary<string, Lazy<IReadOnlyList<string>>>(PathUtility.GetStringComparerBasedOnOS()); 33= new ConcurrentDictionary<string, Lazy<string>>(PathUtility.GetStringComparerBasedOnOS()); 37= new ConcurrentDictionary<string, bool>(PathUtility.GetStringComparerBasedOnOS()); 41= new ConcurrentDictionary<string, Lazy<RuntimeGraph?>>(PathUtility.GetStringComparerBasedOnOS()); 45= new ConcurrentDictionary<string, bool>(PathUtility.GetStringComparerBasedOnOS());

PackagesFolder\NuGetv3LocalRepository.cs (3)

24= new ConcurrentDictionary<string, LocalPackageInfo>(PathUtility.GetStringComparerBasedOnOS()); 28= new ConcurrentDictionary<string, List<LocalPackageInfo>>(StringComparer.OrdinalIgnoreCase); 32= new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase);

Plugins\PluginManager.cs (1)

350_pluginUtilities = new ConcurrentDictionary<string, Lazy<IPluginMulticlientUtilities>>(

Plugins\PluginPackageReader.cs (1)

71_fileStreams = new ConcurrentDictionary<string, Lazy<Task<FileStreamCreator?>>>(StringComparer.OrdinalIgnoreCase);

Providers\ServiceIndexResourceV3Provider.cs (1)

46_cache = new ConcurrentDictionary<string, ServiceIndexCacheInfo>(StringComparer.OrdinalIgnoreCase);

RemoteRepositories\HttpFileSystemBasedFindPackageByIdResource.cs (1)

42new ConcurrentDictionary<string, AsyncLazy<HashSet<NuGetVersion>?>>(StringComparer.OrdinalIgnoreCase);

RemoteRepositories\PluginFindPackageByIdResource.cs (1)

29new ConcurrentDictionary<string, AsyncLazy<SortedDictionary<NuGetVersion, PackageInfo>>>(StringComparer.OrdinalIgnoreCase);

src\nuget-client\build\Shared\TaskResultCache.cs (2)

36_cache = new(comparer); 37_perTaskLock = new(comparer);

MS\Internal\AppModel\DefaultCredentialsZonePolicy.cs (1)

148new(StringComparer.OrdinalIgnoreCase);

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

112private readonly ConcurrentDictionary<object, AllocationInfo> _outstanding = new ConcurrentDictionary<object, AllocationInfo>(ReferenceEqualityComparer.Instance);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (1)

30: base(keyComparer)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(StringComparer.Ordinal);

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

37Interlocked.CompareExchange(ref s_nameToCodePage, new(StringComparer.OrdinalIgnoreCase), null);

System\Security\Cryptography\CryptoConfig.cs (2)

42private static readonly ConcurrentDictionary<string, Type> appNameHT = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 43private static readonly ConcurrentDictionary<string, string> appOidHT = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

16new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);

System\Text\EncodingTable.cs (1)

11private static readonly ConcurrentDictionary<string, int> s_nameToCodePageCache = new(StringComparer.OrdinalIgnoreCase);

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

66_nameCacheForReading = new(StringComparer.Ordinal);

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

80_cachedTypes ??= new(StringComparer.Ordinal);

System\Windows\Forms\Controls\GroupBox\GroupBox.Modern.cs (1)

18new(StringComparer.OrdinalIgnoreCase);