public async Task StartAsync(CancellationToken cancellationToken) { try { await _service.StartAsync(cancellationToken); _logger.LogInformation($"Service {_service.GetType().FullName} started"); } catch (Exception e) { _logger.LogCritical(e, $"Error starting hosted service {_service.GetType().FullName}"); _applicationLifetime.StopApplication(); } }
public void RunService() { log.Trace(() => $"Going to run a service of type {service.GetType().FullName}"); AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload; log.Trace(() => $"Registered Unhandled Exception Event"); handle = new AutoResetEvent(false); Console.CancelKeyPress += Console_CancelKeyPress; service.ServiceFailed += Service_ServiceFailed; service.RunService(); Console.WriteLine("Application Running. Use Cancel Keys (normally Ctrl+C) to close"); log.Info("Service Started, about to block main thread"); handle.WaitOne(); log.Info("Main Thread Resumed to Shutdown"); service.Shutdown(); log.Info("Service Shutdown. Goodbye!"); }
/// <summary> /// Adds the IHostedService to the service collection. /// </summary> /// <param name="serviceBuilder">A collection of services</param> /// <param name="service">The IHostedService to add to the service collection.</param> /// <returns>List of services with the IHostedService attached.</returns> public static IServiceCollection AddHostedService(this IServiceCollection serviceBuilder, IHostedService service) { var type = service.GetType(); ProcessTypes.Add(type); serviceBuilder.AddSingleton(type, service); return(serviceBuilder); }
/// <summary> /// Adds the hosted service into the service collection. /// </summary> /// <param name="service">The service to add.</param> /// <returns>AppHostBuilder with the new service added.</returns> public AppHostBuilder AddHostedService(IHostedService service) { var type = service.GetType(); _services.AddSingleton(type, service); _processTypes.Add(type); return(this); }
private static Task ExecuteAsync(IHostedService hostedService, CancellationToken cancellationToken) { //Microsoft.Extensions.Hosting.BackgroundService.ExecuteAsync Type type = hostedService.GetType(); MethodInfo mi = type.GetMethod("ExecuteAsync", BindingFlags.NonPublic | BindingFlags.Instance); object value = mi.Invoke(hostedService, new object[] { cancellationToken }); var task = value as Task; return(task); }
public void Register <T>(IHostedService service, string friendlyName) where T : class, IHostedService { if (typeof(T) != service.GetType()) { throw new ArgumentException($"Type mismatch: {nameof(T)} is {typeof(T).Name}, but {nameof(service)} is {service.GetType()}."); } if (IsStartAllAsyncStarted) { throw new InvalidOperationException("Services are already started."); } lock (ServicesLock) { if (AnyNoLock <T>()) { throw new InvalidOperationException($"{typeof(T).Name} is already registered."); } Services.Add(new HostedService(service, friendlyName)); } }
public Guid Install(IHostedService service) { this.WriteDebugMessage(string.Format("Installing hosted service {0}({1}).", service.GetType().Name, service.Name)); var serviceId = Guid.NewGuid(); var cancellationTokenSource = new CancellationTokenSource(); var cancellationToken = cancellationTokenSource.Token; var task = createTask(service, cancellationToken); _taskMap.Add(serviceId, task); _taskTokenSources.Add(serviceId, cancellationTokenSource); Services.Add(serviceId, service); this.WriteInfoMessage(string.Format("Installed hosted service {0}.", service.Name)); return serviceId; }
internal HostedServiceWrapper(IHostedService inner, ILogger <HostedServiceWrapper> logger) { _inner = inner; _logger = logger; Name = inner.GetType().Name.Replace("HostedService", ""); }
private void Service_ServiceFailed(IHostedService service) { log.Debug(service.GetType().FullName + " Failed. Stopping Service Host"); Shutdown(); }
public LoggingServiceDecorator(ILoggerFactory loggerFactory, IHostedService inner) { this.inner = inner; this.logger = loggerFactory.CreateLogger(inner.GetType()); }
private static async Task StartServiceAsync(IHostedService service) { Console.WriteLine($"Starting {service.GetType().Name}."); await service.StartAsync(default);