ConcurrentDictionary

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

58private readonly ConcurrentDictionary<IParameterSymbol, bool> _referencedParameters;

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (2)

36private readonly ConcurrentDictionary<IMethodSymbol, bool> _methodsUsedAsDelegates = []; 45private readonly ConcurrentDictionary<IParameterSymbol, bool> _unusedParameters = [];

src\Analyzers\Core\Analyzers\SimplifyTypeNames\SimplifyTypeNamesDiagnosticAnalyzerBase.cs (1)

209private readonly ConcurrentDictionary<SyntaxTree, (StrongBox<bool> completed, TextSpanMutableIntervalTree? intervalTree)> _codeBlockIntervals = [];

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (12)

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

115var reducedNodesMap = new ConcurrentDictionary<SyntaxNode, SyntaxNode>(); 116var reducedTokensMap = new ConcurrentDictionary<SyntaxToken, SyntaxToken>(); 156ConcurrentDictionary<SyntaxNode, SyntaxNode> reducedNodesMap, 157ConcurrentDictionary<SyntaxToken, SyntaxToken> reducedTokensMap,

Binder\InMethodBinder.cs (1)

38public ConcurrentDictionary<IdentifierNameSyntax, int> IdentifierMap;

BoundTree\UnboundLambda.cs (2)

525Constraint = "Avoid " + nameof(ConcurrentDictionary<(NamedTypeSymbol, bool), BoundLambda>) + " which has a large default size, but this cache is normally small.")] 530Constraint = "Avoid " + nameof(ConcurrentDictionary<ReturnInferenceCacheKey, BoundLambda>) + " which has a large default size, but this cache is normally small.")]

Compilation\CSharpCompilation.cs (4)

70private ConcurrentDictionary<ImportInfo, ImmutableArray<AssemblySymbol>>? _lazyImportInfos; 1489private ConcurrentDictionary<string, NamespaceSymbol>? _externAliasTargets; 2474private ConcurrentDictionary<(ImmutableArray<byte> ContentHash, int Position), OneOrMany<(Location AttributeLocation, MethodSymbol Interceptor)>>? _interceptions; 2481var dictionary = LazyInitializer.EnsureInitialized(ref _interceptions,

Compiler\ClsComplianceChecker.cs (1)

32private readonly ConcurrentDictionary<Symbol, Compliance> _declaredOrInheritedCompliance;

Compiler\MethodCompiler.cs (4)

1893ConcurrentDictionary<IdentifierNameSyntax, int>? identifierMap; 2089out InMethodBinder? inMethodBinder, out ConcurrentDictionary<IdentifierNameSyntax, int>? identifierMap) 2142static void addIdentifiers(CSharpSyntaxNode? node, ConcurrentDictionary<IdentifierNameSyntax, int> identifierMap) 2223static void assertBindIdentifierTargets(InMethodBinder? inMethodBinder, ConcurrentDictionary<IdentifierNameSyntax, int>? identifierMap, BoundNode methodBody, BindingDiagnosticBag diagnostics)

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

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

Emitter\Model\PEModuleBuilder.cs (3)

29protected readonly ConcurrentDictionary<Symbol, Cci.IModuleReference> AssemblyOrModuleSymbolToModuleRefMap = new ConcurrentDictionary<Symbol, Cci.IModuleReference>(); 30private readonly ConcurrentDictionary<Symbol, object> _genericInstanceMap = new ConcurrentDictionary<Symbol, object>(Symbols.SymbolEqualityComparer.ConsiderEverything); 31private readonly ConcurrentDictionary<ImportChain, ImmutableArray<Cci.UsedNamespaceOrType>> _translatedImportsMap =

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

FlowAnalysis\NullableWalker.cs (1)

37internal readonly ConcurrentDictionary<object, NullableWalker.Data> Data;

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (10)

32private ConcurrentDictionary<string, AnonymousTypeTemplateSymbol> _lazyAnonymousTypeTemplates; 38private ConcurrentDictionary<SynthesizedDelegateKey, AnonymousDelegateTemplateSymbol> _lazyAnonymousDelegates; 92private readonly ConcurrentDictionary<Location, bool> _sourceLocationsSeen = new ConcurrentDictionary<Location, bool>(); 114private ConcurrentDictionary<string, AnonymousTypeTemplateSymbol> AnonymousTypeTemplates 124var previousCache = (previousSubmission == null) ? null : previousSubmission.AnonymousTypeManager.AnonymousTypeTemplates; 137private ConcurrentDictionary<SynthesizedDelegateKey, AnonymousDelegateTemplateSymbol> AnonymousDelegates 146var previousCache = (previousSubmission == null) ? null : previousSubmission.AnonymousTypeManager._lazyAnonymousDelegates; 608var anonymousTypes = _lazyAnonymousTypeTemplates; 626var anonymousDelegates = _lazyAnonymousDelegates; 648var delegates = _lazyAnonymousDelegates;

Symbols\Metadata\PE\MetadataDecoder.cs (3)

106protected override ConcurrentDictionary<TypeDefinitionHandle, TypeSymbol> GetTypeHandleToTypeMap() 111protected override ConcurrentDictionary<TypeReferenceHandle, TypeSymbol> GetTypeRefHandleToTypeMap() 312ConcurrentDictionary<TypeDefinitionHandle, TypeSymbol> cache = GetTypeHandleToTypeMap();

Symbols\Metadata\PE\PEModuleSymbol.cs (2)

67internal readonly ConcurrentDictionary<TypeDefinitionHandle, TypeSymbol> TypeHandleToTypeMap = 76internal readonly ConcurrentDictionary<TypeReferenceHandle, TypeSymbol> TypeRefHandleToTypeMap =

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

187public ConcurrentDictionary<MethodSymbol, MethodSymbol?>? LazyImplementationMap;

Symbols\MetadataOrSourceAssemblySymbol.cs (2)

266private ConcurrentDictionary<AssemblySymbol, IVTConclusion> _assembliesToWhichInternalAccessHasBeenAnalyzed; 268private ConcurrentDictionary<AssemblySymbol, IVTConclusion> AssembliesToWhichInternalAccessHasBeenDetermined

Symbols\NonMissingAssemblySymbol.cs (1)

32private readonly ConcurrentDictionary<MetadataTypeName.Key, NamedTypeSymbol> _emittedNameToTypeMap =

Symbols\Retargeting\RetargetingAssemblySymbol.cs (2)

75private ConcurrentDictionary<NamedTypeSymbol, NamedTypeSymbol> _noPiaUnificationMap; 80internal ConcurrentDictionary<NamedTypeSymbol, NamedTypeSymbol> NoPiaUnificationMap =>

Symbols\Retargeting\RetargetingModuleSymbol.cs (2)

57private ConcurrentDictionary<NamedTypeSymbol, NamedTypeSymbol>? _symbolMap; 59public ConcurrentDictionary<NamedTypeSymbol, NamedTypeSymbol> SymbolMap => LazyInitializer.EnsureInitialized(ref _symbolMap);

Symbols\Retargeting\RetargetingSymbolTranslator.cs (3)

31private readonly ConcurrentDictionary<Symbol, Symbol> _symbolMap = 118private ConcurrentDictionary<Symbol, Symbol> SymbolMap 314var map = this.RetargetingAssembly.NoPiaUnificationMap;

Symbols\Source\SourceAssemblySymbol.cs (11)

Symbols\TypeSymbol.cs (4)

60private ConcurrentDictionary<Symbol, SymbolAndDiagnostics> _implementationForInterfaceMemberMap; 62public ConcurrentDictionary<Symbol, SymbolAndDiagnostics> ImplementationForInterfaceMemberMap 66var map = _implementationForInterfaceMemberMap; 760var map = info.ImplementationForInterfaceMemberMap;

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (1)

260private readonly ConcurrentDictionary<SyntaxTree, SyntaxTreeState> _codeBlockIntervals = [];

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs (1)

49ConcurrentDictionary<IFieldSymbol, ConcurrentSet<SyntaxNode>> ineligibleFieldUsageIfOutsideProperty,

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs (1)

35private readonly ConcurrentDictionary<IMethodSymbol, MemberInfo> _methodToMemberInfo = new();

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs (1)

31private readonly ConcurrentDictionary<IMethodSymbol, MemberInfo> _methodToMemberInfo = new();

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (4)

79var namedTypeToAnalyzer = new ConcurrentDictionary<INamedTypeSymbol, Analyzer>(); 145ConcurrentDictionary<INamedTypeSymbol, Analyzer> namedTypeToAnalyzer) 154private readonly ConcurrentDictionary<INamedTypeSymbol, Analyzer> _namedTypeToAnalyzer = namedTypeToAnalyzer; 204ConcurrentDictionary<INamedTypeSymbol, Analyzer> namedTypeToAnalyzer)

Diagnostics\DiagnosticAnalyzerTests.cs (1)

4054private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _cache = new ConcurrentDictionary<SyntaxTree, SemanticModel>();

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (1)

260private readonly ConcurrentDictionary<SyntaxTree, SyntaxTreeState> _codeBlockIntervals = [];

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs (1)

49ConcurrentDictionary<IFieldSymbol, ConcurrentSet<SyntaxNode>> ineligibleFieldUsageIfOutsideProperty,

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs (1)

35private readonly ConcurrentDictionary<IMethodSymbol, MemberInfo> _methodToMemberInfo = new();

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs (1)

31private readonly ConcurrentDictionary<IMethodSymbol, MemberInfo> _methodToMemberInfo = new();

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (4)

79var namedTypeToAnalyzer = new ConcurrentDictionary<INamedTypeSymbol, Analyzer>(); 145ConcurrentDictionary<INamedTypeSymbol, Analyzer> namedTypeToAnalyzer) 154private readonly ConcurrentDictionary<INamedTypeSymbol, Analyzer> _namedTypeToAnalyzer = namedTypeToAnalyzer; 204ConcurrentDictionary<INamedTypeSymbol, Analyzer> namedTypeToAnalyzer)

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

63var localsToIsAssignedMap = new ConcurrentDictionary<ILocalSymbol, bool>();

ObjectFormatterTests.cs (1)

688var obj = new ConcurrentDictionary<string, int>();

CaseCorrection\CSharpCaseCorrectionService.cs (1)

30ConcurrentDictionary<SyntaxToken, SyntaxToken> replacements,

IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (1)

252var includedDefaults = new ConcurrentDictionary<string, MatchResult>();

Lightup\LightupHelpers.cs (3)

15private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<Type, bool>> s_supportedObjectWrappers = new(); 31var wrappedObject = s_supportedObjectWrappers.GetOrAdd(underlyingType, static _ => new ConcurrentDictionary<Type, bool>());

Logging\FunctionIdOptions.cs (1)

15private static readonly ConcurrentDictionary<FunctionId, Option2<bool>> s_options = [];

Debugger\Engine\DkmClrAppDomain.cs (1)

30internal ConcurrentDictionary<Type, ReadOnlyCollection<DkmClrEvalAttribute>> TypeToEvalAttributesMap { get; }

Internal\Analyzer\AbstractCopilotCodeAnalysisService.cs (3)

38private readonly ConditionalWeakTable<Document, ConcurrentDictionary<string, (ImmutableArray<Diagnostic> Diagnostics, bool IsCompleteResult)>> _diagnosticsCache = new(); 104if (_diagnosticsCache.TryGetValue(document, out var existingDiagnosticsMap) 126var diagnosticsMap = _diagnosticsCache.GetOrCreateValue(document);

AddImport\AbstractAddImportFeatureService.cs (6)

145var projectToAssembly = new ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>>(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count); 146var referenceToCompilation = new ConcurrentDictionary<PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count)); 170ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, 171ConcurrentDictionary<PortableExecutableReference, Compilation> referenceToCompilation, 215ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, 260ConcurrentDictionary<PortableExecutableReference, Compilation> referenceToCompilation,

AddImport\SearchScopes\SourceSymbolsProjectSearchScope.cs (2)

24ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol?>> projectToAssembly, 27private readonly ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol?>> _projectToAssembly = projectToAssembly;

AddImport\SymbolReferenceFinder.cs (1)

99internal Task<ImmutableArray<SymbolReference>> FindInSourceSymbolsInProjectAsync(ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, Project project, bool exact, CancellationToken cancellationToken)

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (4)

254var documentIdToChangedDocuments = new ConcurrentDictionary<DocumentId, ConcurrentBag<(CodeAction, Document)>>(); 283var documentIdToFinalText = new ConcurrentDictionary<DocumentId, SourceText>(); 298ConcurrentDictionary<DocumentId, SourceText> documentIdToFinalText, 345ConcurrentDictionary<DocumentId, ConcurrentBag<(CodeAction, Document)>> documentIdToChangedDocuments,

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.cs (1)

33private static readonly ConcurrentDictionary<ProjectId, ExtensionMethodImportCompletionCacheEntry> s_projectItemsCache = new();

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.SymbolComputer.cs (1)

40private readonly ConcurrentDictionary<ITypeSymbol, bool> _checkedReceiverTypes = [];

Completion\SharedSyntaxContextsWithSpeculativeModel.cs (1)

20private readonly ConcurrentDictionary<Document, AsyncLazy<SyntaxContext>> _cache;

DesignerAttribute\DesignerAttributeDiscoveryService.cs (1)

60private readonly ConcurrentDictionary<DocumentId, (string? category, VersionStamp projectVersion)> _documentToLastReportedInformation = [];

Diagnostics\CodeAnalysisDiagnosticAnalyzerService.cs (1)

35private readonly ConcurrentDictionary<ProjectId, ImmutableArray<DiagnosticData>> _analyzedProjectToDiagnostics = [];

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingNormalPriorityProcessor.cs (1)

34private readonly ConcurrentDictionary<DocumentId, /*unused*/ object?> _higherPriorityDocumentsNotProcessed;

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (4)

24using CachedIndexMap = ConcurrentDictionary<(IChecksummedPersistentStorageService service, DocumentKey documentKey, StringTable stringTable), AsyncLazy<TopLevelSyntaxTreeIndex?>>; 33private static CachedIndexMap? s_cachedIndexMap = []; 50[NotNullWhen(true)] out CachedIndexMap? cachedIndexMap, 170if (!ShouldSearchCachedDocuments(out var cachedIndexMap, out var stringTable))

Organizing\AbstractOrganizingService.cs (1)

33var map = new ConcurrentDictionary<Type, IEnumerable<ISyntaxOrganizer>>();

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

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

Shared\Extensions\ISymbolExtensions_Sorting.cs (2)

36var symbolToParameterTypeNames = new ConcurrentDictionary<TSymbol, string[]>(); 154ConcurrentDictionary<TSymbol, string[]> symbolToParameterTypeNames,

SignatureHelp\SignatureHelpService.cs (1)

27private readonly ConcurrentDictionary<string, ImmutableArray<ISignatureHelpProvider>> _providersByLanguage = [];

src\Analyzers\Core\Analyzers\IDEDiagnosticIdToOptionMappingHelper.cs (7)

22private static readonly ConcurrentDictionary<string, ImmutableHashSet<IOption2>> s_diagnosticIdToOptionMap = new(); 23private static readonly ConcurrentDictionary<string, ConcurrentDictionary<string, ImmutableHashSet<IOption2>>> s_diagnosticIdToLanguageSpecificOptionsMap = new(); 24private static readonly ConcurrentDictionary<string, PerLanguageOption2<bool>> s_diagnosticIdToFadingOptionMap = new(); 28(s_diagnosticIdToLanguageSpecificOptionsMap.TryGetValue(language, out var map) && 70var map = s_diagnosticIdToLanguageSpecificOptionsMap.GetOrAdd(language, _ => new ConcurrentDictionary<string, ImmutableHashSet<IOption2>>()); 83private static void AddOptionMapping(ConcurrentDictionary<string, ImmutableHashSet<IOption2>> map, string diagnosticId, ImmutableHashSet<IOption2> options)

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (1)

42var fieldStateMap = new ConcurrentDictionary<IFieldSymbol, (bool isCandidate, bool written)>();

src\Analyzers\Core\Analyzers\NamingStyle\NamingStyleDiagnosticAnalyzerBase.cs (6)

47var idToCachedResult = new ConcurrentDictionary<Guid, ConcurrentDictionary<string, string?>>( 106private static readonly Func<Guid, ConcurrentDictionary<string, string?>> s_createCache = 114ConcurrentDictionary<Guid, ConcurrentDictionary<string, string?>> idToCachedResult) 145var cache = idToCachedResult.GetOrAdd(applicableRule.NamingStyle.ID, s_createCache);

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

58private readonly ConcurrentDictionary<IParameterSymbol, bool> _referencedParameters;

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (2)

36private readonly ConcurrentDictionary<IMethodSymbol, bool> _methodsUsedAsDelegates = []; 45private readonly ConcurrentDictionary<IParameterSymbol, bool> _unusedParameters = [];

src\Analyzers\Core\Analyzers\SimplifyTypeNames\SimplifyTypeNamesDiagnosticAnalyzerBase.cs (1)

209private readonly ConcurrentDictionary<SyntaxTree, (StrongBox<bool> completed, TextSpanMutableIntervalTree? intervalTree)> _codeBlockIntervals = [];

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (12)

SymbolSearch\Windows\SymbolSearchUpdateEngine.cs (1)

35private readonly ConcurrentDictionary<string, IAddReferenceDatabaseWrapper> _sourceToDatabase = [];

SymbolSearch\Windows\SymbolSearchUpdateEngine.Update.cs (1)

49private readonly ConcurrentDictionary<string, object> _sourceToUpdateSentinel = [];

LanguageServer\Handler\DebugConfiguration\ProjectTargetFrameworkManager.cs (1)

17private readonly ConcurrentDictionary<ProjectId, string?> _projectToTargetFrameworkIdentifer = new();

Logging\LspLogMessageLoggerProvider.cs (1)

12private readonly ConcurrentDictionary<string, LspLogMessageLogger> _loggers = new(StringComparer.OrdinalIgnoreCase);

Logging\RoslynLogger.cs (3)

19private static readonly ConcurrentDictionary<FunctionId, string> s_eventMap = []; 20private static readonly ConcurrentDictionary<(FunctionId id, string name), string> s_propertyMap = []; 22private readonly ConcurrentDictionary<int, object> _pendingScopes = new(concurrencyLevel: 2, capacity: 10);

Handler\Diagnostics\AbstractPullDiagnosticHandler.cs (1)

51private readonly ConcurrentDictionary<string, DiagnosticsPullCache> _categoryToVersionedCache = [];

Handler\InlineCompletions\XmlSnippetParser.cs (1)

27private readonly ConcurrentDictionary<string, ParsedXmlSnippet?> _parsedSnippetsCache = [];

Handler\PullHandlers\VersionedPullCache.cs (1)

29private readonly ConcurrentDictionary<(Workspace workspace, ProjectOrDocumentId id), CacheItem> _idToLastReportedResult = [];

Protocol\Converters\SumConverter.cs (1)

185private static readonly ConcurrentDictionary<Type, SumConverter.SumTypeInfoCache> SumTypeCache = new ConcurrentDictionary<Type, SumConverter.SumTypeInfoCache>();

Protocol\Internal\Efficiency\OptimizedVSCompletionListJsonConverter.cs (1)

17private static readonly ConcurrentDictionary<ImageId, string> IconRawJson = new ConcurrentDictionary<ImageId, string>();

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\AbstractTypeRefResolver.cs (1)

15private readonly ConcurrentDictionary<TypeRef, Type?> _typeRefToTypeMap = [];

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\RequestExecutionQueue.cs (4)

195var concurrentlyExecutingTasks = new ConcurrentDictionary<Task, CancellationTokenSource>(); 303/// Reflection invokes <see cref="ProcessQueueCoreAsync{TRequest, TResponse}(IQueueItem{TRequestContext}, IMethodHandler, RequestHandlerMetadata, ConcurrentDictionary{Task, CancellationTokenSource}, CancellationTokenSource?, CancellationToken)"/> 311ConcurrentDictionary<Task, CancellationTokenSource> concurrentlyExecutingTasks, 333ConcurrentDictionary<Task, CancellationTokenSource> concurrentlyExecutingTasks,

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\TypeRef.cs (1)

18private static readonly ConcurrentDictionary<(string TypeName, string AssemblyName, string? CodeBase), TypeRef> s_cache = [];

LspFileChangeWatcherTests.cs (1)

118public readonly ConcurrentDictionary<string, Registration> Registrations = new();

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

14private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

430private static readonly BoundedCache<Compilation, ConcurrentDictionary<IMethodSymbol, IBlockOperation?>> s_methodToTopmostOperationBlockCache 438var methodToBlockMap = s_methodToTopmostOperationBlockCache.GetOrCreateValue(compilation); 546public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\INamedTypeSymbolExtensions.cs (1)

74public static bool IsBenchmarkOrXUnitTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (2)

274private static readonly BoundedCache<Compilation, ConcurrentDictionary<IOperation, ControlFlowGraph?>> s_operationToCfgCache 281var operationToCfgMap = s_operationToCfgCache.GetOrCreateValue(operation.SemanticModel.Compilation);

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\AbstractCategorizedAnalyzerConfigOptions.cs (1)

21private readonly ConcurrentDictionary<OptionKey, (bool found, object? value)> _computedOptionValuesMap;

src\RoslynAnalyzers\Utilities\Compiler\Options\OptionKey.cs (1)

13private static readonly ConcurrentDictionary<(string ruleId, string optionName), OptionKey> s_keys = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

59private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 61private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 379internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 381internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (2)

17/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 52private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledConcurrentDictionary<K, V>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentSet.cs (1)

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool.

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (1)

38private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledDictionary<K, V>>> s_poolInstancesByComparer

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledSortedSet.cs (1)

47private static readonly ConcurrentDictionary<IComparer<T>, ObjectPool<PooledSortedSet<T>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\SymbolDisplayStringCache.cs (4)

19private static readonly BoundedCacheWithFactory<Compilation, ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache>> s_byCompilationCache = new(); 29private readonly ConcurrentDictionary<ISymbol, string> SymbolToDisplayNames = new(); 50ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> dict = 55static ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> CreateConcurrentDictionary(Compilation compilation)

src\RoslynAnalyzers\Utilities\Compiler\UnusedValue.cs (1)

10/// A placeholder value type for <see cref="ConcurrentDictionary{TKey, TValue}"/> used as a set.

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

67private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 81private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

115var reducedNodesMap = new ConcurrentDictionary<SyntaxNode, SyntaxNode>(); 116var reducedTokensMap = new ConcurrentDictionary<SyntaxToken, SyntaxToken>(); 156ConcurrentDictionary<SyntaxNode, SyntaxNode> reducedNodesMap, 157ConcurrentDictionary<SyntaxToken, SyntaxToken> reducedTokensMap,

DeclarePublicApiAnalyzer.Impl.cs (3)

83private readonly ConcurrentDictionary<(ITypeSymbol Type, bool IsPublic), bool> _typeCanBeExtendedCache = new(); 84private readonly ConcurrentDictionary<string, UnusedValue> _visitedApiList = new(StringComparer.Ordinal); 85private readonly ConcurrentDictionary<SyntaxTree, ImmutableArray<string>> _skippedNamespacesCache = new();

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

14private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

430private static readonly BoundedCache<Compilation, ConcurrentDictionary<IMethodSymbol, IBlockOperation?>> s_methodToTopmostOperationBlockCache 438var methodToBlockMap = s_methodToTopmostOperationBlockCache.GetOrCreateValue(compilation); 546public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\INamedTypeSymbolExtensions.cs (1)

74public static bool IsBenchmarkOrXUnitTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (2)

274private static readonly BoundedCache<Compilation, ConcurrentDictionary<IOperation, ControlFlowGraph?>> s_operationToCfgCache 281var operationToCfgMap = s_operationToCfgCache.GetOrCreateValue(operation.SemanticModel.Compilation);

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\AbstractCategorizedAnalyzerConfigOptions.cs (1)

21private readonly ConcurrentDictionary<OptionKey, (bool found, object? value)> _computedOptionValuesMap;

src\RoslynAnalyzers\Utilities\Compiler\Options\OptionKey.cs (1)

13private static readonly ConcurrentDictionary<(string ruleId, string optionName), OptionKey> s_keys = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

59private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 61private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 379internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 381internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (2)

17/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 52private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledConcurrentDictionary<K, V>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentSet.cs (1)

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool.

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (1)

38private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledDictionary<K, V>>> s_poolInstancesByComparer

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledSortedSet.cs (1)

47private static readonly ConcurrentDictionary<IComparer<T>, ObjectPool<PooledSortedSet<T>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\SymbolDisplayStringCache.cs (4)

19private static readonly BoundedCacheWithFactory<Compilation, ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache>> s_byCompilationCache = new(); 29private readonly ConcurrentDictionary<ISymbol, string> SymbolToDisplayNames = new(); 50ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> dict = 55static ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> CreateConcurrentDictionary(Compilation compilation)

src\RoslynAnalyzers\Utilities\Compiler\UnusedValue.cs (1)

10/// A placeholder value type for <see cref="ConcurrentDictionary{TKey, TValue}"/> used as a set.

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

67private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 81private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

Host\SolutionAssetCache.cs (1)

46private readonly ConcurrentDictionary<Checksum, Entry> _assets = [];

Services\DiagnosticAnalyzer\PerformanceTrackerService.cs (1)

40private readonly ConcurrentDictionary<string, bool> _builtInMap = new ConcurrentDictionary<string, bool>(concurrencyLevel: 2, capacity: 10);

src\VisualStudio\Core\Def\Telemetry\Shared\TelemetryLogger.cs (3)

75private readonly ConcurrentDictionary<int, object> _pendingScopes = new(concurrencyLevel: 2, capacity: 10); 82private static readonly ConcurrentDictionary<FunctionId, string> s_eventMap = []; 83private static readonly ConcurrentDictionary<(FunctionId id, string name), string> s_propertyMap = [];

Serialization\MessagePackFormatters.cs (1)

57private readonly ConcurrentDictionary<Guid, ProjectId> _projectIds = new ConcurrentDictionary<Guid, ProjectId>();

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

14private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

430private static readonly BoundedCache<Compilation, ConcurrentDictionary<IMethodSymbol, IBlockOperation?>> s_methodToTopmostOperationBlockCache 438var methodToBlockMap = s_methodToTopmostOperationBlockCache.GetOrCreateValue(compilation); 546public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\INamedTypeSymbolExtensions.cs (1)

74public static bool IsBenchmarkOrXUnitTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (2)

274private static readonly BoundedCache<Compilation, ConcurrentDictionary<IOperation, ControlFlowGraph?>> s_operationToCfgCache 281var operationToCfgMap = s_operationToCfgCache.GetOrCreateValue(operation.SemanticModel.Compilation);

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\AbstractCategorizedAnalyzerConfigOptions.cs (1)

21private readonly ConcurrentDictionary<OptionKey, (bool found, object? value)> _computedOptionValuesMap;

src\RoslynAnalyzers\Utilities\Compiler\Options\OptionKey.cs (1)

13private static readonly ConcurrentDictionary<(string ruleId, string optionName), OptionKey> s_keys = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

59private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 61private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 379internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 381internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (2)

17/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 52private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledConcurrentDictionary<K, V>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentSet.cs (1)

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool.

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (1)

38private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledDictionary<K, V>>> s_poolInstancesByComparer

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledSortedSet.cs (1)

47private static readonly ConcurrentDictionary<IComparer<T>, ObjectPool<PooledSortedSet<T>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\SymbolDisplayStringCache.cs (4)

19private static readonly BoundedCacheWithFactory<Compilation, ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache>> s_byCompilationCache = new(); 29private readonly ConcurrentDictionary<ISymbol, string> SymbolToDisplayNames = new(); 50ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> dict = 55static ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> CreateConcurrentDictionary(Compilation compilation)

src\RoslynAnalyzers\Utilities\Compiler\UnusedValue.cs (1)

10/// A placeholder value type for <see cref="ConcurrentDictionary{TKey, TValue}"/> used as a set.

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

67private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 81private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

Diagnostics\CommonDiagnosticAnalyzers.cs (2)

1230private readonly ConcurrentDictionary<IOperation, (ControlFlowGraph Graph, ISymbol AssociatedSymbol)> _controlFlowGraphMapOpt; 1980var seenOperationContainers = new ConcurrentDictionary<OperationAnalysisContext, ISet<ISymbol>>();

TargetFrameworkUtil.cs (1)

168private static readonly ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>> s_dynamicReferenceMap = new ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>>(StringComparer.Ordinal);

InternalUtilities\ConcurrentDictionaryExtensionsTests.cs (2)

17var dictionary = new ConcurrentDictionary<int, int>(); 30var dictionary = new ConcurrentDictionary<int, object>();

Binding\BinderFactory.vb (1)

29Private ReadOnly _cache As ConcurrentDictionary(Of ValueTuple(Of VisualBasicSyntaxNode, Byte), Binder)

Compilation\ClsComplianceChecker.vb (1)

35Private ReadOnly _declaredOrInheritedCompliance As ConcurrentDictionary(Of Symbol, Compliance)

Compilation\VisualBasicCompilation.vb (1)

113Private _lazyImportClauseDependencies As ConcurrentDictionary(Of (SyntaxTree As SyntaxTree, ImportsClausePosition As Integer), ImmutableArray(Of AssemblySymbol))

Emit\EditAndContinue\VisualBasicSymbolMatcher.vb (3)

78Private ReadOnly _matches As ConcurrentDictionary(Of Symbol, Symbol) 89Private ReadOnly _otherMembers As ConcurrentDictionary(Of ISymbolInternal, IReadOnlyDictionary(Of String, ImmutableArray(Of ISymbolInternal))) 563Private ReadOnly _matches As ConcurrentDictionary(Of Symbol, Symbol)

Emit\PEModuleBuilder.vb (1)

22Private ReadOnly _disableJITOptimization As ConcurrentDictionary(Of MethodSymbol, Boolean) = New ConcurrentDictionary(Of MethodSymbol, Boolean)(ReferenceEqualityComparer.Instance)

Operations\VisualBasicOperationFactory.vb (1)

16Private _lazyPlaceholderToParentMap As ConcurrentDictionary(Of BoundValuePlaceholderBase, BoundNode) = Nothing

Symbols\AnonymousTypes\AnonymousTypeManager_Templates.vb (5)

19Private _concurrentTypesCache As ConcurrentDictionary(Of String, AnonymousTypeTemplateSymbol) = Nothing 22Private _concurrentDelegatesCache As ConcurrentDictionary(Of String, AnonymousDelegateTemplateSymbol) = Nothing 45Private ReadOnly Property AnonymousTypeTemplates As ConcurrentDictionary(Of String, AnonymousTypeTemplateSymbol) 65Private ReadOnly Property AnonymousDelegateTemplates As ConcurrentDictionary(Of String, AnonymousDelegateTemplateSymbol) 154cache As ConcurrentDictionary(Of String, T))

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

24Private ReadOnly _symbols As ConcurrentDictionary(Of Symbol, Boolean)

Symbols\Metadata\PE\MetadataDecoder.vb (3)

105Protected Overrides Function GetTypeHandleToTypeMap() As ConcurrentDictionary(Of TypeDefinitionHandle, TypeSymbol) 109Protected Overrides Function GetTypeRefHandleToTypeMap() As ConcurrentDictionary(Of TypeReferenceHandle, TypeSymbol) 273Dim cache As ConcurrentDictionary(Of TypeDefinitionHandle, TypeSymbol) = GetTypeHandleToTypeMap()

Symbols\MetadataOrSourceAssemblySymbol.vb (2)

167Private _assembliesToWhichInternalAccessHasBeenAnalyzed As ConcurrentDictionary(Of AssemblySymbol, IVTConclusion) 169Private ReadOnly Property AssembliesToWhichInternalAccessHasBeenDetermined As ConcurrentDictionary(Of AssemblySymbol, IVTConclusion)

Symbols\Retargeting\RetargetingModuleSymbol.vb (1)

55Public SymbolMap As ConcurrentDictionary(Of NamedTypeSymbol, NamedTypeSymbol)

Symbols\Retargeting\RetargetingSymbolTranslator.vb (1)

89Private ReadOnly Property SymbolMap As ConcurrentDictionary(Of Symbol, Symbol)

Symbols\Source\SourceAssemblySymbol.vb (7)

75Private _lazyInternalsVisibleToMap As ConcurrentDictionary(Of String, ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String))) 869Private _optimisticallyGrantedInternalsAccess As ConcurrentDictionary(Of AssemblySymbol, Boolean) 875Dim haveGrantedAssemblies As ConcurrentDictionary(Of AssemblySymbol, Boolean) = _optimisticallyGrantedInternalsAccess 909Dim result As ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)) = Nothing 979New ConcurrentDictionary(Of String, ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)))(StringComparer.OrdinalIgnoreCase), Nothing) 998Dim keys As ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)) = Nothing

Symbols\Source\SourceNamedTypeSymbol.vb (1)

44Private _lazyWithEventsOverrides As ConcurrentDictionary(Of PropertySymbol, SynthesizedOverridingWithEventsProperty)

Symbols\TypeSymbol.vb (2)

48Private _lazyImplementationForInterfaceMemberMap As ConcurrentDictionary(Of Symbol, Symbol) 668Private ReadOnly Property ImplementationForInterfaceMemberMap As ConcurrentDictionary(Of Symbol, Symbol)

src\Analyzers\VisualBasic\Analyzers\UseAutoProperty\VisualBasicUseAutoPropertyAnalyzer.vb (1)

42ineligibleFieldUsageIfOutsideProperty As ConcurrentDictionary(Of IFieldSymbol, ConcurrentSet(Of SyntaxNode)),

src\Analyzers\VisualBasic\Analyzers\UseAutoProperty\VisualBasicUseAutoPropertyAnalyzer.vb (1)

42ineligibleFieldUsageIfOutsideProperty As ConcurrentDictionary(Of IFieldSymbol, ConcurrentSet(Of SyntaxNode)),

CaseCorrection\VisualBasicCaseCorrectionService.vb (3)

30replacements As ConcurrentDictionary(Of SyntaxToken, SyntaxToken), 40replacements As ConcurrentDictionary(Of SyntaxToken, SyntaxToken), 57Private Shared Sub Rewrite(token As SyntaxToken, rewriter As Rewriter, replacements As ConcurrentDictionary(Of SyntaxToken, SyntaxToken))

CaseCorrection\AbstractCaseCorrectionService.cs (2)

20protected abstract void AddReplacements(SemanticModel? semanticModel, SyntaxNode root, ImmutableArray<TextSpan> spans, ConcurrentDictionary<SyntaxToken, SyntaxToken> replacements, CancellationToken cancellationToken); 49var replacements = new ConcurrentDictionary<SyntaxToken, SyntaxToken>();

Diagnostics\DiagnosticAnalyzerInfoCache.cs (1)

53private readonly ConcurrentDictionary<string, DiagnosticDescriptor?> _idToDescriptorsMap;

Diagnostics\HostDiagnosticAnalyzers.cs (1)

31private readonly ConcurrentDictionary<string, ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>>> _hostDiagnosticAnalyzersPerLanguageMap;

FindSymbols\FindReferences\FindReferenceCache.cs (2)

66private readonly ConcurrentDictionary<SyntaxNode, SymbolInfo> _symbolInfoCache = []; 67private readonly ConcurrentDictionary<string, ImmutableArray<SyntaxToken>> _identifierCache;

FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (2)

30private readonly ConcurrentDictionary<ProjectId, (VersionStamp semanticVersion, SymbolTreeInfo info)> _projectIdToInfo = []; 31private readonly ConcurrentDictionary<PortableExecutableReference, MetadataInfo> _peReferenceToInfo = [];

Log\AbstractLogAggregator.cs (1)

27private readonly ConcurrentDictionary<object, TValue> _map = new(concurrencyLevel: 2, capacity: 2);

Remote\RemoteServiceCallbackDispatcher.cs (2)

19internal readonly struct Handle(ConcurrentDictionary<RemoteServiceCallbackId, object> callbackInstances, RemoteServiceCallbackId callbackId) : IDisposable 30private readonly ConcurrentDictionary<RemoteServiceCallbackId, object> _callbackInstances = new(concurrencyLevel: 2, capacity: 10);

Serialization\SerializerService.cs (1)

48private readonly ConcurrentDictionary<string, IOptionsSerializationService> _lazyLanguageSerializationService = new(concurrencyLevel: 2, capacity: workspaceServices.SupportedLanguages.Count());

Shared\TestHooks\AsynchronousOperationListenerProvider.cs (1)

43private readonly ConcurrentDictionary<string, AsynchronousOperationListener> _singletonListeners;

src\Compilers\Core\Portable\DiagnosticAnalyzer\ShadowCopyAnalyzerPathResolver.cs (2)

49private ConcurrentDictionary<string, int> OriginalDirectoryMap { get; } = new(AnalyzerAssemblyLoader.OriginalPathComparer); 56private ConcurrentDictionary<string, Task<string>> CopyMap { get; } = new(AnalyzerAssemblyLoader.OriginalPathComparer);

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

115var reducedNodesMap = new ConcurrentDictionary<SyntaxNode, SyntaxNode>(); 116var reducedTokensMap = new ConcurrentDictionary<SyntaxToken, SyntaxToken>(); 156ConcurrentDictionary<SyntaxNode, SyntaxNode> reducedNodesMap, 157ConcurrentDictionary<SyntaxToken, SyntaxToken> reducedTokensMap,

Storage\SQLite\v2\SQLitePersistentStorage_DocumentIds.cs (1)

19private readonly ConcurrentDictionary<DocumentId, DocumentPrimaryKey> _documentIdToPrimaryKeyMap = [];

Storage\SQLite\v2\SQLitePersistentStorage_ProjectIds.cs (1)

19private readonly ConcurrentDictionary<ProjectId, ProjectPrimaryKey> _projectIdToPrimaryKeyMap = [];

Storage\SQLite\v2\SQLitePersistentStorage_StringIds.cs (1)

16private readonly ConcurrentDictionary<string, int> _stringToIdMap = [];

Storage\StorageDatabaseLogger.cs (1)

23private readonly ConcurrentDictionary<Type, Exception> _set = new(concurrencyLevel: 2, capacity: 10);

Workspace\Host\Documentation\DocumentationProviderServiceFactory.cs (1)

27private readonly ConcurrentDictionary<string, DocumentationProvider> _assemblyPathToDocumentationProviderMap =

Workspace\Solution\ProjectState.AnalyzerConfigOptionsCache.cs (1)

26private readonly ConcurrentDictionary<string, AnalyzerConfigData> _sourcePathToResult = [];

Workspace\Solution\SolutionState.cs (2)

64private readonly ConcurrentDictionary<string, ImmutableArray<DocumentId>> _lazyFilePathToRelatedDocumentIds = new ConcurrentDictionary<string, ImmutableArray<DocumentId>>(FilePathComparer); 1279var fileMap = _lazyFilePathToRelatedDocumentIds;

Rpc\RpcClient.cs (1)

36private readonly ConcurrentDictionary<int, (TaskCompletionSource<object?>, System.Type? expectedReturnType)> _outstandingRequests = [];

Rpc\RpcServer.cs (1)

33private readonly ConcurrentDictionary<int, object> _rpcTargets = [];

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (1)

33private readonly ConcurrentDictionary<int, object> _rpcTargets = [];

Remote\InProcRemoteHostClientProvider.cs (2)

42ConcurrentDictionary<Guid, TestGeneratorReference> sharedTestGeneratorReferences, 51ConcurrentDictionary<Guid, TestGeneratorReference> sharedTestGeneratorReferences,

Remote\TestSerializerService.cs (4)

29ConcurrentDictionary<Guid, TestGeneratorReference> sharedTestGeneratorReferences, 42private readonly ConcurrentDictionary<Guid, TestGeneratorReference> _sharedTestGeneratorReferences = sharedTestGeneratorReferences; 119private ConcurrentDictionary<Guid, TestGeneratorReference>? _sharedTestGeneratorReferences; 132public ConcurrentDictionary<Guid, TestGeneratorReference> SharedTestGeneratorReferences

AbstractTypeRefResolver.cs (1)

15private readonly ConcurrentDictionary<TypeRef, Type?> _typeRefToTypeMap = [];

RequestExecutionQueue.cs (4)

195var concurrentlyExecutingTasks = new ConcurrentDictionary<Task, CancellationTokenSource>(); 303/// Reflection invokes <see cref="ProcessQueueCoreAsync{TRequest, TResponse}(IQueueItem{TRequestContext}, IMethodHandler, RequestHandlerMetadata, ConcurrentDictionary{Task, CancellationTokenSource}, CancellationTokenSource?, CancellationToken)"/> 311ConcurrentDictionary<Task, CancellationTokenSource> concurrentlyExecutingTasks, 333ConcurrentDictionary<Task, CancellationTokenSource> concurrentlyExecutingTasks,

TypeRef.cs (1)

18private static readonly ConcurrentDictionary<(string TypeName, string AssemblyName, string? CodeBase), TypeRef> s_cache = [];

Microsoft\CSharp\RuntimeBinder\BinderEquivalence.cs (1)

32private static readonly ConcurrentDictionary<ICSharpBinder, ICSharpBinder> binderEquivalenceCache =

TokenCredentialShortCache.cs (1)

32private ConcurrentDictionary<CacheKey, CachedToken> _tokenCache = new ConcurrentDictionary<CacheKey, CachedToken>();

src\AssetPublisherFactory.cs (1)

40private ConcurrentDictionary<string, TokenCredential> _tokenCredentialsPerManagedIdentity = new ConcurrentDictionary<string, TokenCredential>(-1, 10);

src\PublishArtifactsInManifestBase.cs (2)

189private readonly ConcurrentDictionary<(int AssetId, string AssetLocation, LocationType LocationType), ValueTuple> NewAssetLocations = 192private ConcurrentDictionary<string, IArtifactUrlHelper> _artifactUrlHelpers = new ConcurrentDictionary<string, IArtifactUrlHelper>();

PackageIndex.cs (1)

22static ConcurrentDictionary<string, PackageIndex> s_indexCache = new ConcurrentDictionary<string, PackageIndex>();

EqualityAssertsTests.cs (4)

1160 var actual = new ConcurrentDictionary<string, string>(expected); 1170 var actual = new ConcurrentDictionary<string, string> { ["foo"] = "baz" }; 3389 var actual = new ConcurrentDictionary<string, string>(expected); 3412 var actual = new ConcurrentDictionary<string, string> { ["foo"] = "baz" };

Functions\AIFunctionFactory.cs (2)

603private static readonly ConditionalWeakTable<JsonSerializerOptions, ConcurrentDictionary<DescriptorKey, ReflectionAIFunctionDescriptor>> _descriptorCache = new(); 616ConcurrentDictionary<DescriptorKey, ReflectionAIFunctionDescriptor> innerCache = _descriptorCache.GetOrCreateValue(serializerOptions);

ResponseCachingChatClient.cs (1)

16private readonly ConcurrentDictionary<string, Stopwatch> _stopWatches;

ContentSafetyService.cs (1)

38private static readonly ConcurrentDictionary<UrlCacheKey, string> _serviceUrlCache =

TestInMemoryCacheStorage.cs (1)

14private readonly ConcurrentDictionary<string, byte[]> _storage = new();

Internal\DefaultHybridCache.Serialization.cs (1)

18private readonly ConcurrentDictionary<Type, object> _serializers = new();

Internal\DefaultHybridCache.Stampede.cs (1)

14private readonly ConcurrentDictionary<StampedeKey, StampedeState> _currentOperations = new();

Internal\DefaultHybridCache.TagInvalidation.cs (1)

15private readonly ConcurrentDictionary<string, Task<long>> _tagInvalidationTimes = [];

MemoryCache.cs (3)

717private readonly ConcurrentDictionary<string, CacheEntry> _stringEntries = []; 721private readonly ConcurrentDictionary<object, CacheEntry> _nonStringEntries = []; 724private readonly ConcurrentDictionary<string, CacheEntry>.AlternateLookup<ReadOnlySpan<char>> _stringAltLookup;

ServiceLookup\CallSiteFactory.cs (2)

18private readonly ConcurrentDictionary<ServiceCacheKey, ServiceCallSite> _callSiteCache = new ConcurrentDictionary<ServiceCacheKey, ServiceCallSite>(); 20private readonly ConcurrentDictionary<ServiceIdentifier, object> _callSiteLocks = new ConcurrentDictionary<ServiceIdentifier, object>();

ServiceLookup\CallSiteValidator.cs (1)

13private readonly ConcurrentDictionary<ServiceCacheKey, Type?> _scopedServices = new ConcurrentDictionary<ServiceCacheKey, Type?>();

ServiceLookup\Expressions\ExpressionResolverBuilder.cs (1)

45private readonly ConcurrentDictionary<ServiceCacheKey, Func<ServiceProviderEngineScope, object>> _scopeResolverCache;

ServiceLookup\ILEmit\ILEmitResolverBuilder.cs (1)

55private readonly ConcurrentDictionary<ServiceCacheKey, GeneratedMethod> _scopeResolverCache;

ServiceProvider.cs (1)

31private readonly ConcurrentDictionary<ServiceIdentifier, ServiceAccessor> _serviceAccessors;

ActivatorUtilities.cs (1)

28private static readonly ConcurrentDictionary<Type, ConstructorInfoEx[]> s_constructorInfos = new();

ManualHealthCheckTracker.cs (1)

15private readonly ConcurrentDictionary<IManualHealthCheck, bool> _checks = new();

Logging\FakeLogger.cs (1)

31private readonly ConcurrentDictionary<LogLevel, bool> _disabledLevels = new(); // used as a set, the value is ignored

Logging\FakeLoggerProvider.cs (1)

22private readonly ConcurrentDictionary<string, FakeLogger> _loggers = new();

PhysicalFilesWatcher.cs (5)

29private readonly ConcurrentDictionary<string, ChangeTokenInfo> _filePathTokenLookup = new(StringComparer.OrdinalIgnoreCase); 30private readonly ConcurrentDictionary<string, ChangeTokenInfo> _wildcardTokenLookup = new(StringComparer.OrdinalIgnoreCase); 114internal ConcurrentDictionary<IPollingChangeToken, IPollingChangeToken> PollingChangeTokens { get; } 474var changeTokens = (ConcurrentDictionary<IPollingChangeToken, IPollingChangeToken>)state;

DefaultHttpClientFactory.cs (1)

51internal readonly ConcurrentDictionary<string, Lazy<ActiveHandlerTrackingEntry>> _activeHandlers;

Logging\Internal\LoggerMessageStateExtensions.cs (2)

14private static readonly ConcurrentDictionary<string, string> _requestPrefixedNamesCache = new(); 15private static readonly ConcurrentDictionary<string, string> _responsePrefixedNamesCache = new();

Resilience\Internal\ByAuthorityPipelineKeyProvider.cs (1)

12private readonly ConcurrentDictionary<(string scheme, string host, int port), string> _cache = new();

ResourceManagerStringLocalizer.cs (1)

23private readonly ConcurrentDictionary<string, object?> _missingManifestCache = new ConcurrentDictionary<string, object?>();

ResourceManagerStringLocalizerFactory.cs (1)

26private readonly ConcurrentDictionary<string, ResourceManagerStringLocalizer> _localizerCache =

ResourceNamesCache.cs (2)

11/// An implementation of <see cref="IResourceNamesCache"/> backed by a <see cref="ConcurrentDictionary{TKey, TValue}"/>. 15private readonly ConcurrentDictionary<string, IList<string>?> _cache = new ConcurrentDictionary<string, IList<string>?>();

LoggerFactory.cs (1)

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

FormattedLogValues.cs (1)

23private static readonly ConcurrentDictionary<string, LogValuesFormatter> s_formatters = new ConcurrentDictionary<string, LogValuesFormatter>();

ConsoleLoggerProvider.cs (3)

22private readonly ConcurrentDictionary<string, ConsoleLogger> _loggers; 23private ConcurrentDictionary<string, ConsoleFormatter> _formatters; 102var cd = new ConcurrentDictionary<string, ConsoleFormatter>(StringComparer.OrdinalIgnoreCase);

TraceSourceLoggerProvider.cs (1)

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

PredictionEnginePool.cs (1)

25private readonly ConcurrentDictionary<string, PoolLoader<TData, TPrediction>> _namedPools;

OptionsCache.cs (1)

18private readonly ConcurrentDictionary<string, Lazy<TOptions>> _cache = new ConcurrentDictionary<string, Lazy<TOptions>>(concurrencyLevel: 1, capacity: 31, StringComparer.Ordinal); // 31 == default capacity

Http\HttpServiceEndpointResolver.cs (1)

21private readonly ConcurrentDictionary<string, ResolverEntry> _resolvers = new();

ServiceEndpointResolver.cs (1)

20private readonly ConcurrentDictionary<string, ResolverEntry> _resolvers = new();

Http\HttpRouteParser.cs (1)

25private readonly ConcurrentDictionary<string, ParsedRouteSegments> _routeTemplateSegmentsCache = new();

Sampling\LogSamplingRuleSelector.cs (1)

18private readonly ConcurrentDictionary<(string, LogLevel, EventId), T?> _ruleCache = new();

src\Shared\Memoization\MemoizedFunction.cs (2)

58private readonly ConcurrentDictionary<Arg, Lazy<TResult>> _values; 131private readonly ConcurrentDictionary<Args, Lazy<TResult>> _values;

Infrastructure\DotNetDispatcher.cs (3)

29private static readonly ConcurrentDictionary<AssemblyKey, IReadOnlyDictionary<string, (MethodInfo, Type[])>> _cachedMethodsByAssembly = new(); 31private static readonly ConcurrentDictionary<Type, IReadOnlyDictionary<string, (MethodInfo, Type[])>> _cachedMethodsByType = new(); 33private static readonly ConcurrentDictionary<Type, Func<object, Task>> _cachedConvertToTaskByType = new();

Infrastructure\TaskGenericsUtil.cs (2)

11private static readonly ConcurrentDictionary<Type, ITaskResultGetter> _cachedResultGetters 14private static readonly ConcurrentDictionary<Type, ITcsResultSetter> _cachedResultSetters

JSRuntime.cs (3)

22private readonly ConcurrentDictionary<long, object> _pendingTasks = new(); 23private readonly ConcurrentDictionary<long, IDotNetObjectReference> _trackedRefsById = new(); 24private readonly ConcurrentDictionary<long, CancellationTokenRegistration> _cancellationRegistrations = new();

Handlers\HybridWebView\HybridWebViewTaskManager.cs (1)

12 private readonly ConcurrentDictionary<string, TaskCompletionSource<string?>> _asyncTaskCallbacks = new();

Hosting\ImageSources\ImageSourceServiceProvider.cs (2)

15 readonly ConcurrentDictionary<Type, Type> _imageSourceCache = new ConcurrentDictionary<Type, Type>(); 16 readonly ConcurrentDictionary<Type, Type> _serviceCache = new ConcurrentDictionary<Type, Type>();

Hosting\ImageSources\ImageSourceToImageSourceServiceTypeMapping.cs (1)

10 private static readonly ConcurrentDictionary<IImageSourceServiceCollection, ImageSourceToImageSourceServiceTypeMapping> s_instances = new();

Hosting\Internal\MauiFactory.cs (1)

17 readonly ConcurrentDictionary<ServiceDescriptor, object?> _singletons;

Hosting\Internal\MauiHandlersFactory.cs (1)

12 readonly ConcurrentDictionary<Type, Type> _serviceCache = new ConcurrentDictionary<Type, Type>();

Hosting\Internal\RegisteredHandlerServiceTypeSet.cs (1)

10 private static readonly ConcurrentDictionary<IMauiHandlersCollection, RegisteredHandlerServiceTypeSet> s_instances = new();

MauiContext.cs (1)

55 readonly ConcurrentDictionary<Type, (object, Func<object, object?>)> _scopeStatic = new();

AnimationExtensions.cs (1)

46 static readonly ConcurrentDictionary<int, Animation> s_tweeners;

Xaml\TypeConversionExtensions.cs (1)

43 static readonly ConcurrentDictionary<MemberInfo, TypeConverter> s_converterCache = new();

Data\ProgressReporter.cs (1)

38private readonly ConcurrentDictionary<int, SubChannel> _subChannels;

Data\Repository.cs (1)

99protected readonly ConcurrentDictionary<string, string> PathMap;

Environment\HostEnvironmentBase.cs (1)

355protected readonly ConcurrentDictionary<Type, Dispatcher> ListenerDict;

UnitTests\TestHosts.cs (2)

31var children = new ConcurrentDictionary<IHost, List<IHost>>(); 94var children = new ConcurrentDictionary<IHost, List<IHost>>();

DataLoadSave\Text\TextLoaderParser.cs (1)

45private static readonly ConcurrentDictionary<DoubleParser.OptionFlags, ValueCreatorCache> _customInstances

Selector\DiversityMeasure\BaseDisagreementDiversityMeasure.cs (1)

15ConcurrentDictionary<FeatureSubsetModel<TOutput>, TOutput[]> predictions)

Selector\IDiversityMeasure.cs (1)

17ConcurrentDictionary<FeatureSubsetModel<TOutput>, TOutput[]> predictions);

Selector\SubModelSelector\BaseDiverseSelector.cs (2)

22private readonly ConcurrentDictionary<FeatureSubsetModel<TOutput>, TOutput[]> _predictions; 116ConcurrentDictionary<FeatureSubsetModel<TOutput>, TOutput[]> predictions);

Selector\SubModelSelector\BestDiverseSelectorBinary.cs (1)

42ConcurrentDictionary<FeatureSubsetModel<float>, Single[]> predictions)

Selector\SubModelSelector\BestDiverseSelectorMulticlass.cs (1)

43ConcurrentDictionary<FeatureSubsetModel<VBuffer<float>>, VBuffer<Single>[]> predictions)

Selector\SubModelSelector\BestDiverseSelectorRegression.cs (1)

40ConcurrentDictionary<FeatureSubsetModel<float>, Single[]> predictions)

Utils\BufferPoolManager.cs (1)

30private static readonly ConcurrentDictionary<Type, SortedList<int, List<Array>>> _bufferPools = new ConcurrentDictionary<Type, SortedList<int, List<Array>>>();

Debugging.cs (1)

197public readonly ConcurrentDictionary<string, int> Lines;

BaseTestClassAnalyzer.cs (1)

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

IMethodSymbolExtensions.cs (1)

12public static bool IsTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol factAttribute)

INamedTypeSymbolExtensions.cs (1)

13public static bool IsTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol factAttribute)

RelaxTestNamingSuppressor.cs (1)

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

Model\TiktokenTokenizer.cs (1)

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

WeakStringCache.Concurrent.cs (3)

16private readonly ConcurrentDictionary<int, StringWeakHandle> _stringsByHashCode; 17private readonly ConcurrentDictionary<int, StringWeakHandle> _weakHandlesByHashCode; 44ConcurrentDictionary<int, StringWeakHandle> stringsByHashCode = usingWeakHandle ? _weakHandlesByHashCode : _stringsByHashCode;

DesignerAttribute\VisualStudioDesignerAttributeService.cs (1)

50private readonly ConcurrentDictionary<ProjectId, IProjectItemDesignerTypeUpdateService?> _cpsProjects = [];

Packaging\PackageInstallerServiceFactory.cs (1)

82private readonly ConcurrentDictionary<ProjectId, ProjectState> _projectToInstalledPackageAndVersion = [];

ProjectSystem\MiscellaneousFilesWorkspace.cs (1)

37private readonly ConcurrentDictionary<Guid, LanguageInformation> _languageInformationByLanguageGuid = [];

Telemetry\Shared\TelemetryLogger.cs (3)

75private readonly ConcurrentDictionary<int, object> _pendingScopes = new(concurrencyLevel: 2, capacity: 10); 82private static readonly ConcurrentDictionary<FunctionId, string> s_eventMap = []; 83private static readonly ConcurrentDictionary<(FunctionId id, string name), string> s_propertyMap = [];

Venus\ContainedDocument.cs (1)

68private static readonly ConcurrentDictionary<DocumentId, ContainedDocument> s_containedDocuments = [];

Logging\VSCodeTelemetryLogger.cs (1)

30private static readonly ConcurrentDictionary<int, object> _pendingScopes = new(concurrencyLevel: 2, capacity: 10);

src\VisualStudio\Core\Def\Telemetry\Shared\TelemetryLogger.cs (3)

75private readonly ConcurrentDictionary<int, object> _pendingScopes = new(concurrencyLevel: 2, capacity: 10); 82private static readonly ConcurrentDictionary<FunctionId, string> s_eventMap = []; 83private static readonly ConcurrentDictionary<(FunctionId id, string name), string> s_propertyMap = [];

Implementation\XamlProjectService.cs (1)

38private readonly ConcurrentDictionary<string, DocumentId> _documentIds = new ConcurrentDictionary<string, DocumentId>(StringComparer.OrdinalIgnoreCase);

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

77[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Concurrent.ConcurrentDictionary<,>))]

netstandard.cs (1)

95[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Concurrent.ConcurrentDictionary<,>))]

MS\Internal\WindowsRuntime\Generated\WinRT\ComWrappersSupport.cs (1)

19private static readonly ConcurrentDictionary<string, Func<IInspectable, object>> TypedObjectFactoryCache = new ConcurrentDictionary<string, Func<IInspectable, object>>();

System\Windows\Markup\Baml2006\WpfXamlType.cs (4)

34private ConcurrentDictionary<string, XamlMember> _attachableMembers; 35private ConcurrentDictionary<string, XamlMember> _members; 50protected ConcurrentDictionary<string, XamlMember> Members 62protected ConcurrentDictionary<string, XamlMember> AttachableMembers

AbstractDoNotCopyValue.cs (1)

1666private readonly ConcurrentDictionary<INamedTypeSymbol, bool> _typesToNonCopyable

AbstractRunIterations`1.cs (1)

41var knownTestAttributes = new ConcurrentDictionary<INamedTypeSymbol, bool>();

DefaultableTypeShouldHaveDefaultableFieldsAnalyzer.cs (5)

50var knownNonDefaultableTypes = new ConcurrentDictionary<ITypeSymbol, bool>(); 56private static void AnalyzeField(SymbolAnalysisContext context, INamedTypeSymbol nonDefaultableAttribute, ConcurrentDictionary<ITypeSymbol, bool> knownNonDefaultableTypes) 61private static void AnalyzeNamedType(SymbolAnalysisContext context, INamedTypeSymbol nonDefaultableAttribute, ConcurrentDictionary<ITypeSymbol, bool> knownNonDefaultableTypes) 76private static void AnalyzeField(SymbolAnalysisContext originalContext, IFieldSymbol field, INamedTypeSymbol nonDefaultableAttribute, ConcurrentDictionary<ITypeSymbol, bool> knownNonDefaultableTypes) 110private static bool IsDefaultable(ITypeSymbol type, INamedTypeSymbol nonDefaultableAttribute, ConcurrentDictionary<ITypeSymbol, bool> knownNonDefaultableTypes)

RelaxTestNamingSuppressor.cs (1)

39var knownTestAttributes = new ConcurrentDictionary<INamedTypeSymbol, bool>();

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

14private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

430private static readonly BoundedCache<Compilation, ConcurrentDictionary<IMethodSymbol, IBlockOperation?>> s_methodToTopmostOperationBlockCache 438var methodToBlockMap = s_methodToTopmostOperationBlockCache.GetOrCreateValue(compilation); 546public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\INamedTypeSymbolExtensions.cs (1)

74public static bool IsBenchmarkOrXUnitTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (2)

274private static readonly BoundedCache<Compilation, ConcurrentDictionary<IOperation, ControlFlowGraph?>> s_operationToCfgCache 281var operationToCfgMap = s_operationToCfgCache.GetOrCreateValue(operation.SemanticModel.Compilation);

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\AbstractCategorizedAnalyzerConfigOptions.cs (1)

21private readonly ConcurrentDictionary<OptionKey, (bool found, object? value)> _computedOptionValuesMap;

src\RoslynAnalyzers\Utilities\Compiler\Options\OptionKey.cs (1)

13private static readonly ConcurrentDictionary<(string ruleId, string optionName), OptionKey> s_keys = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

59private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 61private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 379internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 381internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (2)

17/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 52private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledConcurrentDictionary<K, V>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentSet.cs (1)

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool.

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (1)

38private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledDictionary<K, V>>> s_poolInstancesByComparer

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledSortedSet.cs (1)

47private static readonly ConcurrentDictionary<IComparer<T>, ObjectPool<PooledSortedSet<T>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\SymbolDisplayStringCache.cs (4)

19private static readonly BoundedCacheWithFactory<Compilation, ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache>> s_byCompilationCache = new(); 29private readonly ConcurrentDictionary<ISymbol, string> SymbolToDisplayNames = new(); 50ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> dict = 55static ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> CreateConcurrentDictionary(Compilation compilation)

src\RoslynAnalyzers\Utilities\Compiler\UnusedValue.cs (1)

10/// A placeholder value type for <see cref="ConcurrentDictionary{TKey, TValue}"/> used as a set.

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

67private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 81private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

115var reducedNodesMap = new ConcurrentDictionary<SyntaxNode, SyntaxNode>(); 116var reducedTokensMap = new ConcurrentDictionary<SyntaxToken, SyntaxToken>(); 156ConcurrentDictionary<SyntaxNode, SyntaxNode> reducedNodesMap, 157ConcurrentDictionary<SyntaxToken, SyntaxToken> reducedTokensMap,

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (2)

75private readonly ConcurrentDictionary<INamedTypeSymbol, UnusedValue> _sourceSymbolsToCheck = new(); 76private readonly ConcurrentDictionary<INamedTypeSymbol, UnusedValue> _typesWithSymbolDeclaredEventInvoked = new();

Memoization\MemoizedFunction.cs (2)

58private readonly ConcurrentDictionary<Arg, Lazy<TResult>> _values; 131private readonly ConcurrentDictionary<Args, Lazy<TResult>> _values;

ConnectionList.cs (1)

12private readonly ConcurrentDictionary<string, ConnectionContext> _connections = new ConcurrentDictionary<string, ConnectionContext>(StringComparer.Ordinal);

ConnectionList.cs (1)

12private readonly ConcurrentDictionary<string, ConnectionContext> _connections =

System\Collections\Concurrent\ConcurrentDictionary.cs (85)

System\ComponentModel\DataAnnotations\AssociatedMetadataTypeTypeDescriptor.cs (3)

96private static readonly ConcurrentDictionary<Type, Type?> s_metadataTypeCache = new ConcurrentDictionary<Type, Type?>(); 99private static readonly ConcurrentDictionary<(Type, string), Attribute[]> s_typeMemberCache = new ConcurrentDictionary<(Type, string), Attribute[]>(); 102private static readonly ConcurrentDictionary<(Type, Type), bool> s_validatedMetadataTypeCache = new ConcurrentDictionary<(Type, Type), bool>();

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

23private readonly ConcurrentDictionary<Type, TypeStoreItem> _typeStoreItems = new();

System\ComponentModel\PropertyDescriptor.cs (1)

21private ConcurrentDictionary<object, EventHandler?>? _valueChangedHandlers;

System\ComponentModel\ReflectTypeDescriptionProvider.cs (1)

27private readonly ConcurrentDictionary<Type, ReflectedTypeData> _typeData = new ConcurrentDictionary<Type, ReflectedTypeData>();

System\ComponentModel\TypeDescriptor.cs (2)

70private static readonly ConcurrentDictionary<Type, TypeDescriptionNode> s_providerTypeTable = new ConcurrentDictionary<Type, TypeDescriptionNode>(); 75private static readonly ConcurrentDictionary<Type, object?> s_defaultProviderInitialized = new ConcurrentDictionary<Type, object?>();

System\Data\Common\DataStorage.cs (1)

128private static readonly ConcurrentDictionary<Type, Tuple<bool, bool, bool, bool>> s_typeImplementsInterface = new ConcurrentDictionary<Type, Tuple<bool, bool, bool, bool>>();

System\Data\Common\DbProviderFactories.cs (1)

36private static readonly ConcurrentDictionary<string, ProviderRegistration> _registeredFactories = new ConcurrentDictionary<string, ProviderRegistration>();

System\Data\Common\SqlUDTStorage.cs (1)

23private static readonly ConcurrentDictionary<Type, object> s_typeToNull = new ConcurrentDictionary<Type, object>();

src\libraries\Common\src\System\Data\ProviderBase\DbConnectionPoolGroup.cs (3)

33private ConcurrentDictionary<DbConnectionPoolIdentity, DbConnectionPool> _poolCollection; 105ConcurrentDictionary<DbConnectionPoolIdentity, DbConnectionPool>? oldPoolCollection = null; 237var newPoolCollection = new ConcurrentDictionary<DbConnectionPoolIdentity, DbConnectionPool>();

System\Diagnostics\DsesFilterAndTransform.cs (1)

1052private ConcurrentDictionary<Type, TransformSpec?>? _implicitTransformsTable; // If there is more than one object type for an implicit transform, they go here.

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

28private readonly ConcurrentDictionary<Instrument, InstrumentState> _instrumentStates = new();

System\Diagnostics\Metrics\AggregatorStore.cs (10)

167public ConcurrentDictionary<TObjectSequence, TAggregator> GetLabelValuesDictionary<TStringSequence, TObjectSequence>(in TStringSequence names) 354ConcurrentDictionary<ObjectSequence1, TAggregator> valuesDict1 = 363ConcurrentDictionary<ObjectSequence2, TAggregator> valuesDict2 = 373ConcurrentDictionary<ObjectSequence3, TAggregator> valuesDict3 = 387ConcurrentDictionary<ObjectSequenceMany, TAggregator> valuesDictMany = 415private readonly ConcurrentDictionary<TObjectSequence, TAggregator> _valuesDict; 421ConcurrentDictionary<TObjectSequence, TAggregator> valuesDict, 481ConcurrentDictionary<TStringSequence, ConcurrentDictionary<TObjectSequence, TAggregator>> 488foreach (KeyValuePair<TStringSequence, ConcurrentDictionary<TObjectSequence, TAggregator>> kvName in this) 513public ConcurrentDictionary<TObjectSequence, TAggregator> GetValuesDictionary(in TStringSequence names) =>

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

54private readonly ConcurrentDictionary<TKey, TValue> _fastDictionary = new();

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

301private static readonly ConcurrentDictionary<nint, int> s_typeToIDCache = new();

System\Runtime\Serialization\Json\JsonDataContract.cs (1)

155private static readonly ConcurrentDictionary<nint, int> s_typeToIDCache = new();

System\Private\Windows\BinaryFormat\SerializationEvents.cs (1)

12private static readonly ConcurrentDictionary<Type, SerializationEvents> s_cache = new();

NoAssertContext.cs (1)

26private static readonly ConcurrentDictionary<int, int> s_suppressedThreads = new();

System\CoreRtBridge.cs (1)

52private readonly ConcurrentDictionary<K, V> _dict = new ConcurrentDictionary<K, V>();

System\Reflection\MetadataLoadContext.Loading.cs (1)

18private readonly ConcurrentDictionary<RoAssemblyName, RoAssembly> _loadedAssemblies = new ConcurrentDictionary<RoAssemblyName, RoAssembly>();

System\Reflection\MetadataLoadContext.Resolving.cs (1)

23private readonly ConcurrentDictionary<RoAssemblyName, RoAssembly> _binds = new ConcurrentDictionary<RoAssemblyName, RoAssembly>();

System\Reflection\TypeLoading\Modules\RoModule.Unifier.cs (5)

21private readonly ConcurrentDictionary<RoType, RoArrayType> _szArrayDict = new ConcurrentDictionary<RoType, RoArrayType>(); 35private readonly ConcurrentDictionary<RoArrayType.Key, RoArrayType> _mdArrayDict = new ConcurrentDictionary<RoArrayType.Key, RoArrayType>(); 48private readonly ConcurrentDictionary<RoType, RoByRefType> _byRefDict = new ConcurrentDictionary<RoType, RoByRefType>(); 59private readonly ConcurrentDictionary<RoType, RoPointerType> _pointerDict = new ConcurrentDictionary<RoType, RoPointerType>(); 70private readonly ConcurrentDictionary<RoConstructedGenericType.Key, RoConstructedGenericType> _constructedGenericTypeDict = new ConcurrentDictionary<RoConstructedGenericType.Key, RoConstructedGenericType>();

System\Resources\Extensions\BinaryFormat\SerializationEvents.cs (1)

14private static readonly ConcurrentDictionary<Type, SerializationEvents> s_cache = new();

System\Runtime\InteropServices\Marshalling\DefaultCaching.cs (1)

15private readonly ConcurrentDictionary<RuntimeTypeHandle, IIUnknownCacheStrategy.TableInfo> _cache = new(concurrencyLevel: 1, capacity: 16);

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

18private static readonly ConcurrentDictionary<MemberHolder, MemberInfo[]> s_memberInfoTable = new ConcurrentDictionary<MemberHolder, MemberInfo[]>();

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

98private static readonly ConcurrentDictionary<Type, SerializationEvents> s_cache = new ConcurrentDictionary<Type, SerializationEvents>();

Internals\System\Runtime\InternalBufferManager.cs (1)

52private ConcurrentDictionary<int, string> _buffersPooled = new ConcurrentDictionary<int, string>();

Internals\System\Runtime\TimeoutHelper.cs (1)

258private static readonly ConcurrentDictionary<long, Task<CancellationToken>> s_tokenCache =

System\ServiceModel\Channels\ServiceChannelProxy.cs (1)

283private static ConcurrentDictionary<Type, TaskCompletionSourceInfo> s_cache = new ConcurrentDictionary<Type, TaskCompletionSourceInfo>();

System\ServiceModel\Description\XmlSerializerOperationBehavior.cs (1)

1291private static ConcurrentDictionary<XmlMapping, string> s_dictionary = new ConcurrentDictionary<XmlMapping, string>();

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

45private readonly ConcurrentDictionary<ulong, JsonEncodedText> _nameCacheForWriting; 50private readonly ConcurrentDictionary<string, ulong> _nameCacheForReading; 252ConcurrentDictionary<string, ulong>.AlternateLookup<ReadOnlySpan<char>> lookup = _nameCacheForReading.GetAlternateLookup<ReadOnlySpan<char>>();

System\Text\Json\Serialization\JsonSerializerOptions.Caching.cs (1)

209private readonly ConcurrentDictionary<Type, CacheEntry> _cache = new();

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

18private readonly ConcurrentDictionary<Type, DerivedJsonTypeInfo?> _typeToDiscriminatorId = new();

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

20private readonly ConcurrentDictionary<TKey, CacheEntry> _cache = new();

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

53private static readonly ConcurrentDictionary<Key, Node> s_cacheDictionary = new ConcurrentDictionary<Key, Node>(concurrencyLevel: 1, capacity: 31);

System\Resources\AssemblyNamesTypeResolutionService.cs (2)

13private ConcurrentDictionary<AssemblyName, Assembly>? _cachedAssemblies; 14private ConcurrentDictionary<string, Type>? _cachedTypes;

System\Windows\Forms\Application.ThreadContext.cs (1)

26private static readonly ConcurrentDictionary<uint, ThreadContext> s_contextHash = [];

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\CategoryGridEntry.cs (1)

15private static readonly ConcurrentDictionary<string, bool> s_categoryStates = [];

System\Windows\Forms\Controls\ToolStrips\ToolStripManager.cs (1)

24private static readonly ConcurrentDictionary<int, Font> s_defaultFontCache = new();

System\Xaml\InfosetObjects\XamlObjectWriter.cs (1)

1463openGeneric == typeof(ConcurrentDictionary<,>);

System\Xaml\MS\Impl\XmlNsInfo.cs (4)

43private ConcurrentDictionary<string, IList<string>> _clrToXmlNs; 44internal ConcurrentDictionary<string, IList<string>> ClrToXmlNs 204private ConcurrentDictionary<string, IList<string>> LoadClrToXmlNs() 206ConcurrentDictionary<string, IList<string>> result =

System\Xaml\Schema\TypeReflector.cs (2)

40private ConcurrentDictionary<XamlDirective, XamlMember> _aliasedProperties; 378var dict = XamlSchemaContext.CreateDictionary<XamlDirective, XamlMember>();

System\Xaml\Schema\XamlNamespace.cs (1)

21private ConcurrentDictionary<string, XamlType> _typeCache;

System\Xaml\XamlSchemaContext.cs (26)

src\ProjectTemplates\Shared\ProjectFactoryFixture.cs (1)

18private readonly ConcurrentDictionary<string, Project> _projects = new ConcurrentDictionary<string, Project>();

src\ProjectTemplates\Shared\ProjectFactoryFixture.cs (1)

18private readonly ConcurrentDictionary<string, Project> _projects = new ConcurrentDictionary<string, Project>();

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

19private readonly ConcurrentDictionary<string, (IWebDriver browser, ILogs log)> _browsers = new();

src\ProjectTemplates\Shared\ProjectFactoryFixture.cs (1)

18private readonly ConcurrentDictionary<string, Project> _projects = new ConcurrentDictionary<string, Project>();

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

19private readonly ConcurrentDictionary<string, (IWebDriver browser, ILogs log)> _browsers = new();

src\ProjectTemplates\Shared\ProjectFactoryFixture.cs (1)

18private readonly ConcurrentDictionary<string, Project> _projects = new ConcurrentDictionary<string, Project>();

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

19private readonly ConcurrentDictionary<string, (IWebDriver browser, ILogs log)> _browsers = new();

src\ProjectTemplates\Shared\ProjectFactoryFixture.cs (1)

18private readonly ConcurrentDictionary<string, Project> _projects = new ConcurrentDictionary<string, Project>();

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

19private readonly ConcurrentDictionary<string, (IWebDriver browser, ILogs log)> _browsers = new();

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

430private static readonly BoundedCache<Compilation, ConcurrentDictionary<IMethodSymbol, IBlockOperation?>> s_methodToTopmostOperationBlockCache 438var methodToBlockMap = s_methodToTopmostOperationBlockCache.GetOrCreateValue(compilation); 546public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\INamedTypeSymbolExtensions.cs (1)

74public static bool IsBenchmarkOrXUnitTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (2)

274private static readonly BoundedCache<Compilation, ConcurrentDictionary<IOperation, ControlFlowGraph?>> s_operationToCfgCache 281var operationToCfgMap = s_operationToCfgCache.GetOrCreateValue(operation.SemanticModel.Compilation);

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\AbstractCategorizedAnalyzerConfigOptions.cs (1)

21private readonly ConcurrentDictionary<OptionKey, (bool found, object? value)> _computedOptionValuesMap;

src\RoslynAnalyzers\Utilities\Compiler\Options\OptionKey.cs (1)

13private static readonly ConcurrentDictionary<(string ruleId, string optionName), OptionKey> s_keys = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

59private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 61private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 379internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 381internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (2)

17/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 52private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledConcurrentDictionary<K, V>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentSet.cs (1)

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool.

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (1)

38private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledDictionary<K, V>>> s_poolInstancesByComparer

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledSortedSet.cs (1)

47private static readonly ConcurrentDictionary<IComparer<T>, ObjectPool<PooledSortedSet<T>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\SymbolDisplayStringCache.cs (4)

19private static readonly BoundedCacheWithFactory<Compilation, ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache>> s_byCompilationCache = new(); 29private readonly ConcurrentDictionary<ISymbol, string> SymbolToDisplayNames = new(); 50ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> dict = 55static ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> CreateConcurrentDictionary(Compilation compilation)

src\RoslynAnalyzers\Utilities\Compiler\UnusedValue.cs (1)

10/// A placeholder value type for <see cref="ConcurrentDictionary{TKey, TValue}"/> used as a set.

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

67private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 81private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

Services\AsyncOperationService.cs (1)

10private readonly ConcurrentDictionary<string, TaskCompletionSource> _tasks = new();

src\Compilers\Core\Portable\InternalUtilities\ConcurrentDictionaryExtensions.cs (3)

19public static void Add<K, V>(this ConcurrentDictionary<K, V> dict, K key, V value) 28public static TValue GetOrAdd<TKey, TArg, TValue>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) 45this ConcurrentDictionary<TKey, TValue> dictionary,

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

35private readonly ConcurrentDictionary<T, byte> _dictionary;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

14private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

430private static readonly BoundedCache<Compilation, ConcurrentDictionary<IMethodSymbol, IBlockOperation?>> s_methodToTopmostOperationBlockCache 438var methodToBlockMap = s_methodToTopmostOperationBlockCache.GetOrCreateValue(compilation); 546public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\INamedTypeSymbolExtensions.cs (1)

74public static bool IsBenchmarkOrXUnitTestAttribute(this INamedTypeSymbol attributeClass, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (2)

274private static readonly BoundedCache<Compilation, ConcurrentDictionary<IOperation, ControlFlowGraph?>> s_operationToCfgCache 281var operationToCfgMap = s_operationToCfgCache.GetOrCreateValue(operation.SemanticModel.Compilation);

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\AbstractCategorizedAnalyzerConfigOptions.cs (1)

21private readonly ConcurrentDictionary<OptionKey, (bool found, object? value)> _computedOptionValuesMap;

src\RoslynAnalyzers\Utilities\Compiler\Options\OptionKey.cs (1)

13private static readonly ConcurrentDictionary<(string ruleId, string optionName), OptionKey> s_keys = new();

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

59private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 61private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 379internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 381internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentDictionary.cs (2)

17/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 52private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledConcurrentDictionary<K, V>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledConcurrentSet.cs (1)

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool.

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (1)

38private static readonly ConcurrentDictionary<IEqualityComparer<K>, ObjectPool<PooledDictionary<K, V>>> s_poolInstancesByComparer

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledSortedSet.cs (1)

47private static readonly ConcurrentDictionary<IComparer<T>, ObjectPool<PooledSortedSet<T>>> s_poolInstancesByComparer = new();

src\RoslynAnalyzers\Utilities\Compiler\SymbolDisplayStringCache.cs (4)

19private static readonly BoundedCacheWithFactory<Compilation, ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache>> s_byCompilationCache = new(); 29private readonly ConcurrentDictionary<ISymbol, string> SymbolToDisplayNames = new(); 50ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> dict = 55static ConcurrentDictionary<SymbolDisplayFormat, SymbolDisplayStringCache> CreateConcurrentDictionary(Compilation compilation)

src\RoslynAnalyzers\Utilities\Compiler\UnusedValue.cs (1)

10/// A placeholder value type for <see cref="ConcurrentDictionary{TKey, TValue}"/> used as a set.

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

67private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 81private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

19private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.Changes.cs (2)

22private ConcurrentDictionary<int, TriviaData> _map; 32var map = InterlockedOperations.Initialize(ref _map, () => new ConcurrentDictionary<int, TriviaData>(concurrencyLevel: 1, capacity: 8));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\Extensions.cs (2)

302public static void ClearAndFree<TKey, TValue>(this ObjectPool<ConcurrentDictionary<TKey, TValue>> pool, ConcurrentDictionary<TKey, TValue> map)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

26private readonly ConcurrentDictionary<string, Optional<T>> _cachedValues = [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (2)

14private static readonly ConcurrentDictionary<SpecialType, string> s_fromSpecialTypes = new(); 15private static readonly ConcurrentDictionary<string, SpecialType> s_toSpecialTypes = new();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (4)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 17private static readonly ConditionalWeakTable<Compilation, TreeMap> s_treeAliasMap = new(); 34if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) || 50var treeMap = s_treeAliasMap.GetValue(semanticModel.Compilation, static _ => new TreeMap());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

115var reducedNodesMap = new ConcurrentDictionary<SyntaxNode, SyntaxNode>(); 116var reducedTokensMap = new ConcurrentDictionary<SyntaxToken, SyntaxToken>(); 156ConcurrentDictionary<SyntaxNode, SyntaxNode> reducedNodesMap, 157ConcurrentDictionary<SyntaxToken, SyntaxToken> reducedTokensMap,

ObjectModel\Build.cs (2)

21private readonly ConcurrentDictionary<int, Project> _projectIdToProjectMap = new ConcurrentDictionary<int, Project>(); 26private readonly ConcurrentDictionary<string, string> _taskToAssemblyMap = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ObjectModel\Project.cs (1)

29private readonly ConcurrentDictionary<string, Target> _targetNameToTargetMap = new ConcurrentDictionary<string, Target>(StringComparer.OrdinalIgnoreCase);

DictionaryAsserts.cs (2)

119 ConcurrentDictionary<TKey, TValue> collection) 260 ConcurrentDictionary<TKey, TValue> collection)

Sdk\AssertEqualityComparer.cs (2)

140 static readonly ConcurrentDictionary<Type, TypeInfo> cacheOfIComparableOfT = new ConcurrentDictionary<Type, TypeInfo>(); 141 static readonly ConcurrentDictionary<Type, TypeInfo> cacheOfIEquatableOfT = new ConcurrentDictionary<Type, TypeInfo>();

Sdk\AssertHelper.cs (1)

63 static readonly ConcurrentDictionary<Type, Dictionary<string, Func<object?, object?>>> gettersByType = new ConcurrentDictionary<Type, Dictionary<string, Func<object?, object?>>>();

Sdk\CollectionTrackerExtensions.cs (1)

46 static readonly ConcurrentDictionary<Type, MethodInfo> cacheOfAsTrackerByType = new ConcurrentDictionary<Type, MethodInfo>();

common\AssemblyResolution\DependencyContextAssemblyCache.cs (2)

32readonly ConcurrentDictionary<string, Assembly> managedAssemblyCache; 36readonly ConcurrentDictionary<string, string> unmanagedAssemblyCache;

ConsoleRunner.cs (1)

22readonly ConcurrentDictionary<string, ExecutionSummary> completionMessages = new ConcurrentDictionary<string, ExecutionSummary>();