コード例 #1
0
        protected override async Task InitializeCoreAsync(CancellationToken cancellationToken)
        {
            IProjectGuidService2 projectGuidService = ProjectGuidServices.FirstOrDefault()?.Value as IProjectGuidService2;

            if (projectGuidService == null)
            {
                return;
            }

            _projectGuid = await projectGuidService.GetProjectGuidAsync()
                           .ConfigureAwait(false);

            Assumes.False(_projectGuid == Guid.Empty);

            _startupProjectsListService = (IVsStartupProjectsListService)await _serviceProvider.GetServiceAsync(typeof(SVsStartupProjectsListService))
                                          .ConfigureAwait(false);

            Assumes.Present(_startupProjectsListService);

            _subscription = _projectSubscriptionService.ProjectRuleSource.SourceBlock.LinkTo(
                target: new ActionBlock <IProjectVersionedValue <IProjectSubscriptionUpdate> >(OnProjectChangedAsync),
                suppressVersionOnlyUpdates: true,
                linkOptions: new DataflowLinkOptions()
            {
                PropagateCompletion = true
            });
        }
コード例 #2
0
        public async Task <Guid> GetProjectGuidAsync()
        {
            await _tasksService.PrioritizedProjectLoadedInHost;

#pragma warning disable RS0030 // IProjectGuidService is banned
            IProjectGuidService?projectGuidService = ProjectGuidServices.FirstOrDefault()?.Value;
            return(projectGuidService switch
            {
                null => Guid.Empty,
                IProjectGuidService2 projectGuidService2 => await projectGuidService2.GetProjectGuidAsync(),
                _ => projectGuidService.ProjectGuid
            });
コード例 #3
0
        private async Task <AggregateWorkspaceProjectContext> CreateProjectContextAsyncCore()
        {
            string languageName = await GetLanguageServiceName().ConfigureAwait(false);

            if (string.IsNullOrEmpty(languageName))
            {
                return(null);
            }

            Guid projectGuid = await _projectGuidService.GetProjectGuidAsync()
                               .ConfigureAwait(false);

            string targetPath = await GetTargetPathAsync().ConfigureAwait(false);

            if (string.IsNullOrEmpty(targetPath))
            {
                return(null);
            }

            // Don't initialize until the project has been loaded into the IDE and available in Solution Explorer
            await _asyncLoadDashboard.ProjectLoadedInHostWithCancellation(_commonServices.Project).ConfigureAwait(false);

            // TODO: https://github.com/dotnet/roslyn-project-system/issues/353
            return(await _taskScheduler.RunAsync(TaskSchedulerPriority.UIThreadBackgroundPriority, async() =>
            {
                await _commonServices.ThreadingService.SwitchToUIThread();

                var projectData = GetProjectData();

                // Get the set of active configured projects ignoring target framework.
#pragma warning disable CS0618 // Type or member is obsolete
                var configuredProjectsMap = await _activeConfiguredProjectsProvider.GetActiveConfiguredProjectsMapAsync().ConfigureAwait(true);
#pragma warning restore CS0618 // Type or member is obsolete

                // Get the unconfigured project host object (shared host object).
                var configuredProjectsToRemove = new HashSet <ConfiguredProject>(_configuredProjectHostObjectsMap.Keys);
                var activeProjectConfiguration = _commonServices.ActiveConfiguredProject.ProjectConfiguration;

                var innerProjectContextsBuilder = ImmutableDictionary.CreateBuilder <string, IWorkspaceProjectContext>();
                string activeTargetFramework = string.Empty;
                IConfiguredProjectHostObject activeIntellisenseProjectHostObject = null;

                foreach (var kvp in configuredProjectsMap)
                {
                    var targetFramework = kvp.Key;
                    var configuredProject = kvp.Value;
                    if (!TryGetConfiguredProjectState(configuredProject, out IWorkspaceProjectContext workspaceProjectContext, out IConfiguredProjectHostObject configuredProjectHostObject))
                    {
                        // Get the target path for the configured project.
                        var projectProperties = configuredProject.Services.ExportProvider.GetExportedValue <ProjectProperties>();
                        var configurationGeneralProperties = await projectProperties.GetConfigurationGeneralPropertiesAsync().ConfigureAwait(true);
                        targetPath = (string)await configurationGeneralProperties.TargetPath.GetValueAsync().ConfigureAwait(true);
                        var targetFrameworkMoniker = (string)await configurationGeneralProperties.TargetFrameworkMoniker.GetValueAsync().ConfigureAwait(true);
                        var displayName = GetDisplayName(configuredProject, projectData, targetFramework);
                        configuredProjectHostObject = _projectHostProvider.GetConfiguredProjectHostObject(_unconfiguredProjectHostObject, displayName, targetFrameworkMoniker);

                        // TODO: https://github.com/dotnet/roslyn-project-system/issues/353
                        await _commonServices.ThreadingService.SwitchToUIThread();
                        workspaceProjectContext = _contextFactory.Value.CreateProjectContext(languageName, displayName, projectData.FullPath, projectGuid, configuredProjectHostObject, targetPath);

                        // By default, set "LastDesignTimeBuildSucceeded = false" to turn off diagnostics until first design time build succeeds for this project.
                        workspaceProjectContext.LastDesignTimeBuildSucceeded = false;

                        AddConfiguredProjectState(configuredProject, workspaceProjectContext, configuredProjectHostObject);
                    }

                    innerProjectContextsBuilder.Add(targetFramework, workspaceProjectContext);

                    if (activeIntellisenseProjectHostObject == null && configuredProject.ProjectConfiguration.Equals(activeProjectConfiguration))
                    {
                        activeIntellisenseProjectHostObject = configuredProjectHostObject;
                        activeTargetFramework = targetFramework;
                    }
                }

                _unconfiguredProjectHostObject.ActiveIntellisenseProjectHostObject = activeIntellisenseProjectHostObject;

                return new AggregateWorkspaceProjectContext(innerProjectContextsBuilder.ToImmutable(), configuredProjectsMap, activeTargetFramework, _unconfiguredProjectHostObject);
            }));