sealed class CarterOptionsBuilder {
    delegate Task<bool> BeforeDelegate(HttpContext context);
    delegate Task AfterDelegate(HttpContext context);

    private readonly Stack<Func<BeforeDelegate, BeforeDelegate>> befores = new Stack<Func<BeforeDelegate, BeforeDelegate>>();
    private readonly Stack<Func<AfterDelegate, AfterDelegate>> afters = new Stack<Func<AfterDelegate, AfterDelegate>>();

    public CarterOptionsBuilder HandleBefore(Func<HttpContext, Task<bool>> before) {
        befores.Push(next => async context => {
            return await before(context) && await next(context);
        });
        return this;
    }

    public CarterOptionsBuilder HandleAfter(Func<HttpContext, Task> after) {
        afters.Push(next => context => {
            after(context);
            return next(context);
        });
        return this;
    }

    public CarterOptions Build() {
        var before = new BeforeDelegate(c => Task.FromResult(true));
        while (befores.Any()) {
            var current = befores.Pop();
            before = current(before);
        }
        var after = new AfterDelegate(c => Task.CompletedTask);
        while (afters.Any()) {
            var current = afters.Pop();
            after = current(after);
        }
        return new CarterOptions(before.Invoke, after.Invoke);
    }
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env) {
     CarterOptions options = new CarterOptionsBuilder()
        .HandleBefore(this.AddRequestId)
        .HandleBefore(this.BeforeLog)
        .HandleAfter(this.AfterLog)
        .Build();

    app.UseCarter(options);
}

private Task AfterLog(HttpContext arg) {
    //...
    return Task.CompletedTask;
}

private Task<bool> BeforeLog(HttpContext arg) {
    //...
    return Task.FromResult(true);
}

private Task<bool> AddRequestId(HttpContext ctx) {
    ctx.Request.Header["x-request-id"] = Guid.NewGuid().ToString();
    return Task.FromResult(true);
}

public static CarterOptionsBuilder AddLog(this CarterOptionsBuilder builder) {
    return builder
        .HandleBefore(this.BeforeLog)
        .HandleAfter(this.AfterLog);
}
private static Task AfterLog(HttpContext arg) {
    //...
    return Task.CompletedTask;
}

private static Task<bool> BeforeLog(HttpContext arg) {
    //...
    return Task.FromResult(true);
}