public void Configuration(IAppBuilder app)
{
IDependencyGraphFactory dependencyGraphFactory = new DependencyGraphFactory();
ISegmenterFactory segmenterFactory = new SegmenterFactory(dependencyGraphFactory);
IConfiguration config = new DefaultValueConfiguration();
IBuilder builder = new Builder(dependencyGraphFactory, segmenterFactory, config);
var uiPath = new PathString("/ui");
builder.Register(new Router(config, dependencyGraphFactory))
.AddRoute("ui", c => c.Request.Path.StartsWithSegments(uiPath))
.As("Router");
builder.Register(new OutputCache())
.As("OutputCache")
.RunOnRoute("ui")
.ConfigureWith(config, "/ui/outputCache");
builder.Register(new TestMiddleware2())
.As("Versioning")
.RunOnRoute("ui")
.ConfigureWith(config, "/ui/versioning");
builder.Register(new TestMiddleware2())
.As("Dart")
.RunOnRoute("ui")
.ConfigureWith(config, "/ui/dart");
builder.Register(new TestMiddleware2())
.As("Less")
.RunAfter("Dart")
.RunAfter("Versioning")
.RunOnRoute("ui")
.ConfigureWith(config, "/ui/less");
builder.Register(new TestMiddleware3()).
As("Static files")
.RunAfter("Dart")
.RunAfter("Versioning")
.RunOnRoute("ui")
.ConfigureWith(config, "/ui/staticFiles");
builder.Register(new TestMiddleware1())
.As("Route visualizer")
.RunOnRoute("ui")
.ConfigureWith(config, "/ui/visualizer");
app.UseBuilder(builder);
}
public void Configuration(IAppBuilder app)
{
// This demonstrates how you would configure the builder without using IoC
// There are other startup examples in this project that demonstrate the IoC version
IDependencyGraphFactory dependencyGraphFactory = new DependencyGraphFactory();
ISegmenterFactory segmenterFactory = new SegmenterFactory(dependencyGraphFactory);
IBuilder builder = new Builder(dependencyGraphFactory, segmenterFactory);
IConfiguration configuration = new DefaultValueConfiguration();
// Note that the middleware components below can be registerd with the builder
// in any order. The builder will resolve dependencies and add middleware into
// the OWIN pipeline so that all dependencies are satisfied. If there are
// circular dependencies an exception will be thrown.
// This middleware is built to run at the front of the Owin pipeline
// so not much more to set up here.
builder.Register(new ReportExceptions());
// Configure different 404 behaviours for different routes.
// Note that NotFoundError middleware is built to run at the end of the Owin
// pipeline after all other middleware. If no other middleware handled the
// request then it returns a 404 response.
builder.Register(new NotFoundError())
.As("apiNotFoundError")
.RunOnRoute("api")
.ConfigureWith(configuration, "/owin/notFound/api");
builder.Register(new NotFoundError())
.As("uiNotFoundError")
.RunOnRoute("ui")
.ConfigureWith(configuration, "/owin/notFound/ui");
builder.Register(new NotFoundError())
.As("staticFilesNotFoundError")
.RunOnRoute("staticFiles")
.ConfigureWith(configuration, "/owin/notFound/staticFiles");
builder.Register(new NotFoundError())
.As("invalidNotFoundError")
.RunOnRoute("invalid")
.ConfigureWith(configuration, "/owin/notFound/invalid");
// This says that we want to use forms based identification, that
// we will refer to it by the name 'loginId', and it will
// only be configured for the 'secure' route. This also defines
// the configureation mechanism and specifies where to get config
// for this instance in the config file.
builder.Register(new FormsIdentification())
.As("loginId")
.ConfigureWith(configuration, "/owin/auth/forms")
.RunOnRoute("secure");
// This says that we want to use certificate based identification, that
// we will refer to it by the name 'certificateId'.
builder.Register(new CertificateIdentification())
.As("certificateId")
.ConfigureWith(configuration, "/owin/auth/cert");
// This specifies the mechanism we want to use to store session.
// We don't need to specify anything else because each middleware knows
// already whether it needs session or not and the builder will ensure
// that session is included in the pipeline before anything that needs it.
builder.Register(new InProcessSession())
.ConfigureWith(configuration, "/owin/session");
// This configures a routing element that will split the OWIN pipeline into
// two routes. There is a 'ui' route that has forms based authentication and
// template based rendering. There is an 'api' route that has certifcate based
// authentication and REST service rendering.
// Since this router does not have any route dependencies it will run directly
// off the incomming request.
builder.Register(new Router(dependencyGraphFactory))
.AddRoute("ui", context => context.Request.Path.Value.EndsWith(".aspx"))
.AddRoute("staticFiles", context =>
{
var path = context.Request.Path.Value;
var fileExtensionIndex = path.LastIndexOf('.');
if (fileExtensionIndex < 0)
{
return(false);
}
var fileExtension = path.Substring(fileExtensionIndex).ToLower();
if (fileExtension == ".html")
{
return(true);
}
if (fileExtension == ".css")
{
return(true);
}
if (fileExtension == ".js")
{
return(true);
}
if (fileExtension == ".jpg")
{
return(true);
}
if (fileExtension == ".png")
{
return(true);
}
return(false);
})
.AddRoute("api", context => context.Request.Path.Value.StartsWith("/api/"))
.AddRoute("invalid", context => true);
// This configures another routing split that divides the 'ui' route into
// 'secure' and 'public' routes.
builder.Register(new Router(dependencyGraphFactory))
.AddRoute("secure", context => context.Request.Path.Value.StartsWith("/secure"))
.AddRoute("public", context => true)
.RunOnRoute("ui");
// This specifies that we want to use the template page rendering
// middleware and that it should run on both the "public" route and
// the "secure" route. This creates a join bewteen the routes.
builder.Register(new TemplatePageRendering())
.RunOnRoute("public")
.RunOnRoute("secure")
.ConfigureWith(configuration, "/owin/templates");
// This specifies that we want to use the REST service mapper on the 'api' route
// and that it should run after the 'certificateId' middleware
builder.Register(new RestServiceMapper())
.RunAfter("certificateId")
.RunOnRoute("api")
.ConfigureWith(configuration, "/owin/rest");
// This statement will add all of the middleware registered with the builder into
// the OWIN pipeline. The builder will add middleware to the pipeline in an order
// that ensures all dependencies are met.
// The builder will also create splits in the OWIN pipeline where there are routing
// components configured, and joins where middleware has a dependency on multiple
// routes.
// If you want to see exactly how the Owin pipeline got built, there is a
// PipelineVisualizer middleware in the OwinFramework.Middleware package that you
// can add to your configuraton. This middleware will return an SVG vizualization
// of the pipeline including configurations and analytics.
app.UseBuilder(builder);
// Anything that you do with the builder after this point will have no effect on
// to Owin pipeline which has already been built.
}
