在 C# 中实现模式匹配

模式匹配是函数式编程语言（如 F#）中最常见的可爱功能之一。在代码复合体中有一个很棒的项目，名为函数式 C#。请考虑以下 F# 代码：

let operator x = match x with
                 | ExpressionType.Add -> "+"
let rec toString exp = match exp with
                       | LambdaExpression(args, body) -> toString(body)
                       | ParameterExpression(name) -> name
                       | BinaryExpression(op,l,r) -> sprintf "%s %s %s" (toString l) (operator op) (toString r)

使用函数式 C# 库，C# 等效项为：

var Op = new Dictionary<ExpressionType, string> { { ExpressionType.Add, "+" } };
Expression<Func<int,int,int>> add = (x,y) => x + y;
Func<Expression, string> toString = null;
 toString = exp =>
 exp.Match()
    .With<LambdaExpression>(l => toString(l.Body))
    .With<ParameterExpression>(p => p.Name)
    .With<BinaryExpression>(b => String.Format("{0} {1} {2}", toString(b.Left), Op[b.NodeType], toString(b.Right)))
    .Return<string>();

使用函数式 C#（来自@Alireza）

var title = content.Match()
   .With<BlogPost>(blogPost => blogPost.Blog.Title + ": " + blogPost.Title)
   .With<Blog>(blog => blog.Title)
   .Result<string>();

为了确保完全模式匹配，您需要将函数构建到类型本身中。 以下是我的做法：

public abstract class Content
{
    private Content() { }
    public abstract T Match<T>(Func<Blog, T> convertBlog, Func<BlogPost, T> convertPost);
    public class Blog : Content
    {
        public Blog(string title)
        {
            Title = title;
        }
        public string Title { get; private set; }
        public override T Match<T>(Func<Blog, T> convertBlog, Func<BlogPost, T> convertPost)
        {
            return convertBlog(this);
        }
    }
    public class BlogPost : Content
    {
        public BlogPost(string title, Blog blog)
        {
            Title = title;
            Blog = blog;
        }
        public string Title { get; private set; }
        public Blog Blog { get; private set; }
        public override T Match<T>(Func<Blog, T> convertBlog, Func<BlogPost, T> convertPost)
        {
            return convertPost(this);
        }
    }
}
public static class Example
{
    public static string GetTitle(Content content)
    {
        return content.Match(blog => blog.Title, post => post.Blog.Title + ": " + post.Title);
    }
}

查看我的模式匹配实现：存储库

基于表达式，因此它提供与嵌套 if 相同的性能。

用法示例：

string s1 = "Hello";
string s2 = null;
Func<Option<string>> match = new Matcher<Option<string>>
{
     {s => s is None, s => Console.WriteLine("None")},
     {s => s is Some, s => Console.WriteLine((string)s) // or s.Value
};
match(s1); // Hello
match(s2); // None

可通过 NuGet 获得：Nuget 包

我正在使用的通用实现，可以与类型、条件或值匹配：

public static class Match
{
    public static PatternMatch<T, R> With<T, R>(T value)
    {
        return new PatternMatch<T, R>(value);
    }
    public struct PatternMatch<T, R>
    {
        private readonly T _value;
        private R _result;
        private bool _matched;
        public PatternMatch(T value)
        {
            _value = value;
            _matched = false;
            _result = default(R);
        }
        public PatternMatch<T, R> When(Func<T, bool> condition, Func<R> action)
        {
            if (!_matched && condition(_value))
            {
                _result = action();
                _matched = true;
            }
            return this;
        }
        public PatternMatch<T, R> When<C>(Func<C, R> action)
        {
            if (!_matched && _value is C)
            {
                _result = action((C)(object)_value);
                _matched = true;
            }
            return this;
        }

        public PatternMatch<T, R> When<C>(C value, Func<R> action)
        {
            if (!_matched && value.Equals(_value))
            {
                _result = action();
                _matched = true;
            }
            return this;
        }

        public R Result => _result;
        public R Default(Func<R> action)
        {
            return !_matched ? action() : _result;
        }
    }
}

在您的情况下，用法如下所示：

Match.With<IContent, string>(content)
     .When<BlogPost>(blogPost => blogPost.Blog.Title)
     .When<Blog>(blog => blog.Title)
     .Result; // or just .Default(()=> "none");

其他一些例子：

var result = Match.With<IFoo, int>(new Foo() { A = 5 })
    .When<IFoo>(foo => foo.A)
    .When<IBar>(bar => bar.B)
    .When<string>(Convert.ToInt32)
    .Result;
Assert.Equal(5, result);
var result = Match.With<int, string>(n)
    .When(x => x > 100, () => "n>100")
    .When(x => x > 10, () => "n>10")
    .Default(() => "");
Assert.Equal("n>10", result);
 var result = Match.With<int, string>(5)
     .When(1, () => "1")
     .When(5, () => "5")
     .Default(() => "e");
 Assert.Equal("5", result);