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)

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

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

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)

23private 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)

37public 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 (3)

70private ConcurrentDictionary<ImportInfo, ImmutableArray<AssemblySymbol>>? _lazyImportInfos; 1489private ConcurrentDictionary<string, NamespaceSymbol>? _externAliasTargets; 2450private ConcurrentDictionary<(ImmutableArray<byte> ContentHash, int Position), OneOrMany<(Location AttributeLocation, MethodSymbol Interceptor)>>? _interceptions;

Compiler\ClsComplianceChecker.cs (1)

32private readonly ConcurrentDictionary<Symbol, Compliance> _declaredOrInheritedCompliance;

Compiler\MethodCompiler.cs (4)

1882ConcurrentDictionary<IdentifierNameSyntax, int>? identifierMap; 2078out InMethodBinder? inMethodBinder, out ConcurrentDictionary<IdentifierNameSyntax, int>? identifierMap) 2131static void addIdentifiers(CSharpSyntaxNode? node, ConcurrentDictionary<IdentifierNameSyntax, int> identifierMap) 2212static void assertBindIdentifierTargets(InMethodBinder? inMethodBinder, ConcurrentDictionary<IdentifierNameSyntax, int>? identifierMap, BoundNode methodBody, BindingDiagnosticBag diagnostics)

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

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

Emitter\Model\PEModuleBuilder.cs (3)

28protected readonly ConcurrentDictionary<Symbol, Cci.IModuleReference> AssemblyOrModuleSymbolToModuleRefMap = new ConcurrentDictionary<Symbol, Cci.IModuleReference>(); 29private readonly ConcurrentDictionary<Symbol, object> _genericInstanceMap = new ConcurrentDictionary<Symbol, object>(Symbols.SymbolEqualityComparer.ConsiderEverything); 30private 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; 758var map = info.ImplementationForInterfaceMemberMap;

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

266private 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)

266private 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)

68var 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)

251var 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)

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

Internal\Analyzer\AbstractCopilotCodeAnalysisService.cs (1)

38private readonly ConditionalWeakTable<Document, ConcurrentDictionary<string, (ImmutableArray<Diagnostic> Diagnostics, bool IsCompleteResult)>> _diagnosticsCache = new();

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)

98internal 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.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)

36private 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)

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

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

SymbolSearch\Windows\SymbolSearchUpdateEngine.cs (1)

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

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

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

HostWorkspace\LanguageServerProjectLoader.cs (1)

52private readonly ConcurrentDictionary<string, List<LoadedProject>> _loadedProjects = [];

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

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

Logging\LspLogMessageLoggerProvider.cs (1)

11private 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)

184private 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)

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

DeclarePublicApiAnalyzer.Impl.cs (3)

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

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

731public static bool IsBenchmarkOrXUnitTestMethod(this IMethodSymbol method, ConcurrentDictionary<INamedTypeSymbol, bool> knownTestAttributes, INamedTypeSymbol? benchmarkAttribute, INamedTypeSymbol? xunitFactAttribute)

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

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

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

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new(); 33ConcurrentDictionary<OperationKind, bool> wrappedSyntax = s_supportedOperationWrappers.GetOrAdd(underlyingType, _ => new ConcurrentDictionary<OperationKind, bool>());

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)

58private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 60private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 378internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 380internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

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

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 51private 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)

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

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

64private static readonly ConcurrentDictionary<IEqualityComparer<T>, ObjectPool<PooledHashSet<T>>> s_poolInstancesByComparer = new();

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

46private 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)

65private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 79private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

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\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

16private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

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

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

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

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

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

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

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

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new(); 33ConcurrentDictionary<OperationKind, bool> wrappedSyntax = s_supportedOperationWrappers.GetOrAdd(underlyingType, _ => new ConcurrentDictionary<OperationKind, bool>());

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)

58private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 60private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 378internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 380internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

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

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 51private 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)

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

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

64private static readonly ConcurrentDictionary<IEqualityComparer<T>, ObjectPool<PooledHashSet<T>>> s_poolInstancesByComparer = new();

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

46private 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)

65private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 79private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

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)

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

Emit\EditAndContinue\VisualBasicSymbolMatcher.vb (3)

75Private ReadOnly _matches As ConcurrentDictionary(Of Symbol, Symbol) 86Private ReadOnly _otherMembers As ConcurrentDictionary(Of ISymbolInternal, IReadOnlyDictionary(Of String, ImmutableArray(Of ISymbolInternal))) 560Private ReadOnly _matches As ConcurrentDictionary(Of Symbol, Symbol)

Emit\PEModuleBuilder.vb (1)

21Private 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)

74Private _lazyInternalsVisibleToMap As ConcurrentDictionary(Of String, ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String))) 874Private _optimisticallyGrantedInternalsAccess As ConcurrentDictionary(Of AssemblySymbol, Boolean) 880Dim haveGrantedAssemblies As ConcurrentDictionary(Of AssemblySymbol, Boolean) = _optimisticallyGrantedInternalsAccess 914Dim result As ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)) = Nothing 984New ConcurrentDictionary(Of String, ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)))(StringComparer.OrdinalIgnoreCase), Nothing) 1003Dim keys As ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)) = Nothing

Symbols\Source\SourceNamedTypeSymbol.vb (1)

43Private _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)

23private 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)

63private readonly ConcurrentDictionary<string, ImmutableArray<DocumentId>> _lazyFilePathToRelatedDocumentIds = new ConcurrentDictionary<string, ImmutableArray<DocumentId>>(FilePathComparer); 1282var 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 =

src\AssetPublisherFactory.cs (1)

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

src\PublishArtifactsInManifestBase.cs (2)

195private readonly ConcurrentDictionary<(int AssetId, string AssetLocation, LocationType LocationType), ValueTuple> NewAssetLocations = 198private 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)

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

ResponseCachingChatClient.cs (1)

18private readonly ConcurrentDictionary<string, Stopwatch> _stopWatches;

ContentSafetyService.cs (1)

35private 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 (2)

15private readonly ConcurrentDictionary<string, Task<long>> _tagInvalidationTimes = []; 18private readonly ConcurrentDictionary<string, Task<long>>.AlternateLookup<ReadOnlySpan<char>> _tagInvalidationTimesBySpan;

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;

Latency\Internal\HttpRequestLatencyListener.cs (1)

20private readonly ConcurrentDictionary<string, EventSource?> _eventSources = new()

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)

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

FormattedLogValues.cs (1)

22private 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();

Buffering\GlobalLogBufferManager.cs (1)

14private readonly ConcurrentDictionary<string, GlobalBuffer> _buffers = [];

Buffering\LogBufferingFilterRuleSelector.cs (1)

30private readonly ConcurrentDictionary<(LogLevel, EventId), List<LogBufferingFilterRule>> _ruleCache = 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>();

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

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 (1)

16private readonly ConcurrentDictionary<int, StringWeakHandle> _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);

CachingFileSystemWrapper.cs (2)

16private readonly ConcurrentDictionary<string, bool> _existenceCache = new ConcurrentDictionary<string, bool>(); 17private readonly ConcurrentDictionary<string, DateTime> _lastWriteTimeCache = new ConcurrentDictionary<string, DateTime>();

FileUtilities.cs (1)

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

RegisteredTaskObjectCacheBase.cs (13)

TypeLoader.cs (11)

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)

40var 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\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeMetricsAnalysisContext.cs (1)

16private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

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

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

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

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

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

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

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

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new(); 33ConcurrentDictionary<OperationKind, bool> wrappedSyntax = s_supportedOperationWrappers.GetOrAdd(underlyingType, _ => new ConcurrentDictionary<OperationKind, bool>());

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)

58private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 60private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 378internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 380internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

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

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 51private 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)

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

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

64private static readonly ConcurrentDictionary<IEqualityComparer<T>, ObjectPool<PooledHashSet<T>>> s_poolInstancesByComparer = new();

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

46private 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)

65private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 79private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (2)

72private readonly ConcurrentDictionary<INamedTypeSymbol, UnusedValue> _sourceSymbolsToCheck = new(); 73private 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)

60private static readonly ConcurrentDictionary<Type, TypeDescriptionNode> s_providerTypeTable = new ConcurrentDictionary<Type, TypeDescriptionNode>(); 65private 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\Net\Http\SocketsHttpHandler\FailedProxyCache.cs (1)

31private readonly ConcurrentDictionary<Uri, long> _failedProxies = new ConcurrentDictionary<Uri, long>();

System\Net\Http\SocketsHttpHandler\HttpConnectionPoolManager.cs (4)

37private readonly ConcurrentDictionary<HttpConnectionKey, HttpConnectionPool> _pools; 53/// <see cref="ConcurrentDictionary{TKey,TValue}.IsEmpty"/> call. 155var poolsRef = new WeakReference<ConcurrentDictionary<HttpConnectionKey, HttpConnectionPool>>(_pools); 158if (poolsRef.TryGetTarget(out ConcurrentDictionary<HttpConnectionKey, HttpConnectionPool>? pools))

src\libraries\Common\src\System\Net\SafeHandleCache.cs (1)

38private readonly ConcurrentDictionary<TKey, THandle> _cache = new();

System\Net\ServicePoint\ServicePointManager.cs (1)

18private static readonly ConcurrentDictionary<string, WeakReference<ServicePoint>> s_servicePointTable = new ConcurrentDictionary<string, WeakReference<ServicePoint>>();

src\libraries\Common\src\System\Net\SafeHandleCache.cs (1)

38private readonly ConcurrentDictionary<TKey, THandle> _cache = new();

System\Net\Security\SslSessionsCache.cs (1)

17private static readonly ConcurrentDictionary<SslCredKey, SafeCredentialReference> s_cachedCreds =

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

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.Nid.cs (1)

13private static readonly ConcurrentDictionary<string, int> s_nidLookup =

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

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

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

12private static readonly ConcurrentDictionary<string, string> s_lateBoundOidToFriendlyName = 15private static readonly ConcurrentDictionary<string, string> s_lateBoundFriendlyNameToOid =

System\Security\Cryptography\X509Certificates\OpenSslX509ChainProcessor.cs (1)

40private static readonly ConcurrentDictionary<int, string> s_errorStrings =

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\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\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (3)

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

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

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

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

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

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

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new(); 33ConcurrentDictionary<OperationKind, bool> wrappedSyntax = s_supportedOperationWrappers.GetOrAdd(underlyingType, _ => new ConcurrentDictionary<OperationKind, bool>());

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)

58private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 60private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 378internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 380internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

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

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 51private 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)

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

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

64private static readonly ConcurrentDictionary<IEqualityComparer<T>, ObjectPool<PooledHashSet<T>>> s_poolInstancesByComparer = new();

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

46private 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)

65private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 79private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

Services\AsyncOperationService.cs (1)

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

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

16private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelMap;

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

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

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

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

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

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

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

17private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<OperationKind, bool>> s_supportedOperationWrappers = new(); 33ConcurrentDictionary<OperationKind, bool> wrappedSyntax = s_supportedOperationWrappers.GetOrAdd(underlyingType, _ => new ConcurrentDictionary<OperationKind, bool>());

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)

58private readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> _wildcardMatchResult = new(); 60private readonly ConcurrentDictionary<ISymbol, string> _symbolToDeclarationId = new(); 378internal ref readonly ConcurrentDictionary<ISymbol, KeyValuePair<string?, TValue?>> WildcardMatchResult => ref _symbolNamesWithValueOption._wildcardMatchResult; 380internal ref readonly ConcurrentDictionary<ISymbol, string> SymbolToDeclarationId => ref _symbolNamesWithValueOption._symbolToDeclarationId;

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

16/// <see cref="ConcurrentDictionary{TKey, TValue}"/> that can be recycled via an object pool. 51private 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)

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

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

64private static readonly ConcurrentDictionary<IEqualityComparer<T>, ObjectPool<PooledHashSet<T>>> s_poolInstancesByComparer = new();

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

46private 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)

65private readonly ConcurrentDictionary<string, INamedTypeSymbol?> _fullNameToTypeMap; 79private static readonly ConcurrentDictionary<string, ImmutableArray<string>> _fullTypeNameToNamespaceNames =

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