ConcurrentDictionary

119 references to ConcurrentDictionary

Aspire.Dashboard (8)

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

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

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

98private readonly ConcurrentDictionary<string, ResourceViewModel> _resourceByName = new(StringComparers.ResourceName); 810public ConcurrentDictionary<string, bool> ResourceTypesToVisibility { get; } = new(StringComparers.ResourceName); 811public ConcurrentDictionary<string, bool> ResourceStatesToVisibility { get; } = new(StringComparers.ResourceState); 812public ConcurrentDictionary<string, bool> ResourceHealthStatusesToVisibility { get; } = new(StringComparer.Ordinal);

Model\ResourceOutgoingPeerResolver.cs (1)

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

Otlp\Model\ColorGenerator.cs (1)

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

Otlp\Model\OtlpApplication.cs (1)

35private readonly ConcurrentDictionary<KeyValuePair<string, string>[], OtlpApplicationView> _applicationViews = new(ApplicationViewKeyComparer.Instance);

Aspire.Hosting (1)

Dashboard\DashboardLifecycleHook.cs (1)

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

Aspire.Microsoft.Data.SqlClient (1)

src\Vendoring\OpenTelemetry.Instrumentation.SqlClient\SqlClientTraceInstrumentationOptions.cs (1)

52private static readonly ConcurrentDictionary<string, SqlConnectionDetails> ConnectionDetailCache = new(StringComparer.OrdinalIgnoreCase);

Aspire.Microsoft.EntityFrameworkCore.SqlServer (1)

src\Vendoring\OpenTelemetry.Instrumentation.SqlClient\SqlClientTraceInstrumentationOptions.cs (1)

52private static readonly ConcurrentDictionary<string, SqlConnectionDetails> ConnectionDetailCache = new(StringComparer.OrdinalIgnoreCase);

GenerateDocumentationAndConfigFiles (3)

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

30: base(keyComparer)

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

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

JwtClientSample (1)

Program.cs (1)

24private readonly ConcurrentDictionary<string, Task<string>> _tokens = new ConcurrentDictionary<string, Task<string>>(StringComparer.Ordinal);

Metrics (3)

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

30: base(keyComparer)

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

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

Metrics.Legacy (3)

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

30: base(keyComparer)

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

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

Microsoft.AspNetCore.Components (1)

Reflection\ComponentProperties.cs (1)

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

Microsoft.AspNetCore.Components.Server (1)

ProtectedBrowserStorage\ProtectedBrowserStorage.cs (1)

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

Microsoft.AspNetCore.Http.Connections (1)

Internal\HttpConnectionManager.cs (1)

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

Microsoft.AspNetCore.Mvc.Razor (1)

Compilation\DefaultViewCompiler.cs (1)

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

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation (1)

RuntimeViewCompiler.cs (1)

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

Microsoft.AspNetCore.Mvc.TagHelpers (1)

JavaScriptResources.cs (1)

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

Microsoft.AspNetCore.Mvc.ViewFeatures (2)

CachedExpressionCompiler.cs (1)

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

ModelExpressionProvider.cs (1)

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

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

ExpressionHelperTest.cs (1)

11private readonly ConcurrentDictionary<LambdaExpression, string> _expressionTextCache = new ConcurrentDictionary<LambdaExpression, string>(LambdaExpressionComparer.Instance);

Microsoft.AspNetCore.SignalR.Client.Core (1)

HubConnection.cs (1)

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

Microsoft.AspNetCore.SignalR.Core (3)

HubConnectionContext.cs (1)

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

HubConnectionStore.cs (1)

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

Internal\HubGroupList.cs (1)

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

Microsoft.AspNetCore.SignalR.StackExchangeRedis (1)

Internal\RedisSubscriptionManager.cs (1)

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

Microsoft.AspNetCore.SignalR.Tests.Utils (1)

ServerLogScope.cs (1)

27_serverLoggers = new ConcurrentDictionary<string, ILogger>(StringComparer.Ordinal);

Microsoft.Build.Framework (1)

ImmutableFilesTimestampCache.cs (1)

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

Microsoft.CodeAnalysis (16)

CodeGen\ItemTokenMap.cs (1)

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

CodeGen\PrivateImplementationDetails.cs (3)

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

CodeGen\StringTokenMap.cs (1)

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

CommandLine\AnalyzerConfigSet.cs (1)

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

DiagnosticAnalyzer\ShadowCopyAnalyzerPathResolver.cs (2)

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

Emit\CommonPEModuleBuilder.cs (2)

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

Emit\DebugDocumentsBuilder.cs (1)

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

Emit\NoPia\EmbeddedTypesManager.cs (5)

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

Microsoft.CodeAnalysis.Analyzers (3)

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

30: base(keyComparer)

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

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

Microsoft.CodeAnalysis.AnalyzerUtilities (3)

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

30: base(keyComparer)

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

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (3)

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

30: base(keyComparer)

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

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

Microsoft.CodeAnalysis.CSharp (12)

Compilation\CSharpCompilation.cs (1)

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

Compiler\ClsComplianceChecker.cs (1)

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

Compiler\MethodCompiler.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

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

Emitter\Model\PEModuleBuilder.cs (2)

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

Emitter\NoPia\EmbeddedTypesManager.cs (2)

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

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

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

Symbols\Source\SourceAssemblySymbol.cs (1)

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

Microsoft.CodeAnalysis.Features (2)

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (1)

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

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

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

Microsoft.CodeAnalysis.LanguageServer (1)

Logging\LspLogMessageLoggerProvider.cs (1)

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

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (3)

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

30: base(keyComparer)

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (4)

DeclarePublicApiAnalyzer.Impl.cs (1)

84private readonly ConcurrentDictionary<string, UnusedValue> _visitedApiList = new(StringComparer.Ordinal);

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

30: base(keyComparer)

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

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

Microsoft.CodeAnalysis.ResxSourceGenerator (3)

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

30: base(keyComparer)

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

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

Microsoft.CodeAnalysis.Test.Utilities (1)

TargetFrameworkUtil.cs (1)

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

Microsoft.CodeAnalysis.Workspaces (4)

FindSymbols\FindReferences\FindReferenceCache.cs (1)

84_identifierCache = new(comparer: semanticModel.Language switch

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

Workspace\Solution\SolutionState.cs (1)

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

Microsoft.Extensions.FileProviders.Physical (2)

PhysicalFilesWatcher.cs (2)

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

Microsoft.Extensions.Http (1)

DefaultHttpClientFactory.cs (1)

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

Microsoft.Extensions.Logging (1)

LoggerFactory.cs (1)

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

Microsoft.Extensions.Logging.Console (1)

ConsoleLoggerProvider.cs (1)

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

Microsoft.Extensions.Logging.TraceSource (1)

TraceSourceLoggerProvider.cs (1)

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

Microsoft.ML.InternalCodeAnalyzer (2)

BaseTestClassAnalyzer.cs (1)

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

RelaxTestNamingSuppressor.cs (1)

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

Microsoft.ML.Tokenizers (1)

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

Microsoft.VisualStudio.LanguageServices.Xaml (1)

Implementation\XamlProjectService.cs (1)

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

Roslyn.Diagnostics.Analyzers (3)

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

30: base(keyComparer)

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

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

SignalRSamples (1)

ConnectionList.cs (1)

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

SocialWeather (1)

ConnectionList.cs (1)

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

System.Text.Json (1)

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

66_nameCacheForReading = new(StringComparer.Ordinal);

System.Windows.Forms (1)

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

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

Test.Utilities (3)

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

30: base(keyComparer)

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

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

Text.Analyzers (3)

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

30: base(keyComparer)

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

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

XmlFileLogger (2)

ObjectModel\Build.cs (1)

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

xunit.console (2)

common\AssemblyResolution\DependencyContextAssemblyCache.cs (2)

64managedAssemblyCache = new ConcurrentDictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 79unmanagedAssemblyCache = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);