public UnconfiguredProjectTasksService([Import(ExportContractNames.Scopes.UnconfiguredProject)] IProjectAsynchronousTasksService tasksService, IProjectThreadingService threadingService, ILoadedInHostListener loadedInHostListener) { _prioritizedTaskQueue = new JoinableTaskQueue(threadingService.JoinableTaskContext); _tasksService = tasksService; _threadingService = threadingService; _loadedInHostListener = loadedInHostListener; }
public ProjectOutputWindowProjectLogger(IProjectThreadingService threadingService, IProjectSystemOptions options, IProjectOutputWindowPaneProvider outputWindowProvider) { _threadingService = threadingService; _options = options; _outputWindowProvider = outputWindowProvider; }
#pragma warning disable CA1725 // Parameter names should match base declaration public void SetObjects(uint cObjects, object[] ppUnk) #pragma warning restore CA1725 // Parameter names should match base declaration { if (cObjects == 0) { return; } #if DEBUG if (ppUnk == null) { throw new ArgumentNullException(nameof(ppUnk)); } if (ppUnk.Length < cObjects) { throw new ArgumentOutOfRangeException(nameof(cObjects)); } #endif ThreadHelper.ThrowIfNotOnUIThread(); var configuredProjects = new List <ConfiguredProject>((int)cObjects); for (int i = 0; i < cObjects; i++) { var unk = ppUnk[i]; var context = unk as IVsBrowseObjectContext; if (context == null && unk is IVsBrowseObject browseObject) { int hr = browseObject.GetProjectItem(out var hierarchy, out uint itemId); if (hr == VSConstants.S_OK && itemId == VSConstants.VSITEMID_ROOT) { if (hierarchy != null) { if (ErrorHandler.Succeeded(hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ExtObject, out var extObject))) { context = extObject as IVsBrowseObjectContext; if (context == null) { if (extObject is EnvDTE.Project dteProject) { context = dteProject.Object as IVsBrowseObjectContext; } } } } } } if (context != null) { configuredProjects.Add(context.ConfiguredProject); } } #if DEBUG if (!configuredProjects.Any()) { throw new InvalidOperationException("cObjects > 0, but no configurations were found!"); } #endif _unconfiguredProject = configuredProjects.First().UnconfiguredProject; _projectThreadingService = _unconfiguredProject.ProjectService.Services.ThreadingPolicy; if (_propertyManager == null) { _propertyManager = CreatePropertyManager(configuredProjects); _propertyManager.PropertyChanged += PropertyChanged; _propertyManager.PropertyChanging += PropertyChanging; } else { WaitForAsync(() => _propertyManager.UpdateConfigurationsAsync(configuredProjects)); } }
public ConfiguredProjectLanguageServiceTelemetryService(ConfiguredProject project, ITelemetryService telemetryService, IProjectThreadingService projectThreadingService) { _project = project; _telemetryService = telemetryService; _projectGuidLazy = new AsyncLazy <Guid>(async() => { return(await _project.UnconfiguredProject.GetProjectGuidAsync()); }, projectThreadingService.JoinableTaskFactory); }
public CosmosPropertyPageViewModel( IPropertyManager propertyManager, IProjectThreadingService projectThreadingService) : base(propertyManager, projectThreadingService) { }
public ActiveLaunchProfileCommonValueProvider(UnconfiguredProject project, ILaunchSettingsProvider launchSettingsProvider, IProjectThreadingService projectThreadingService) : base(project, launchSettingsProvider, projectThreadingService) { }
public VsSolutionEventListener(IVsService <SVsSolution, IVsSolution> solution, IProjectThreadingService threadingService) : base(threadingService.JoinableTaskContext) { _solution = solution; _threadingService = threadingService; }
public CommandLineArgumentsDataSource(IProjectThreadingService projectThreadingService, IActiveConfiguredProjectSubscriptionService activeProjectSubscriptionService) : base(projectThreadingService.JoinableTaskContext) { _activeProjectSubscriptionService = activeProjectSubscriptionService; }
public VsService([Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider serviceProvider, IProjectThreadingService threadingService) : base(serviceProvider, threadingService) { }
/// <summary> /// Executes the specified delegate in a safe fire-and-forget manner, prevent the project from /// closing until it has completed. /// </summary> /// <param name="threadingService"> /// The <see cref="IProjectThreadingService"/> that handles the fork. /// </param> /// <param name="asyncAction"> /// The async delegate to invoke. It is invoked asynchronously with respect to the caller. /// </param> /// <param name="configuredProject"> /// The configured project which the delegate operates on, if applicable. Can be <see langword="null"/>. /// </param> /// <param name="faultSeverity"> /// Suggests to the user how severe the fault is if the delegate throws. /// </param> /// <param name="options"> /// Influences the environment in which the delegate is executed. /// </param> public static void RunAndForget(this IProjectThreadingService threadingService, Func <Task> asyncAction, ConfiguredProject configuredProject, ProjectFaultSeverity faultSeverity = ProjectFaultSeverity.Recoverable, ForkOptions options = ForkOptions.Default) { Requires.NotNull(threadingService, nameof(threadingService)); threadingService.Fork(asyncAction, factory: null, configuredProject: configuredProject, watsonReportSettings: s_defaultReportSettings, faultSeverity: faultSeverity, options: options); }
internal CSharpProjectConfigurationProperties( ProjectProperties projectProperties, IProjectThreadingService threadingService) : base(projectProperties, threadingService) { }
private WorkspaceProjectContextHost CreateInstance(ConfiguredProject project = null, IProjectThreadingService threadingService = null, IUnconfiguredProjectTasksService tasksService = null, IProjectSubscriptionService projectSubscriptionService = null, IActiveEditorContextTracker activeWorkspaceProjectContextTracker = null, IWorkspaceProjectContextProvider workspaceProjectContextProvider = null, IApplyChangesToWorkspaceContext applyChangesToWorkspaceContext = null) { project = project ?? ConfiguredProjectFactory.Create(); threadingService = threadingService ?? IProjectThreadingServiceFactory.Create(); tasksService = tasksService ?? IUnconfiguredProjectTasksServiceFactory.Create(); projectSubscriptionService = projectSubscriptionService ?? IProjectSubscriptionServiceFactory.Create(); activeWorkspaceProjectContextTracker = activeWorkspaceProjectContextTracker ?? IActiveEditorContextTrackerFactory.Create(); workspaceProjectContextProvider = workspaceProjectContextProvider ?? IWorkspaceProjectContextProviderFactory.ImplementCreateProjectContextAsync(IWorkspaceProjectContextAccessorFactory.Create()); applyChangesToWorkspaceContext = applyChangesToWorkspaceContext ?? IApplyChangesToWorkspaceContextFactory.Create(); return(new WorkspaceProjectContextHost(project, threadingService, tasksService, projectSubscriptionService, workspaceProjectContextProvider, activeWorkspaceProjectContextTracker, ExportFactoryFactory.ImplementCreateValueWithAutoDispose(() => applyChangesToWorkspaceContext))); }
public SimpleRenameStrategy(IProjectThreadingService threadingService, IUserNotificationServices userNotificationService, IEnvironmentOptions environmentOptions, IRoslynServices roslynServices) : base(threadingService, userNotificationService, environmentOptions) { _roslynServices = roslynServices; }
public DefaultHttpClient(IProjectThreadingService threadingService) { _threadingService = threadingService; }
internal abstract AbstractGenerateNuGetPackageCommand CreateInstanceCore( UnconfiguredProject project, IProjectThreadingService threadingService, IVsService <SVsSolutionBuildManager, IVsSolutionBuildManager2> vsSolutionBuildManagerService, GeneratePackageOnBuildPropertyProvider generatePackageOnBuildPropertyProvider);
public ProjectContextCodeModelProvider(IProjectThreadingService threadingService, ICodeModelFactory codeModelFactory, IActiveWorkspaceProjectContextHost projectContextHost) { _threadingService = threadingService; _codeModelFactory = codeModelFactory; _projectContextHost = projectContextHost; }
public UserNotificationServices(SVsServiceProvider serviceProvider, IProjectThreadingService threadingService) { _serviceProvider = serviceProvider; _threadingService = threadingService; }
public PackageRestoreSharedJoinableTaskCollection(IProjectThreadingService threadingService) { JoinableTaskCollection = threadingService.JoinableTaskContext.CreateCollection(); JoinableTaskFactory = threadingService.JoinableTaskContext.CreateFactory(JoinableTaskCollection); }
public ProjectOutputWindowPaneProvider(IProjectThreadingService threadingService, IVsOptionalService <SVsOutputWindow, IVsOutputWindow> outputWindow) { _threadingService = threadingService; _outputWindow = outputWindow; _outputWindowPane = new AsyncLazy <IVsOutputWindowPane>(CreateOutputWindowPaneAsync, threadingService.JoinableTaskFactory); }
protected PlugsProjectTreeProvider( IProjectThreadingService threadingService, UnconfiguredProject unconfiguredProject) : base(threadingService, unconfiguredProject) { }
public static UnconfiguredProject Create(IProjectThreadingService threadingService) { var project = CreateDefault(threadingService); return(project.Object); }
public WorkingDirectoryValueProvider(UnconfiguredProject project, ILaunchSettingsProvider launchSettingsProvider, IProjectThreadingService projectThreadingService) : base(project, launchSettingsProvider, projectThreadingService) { }
public EditAndContinueProvider(IActiveWorkspaceProjectContextHost projectContextHost, IProjectThreadingService threadingService) { _projectContextHost = projectContextHost; _threadingService = threadingService; }
private UndoScope(string renameOperationName, IVsService <DTE> dte, IProjectThreadingService threadingService) { _renameOperationName = renameOperationName; _dte = dte; _threadingService = threadingService; }
private VsService <TService, TInterface> CreateInstance <TService, TInterface>(IAsyncServiceProvider serviceProvider = null, IProjectThreadingService threadingService = null) { serviceProvider = serviceProvider ?? IAsyncServiceProviderFactory.Create(); threadingService = threadingService ?? IProjectThreadingServiceFactory.Create(); return(new VsService <TService, TInterface>(serviceProvider, threadingService.JoinableTaskContext.Context)); }
public DebugProfileLaunchTargetsProvider(ConfiguredProject configuredProject, IProjectThreadingService projectThreadingService) { Assumes.ThrowIfNull(configuredProject, nameof(configuredProject)); Assumes.ThrowIfNull(projectThreadingService, nameof(projectThreadingService)); _configuredProject = configuredProject; _projectThreadingService = projectThreadingService; }
internal abstract AbstractGenerateNuGetPackageCommand CreateInstanceCore( UnconfiguredProject project, IProjectThreadingService threadingService, Shell.SVsServiceProvider serviceProvider, GeneratePackageOnBuildPropertyProvider generatePackageOnBuildPropertyProvider);
/// <summary> /// Creates an instance of the TaskDelayScheduler. If an originalSourceToken is passed, it will be linked to the PendingUpdateTokenSource so /// that cancelling that token will also flow through and cancel a pending update. /// </summary> public TaskDelayScheduler(TimeSpan taskDelayTime, IProjectThreadingService threadService, CancellationToken originalSourceToken) { _taskDelayTime = taskDelayTime; _threadingService = threadService; _cancellationSeries = new CancellationSeries(originalSourceToken); }
private async Task <WorkspaceProjectContextHostInstance> CreateInitializedInstanceAsync(ConfiguredProject project = null, IProjectThreadingService threadingService = null, IUnconfiguredProjectTasksService tasksService = null, IProjectSubscriptionService projectSubscriptionService = null, IActiveEditorContextTracker activeWorkspaceProjectContextTracker = null, IWorkspaceProjectContextProvider workspaceProjectContextProvider = null, IApplyChangesToWorkspaceContext applyChangesToWorkspaceContext = null) { var instance = CreateInstance(project, threadingService, tasksService, projectSubscriptionService, activeWorkspaceProjectContextTracker, workspaceProjectContextProvider, applyChangesToWorkspaceContext); await instance.InitializeAsync(); return(instance); }
public static IUnconfiguredProjectCommonServices Create(UnconfiguredProject project = null, IPhysicalProjectTree projectTree = null, IProjectThreadingService threadingService = null, ConfiguredProject configuredProject = null, ProjectProperties projectProperties = null) { var mock = new Mock <IUnconfiguredProjectCommonServices>(); if (project != null) { mock.Setup(s => s.Project) .Returns(project); } if (projectTree != null) { mock.Setup(s => s.ProjectTree) .Returns(projectTree); } if (threadingService != null) { mock.Setup(s => s.ThreadingService) .Returns(threadingService); } if (configuredProject != null) { mock.Setup(s => s.ActiveConfiguredProject) .Returns(configuredProject); } if (projectProperties != null) { mock.Setup(s => s.ActiveConfiguredProjectProperties) .Returns(projectProperties); } return(mock.Object); }