C# Project.GetSemanticVersionAsync方法代码示例

        /// <summary>
        /// this is for a project in a solution
        /// </summary>
        private static async Task<ValueTuple<bool, SymbolTreeInfo>> LoadOrCreateAsync(Project project, CancellationToken cancellationToken)
        {
            if (await project.IsForkedProjectWithSemanticChangesAsync(cancellationToken).ConfigureAwait(false))
            {
                return ValueTuple.Create(false, await CreateAsync(project, cancellationToken).ConfigureAwait(false));
            }

            var persistentStorageService = project.Solution.Workspace.Services.GetService<IPersistentStorageService>();
            var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);

            // attempt to load from persisted state
            SymbolTreeInfo info;
            var succeeded = false;
            using (var storage = persistentStorageService.GetStorage(project.Solution))
            {
                using (var stream = await storage.ReadStreamAsync(project, ProjectSymbolTreeInfoPersistenceName, cancellationToken).ConfigureAwait(false))
                {
                    if (stream != null)
                    {
                        using (var reader = new ObjectReader(stream))
                        {
                            info = ReadFrom(reader);
                            if (info != null && VersionStamp.CanReusePersistedVersion(version, info.version))
                            {
                                return ValueTuple.Create(true, info);
                            }
                        }
                    }
                }

                cancellationToken.ThrowIfCancellationRequested();

                // compute it if we couldn't load it from cache
                info = await CreateAsync(project, cancellationToken).ConfigureAwait(false);
                if (info != null)
                {
                    using (var stream = SerializableBytes.CreateWritableStream())
                    using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
                    {
                        info.WriteTo(writer);
                        stream.Position = 0;

                        succeeded = await storage.WriteStreamAsync(project, ProjectSymbolTreeInfoPersistenceName, stream, cancellationToken).ConfigureAwait(false);
                    }
                }
            }

            return ValueTuple.Create(succeeded, info);
        }

            private async Task UpdateSymbolTreeInfoAsync(Project project, CancellationToken cancellationToken)
            {
                if (!project.SupportsCompilation)
                {
                    return;
                }

                // Check the semantic version of this project.  The semantic version will change
                // if any of the source files changed, or if the project version itself changed.
                // (The latter happens when something happens to the project like metadata 
                // changing on disk).
                var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);

                ProjectInfo projectInfo;
                if (!_projectToInfo.TryGetValue(project.Id, out projectInfo) || projectInfo.VersionStamp != version)
                {
                    var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

                    // Update the symbol tree infos for metadata and source in parallel.
                    var referencesTask = UpdateReferencesAync(project, compilation, cancellationToken);
                    var projectTask = SymbolTreeInfo.GetInfoForSourceAssemblyAsync(project, cancellationToken);

                    await Task.WhenAll(referencesTask, projectTask).ConfigureAwait(false);

                    // Mark that we're up to date with this project.  Future calls with the same 
                    // semantic version can bail out immediately.
                    projectInfo = new ProjectInfo(version, await projectTask.ConfigureAwait(false));
                    _projectToInfo.AddOrUpdate(project.Id, projectInfo, (_1, _2) => projectInfo);
                }
            }

            public async Task<SymbolTreeInfo> TryGetSourceSymbolTreeInfoAsync(
                Project project, CancellationToken cancellationToken)
            {
                ProjectInfo projectInfo;
                if (_projectToInfo.TryGetValue(project.Id, out projectInfo))
                {
                    var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);
                    if (version == projectInfo.VersionStamp)
                    {
                        return projectInfo.SymbolTreeInfo;
                    }
                }

                return null;
            }

        /// <summary>
        /// this gives you SymbolTreeInfo for a project
        /// </summary>
        public static async Task<SymbolTreeInfo> GetInfoForProjectAsync(Project project, CancellationToken cancellationToken)
        {
            if (!project.SupportsCompilation)
            {
                return null;
            }

            var branchId = project.Solution.BranchId;
            var workspace = project.Solution.Workspace;

            ConditionalWeakTable<ProjectId, SymbolTreeInfo> infoTable;
            if (!inMemoryCache.TryGetValue(branchId, out infoTable))
            {
                infoTable = inMemoryCache.GetValue(branchId, id => new ConditionalWeakTable<ProjectId, SymbolTreeInfo>());
            }

            // version doesn't need to know about dependent projects since we only care about names of top level declarations.
            var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);

            // first look to see if we already have the info
            SymbolTreeInfo info;
            if (infoTable.TryGetValue(project.Id, out info) && info != null && info.version == version)
            {
                return info;
            }

            infoTable.Remove(project.Id);

            // next, either get the info from the persistent service or create one
            var persistAndInfo = await LoadOrCreateAsync(project, cancellationToken).ConfigureAwait(false);

            var persisted = persistAndInfo.Item1;
            var newInfo = persistAndInfo.Item2;

            if (!persisted || ShouldCache(project))
            {
                // there could be someone already have put something in here.
                infoTable.GetValue(project.Id, _ => newInfo);
            }

            // use the info we calculated. otherwise, we can encounter a race.
            return newInfo;
        }

        private static async Task<SymbolTreeInfo> CreateAsync(Project project, CancellationToken cancellationToken)
        {
            var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
            var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);

            return Create(version, compilation.Assembly, cancellationToken);
        }