private static IHighlightJSService GetOrCreateHighlightJSService() { if (_highlightJSService == null || _services != null) { lock (_createLock) { if (_highlightJSService == null || _services != null) { // Dispose of service provider _serviceProvider?.Dispose(); // Create new service provider (_services ?? (_services = new ServiceCollection())).AddHighlightJS(); _serviceProvider = _services.BuildServiceProvider(); _highlightJSService = _serviceProvider.GetRequiredService <IHighlightJSService>(); // Only set to null after new _highlightJSService is initialized, otherwise another thread might skip the lock and try to use the old _highlightJSService _services = null; } } } // HighlightJSService already exists and no configuration pending return(_highlightJSService); }
public void Setup() { var services = new ServiceCollection(); services.AddBeeBus(typeof(BasicMessage).Assembly); _serviceProvider?.Dispose(); _serviceProvider = services.BuildServiceProvider(false); }
static void Main(string[] args) { ServiceProvider serviceProvider = null; try { var configuration = new ConfigurationBuilder() .AddJsonFile("settings.json") .Build(); var services = new ServiceCollection(); services.AddLogging(logging => { logging.AddConsole(); }); services.AddOptions(); services.AddHttpClient(); services.AddSingleton(configuration.Get <Settings>()); services.AddSingleton <ColoredBtcClITool>(); serviceProvider = services.BuildServiceProvider(); serviceProvider.GetRequiredService <ColoredBtcClITool>().Execute(args); } catch (Exception ex) { Console.WriteLine($"args: {string.Join(", ", args)}. {ex}"); } finally { serviceProvider?.Dispose(); } }
void IDisposable.Dispose() { ServiceContainer.ServiceProviderOverride = null; _serviceProvider?.Dispose(); _serviceProvider = null; JsiiTypeAttributeBase.Reset(); }
public void TearDown() { serviceScope?.Dispose(); serviceProvider?.Dispose(); File.Delete(databaseFileName); }
public void Dispose() { using IDbConnection db = new SqlConnection(ConnectionString); db.Execute(@"DELETE FROM [dbo].[Pet] DELETE FROM [dbo].[User]"); ServiceProvider?.Dispose(); }
public void AddBewitValidation_WithMyPayload_ShouldAddBewitTokenValidatorForMyPayload() { //Arrange const string secret = "112"; var services = new ServiceCollection(); //Act services.AddBewitValidation(new BewitOptions { Secret = secret }, b => b.AddPayload <Foo>()); //Assert ServiceProvider serviceProvider = null; try { serviceProvider = services.BuildServiceProvider(); IBewitTokenValidator <Foo> bewitTokenGenerator = serviceProvider.GetService <IBewitTokenValidator <Foo> >(); bewitTokenGenerator.Should().NotBeNull(); bewitTokenGenerator.Should() .BeOfType <BewitTokenValidator <Foo> >(); } finally { serviceProvider?.Dispose(); } }
public void AddBewitValidation_WithPersistance_ShouldAddPersistedBewitTokenGenerator() { //Arrange const string secret = "112"; var services = new ServiceCollection(); //Act services.AddSingleton <INonceRepository>(new Mock <INonceRepository>().Object); services.AddBewitValidation(new BewitOptions { Secret = secret }, builder => { builder.AddPayload <Foo>(); }); //Assert ServiceProvider serviceProvider = null; try { serviceProvider = services.BuildServiceProvider(); IBewitTokenValidator <Foo> bewitTokenGenerator = serviceProvider.GetService <IBewitTokenValidator <Foo> >(); bewitTokenGenerator.Should().NotBeNull(); bewitTokenGenerator.Should() .BeOfType <BewitTokenValidator <Foo> >(); } finally { serviceProvider?.Dispose(); } }
public void AddBewitValidation_WithValidConfiguration_ShouldAddBewitTokenValidatorForMyPayload() { //Arrange var services = new ServiceCollection(); var configuration = new ConfigurationBuilder() .AddInMemoryCollection(new[] { new KeyValuePair <string, string>("Bewit:Secret", "123") }) .Build(); //Act services.AddBewitValidation(configuration, b => b.AddPayload <Foo>()); //Assert ServiceProvider serviceProvider = null; try { serviceProvider = services.BuildServiceProvider(); IBewitTokenValidator <Foo> bewitTokenGenerator = serviceProvider.GetService <IBewitTokenValidator <Foo> >(); bewitTokenGenerator.Should().NotBeNull(); bewitTokenGenerator.Should() .BeOfType <BewitTokenValidator <Foo> >(); } finally { serviceProvider?.Dispose(); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Main entry-point for this application. </summary> /// /// <param name="args"> An array of command-line argument strings. </param> //////////////////////////////////////////////////////////////////////////////////////////////////// #pragma warning disable IDE0060 // Remove unused parameter private static void Main(string[] args) #pragma warning restore IDE0060 // Remove unused parameter { //Note that I still do not know if I need this line. I adopted it when I was // trying to find out how to start a WinUI desktop application from a Main method like this. // I found that Scott Jones from Microsoft had this call in his example. So far I have not // needed it, but I am leaving it here as a reminder of random stuff to try when I have some // problem that has sucked my brain clean of any solutions. //WinRT.ComWrappersSupport.InitializeComWrappers(); //In WPF it is easier to know when the application is exiting. This is a solid way to // be notified for any required cleanup. AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit; //If you are new to WinUI, coming from WPF like me, you will probably be a bit confused how this // initializer works. Merely declaring an instance of an Application is all that is required. // I could have placed all of this logic in "Main" itself, so be aware that you can just use // a simple lambda if you wish. Microsoft.UI.Xaml.Application.Start(ApplicationInitializationCallback); //Assure all services that implement IDisposable get a chance to run their dispose logic. ServiceProvider?.Dispose(); //Not really needed, but I tend to do things like this out of good habit, plus some // testing scenarios can cause abnormal control flow. ServiceProvider = null; Current = null; }
protected virtual void Dispose(bool disposing) { if (disposing) { _provider?.Dispose(); } }
private async Task <int> ExecuteAsync( CommandLineApplication cmd) { int resultCode; ServiceProvider serviceProvider = null; try { if (Options.ShowHelp || !Options.Validate()) { cmd.ShowHelp(); } else { serviceProvider = ConfigureServices().BuildServiceProvider(); await serviceProvider .GetService <TStrategy>() .ExecuteAsync(); } resultCode = 0; } catch (Exception e) { _log.Critical(e, "Execution burning failed."); resultCode = 1; } serviceProvider?.Dispose(); return(resultCode); }
private static int Main(string[] args) { int resultCode; ServiceProvider serviceProvider = null; try { serviceProvider = ConfigureServices().BuildServiceProvider(); var rootCommand = serviceProvider.GetService <IRootCommand>(); var app = rootCommand.Configure(); resultCode = app.Execute(args); } catch (Exception e) { Console.WriteLine(e.Message); resultCode = 1; } serviceProvider?.Dispose(); return(resultCode); }
public async Task TestAbstractReturn() { var queues = new List <IQueue>() { new Config.Queue(Q1), new Config.Queue(Q2), new Config.Queue(Q3), new Config.Queue(Q4) }; ServiceProvider provider = null; try { provider = await CreateAndStartServices(null, queues, typeof(Listener)); var template = provider.GetRabbitTemplate(); var reply = template.ConvertSendAndReceive <Three>("EnableRabbitReturnTypesTests.2", "3"); Assert.NotNull(reply); var reply2 = template.ConvertSendAndReceive <Four>("EnableRabbitReturnTypesTests.2", "4"); Assert.NotNull(reply2); } catch (Exception) { } finally { var admin = provider.GetRabbitAdmin(); admin.DeleteQueue(Q1); admin.DeleteQueue(Q2); admin.DeleteQueue(Q3); admin.DeleteQueue(Q4); provider?.Dispose(); } }
public async Task TearDown() { serviceScope?.Dispose(); serviceProvider?.Dispose(); await DropDatabaseAsync() .ConfigureAwait(false); }
public void TestCleanup() { _servicesCollection.Clear(); _servicesCollection = null; _serviceProvider?.Dispose(); _serviceProvider = null; }
public void TearDown() { unitOfWork?.Dispose(); serviceScope?.Dispose(); serviceProvider?.Dispose(); DropDatabase(); }
protected virtual void Dispose(bool disposing) { if (disposing) { _serviceProvider?.Dispose(); } _serviceProvider = null; }
/// <summary> /// Dispose all created objects. /// </summary> public void Dispose() { scope?.Dispose(); serviceProvider?.Dispose(); foreach (var o in createdObjects.Values.Select(i => i as IDisposable).Where(i => i != null)) { o.Dispose(); } }
/// <summary> /// Entry point for the program. /// </summary> /// <param name="args">Arguments passed to the program, if any.</param> /// <returns>A <see cref="Task" /> representing program progress.</returns> public static async Task Main(string[] args) { ServiceProvider provider = null; ILogger log = null; try { var configuration = BuildConfiguration(args); var services = new ServiceCollection(); services.AddLogging( builder => { var logger = new LoggerConfiguration().ReadFrom.Configuration(configuration).CreateLogger(); Log.Logger = logger; builder.AddSerilog(logger, true); }); services.AddCshrixServices(configuration, "ClientConfiguration"); services.AddTransient <Bot>(); provider = services.BuildServiceProvider(); log = provider.GetRequiredService <ILoggerFactory>().CreateLogger("MAIN"); var bot = provider.GetRequiredService <Bot>(); await bot.TestAsync(); Console.WriteLine("Press <ENTER> to exit"); Console.ReadLine(); log.LogInformation("<ENTER> pressed, disposing service provider and exiting"); provider.Dispose(); } catch (Exception ex) { if (log == null) { Console.WriteLine($"Unhandled exception {ex.GetType()} in main: {ex.Message}"); Console.WriteLine(ex.StackTrace); } else { log.LogCritical(ex, "Unhandled exception in main"); } throw; } finally { provider?.Dispose(); } }
protected virtual void Dispose(bool disposing) { if (!disposing) { return; } ServiceProvider?.Dispose(); ServiceProvider = null; }
public void Dispose() { ServiceProvider?.Dispose(); ((IDisposable)CommandService)?.Dispose(); CancellationTokenSource?.Dispose(); foreach (var task in TasksToAwait) { task.Dispose(); } }
public void TearDown() { ServiceScope?.Dispose(); ServiceProvider?.Dispose(); if (_temporaryDatabase != null) { var connString = _temporaryDatabase.ConnectionString; _temporaryDatabase = null; FbDatabase.DropDatabase(connString); } }
/// <summary> /// Disposes underlying service provider. /// </summary> /// <param name="disposing"></param> protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { _serviceProvider?.Dispose(); } _disposed = true; }
private static ServiceProvider GetOrCreateServiceProvider() { if (_serviceProvider == null || _services != null) { lock (_createLock) { if (_serviceProvider == null || _services != null) { // Dispose of service provider _serviceProvider?.Dispose(); // Create new service provider (_services ?? (_services = new ServiceCollection())).AddFlexiBlocks(); _serviceProvider = _services.BuildServiceProvider(); _services = null; } } } return(_serviceProvider); }
public void Dispose() { if (codeDomProvider != null) { codeDomProvider.Dispose(); codeDomProvider = null; } if (serviceProvider != null) { serviceProvider.Dispose(); serviceProvider = null; } }
static void Main(string[] args) { SetupDI(); var onboardingClient = ServiceProvider.GetService <IOnboardingClient>(); var v = onboardingClient.GetProcesses(); Console.WriteLine(v.Result); Console.ReadLine(); ServiceProvider.Dispose(); }
public void Dispose() { CheckDisposed(); _services?.Clear(); _services = null; _queue = null; _provider?.Dispose(); _provider = null; _disposed = true; }
private void Dispose(bool disposing) { if (disposing) { var _dbContext = GetService <DbContext>(); if (_dbContext != null) { _dbContext.Dispose(); } serviceProvider.Dispose(); } }
protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { if (serviceProvider != null) { serviceProvider.Dispose(); } } } _disposed = true; }
private static bool ProcessCommandLine(Dictionary<string, string> pArgs) { if (pArgs.ContainsKey("-assistant")) { Assistant.Main(pArgs); return true; } if (pArgs.ContainsKey("-e")) { try { ExtendedCmd.Run(pArgs); } catch (Exception ex) { PhUtils.ShowException("Unable to complete the operation", ex); } return true; } if (pArgs.ContainsKey("-installkph")) { try { using (ServiceManagerHandle scm = new ServiceManagerHandle(ScManagerAccess.CreateService)) { using (ServiceHandle shandle = scm.CreateService( "KProcessHacker2", "KProcessHacker2", ServiceType.KernelDriver, ServiceStartType.SystemStart, ServiceErrorControl.Ignore, Application.StartupPath + "\\kprocesshacker.sys", null, null, null )) { shandle.Start(); } } } catch (WindowsException ex) { // Need to pass status back. Environment.Exit((int)ex.ErrorCode); } return true; } if (pArgs.ContainsKey("-uninstallkph")) { try { using (ServiceHandle shandle = new ServiceHandle("KProcessHacker2", ServiceAccess.Stop | (ServiceAccess)StandardRights.Delete)) { try { shandle.Control(ServiceControl.Stop); } catch { } shandle.Delete(); } } catch (WindowsException ex) { // Need to pass status back. Environment.Exit((int)ex.ErrorCode); } return true; } if (pArgs.ContainsKey("-ip")) InspectPid = int.Parse(pArgs["-ip"]); if (pArgs.ContainsKey("-pw")) { int pid = int.Parse(pArgs["-pw"]); PrimaryProviderThread = new ProviderThread(Settings.Instance.RefreshInterval); SecondaryProviderThread = new ProviderThread(Settings.Instance.RefreshInterval); ProcessProvider = new ProcessSystemProvider(); ServiceProvider = new ServiceProvider(); PrimaryProviderThread.Add(ProcessProvider); PrimaryProviderThread.Add(ServiceProvider); ProcessProvider.Boost(); ServiceProvider.Boost(); ProcessProvider.Enabled = true; ServiceProvider.Enabled = true; Win32.LoadLibrary(Settings.Instance.DbgHelpPath); if (!ProcessProvider.Dictionary.ContainsKey(pid)) { PhUtils.ShowError("The process (PID " + pid.ToString() + ") does not exist."); Environment.Exit(0); return true; } ProcessWindow pw = new ProcessWindow(ProcessProvider.Dictionary[pid]); Application.Run(pw); PrimaryProviderThread.Dispose(); ProcessProvider.Dispose(); ServiceProvider.Dispose(); Environment.Exit(0); return true; } if (pArgs.ContainsKey("-pt")) { int pid = int.Parse(pArgs["-pt"]); try { using (var phandle = new ProcessHandle(pid, Program.MinProcessQueryRights)) Application.Run(new TokenWindow(phandle)); } catch (Exception ex) { PhUtils.ShowException("Unable to show token properties", ex); } return true; } if (pArgs.ContainsKey("-o")) { OptionsWindow options = new OptionsWindow(true) { StartPosition = FormStartPosition.CenterScreen }; IWin32Window window; if (pArgs.ContainsKey("-hwnd")) window = new WindowFromHandle(new IntPtr(int.Parse(pArgs["-hwnd"]))); else window = new WindowFromHandle(IntPtr.Zero); if (pArgs.ContainsKey("-rect")) { Rectangle rect = Utils.GetRectangle(pArgs["-rect"]); options.Location = new Point(rect.X + 20, rect.Y + 20); options.StartPosition = FormStartPosition.Manual; } options.SelectedTab = options.TabPages["tabAdvanced"]; options.ShowDialog(window); return true; } if (pArgs.ContainsKey(string.Empty)) if (pArgs[string.Empty].Replace("\"", string.Empty).Trim().EndsWith("taskmgr.exe", StringComparison.OrdinalIgnoreCase)) StartVisible = true; if (pArgs.ContainsKey("-m")) StartHidden = true; if (pArgs.ContainsKey("-v")) StartVisible = true; if (pArgs.ContainsKey("-a")) { try { Unhook(); } catch { } try { NProcessHacker.KphHookInit(); } catch { } } if (pArgs.ContainsKey("-t")) { if (pArgs["-t"] == "0") SelectTab = "Processes"; else if (pArgs["-t"] == "1") SelectTab = "Services"; else if (pArgs["-t"] == "2") SelectTab = "Network"; } return false; }