public static Task <DebugAdapterServer> From(Action <DebugAdapterServerOptions> optionsAction, IServiceProvider?outerServiceProvider, CancellationToken cancellationToken) { var options = new DebugAdapterServerOptions(); optionsAction(options); return(From(options, outerServiceProvider, cancellationToken)); }
public static DebugAdapterServer Create(Action <DebugAdapterServerOptions> optionsAction, IServiceProvider?outerServiceProvider) { var options = new DebugAdapterServerOptions(); optionsAction(options); return(Create(options, outerServiceProvider)); }
public static async Task <DebugAdapterServer> From(DebugAdapterServerOptions options, IServiceProvider?outerServiceProvider, CancellationToken cancellationToken) { var server = Create(options, outerServiceProvider); await server.Initialize(cancellationToken).ConfigureAwait(false); return(server); }
public static DebugAdapterServer Create(DebugAdapterServerOptions options) => Create(options, null);
internal static IContainer CreateContainer(DebugAdapterServerOptions options, IServiceProvider?outerServiceProvider) => JsonRpcServerContainer.Create(outerServiceProvider) .AddDebugAdapterServerInternals(options, outerServiceProvider);
internal static IContainer AddDebugAdapterServerInternals(this IContainer container, DebugAdapterServerOptions options, IServiceProvider outerServiceProvider) { container = container.AddDebugAdapterProtocolInternals(options); if (options.OnUnhandledException != null) { container.RegisterInstance(options.OnUnhandledException); } else { container.RegisterDelegate(_ => new OnUnhandledExceptionHandler(e => { }), Reuse.Singleton); } container.RegisterInstance <IOptionsFactory <DebugAdapterServerOptions> >(new ValueOptionsFactory <DebugAdapterServerOptions>(options)); container.RegisterInstance(options.Capabilities); container.RegisterInstance(options.RequestProcessIdentifier); container.RegisterMany <DebugAdapterServerProgressManager>(nonPublicServiceTypes: true, reuse: Reuse.Singleton); container.RegisterMany <DebugAdapterServer>( serviceTypeCondition: type => type == typeof(IDebugAdapterServer) || type == typeof(DebugAdapterServer), reuse: Reuse.Singleton ); // container. var providedConfiguration = options.Services.FirstOrDefault(z => z.ServiceType == typeof(IConfiguration) && z.ImplementationInstance is IConfiguration); container.RegisterDelegate <IConfiguration>( _ => { var builder = new ConfigurationBuilder(); if (outerServiceProvider != null) { var outerConfiguration = outerServiceProvider.GetService <IConfiguration>(); if (outerConfiguration != null) { builder.AddConfiguration(outerConfiguration, false); } } if (providedConfiguration != null) { builder.AddConfiguration(providedConfiguration.ImplementationInstance as IConfiguration); } return(builder.Build()); }, Reuse.Singleton ); return(container); }
/// <summary> /// Sets the default scheduler to be used when scheduling other tasks /// </summary> /// <param name="options"></param> /// <param name="defaultScheduler"></param> /// <returns></returns> public static DebugAdapterServerOptions WithDefaultScheduler(this DebugAdapterServerOptions options, IScheduler defaultScheduler) { options.DefaultScheduler = defaultScheduler; return(options); }
public static Task <DebugAdapterServer> From(DebugAdapterServerOptions options, CancellationToken cancellationToken) => From(options, null, cancellationToken);
public static DebugAdapterServerOptions ConfigureLogging(this DebugAdapterServerOptions options, Action <ILoggingBuilder> builderAction) { options.LoggingBuilderAction = builderAction; return(options); }
public static DebugAdapterServerOptions OnStarted(this DebugAdapterServerOptions options, OnDebugAdapterServerStartedDelegate @delegate) { options.Services.AddSingleton(@delegate); return(options); }
public static DebugAdapterServerOptions OnInitialized(this DebugAdapterServerOptions options, OnDebugAdapterServerInitializedDelegate initializedDelegate) { options.Services.AddSingleton(initializedDelegate); return(options); }
public static DebugAdapterServerOptions WithRequestProcessIdentifier(this DebugAdapterServerOptions options, IRequestProcessIdentifier requestProcessIdentifier) { options.RequestProcessIdentifier = requestProcessIdentifier; return(options); }
public static DebugAdapterServerOptions WithSerializer(this DebugAdapterServerOptions options, ISerializer serializer) { options.Serializer = serializer; return(options); }
/// <summary> /// Sets the scheduler use during writing output /// </summary> /// <param name="options"></param> /// <param name="outputScheduler"></param> /// <returns></returns> public static DebugAdapterServerOptions WithOutputScheduler(this DebugAdapterServerOptions options, IScheduler outputScheduler) { options.OutputScheduler = outputScheduler; return(options); }
public static DebugAdapterServer Create(DebugAdapterServerOptions options, IServiceProvider?outerServiceProvider) => CreateContainer(options, outerServiceProvider).Resolve <DebugAdapterServer>();
public static Task <DebugAdapterServer> From(DebugAdapterServerOptions options) => From(options, null, CancellationToken.None);
public static DebugAdapterServerOptions AddDefaultLoggingProvider(this DebugAdapterServerOptions options) { options.AddDefaultLoggingProvider = true; return(options); }
public static Task <DebugAdapterServer> From(DebugAdapterServerOptions options, IServiceProvider?outerServiceProvider) => From(options, outerServiceProvider, CancellationToken.None);
public static DebugAdapterServerOptions ConfigureConfiguration(this DebugAdapterServerOptions options, Action <IConfigurationBuilder> builderAction) { options.ConfigurationBuilderAction = builderAction; return(options); }
internal static IContainer AddDebugAdapterServerInternals(this IContainer container, DebugAdapterServerOptions options, IServiceProvider?outerServiceProvider) { container = container.AddDebugAdapterProtocolInternals(options); if (options.OnUnhandledException != null) { container.RegisterInstance(options.OnUnhandledException); } else { container.RegisterDelegate(_ => new OnUnhandledExceptionHandler(_ => { }), Reuse.Singleton); } container.RegisterInstance <IOptionsFactory <DebugAdapterServerOptions> >(new ValueOptionsFactory <DebugAdapterServerOptions>(options)); container.RegisterInstance(options.Capabilities); container.RegisterInstance(options.RequestProcessIdentifier); container.RegisterMany <DebugAdapterServerProgressManager>(nonPublicServiceTypes: true, reuse: Reuse.Singleton); container.RegisterMany <DebugAdapterServer>( serviceTypeCondition: type => type == typeof(IDebugAdapterServer) || type == typeof(DebugAdapterServer), reuse: Reuse.Singleton, setup: Setup.With(condition: req => req.IsResolutionRoot || req.Container.Resolve <IInsanceHasStarted>().Started) ); container.RegisterMany <DefaultDebugAdapterServerFacade>( serviceTypeCondition: type => type.IsClass || !type.Name.Contains("Proxy") && typeof(DefaultDebugAdapterServerFacade).GetInterfaces().Except(typeof(DefaultDebugAdapterServerFacade).BaseType !.GetInterfaces()).Any(z => type == z), reuse: Reuse.Singleton ); // container. var providedConfiguration = options.Services.FirstOrDefault(z => z.ServiceType == typeof(IConfiguration) && z.ImplementationInstance is IConfiguration); container.RegisterDelegate <IConfiguration>( _ => { var builder = new ConfigurationBuilder(); if (outerServiceProvider != null) { var outerConfiguration = outerServiceProvider.GetService <IConfiguration>(); if (outerConfiguration != null) { builder.CustomAddConfiguration(outerConfiguration, false); } } if (providedConfiguration != null) { builder.CustomAddConfiguration((providedConfiguration.ImplementationInstance as IConfiguration) !); } return(builder.Build()); }, Reuse.Singleton ); return(container); }
/// <summary> /// Sets the scheduler used during reading input /// </summary> /// <param name="options"></param> /// <param name="inputScheduler"></param> /// <returns></returns> public static DebugAdapterServerOptions WithInputScheduler(this DebugAdapterServerOptions options, IScheduler inputScheduler) { options.InputScheduler = inputScheduler; return(options); }