Quick and easy OWIN pipeline hooks

Once you get your head around OWIN's Func<yness> you begin to see how powerful it can be.

In my last post I discussed the different ways you can add middleware to the OWIN pipeline; one of which was to pass an inline delegate/lambda expression.

As I continue to hack around with OWIN I often find that I want to execute logic at the beginning and/or end of request.

The extension methods below enable you to register before and/or after pipeline hooks; so rather than having to write a middleware class you can just pass a delegate. I'm not advocating that you do this for complex middleware but these are useful extensions if you're learning OWIN and want to understand how the pipeline fits together.

The UseHooks/UseHooksAsync extensions allow you to share state between the before and after hooks without polluting the OWIN environment dictionary (effectively wrapping the two hooks in a closure).

Example 1 - Timing the OWIN pipeline

app.UseHooks(
    before: env => Stopwatch.StartNew(),
    after: (stopwatch, env) =>
    {
        stopwatch.Stop();
        Console.WriteLine(
            "Request completed in {0} milliseconds.", 
            stopwatch.ElapsedMilliseconds);
    }
);

Example 2 - Introducing latency

app.UseHooksAsync(before: env => Task.Delay(2000));

Example 3 - Logging the end of the request

app.UseHooks(after: env => Console.WriteLine(
    "Completed request to {0}", env["owin.RequestPath"]));

Both UseHooks and UseHooksAsync have overloads for optionally passing state and as the method names suggest, one executes the hooks synchronously, the other asynchronously.

using AppFunc = Func<IDictionary<string, object>, Task>;

public static class OwinPipelineHookExtensions
{
    public static IAppBuilder UseHooks(
        this IAppBuilder app,
        Action<IDictionary<string, object>> before = null,
        Action<IDictionary<string, object>> after = null)
    {
        return app.Use(new Func<AppFunc, AppFunc>(next => (async env =>
        {
            if (before != null)
            {
                before.Invoke(env);
            }

            await next.Invoke(env);

            if (after != null)
            {
                after.Invoke(env);
            }
        })));
    }

    public static IAppBuilder UseHooks<TState>(
        this IAppBuilder app,
        Func<IDictionary<string, object>, TState> before = null,
        Action<TState, IDictionary<string, object>> after = null,
        TState defaultState = default(TState))
    {
        return app.Use(new Func<AppFunc, AppFunc>(next => (async env =>
        {
            TState state = defaultState;

            if (before != null)
            {
                state = before.Invoke(env);
            }

            await next.Invoke(env);

            if (after != null)
            {
                after.Invoke(state, env);
            }
        })));
    }

    public static IAppBuilder UseHooksAsync(
        this IAppBuilder app,
        Func<IDictionary<string, object>, Task> before = null,
        Func<IDictionary<string, object>, Task> after = null)
    {
        return app.Use(new Func<AppFunc, AppFunc>(next => (async env =>
        {
            if (before != null)
            {
                await before.Invoke(env);
            }

            await next.Invoke(env);

            if (after != null)
            {
                await after.Invoke(env);
            }
        })));
    }

    public static IAppBuilder UseHooksAsync<TState>(
        this IAppBuilder app,
        Func<IDictionary<string, object>, Task<TState>> before = null,
        Func<TState, IDictionary<string, object>, Task> after = null,
        TState defaultState = default(TState))
    {
        return app.Use(new Func<AppFunc, AppFunc>(next => (async env =>
        {
            TState state = defaultState;

            if (before != null)
            {
                state = await before.Invoke(env);
            }

            await next.Invoke(env);

            if (after != null)
            {
                await after.Invoke(state, env);
            }
        })));
    }
}

View as Gist


Ben Foster

About Me

I'm a software engineer and aspiring entrepreneur with 12+ years experience in the tech industry and have worked with startups and SMB’s in areas such as healthcare, recruitment and e-commerce (I even worked in enterprise, once). I founded my first startup Fabrik in 2011.

I now head up the engineering team at Checkout.com. If you're interested in working in an exciting fin-tech company, drop me a message on Twitter.

Creative Commons Licence