public TestContainerDiscoverer ( [Import(typeof(IOperationState))] IOperationState operationState, IFCCEngine fccEngine, IInitializer initializer, ITestOperationFactory testOperationFactory, ILogger logger, IAppOptionsProvider appOptionsProvider ) { appOptionsProvider.OptionsChanged += AppOptionsEvents_OptionsChanged; this.appOptionsProvider = appOptionsProvider; this.fccEngine = fccEngine; this.testOperationFactory = testOperationFactory; this.logger = logger; initializeThread = new Thread(() => { operationState.StateChanged += OperationState_StateChanged; initializer.Initialize(); }); initializeThread.Start(); }
/// <summary> /// Initializes a new instance of the <see cref="OutputToolWindowControl"/> class. /// </summary> public OutputToolWindowControl(ScriptManager scriptManager, IFCCEngine fccEngine) { InitializeComponent(); ThreadHelper.JoinableTaskFactory.Run(async() => { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); Dte = (DTE)await OutputToolWindowCommand.Instance.ServiceProvider.GetServiceAsync(typeof(DTE)); Assumes.Present(Dte); Events = Dte.Events; SolutionEvents = Events.SolutionEvents; SolutionEvents.Opened += () => Clear(); SolutionEvents.AfterClosing += () => Clear(); }); FCCOutputBrowser.ObjectForScripting = scriptManager; fccEngine.UpdateOutputWindow += (args) => { ThreadHelper.JoinableTaskFactory.Run(async() => { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if (string.IsNullOrWhiteSpace(args?.HtmlContent)) { Clear(); return; } FCCOutputBrowser.NavigateToString(args.HtmlContent); FCCOutputBrowser.Visibility = Visibility.Visible; }); }; }
public void Initialize(string appDataFolder, IFCCEngine fccEngine, CancellationToken cancellationToken) { this.fccEngine = fccEngine; var zipDestination = toolFolder.EnsureUnzipped(appDataFolder, zipDirectoryName, toolZipProvider.ProvideZip(zipPrefix), cancellationToken); fccMsTestAdapterPath = Path.Combine(zipDestination, "build", "netstandard1.0"); shimPath = Path.Combine(zipDestination, "build", "netstandard1.0", "CodeCoverage", "coreclr", "Microsoft.VisualStudio.CodeCoverage.Shim.dll"); }
public PackageInitializer( IFCCEngine fccEngine, [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider) { this.fccEngine = fccEngine; this.serviceProvider = serviceProvider; }
/// <summary> /// Initializes the singleton instance of the command. /// </summary> /// <param name="package">Owner package, not null.</param> public static async Task InitializeAsync(AsyncPackage package, IFCCEngine fccEngine) { // Switch to the main thread - the call to AddCommand in ClearUICommand's constructor requires // the UI thread. await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(package.DisposalToken); OleMenuCommandService commandService = await package.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService; Instance = new ClearUICommand(commandService, fccEngine); }
/// <summary> /// Initializes a new instance of the <see cref="ClearUICommand"/> class. /// Adds our command handlers for menu (commands must exist in the command table file) /// </summary> /// <param name="package">Owner package, not null.</param> /// <param name="commandService">Command service to add command to, not null.</param> private ClearUICommand(OleMenuCommandService commandService, IFCCEngine fccEngine) { this.fccEngine = fccEngine; commandService = commandService ?? throw new ArgumentNullException(nameof(commandService)); var menuCommandID = new CommandID(CommandSet, CommandId); var menuItem = new MenuCommand(this.Execute, menuCommandID); commandService.AddCommand(menuItem); }
public Initializer( IFCCEngine fccEngine, ILogger logger, ICoverageProjectFactory coverageProjectFactory, IPackageInitializer packageInitializer ) { this.fccEngine = fccEngine; this.logger = logger; this.coverageProjectFactory = coverageProjectFactory; this.packageInitializer = packageInitializer; }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread. await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); var _dte2 = (DTE2)GetGlobalService(typeof(SDTE)); var sp = new ServiceProvider(_dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); componentModel = sp.GetService(typeof(Microsoft.VisualStudio.ComponentModelHost.SComponentModel)) as Microsoft.VisualStudio.ComponentModelHost.IComponentModel; Assumes.Present(componentModel); fccEngine = componentModel.GetService <IFCCEngine>(); await OutputToolWindowCommand.InitializeAsync(this, componentModel.GetService <ILogger>()); await ClearUICommand.InitializeAsync(this, fccEngine); }
public TestContainerDiscoverer ( [Import(typeof(IOperationState))] IOperationState operationState, IFCCEngine fccEngine, IInitializer initializer, ITestOperationFactory testOperationFactory, ILogger logger, IAppOptionsProvider appOptionsProvider, IReportGeneratorUtil reportGeneratorUtil, IDisposeAwareTaskRunner disposeAwareTaskRunner, IMsCodeCoverageRunSettingsService msCodeCoverageRunSettingsService ) { this.appOptionsProvider = appOptionsProvider; this.reportGeneratorUtil = reportGeneratorUtil; this.msCodeCoverageRunSettingsService = msCodeCoverageRunSettingsService; this.fccEngine = fccEngine; this.testOperationFactory = testOperationFactory; this.logger = logger; testOperationStateChangeHandlers = new Dictionary <TestOperationStates, Func <IOperation, Task> > { { TestOperationStates.TestExecutionCanceling, TestExecutionCancellingAsync }, { TestOperationStates.TestExecutionStarting, TestExecutionStartingAsync }, { TestOperationStates.TestExecutionFinished, TestExecutionFinishedAsync }, { TestOperationStates.TestExecutionCancelAndFinished, TestExecutionCancelAndFinishedAsync }, }; disposeAwareTaskRunner.RunAsync(() => { initializeTask = Task.Run(async() => { operationState.StateChanged += OperationState_StateChanged; await initializer.InitializeAsync(disposeAwareTaskRunner.DisposalToken); }); return(initializeTask); }); }
public Tagger(ITextBuffer textBuffer, IFCCEngine fccEngine) { _textBuffer = textBuffer; this.fccEngine = fccEngine; fccEngine.UpdateMarginTags += FCCEngine_UpdateMarginTags; }
public TaggerProvider(IFCCEngine fccEngine) { this.fccEngine = fccEngine; }