AsyncLazy

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCommitter.cs (1)

49_renameSymbolResultGetter = new AsyncLazy<RenameTrackingSolutionSet>(c => RenameSymbolWorkerAsync(c), cacheResult: true);

Utilities\AsyncLazyTests.cs (4)

46var lazy = new AsyncLazy<object>( 69var lazy = new AsyncLazy<object>(c => Task.FromResult(new object()), cacheResult: true); 95? new AsyncLazy<object>(asynchronousComputeFunction, cacheResult: true) 96: new AsyncLazy<object>(asynchronousComputeFunction, synchronousComputeFunction, cacheResult: true);

AddImport\SearchScopes\SourceSymbolsProjectSearchScope.cs (1)

57=> new(async c =>

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (1)

191var lazyResults = new AsyncLazy<DocumentAnalysisResults>(

EditAndContinue\EditSession.cs (3)

113? new AsyncLazy<ActiveStatementsMap>(GetBaseActiveStatementsAsync, cacheResult: true) 114: new AsyncLazy<ActiveStatementsMap>(ActiveStatementsMap.Empty)); 116Capabilities = new AsyncLazy<EditAndContinueCapabilities>(GetCapabilitiesAsync, cacheResult: true);

EncapsulateField\EncapsulateFieldResult.cs (1)

24_lazySolution = new AsyncLazy<Solution>(getSolutionAsync, cacheResult: true);

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

161static t => new AsyncLazy<TopLevelSyntaxTreeIndex?>(

Services\ClientOptionProviders.cs (1)

37var lazyOptions = ImmutableInterlocked.GetOrAdd(ref _cache, languageServices.Language, _ => new AsyncLazy<TOptions>(GetRemoteOptions, cacheResult: true));

AsyncLazy`1.cs (2)

17=> new(asynchronousComputeFunction, cacheResult); 20=> new(value);

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (2)

66var lazyCompilation = new AsyncLazy<Compilation>(project.GetRequiredCompilationAsync, cacheResult: true); 117var lazyAssembly = new AsyncLazy<IAssemblySymbol?>(async cancellationToken =>

FindSymbols\FindReferences\DependentTypeFinder_ProjectIndex.cs (1)

42project, p => new AsyncLazy<ProjectIndex>(

FindSymbols\SymbolTree\SymbolTreeInfo.cs (1)

129query, new AsyncLazy<IAssemblySymbol?>(assembly), filter, cancellationToken);

FindSymbols\SymbolTree\SymbolTreeInfo_Metadata.cs (2)

138id => new AsyncLazy<SymbolTreeInfo>( 158metadataId => new AsyncLazy<SymbolTreeInfo>(

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (1)

75project.State, static p => new AsyncLazy<Checksum>(c => ComputeSourceSymbolsChecksumAsync(p, c), cacheResult: true));

ValueSource.cs (1)

22=> new AsyncLazy<T>(value);

Workspace\Solution\AnalyzerConfigDocumentState.cs (1)

41return new AsyncLazy<AnalyzerConfig>(

Workspace\Solution\Document.cs (1)

491var newAsyncLazy = new AsyncLazy<DocumentOptionSet>(async cancellationToken =>

Workspace\Solution\DocumentState.cs (3)

108return new AsyncLazy<TreeAndVersion>( 171return new AsyncLazy<TreeAndVersion>( 548new AsyncLazy<SourceText>(

Workspace\Solution\DocumentState_LinkedFileReuse.cs (1)

76return new AsyncLazy<TreeAndVersion>(

Workspace\Solution\LoadableTextAndVersionSource.cs (1)

24LazyValue = new AsyncLazy<TextAndVersion>(LoadAsync, LoadSynchronously, source.CacheResult);

Workspace\Solution\ProjectState.cs (10)

Workspace\Solution\SolutionState.CompilationTracker.cs (3)

1140Interlocked.CompareExchange(ref _lazyDependentVersion, new AsyncLazy<VersionStamp>(c => ComputeDependentVersionAsync(tmp, c), cacheResult: true), null); 1173Interlocked.CompareExchange(ref _lazyDependentSemanticVersion, new AsyncLazy<VersionStamp>(c => ComputeDependentSemanticVersionAsync(tmp, c), cacheResult: true), null); 1204Interlocked.CompareExchange(ref _lazyDependentChecksum, new AsyncLazy<Checksum>(c => ComputeDependentChecksumAsync(tmp, c), cacheResult: true), null);

Workspace\Solution\SolutionState.cs (1)

108_lazyChecksums = new AsyncLazy<SolutionStateChecksums>(

Workspace\Solution\SolutionState.GeneratedFileReplacingCompilationTracker.cs (1)

125Interlocked.CompareExchange(ref _lazyDependentChecksum, new AsyncLazy<Checksum>(c => ComputeDependentChecksumAsync(tmp, c), cacheResult: true), null);

Workspace\Solution\SolutionState.SkeletonReferenceCache.cs (1)

192compilation => new AsyncLazy<SkeletonReferenceSet?>(

Workspace\Solution\SolutionState_Checksum.cs (1)

77return new AsyncLazy<SolutionStateChecksums>(

Workspace\Solution\TextDocumentState.cs (1)

55_lazyChecksums = new AsyncLazy<DocumentStateChecksums>(ComputeChecksumsAsync, cacheResult: true);

UtilityTest\AsyncLazyTests.cs (4)

26var lazy = new AsyncLazy<int>(c => Task.FromResult(5), cacheResult: true); 52var lazy = new AsyncLazy<int>( 170lazy = new AsyncLazy<object>(c => 204var lazy = new AsyncLazy<object>(c => Task.Run((Func<object>)(() =>

ProjectSystem\FileChangeTracker.cs (2)

23private static readonly AsyncLazy<uint?> s_none = new(value: null); 110_fileChangeCookie = new AsyncLazy<uint?>(async cancellationToken =>

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (4)

127var baseActiveStatements = AsyncLazy.Create(activeStatementMap ?? ActiveStatementsMap.Empty); 128var lazyCapabilities = AsyncLazy.Create(capabilities); 750var baseActiveStatements = AsyncLazy.Create(ActiveStatementsMap.Empty); 751var capabilities = AsyncLazy.Create(EditAndContinueTestHelpers.Net5RuntimeCapabilities);

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCommitter.cs (1)

35private readonly AsyncLazy<RenameTrackingSolutionSet> _renameSymbolResultGetter;

EditAndContinue\EditAndContinueTestHelpers.cs (2)

126var lazyCapabilities = AsyncLazy.Create(requiredCapabilities); 153var lazyOldActiveStatementMap = AsyncLazy.Create(expectedResult.ActiveStatements.OldStatementsMap);

Utilities\AsyncLazyTests.cs (4)

27private static void CancellationDuringInlinedComputationFromGetValueOrGetValueAsyncStillCachesResultCore(Func<AsyncLazy<object>, CancellationToken, object> doGetValue, bool includeSynchronousComputation) 46var lazy = new AsyncLazy<object>( 69var lazy = new AsyncLazy<object>(c => Task.FromResult(new object()), cacheResult: true); 94var lazy = producerAsync

AddImport\AbstractAddImportFeatureService.cs (3)

128var projectToAssembly = new ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>>(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count); 160ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, 203ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly,

AddImport\SearchScopes\SourceSymbolsProjectSearchScope.cs (4)

24private readonly ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol?>> _projectToAssembly; 28ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol?>> projectToAssembly, 49var lazyAssembly = _projectToAssembly.GetOrAdd(_project, CreateLazyAssembly); 56static AsyncLazy<IAssemblySymbol?> CreateLazyAssembly(Project project)

AddImport\SymbolReferenceFinder.cs (1)

99ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly,

Completion\SharedSyntaxContextsWithSpeculativeModel.cs (3)

20private readonly ConcurrentDictionary<Document, AsyncLazy<SyntaxContext>> _cache; 33if (!_cache.TryGetValue(document, out var lazyContext)) 44static AsyncLazy<SyntaxContext> GetLazySyntaxContextWithSpeculativeModel(Document document, SharedSyntaxContextsWithSpeculativeModel self)

DesignerAttribute\DesignerAttributeDiscoveryService.cs (9)

32private static readonly ConditionalWeakTable<IReadOnlyList<MetadataReference>, AsyncLazy<bool>> s_metadataReferencesToDesignerAttributeInfo = new(); 54private static AsyncLazy<bool> GetLazyHasDesignerCategoryType(Project project) 114var lazyProjectVersion = AsyncLazy.Create(project.GetSemanticVersionAsync, cacheResult: true); 134var lazyHasDesignerCategoryType = GetLazyHasDesignerCategoryType(project); 148AsyncLazy<VersionStamp> lazyProjectVersion, 149AsyncLazy<bool> lazyHasDesignerCategoryType, 172AsyncLazy<VersionStamp> lazyProjectVersion, 173AsyncLazy<bool> lazyHasDesignerCategoryType, 230AsyncLazy<bool> lazyHasDesignerCategoryType, Document document, CancellationToken cancellationToken)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (2)

504AsyncLazy<ActiveStatementsMap> lazyOldActiveStatementMap, 507AsyncLazy<EditAndContinueCapabilities> lazyCapabilities,

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (8)

28private readonly Dictionary<DocumentId, (AsyncLazy<DocumentAnalysisResults> results, Project baseProject, Document document, ImmutableArray<LinePositionSpan> activeStatementSpans)> _analyses = new(); 29private readonly AsyncLazy<ActiveStatementsMap> _baseActiveStatements; 30private readonly AsyncLazy<EditAndContinueCapabilities> _capabilities; 32public EditAndContinueDocumentAnalysesCache(AsyncLazy<ActiveStatementsMap> baseActiveStatements, AsyncLazy<EditAndContinueCapabilities> capabilities) 88AsyncLazy<DocumentAnalysisResults> lazyResults; 170private AsyncLazy<DocumentAnalysisResults> GetDocumentAnalysisNoLock(Project baseProject, Document document, ImmutableArray<LinePositionSpan> activeStatementSpans) 191var lazyResults = new AsyncLazy<DocumentAnalysisResults>(

EditAndContinue\EditSession.cs (3)

71internal readonly AsyncLazy<EditAndContinueCapabilities> Capabilities; 77internal readonly AsyncLazy<ActiveStatementsMap> BaseActiveStatements; 102AsyncLazy<ActiveStatementsMap>? lazyActiveStatementMap,

EditAndContinue\IEditAndContinueAnalyzer.cs (2)

18AsyncLazy<ActiveStatementsMap> lazyBaseActiveStatements, 21AsyncLazy<EditAndContinueCapabilities> lazyCapabilities,

EncapsulateField\EncapsulateFieldResult.cs (1)

18private readonly AsyncLazy<Solution> _lazySolution;

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (2)

21using CachedIndexMap = ConcurrentDictionary<(IChecksummedPersistentStorageService service, DocumentKey documentKey, StringTable stringTable), AsyncLazy<TopLevelSyntaxTreeIndex?>>; 159var asyncLazy = cachedIndexMap.GetOrAdd(

Services\ClientOptionProviders.cs (3)

27private ImmutableDictionary<string, AsyncLazy<TOptions>> _cache = ImmutableDictionary<string, AsyncLazy<TOptions>>.Empty; 37var lazyOptions = ImmutableInterlocked.GetOrAdd(ref _cache, languageServices.Language, _ => new AsyncLazy<TOptions>(GetRemoteOptions, cacheResult: true));

AsyncLazy`1.cs (5)

16public static AsyncLazy<T> Create<T>(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult) 19public static AsyncLazy<T> Create<T>(T value) 30/// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is 134private readonly AsyncLazy<T> _asyncLazy; 136public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)

FindSymbols\Declarations\DeclarationFinder.cs (1)

71AsyncLazy<IAssemblySymbol?> lazyAssembly,

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (2)

66var lazyCompilation = new AsyncLazy<Compilation>(project.GetRequiredCompilationAsync, cacheResult: true); 117var lazyAssembly = new AsyncLazy<IAssemblySymbol?>(async cancellationToken =>

FindSymbols\FindReferences\DependentTypeFinder_ProjectIndex.cs (2)

18private static readonly ConditionalWeakTable<Project, AsyncLazy<ProjectIndex>> s_projectToIndex = 39if (!s_projectToIndex.TryGetValue(project, out var lazyIndex))

FindSymbols\SymbolTree\SymbolTreeInfo.cs (4)

133SearchQuery query, AsyncLazy<IAssemblySymbol?> lazyAssembly, 146SearchQuery query, AsyncLazy<IAssemblySymbol?> lazyAssembly, CancellationToken cancellationToken) 171AsyncLazy<IAssemblySymbol?> lazyAssembly, string name, CancellationToken cancellationToken) 189AsyncLazy<IAssemblySymbol?> lazyAssembly,

FindSymbols\SymbolTree\SymbolTreeInfo_Metadata.cs (6)

40private static readonly ConditionalWeakTable<PortableExecutableReference, AsyncLazy<SymbolTreeInfo>> s_peReferenceToInfo = new(); 52private static readonly ConditionalWeakTable<MetadataId, AsyncLazy<SymbolTreeInfo>> s_metadataIdToSymbolTreeInfo = new(); 110if (s_peReferenceToInfo.TryGetValue(reference, out var infoTask)) 136var asyncLazy = s_peReferenceToInfo.GetValue( 156var asyncLazy = s_metadataIdToSymbolTreeInfo.GetValue( 180if (!s_peReferenceToInfo.TryGetValue(reference, out var infoTask))

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (2)

70private static readonly ConditionalWeakTable<ProjectState, AsyncLazy<Checksum>> s_projectToSourceChecksum = new(); 74var lazy = s_projectToSourceChecksum.GetValue(

Workspace\Solution\Document.cs (2)

468private AsyncLazy<DocumentOptionSet>? _cachedOptions; 491var newAsyncLazy = new AsyncLazy<DocumentOptionSet>(async cancellationToken =>

Workspace\Solution\DocumentState_LinkedFileReuse.cs (2)

55var newTreeSource = GetReuseTreeSource( 67static AsyncLazy<TreeAndVersion> GetReuseTreeSource(

Workspace\Solution\LoadableTextAndVersionSource.cs (2)

19public readonly AsyncLazy<TextAndVersion> LazyValue; 50private AsyncLazy<TextAndVersion> GetLazyValue(LoadTextOptions options)

Workspace\Solution\ProjectState.cs (13)

50private readonly AsyncLazy<VersionStamp> _lazyLatestDocumentVersion; 51private readonly AsyncLazy<VersionStamp> _lazyLatestDocumentTopLevelChangeVersion; 74AsyncLazy<VersionStamp> lazyLatestDocumentVersion, 75AsyncLazy<VersionStamp> lazyLatestDocumentTopLevelChangeVersion, 191private AsyncLazy<VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion( 606AsyncLazy<VersionStamp>? latestDocumentVersion = null, 607AsyncLazy<VersionStamp>? latestDocumentTopLevelChangeVersion = null, 877out var dependentDocumentVersion, out var dependentSemanticVersion); 896out var dependentDocumentVersion, out var dependentSemanticVersion); 934out AsyncLazy<VersionStamp> dependentDocumentVersion, out AsyncLazy<VersionStamp> dependentSemanticVersion)

Workspace\Solution\SolutionState.CompilationTracker.cs (3)

1130private AsyncLazy<VersionStamp>? _lazyDependentVersion; 1131private AsyncLazy<VersionStamp>? _lazyDependentSemanticVersion; 1132private AsyncLazy<Checksum>? _lazyDependentChecksum;

Workspace\Solution\SolutionState.GeneratedFileReplacingCompilationTracker.cs (1)

26private AsyncLazy<Checksum>? _lazyDependentChecksum;

Workspace\Solution\SolutionState.SkeletonReferenceCache.cs (2)

78private static readonly ConditionalWeakTable<Compilation, AsyncLazy<SkeletonReferenceSet?>> s_compilationToSkeletonSet = new(); 191var lazy = s_compilationToSkeletonSet.GetValue(compilation,

UtilityTest\AsyncLazyTests.cs (7)

26var lazy = new AsyncLazy<int>(c => Task.FromResult(5), cacheResult: true); 52var lazy = new AsyncLazy<int>( 147private static void GetValueOrGetValueAsyncThrowsCorrectExceptionDuringCancellation(Action<AsyncLazy<object>, CancellationToken> doGetValue, bool includeSynchronousComputation) 155AsyncLazy<object> lazy; 191AssertEx.Fail(nameof(AsyncLazy<object>.GetValue) + " did not throw an exception."); 204var lazy = new AsyncLazy<object>(c => Task.Run((Func<object>)(() => 219AssertEx.Fail(nameof(AsyncLazy<object>.GetValueAsync) + " did not throw an exception.");

ProjectSystem\FileChangeTracker.cs (3)

23private static readonly AsyncLazy<uint?> s_none = new(value: null); 35private AsyncLazy<uint?> _fileChangeCookie; 84var cookie = _fileChangeCookie;