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);
}
