使用C# 11的靜態介面方法改進面向約定的設計

C# 11帶來了一個我期待已久的特性——介面方法。我們知道介面是針對契約的定義，但是一直以來它只能定義一組「範例」的契約，而不能定義型別（的靜態成員）的契約，因為定義在介面中的方法只能是實體方法。由於缺乏針對「型別契約」的支援，我們在設計一些框架或者類庫的時候，只能採用「按照約定」的設計，比如ASP.NET Core Minimal API針對引數的繫結就是一個典型的案例。以如下這個簡單的應用為例，我們採用Minimal API的形式註冊了一個針對根地址「/」的路由，作為處理器的委託的輸出和輸出都是我們自定義的Point物件。

var app = WebApplication.Create();
app.Map("/", (Point point) => point);
app.Run();

public class Point
{
    public double X { get; }
    public double Y { get; }
    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }

    public override string ToString() => $"{X},{Y}";

    public static bool TryParse(string expression, out Point? result)
    {
        result = default;
        var parts = expression.Split(',');
        if (parts.Length != 2) return false;
        if (!double.TryParse(parts[0], out var x) || !double.TryParse(parts[1], out var y)) return false;
        result = new Point(x, y);
        return true;
    }
}

Minimal API的約定，如果我們為Point型別定義了具有如上宣告的TryParse方法，該方法就會用來幫助我們繫結處理方法的Point引數，如下的演示結果證實了這一點。

其實針對引數繫結，我們還可以定義如下這樣BindAsync引數來完成。

public class Point
{
    ...
    public static ValueTask<Point?> BindAsync(HttpContext httpContext, ParameterInfo parameter)
    {
        Point? result = default;
        var name = parameter.Name;
        var value = httpContext.GetRouteData().Values.TryGetValue(name!, out var v) ? v : httpContext.Request.Query[name!].SingleOrDefault();
        if (value is string expression && TryParse(expression, out var point))
        {
            result = point;
        }
        return new ValueTask<Point?>(result);
    }
}

對於這種「基於約定」的程式設計，可以你覺得還不錯，但是我想有90%的ASP.NET Core的開發者不知道有這個特性，就從這一點就充分證明了這樣的設計還不夠好。這樣的實現也比較繁瑣，我們不得不通過反射檢驗待繫結引數的型別是否滿足約定，並以反射（或者表示式樹）的方式呼叫對應的方法。其實上述兩個方法本應該寫入「契約」，無賴它們是靜態方法，沒法定義在介面中。現在我們有了靜態介面方法，它們可以定義如下所示的IBindable<T>和IParsable<T>。

public interface IBindable<T>
{
    abstract static ValueTask<T?> BindAsync(HttpContext httpContext, ParameterInfo parameter);
}

public interface IParsable<T>
{
    abstract static bool TryParse(string expression, out T? result);
}

public class Point : IBindable<Point>, IParsable<Point>
{
    public double X { get; }
    public double Y { get; }
    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }

    public override string ToString() => $"{X},{Y}";

    public static bool TryParse(string expression, out Point? result)
    {
        result = default;
        var parts = expression.Split(',');
        if (parts.Length != 2) return false;
        if (!double.TryParse(parts[0], out var x) || !double.TryParse(parts[1], out var y)) return false;
        result = new Point(x, y);
        return true;
    }

    public static ValueTask<Point?> BindAsync(HttpContext httpContext, ParameterInfo parameter)
    {
        Point? result = default;
        var name = parameter.Name;
        var value = httpContext.GetRouteData().Values.TryGetValue(name!, out var v) ? v : httpContext.Request.Query[name!].SingleOrDefault();
        if (value is string expression && TryParse(expression, out var point))
        {
            result = point;
        }
        return new ValueTask<Point?>(result);
    }
}

實際上IParsable<T>已經存在了，它真正的定義是這樣的。如果有了這樣的介面，確定帶繫結引數型別是否滿足之前的約定條件只需要確定其是否實現了對應的介面就可以了。

public interface IParsable<TSelf> where TSelf : IParsable<TSelf>?
{
    static TSelf Parse(string s, IFormatProvider? provider);
    static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result);
}

靜態介面設計被應用到《用最少的程式碼打造一個Mini版的gRPC框架》中，我在表示gRPC服務的介面中定義瞭如下的靜態方法Bind將本服務型別中定義的gRPC方法系結成路由。

public interface IGrpcService<TService> where TService : class
{
    static abstract void Bind(IServiceBinder<TService> binder);
}

[GrpcService(ServiceName = "Greeter")]
public class GreeterService: IGrpcService<GreeterService>
{
    public Task<HelloReply> SayHelloUnaryAsync(HelloRequest request, ServerCallContext context);

    public async Task<HelloReply> SayHelloClientStreamingAsync(IAsyncStreamReader<HelloRequest> reader, ServerCallContext context);

    public  async Task SayHelloServerStreamingAsync(Empty request, IServerStreamWriter<HelloReply> responseStream, ServerCallContext context);

    public async Task SayHelloDuplexStreamingAsync(IAsyncStreamReader<HelloRequest> reader, IServerStreamWriter<HelloReply> writer, ServerCallContext context);

    public static void Bind(IServiceBinder<GreeterService> binder)
    {
        binder
            .AddUnaryMethod<HelloRequest, HelloReply>(it =>it.SayHelloUnaryAsync(default!,default!), HelloRequest.Parser)
            .AddClientStreamingMethod<HelloRequest, HelloReply>(it => it.SayHelloClientStreamingAsync(default!, default!), HelloRequest.Parser)
            .AddServerStreamingMethod<Empty, HelloReply>(nameof(SayHelloServerStreamingAsync), it => it.SayHelloServerStreamingAsync, Empty.Parser)
            .AddDuplexStreamingMethod<HelloRequest, HelloReply>(nameof(SayHelloDuplexStreamingAsync), it => it.SayHelloDuplexStreamingAsync, HelloRequest.Parser);
    }
}

使用C# 11的靜態介面方法改進 面向約定 的設計

使用C# 11的靜態介面方法改進面向約定的設計