Quick hack to adapt the current HttpMessageHandlerAdapter to the OWIN signatures

MidFuncAsClass.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

using AppFunc = Func<IDictionary<string, obj>, Task>;
using MidFunc = Func<AppFunc, AppFunc>;

public class MidFuncType
{
    private readonly AppFunc next;
    
    public MidFuncType(AppFunc next)
    {
        this.next = next;
    }
    
    public Task Invoke(IDictionary<string, obj> environment)
    {
        // invoke the middleware, call `next`, etc.
        // return the `Task`
        return Task.FromResult<obj>(null) :> Task
    }
}

MidFuncAsType.fs

open System
open System.Collections.Generic
open System.Threading.Tasks

type AppFunc = Func<IDictionary<string, obj>, Task>
type MidFunc = Func<AppFunc, AppFunc>

type MidFuncType(next: AppFunc) =
    // set up the middleware
    member this.Invoke(environment: IDictionary<string, obj>) : Task =
        // invoke the middleware, call `next`, etc.
        // return the `Task`
        Task.FromResult<obj>(null) :> Task

OwinMessageHandlerAdapter.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Owin;
using System.Web.Http.Owin;
using AppFunc = Func<IDictionary<string, obj>, Task>

/// See https://katanaproject.codeplex.com/SourceControl/latest#src/Microsoft.Owin/Infrastructure/AppFuncTransition.cs
internal sealed class AppFuncTransition : OwinMiddleware
    : base(null)
{
    private readonly AppFunc next;
    
    public AppFuncTransition(next: AppFunc)
    {
        this.next = next;
    }
    
    public Task Invoke(IOwinContext context)
    {
        // TODO: check for null
        return this.next(context.Environment)
    }
}

/// Explicit wrapper for HttpMessageHandlerAdapter
public class OwinMessageHandlerMiddleware
{
    private readonly OwinMiddleware next;
    
    OwinMessageHandlerMiddleware(AppFunc next, HttpMessageHandlerAdapterOptions /* I think this is the right name */ options)
    {
        var nextKatana = new AppFuncTransition(next);
        this.next = new HttpMessageHandlerAdapter(nextKatana, options);
    }
    
    public Task Invoke(IDictionary<string, obj> environment)
    {
        // TODO: check for null
        var context = new OwinContext(environment);
        return next(context);
    }
}

// This can be made generic:

/// Generic OwinMiddleware adapter
public abstract class OwinMiddlewareAdapter
{
    private readonly OwinMiddleware next;
    
    protected OwinMiddlewareAdapter(AppFunc next, Func<OwinMiddleware, OwinMiddleware> factory)
    {
        var nextKatana = new AppFuncTransition(next);
        this.next = factory(nextKatana);
    }
    
    public Task Invoke(IDictionary<string, obj> environment)
    {
        // TODO: check for null
        var context = new OwinContext(environment)
        return next(context)
    }
}
    
/// HttpMessageHandlerAdapter using the Generic OwinMiddleware adapter
public class OwinMessageHandlerMiddlewareAdapter : OwinMiddlewareAdapter
{
    public OwinMessageHandlerMiddlewareAdapter(AppFunc next, HttpMessageHandlerAdapterOptions /* I think this is the right name */ options)
        : base(next, m => new HttpMessageHandlerAdapter(m, options))
    {
    }
}

OwinMessageHandlerMiddleware.fs

open System
open System.Collections.Generic
open System.Threading.Tasks
open Microsoft.Owin
open System.Web.Http.Owin

type AppFunc = Func<IDictionary<string, obj>, Task>

/// See https://katanaproject.codeplex.com/SourceControl/latest#src/Microsoft.Owin/Infrastructure/AppFuncTransition.cs
[<Sealed>]
type AppFuncTransition(next: AppFunc) =
    inherit OwinMiddleware(null)
    default x.Invoke(context: IOwinContext) =
        // TODO: check for null
        next.Invoke(context.Environment)

/// Explicit wrapper for HttpMessageHandlerAdapter
type OwinMessageHandlerMiddleware(next: AppFunc, options) =
    let nextKatana = AppFuncTransition(next) :> OwinMiddleware
    let webApiKatana = new HttpMessageHandlerAdapter(nextKatana, options)
    member x.Invoke(environment: IDictionary<string, obj>) =
        // TODO: check for null
        let context = new OwinContext(environment)
        webApiKatana.Invoke(context)

// This can be made generic:

/// Generic OwinMiddleware adapter
type OwinMiddlewareAdapter(next: AppFunc, factory: Func<OwinMiddleware, OwinMiddleware>) =
    let nextKatana = AppFuncTransition(next) :> OwinMiddleware
    let middlewareKatana = factory.Invoke(nextKatana)
    member x.Invoke(environment: IDictionary<string, obj>) =
        // TODO: check for null
        let context = new OwinContext(environment)
        middlewareKatana.Invoke(context)
    
/// HttpMessageHandlerAdapter using the Generic OwinMiddleware adapter
type OwinMessageHandlerMiddlewareAdapter(next: AppFunc, options) =
    inherit OwinMiddlewareAdapter(next, (fun m -> new HttpMessageHandlerAdapter(m, options) :> _))