public async Task <object> CreatePluginService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { var service = new PluginLogicService(this); await service.InitializeAsync(cancellationToken); return(service); }
public async Task <object> CreateTidyServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { InvokeTidyService service = new InvokeTidyService(this); await service.InitializeAsync(cancellationToken); return(service); }
public async Task <object> CreateGitService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { sccService = new SccProviderService(this); await sccService.InitializeAsync(cancellationToken); return(sccService); }
private async Task <object> CreateMyServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { var svc = new SolutionRefreshService(); await svc.InitializeAsync(this, cancellationToken); return(svc); }
async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == null) { return(null); } if (serviceType == typeof(IUIProvider)) { var result = new GitHubServiceProvider(this); await result.Initialize(); return(result); } else if (serviceType == typeof(IMenuProvider)) { var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider; return(new MenuProvider(sp)); } else if (serviceType == typeof(IUsageTracker)) { var uiProvider = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider; return(new UsageTracker(uiProvider)); } // go the mef route else { var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider; return(sp.TryGetService(serviceType)); } }
private async Task <object> CreateDoxygenConfigServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { var svc = new DoxygenConfigService(); await svc.InitializeAsync(this, cancellationToken); return(svc); }
private async Task <object> CreateReAttachUiAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { var service = new ReAttachUi(); await service.InitializeAsync(this, _history, cancellationToken); return(service); }
public async System.Threading.Tasks.Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { STextWriterService service = null; await System.Threading.Tasks.Task.Run(() => { service = new TextWriterService(this); }); return(service); }
public System.Threading.Tasks.Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == typeof(SVSGestureService)) { return(System.Threading.Tasks.Task.FromResult <object>(new VSGestureService(this))); } throw new Exception("Null Service"); }
private static Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == typeof(TemplateLocator)) { return(System.Threading.Tasks.Task.FromResult <object>(new TemplateLocator(container as IAsyncServiceProvider2))); } return(System.Threading.Tasks.Task.FromResult <object>(null)); }
private Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken token, Type type) { if (type == typeof(TimeLog)) { return(Task.FromResult <object>(new TimeLog(_solService))); } return(null); }
private async Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (typeof(IClassOutlineSettingsProvider) == serviceType) { return(this); } return(null); }
private Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (typeof(SPlcncliCommunication) == serviceType) { PlcncliProcessCommunication service = new PlcncliProcessCommunication(_locationService); return(Task.FromResult <object>(service)); } return(null); }
private async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { ISGenContextBootstrapService service = null; await System.Threading.Tasks.Task.Run(() => { service = new GenContextBootstrapService(this); }); return(service); }
public async Task <object> CreateNanoDeviceCommServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { NanoDeviceCommService service = null; await System.Threading.Tasks.Task.Run(() => { service = new NanoDeviceCommService(this); }); return(service); }
private Task <object> CreateServiceAsync( IAsyncServiceContainer asyncServiceContainer, CancellationToken cancellationToken, Type serviceType) { if (serviceType.IsEquivalentTo(typeof(STraceController))) { return(Task.FromResult <object>(traceController)); } return(null); }
private async Task <object> CreateRepositoryServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (typeof(SRepositoryService).IsEquivalentTo(serviceType)) { RepositoryService service = new RepositoryService(this); // await service.InitializeAsync(cancellationToken); return(service); } Debug.WriteLine("ServicesPackage.CreateService called for an unknown service type."); return(null); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// private async Task <object> CreateDebuggerConnectionServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { // // Create a service to manage the 'attach' status dialog. As we need to access this via VsDebugLauncher/VsDebugEngine. // var launchService = new DebuggerConnectionService(); await launchService.InitializeAsync(this, cancellationToken); return(launchService); }
/// <summary> /// Initializes a new instance of the <see cref="StartTunnelOld"/> class. /// </summary> public NgrokExtensionsPackage() { // Inside this method you can place any initialization code that does not require // any Visual Studio service because at this point the package object is created but // not sited yet inside Visual Studio environment. The place to do all the other // initialization is the Initialize method. IAsyncServiceContainer serviceContainer = this; serviceContainer.AddService(typeof(SLoggerService), CreateLoggerServiceAsync, true); serviceContainer.AddService(typeof(SRepositoryService), CreateRepositoryServiceAsync, true); serviceContainer.AddService(typeof(SProcessManagerService), CreateProcessManagerServiceAsync, true); serviceContainer.AddService(typeof(SWebApplicationsManagerService), CreateWebApplicationsManagerServiceAsync, true); serviceContainer.AddService(typeof(STunnelManagerService), CreateTunnelManagerServiceAsync, true); }
async tasks.Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == null) { return(null); } string contract = AttributedModelServices.GetContractName(serviceType); var cm = await GetServiceAsync(typeof(SComponentModel)) as IComponentModel; if (cm == null) { return(null); } return(await tasks.Task.Run(() => cm.DefaultExportProvider.GetExportedValueOrDefault <object>(contract))); }
private async Task <object> CreateServiceGeneratePageObjectsServiceAsync( IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (typeof(SGeneratePageObjectsService) != serviceType) { return(null); } var service = new GeneratePageObjectsService(); await service.InitializeServiceAsync(cancellationToken); return(service); }
private async Task <object> CreateServiceNopyCopyServiceAsync( IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (typeof(SNopyCopyService) == serviceType) { var optionsPage = GetDialogPage(typeof(OptionsPage)) as OptionsPage; var service = new NopyCopyService(this, optionsPage); await service.InitializeServiceAsync(cancellationToken); return(service); } return(null); }
private async Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == null) { return(null); } if (container != this) { return(null); } if (serviceType == typeof(ISharperCryptoAnalysisServiceProvider)) { var result = new SharperCryptoAnalysisServiceProvider(this, this); await result.InitializeAsync(); return(result); } if (serviceType == typeof(IToolWindowManager)) { return(this); } if (serviceType == typeof(IConfigurationManager)) { var settings = await GetServiceAsync(typeof(ISharperCryptoApiAnalysisSettings)) as ISharperCryptoApiAnalysisSettings; return(new ConfigurationManager(settings)); } if (serviceType == typeof(IAnalyzerManager)) { var settings = await GetServiceAsync(typeof(ISharperCryptoApiAnalysisSettings)) as ISharperCryptoApiAnalysisSettings; return(new AnalyzerManager(settings)); } if (serviceType == typeof(ISharperCryptoApiAnalysisSettings)) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var dte = new ServiceProvider(VisualStudio.Integration.Services.Dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); return(new SharperCryptoApiAnalysisSettings(dte)); } var sp = await GetServiceAsync(typeof(ISharperCryptoAnalysisServiceProvider)) as ISharperCryptoAnalysisServiceProvider; return(sp.TryGetService(serviceType)); }
private Task <object> CreateServiceAsync(IAsyncServiceContainer asyncServiceContainer, CancellationToken cancellationToken, Type serviceType) { if (serviceType == typeof(SEyetrackerService)) { return(Task.FromResult((object)_eyetrackerService)); } if (serviceType == typeof(SKeyboardEventService)) { return(Task.FromResult((object)_keyboardEventService)); } if (serviceType == typeof(SScrollVelocityService)) { return(Task.FromResult((object)_scrollVelocityService)); } // ??? return(Task.FromResult((object)null)); }
async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == null) { return(null); } if (container != this) { return(null); } if (serviceType == typeof(IGitHubServiceProvider)) { //var sp = await GetServiceAsync(typeof(SVsServiceProvider)) as IServiceProvider; var result = new GitHubServiceProvider(this, this); await result.Initialize(); return(result); } else if (serviceType == typeof(ILoginManager)) { var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; var loginCache = serviceProvider.GetService <ILoginCache>(); var twoFaHandler = serviceProvider.GetService <ITwoFactorChallengeHandler>(); return(new LoginManager( loginCache, twoFaHandler, ApiClientConfiguration.ClientId, ApiClientConfiguration.ClientSecret, ApiClientConfiguration.AuthorizationNote, ApiClientConfiguration.MachineFingerprint)); } else if (serviceType == typeof(IMenuProvider)) { var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; return(new MenuProvider(sp)); } else if (serviceType == typeof(IUsageTracker)) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; var usageService = serviceProvider.GetService <IUsageService>(); return(new UsageTracker(serviceProvider, usageService)); } else if (serviceType == typeof(IUIProvider)) { var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; return(new UIProvider(sp)); } else if (serviceType == typeof(IGitHubToolWindowManager)) { return(this); } // go the mef route else { var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; return(sp.TryGetService(serviceType)); } }
async Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == null) { return(null); } if (container != this) { return(null); } if (serviceType == typeof(IGitHubServiceProvider)) { //var sp = await GetServiceAsync(typeof(SVsServiceProvider)) as IServiceProvider; var result = new GitHubServiceProvider(this, this); await result.Initialize(); return(result); } else if (serviceType == typeof(ILoginManager)) { // These services are got through MEF and we will take a performance hit if ILoginManager is requested during // InitializeAsync. TODO: We can probably make LoginManager a normal MEF component rather than a service. var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; var keychain = serviceProvider.GetService <IKeychain>(); var oauthListener = serviceProvider.GetService <IOAuthCallbackListener>(); // HACK: We need to make sure this is run on the main thread. We really // shouldn't be injecting a view model concern into LoginManager - this // needs to be refactored. See #1398. var lazy2Fa = new Lazy <ITwoFactorChallengeHandler>(() => ThreadHelper.JoinableTaskFactory.Run(async() => { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); return(serviceProvider.GetService <ITwoFactorChallengeHandler>()); })); return(new LoginManager( keychain, lazy2Fa, oauthListener, ApiClientConfiguration.ClientId, ApiClientConfiguration.ClientSecret, ApiClientConfiguration.RequiredScopes, ApiClientConfiguration.AuthorizationNote, ApiClientConfiguration.MachineFingerprint)); } else if (serviceType == typeof(IMenuProvider)) { var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; return(new MenuProvider(sp)); } else if (serviceType == typeof(IUsageService)) { var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; var environment = new Rothko.Environment(); return(new UsageService(sp, environment)); } else if (serviceType == typeof(IUsageTracker)) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var usageService = await GetServiceAsync(typeof(IUsageService)) as IUsageService; var serviceProvider = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; return(new UsageTracker(serviceProvider, usageService)); } else if (serviceType == typeof(IVSGitExt)) { var vsVersion = ApplicationInfo.GetHostVersionInfo().FileMajorPart; return(VSGitExtFactory.Create(vsVersion, this)); } else if (serviceType == typeof(IGitHubToolWindowManager)) { return(this); } // go the mef route else { var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider; return(sp.TryGetService(serviceType)); } }
async Task<object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { if (serviceType == null) return null; if (serviceType == typeof(IUIProvider)) { var result = new GitHubServiceProvider(this); await result.Initialize(); return result; } else if (serviceType == typeof(IMenuProvider)) { var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider; return new MenuProvider(sp); } else if (serviceType == typeof(IUsageTracker)) { var uiProvider = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider; return new UsageTracker(uiProvider); } // go the mef route else { var sp = await GetServiceAsync(typeof(IUIProvider)) as IUIProvider; return sp.TryGetService(serviceType); } }
async Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellation, Type serviceType) { await JoinableTaskFactory.SwitchToMainThreadAsync(cancellation); var sp = new ServiceProvider(Services.Dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); Assumes.Present(sp); if (serviceType == typeof(IPackageSettingsProvider)) { return(new PackageSettingsProvider(sp)); } else if (serviceType == typeof(IWindowStateService)) { return(new WindowStateService(sp, this)); } else if (serviceType == typeof(ISolutionProvider)) { return(new SolutionProvider(sp)); } else if (serviceType == typeof(IBuildOutputLogger)) { return(new BuildOutputLogger(_parsingErrorsLoggerId, Microsoft.Build.Framework.LoggerVerbosity.Quiet)); } else if (serviceType == typeof(IErrorNavigationService)) { return(new ErrorNavigationService(sp)); } else if (serviceType == typeof(IBuildService)) { var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation); return(new BuildService(sp, packageSettingsProvider)); } else if (serviceType == typeof(IStatusBarNotificationService)) { var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation); return(new StatusBarNotificationService(sp, packageSettingsProvider)); } else if (serviceType == typeof(IBuildMessagesFactory)) { var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation); return(new BuildMessagesFactory(packageSettingsProvider)); } else if (serviceType == typeof(ITaskBarInfoService)) { var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation); return(new TaskBarInfoService(packageSettingsProvider)); } else if (serviceType == typeof(IBuildInformationProvider)) { var solutionProvider = await GetServiceAsync <ISolutionProvider>(cancellation); var buildMessagesFactory = await GetServiceAsync <IBuildMessagesFactory>(cancellation); var buildOutputLogger = await GetServiceAsync <IBuildOutputLogger>(cancellation); var packageSettingsProvider = await GetServiceAsync <IPackageSettingsProvider>(cancellation); var statusBarNotificationService = await GetServiceAsync <IStatusBarNotificationService>(cancellation); var windowStateService = await GetServiceAsync <IWindowStateService>(cancellation); var taskBarInfoService = await GetServiceAsync <ITaskBarInfoService>(cancellation); var buildService = await GetServiceAsync <IBuildService>(cancellation); var errorNavigationService = await GetServiceAsync <IErrorNavigationService>(cancellation); return(new BuildInformationProvider(buildOutputLogger, statusBarNotificationService, buildMessagesFactory, windowStateService, packageSettingsProvider, errorNavigationService, solutionProvider, buildService, taskBarInfoService)); } else { throw new Exception("Not found"); } }
Task <object> CreateService(IAsyncServiceContainer container, CancellationToken cancellationtoken, Type servicetype) => servicetype == typeof(NpgsqlProviderObjectFactory) ? Task.FromResult <object>(new NpgsqlProviderObjectFactory()) : throw new ArgumentException($"Can't create service of type '{servicetype.Name}'");
private Task <object> CreateServiceAsync(IAsyncServiceContainer container, CancellationToken cancellationToken, Type serviceType) { return(Task.FromResult((object)new EmbeddedTerminalService(this))); }
private System.Threading.Tasks.Task <object> CreateVSUIVisualizerServiceAsync(IAsyncServiceContainer container, System.Threading.CancellationToken cancellationToken, Type serviceType) { return(System.Threading.Tasks.Task.FromResult <object>(new VSUIVisualizerService())); }