public static ISunnyApplicationBuilder UseService(this ISunnyApplicationBuilder app, Type serviceType)
{
if (!typeof(ISunnyService).GetTypeInfo().IsAssignableFrom(serviceType.GetTypeInfo()))
{
throw new InvalidOperationException(Resources.FormatException_UseServiceServiceTypeNotInheritedISunnyService(serviceType));
}
return(app.Use(next =>
{
return async context =>
{
var serviceFactory = context.RequestServices.GetService <ISunnyServiceFactory>();
if (serviceFactory == null)
{
// No service factory
throw new InvalidOperationException(Resources.FormatException_UseServiceNoSuunyServiceFactory(typeof(ISunnyServiceFactory)));
}
var service = serviceFactory.Create(serviceType);
if (service == null)
{
// The factory returned null, it's a broken implementation
throw new InvalidOperationException(Resources.FormatException_UseServiceUnableToCreateSunnyService(serviceFactory.GetType(), serviceType));
}
try
{
await service.InvokeAsync(context, next);
}
finally
{
serviceFactory.Release(service);
}
};
}));
}
public void Configure(ISunnyApplicationBuilder app)
{
app.UseClientServices();
Func <RequestDelegate, RequestDelegate> middleware = next =>
{
return(context =>
{
return next(context);
});
};
app.Use(middleware);
}
private static DefaultSunnyApplication BuilderSunnyApplication(this IApplicationBuilder app, Action <ISunnyApplicationBuilder> configureApp)
{
//Get the ISunnyApplicationBuilder
var builderFactory = app.ApplicationServices.GetRequiredService <ISunnyApplicationBuilderFactory>();
var sunnyContextFactory = app.ApplicationServices.GetRequiredService <ISunnyContextFactory>();
ISunnyApplicationBuilder applicationBuilder = builderFactory.CreateBuilder();
configureApp?.Invoke(applicationBuilder);
//Building SunnyApplication
var sunnyApplication = applicationBuilder.Build();
return(new DefaultSunnyApplication(sunnyApplication, sunnyContextFactory));
}
public void Start()
{
ISunnyApplicationBuilder applicationBuilder = serviceProvider.GetRequiredService <ISunnyApplicationBuilderFactory>().CreateBuilder();
this.startup.Configure(applicationBuilder);
IServer server = serviceProvider.GetRequiredService <IServerFactory>().CreateServer();
//Building SunnyApplication
var sunnyContextFactory = serviceProvider.GetRequiredService <ISunnyContextFactory>();
var sunnyApplication = applicationBuilder.Build();
var hostingApp = new DefaultSunnyApplication(sunnyApplication, sunnyContextFactory);
//Start Server
server.StartAsync(hostingApp);
}
public static ISunnyApplicationBuilder UseSunnyService(this ISunnyApplicationBuilder builder)
{
builder.UseExceptionService()//Exception Handling
.UseServiceDiscoveryService();
return(builder);
}
public static ISunnyApplicationBuilder UseServiceDiscoveryService(this ISunnyApplicationBuilder builder)
{
builder.UseService <IServiceDiscoveryService>();
return(builder);
}
public static ISunnyApplicationBuilder UseExceptionService(this ISunnyApplicationBuilder builder)
{
builder.UseService <IExceptionService>();
return(builder);
}
public static ISunnyApplicationBuilder UseService <TService>(this ISunnyApplicationBuilder app) where TService : ISunnyService
{
return(app.UseService(typeof(TService)));
}
public void Configure(ISunnyApplicationBuilder app)
{
}
