C# 6 元组应用 Part 2：C# 也玩模式匹配

C# 7给我们带来了一个半吊子的 switch 语句模式匹配，只能简单的匹配类型而已，完全没有什么用处。这里我提供个更好的简单实现，用 C# 6 的 ValueTuple 模拟函数式语言的模式匹配功能。

首先就是实现：

  public static class ValueTupleExtensions
    {

        /// <summary>
        /// 至少匹配一个条件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name=""></param>
        /// <returns></returns>
        public static TResult MatchOne<TResult>(params (Func<bool> condExpr, Func<TResult> resultExpr)[] pairs)
        {
            foreach (var pair in pairs)
            {
                if (pair.condExpr())
                {
                    return pair.resultExpr();
                }
            }
            throw new InvalidOperationException("无匹配的表达式");
        }

        /// <summary>
        /// 匹配默认或指定的条件
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="defaultMatch"></param>
        /// <param name="matchs"></param>
        /// <returns></returns>
        public static TResult MatchOneOrDefault<TResult>(
            Func<TResult> defaultMatchExpr,
            params (Func<bool> condExpr, Func<TResult> resultExpr)[] matchs)
        {
            foreach (var pair in matchs)
            {
                if (pair.condExpr())
                {
                    return pair.resultExpr();
                }
            }

            return defaultMatchExpr();
        }

        public static TOutput MatchOne<TInput, TOutput>(TInput inputValue, params (TInput matcheValue, Func<TOutput> resultValueExpr)[] pairs)
            where TInput : IEquatable<TInput>
        {
            foreach (var pair in pairs)
            {
                if (inputValue.Equals(pair.matcheValue))
                {
                    return pair.resultValueExpr();
                }
            }

            throw new InvalidOperationException("无匹配的值");
        }

        public static TOutput MatchOneOrDefault<TInput, TOutput>(TInput inputValue, params (TInput matcheValue, Func<TOutput> resultValueExpr)[] pairs)
            where TInput : IEquatable<TInput>
        {
            if (inputValue == null)
            {
                throw new ArgumentNullException(nameof(inputValue));
            }

            foreach (var pair in pairs)
            {
                if (pair.matcheValue == null)
                {
                    throw new ArgumentNullException(nameof(pairs));
                }

                if (inputValue.Equals(pair.matcheValue))
                {
                    return pair.resultValueExpr();
                }
            }
            return default(TOutput);
        }
    }

然后用起来就非常简单了，首先使用 `using static` 引入静态函数：

using static ValueTupleExtensions;

然后我们实际操练下：

 class Program
    {
        static void Main(string[] args)
        {
            var a = 5;

            //最简单的重载，与某个值相等就执行后面的 lambda 表达式
            var matched = MatchOne(
                a,
                (1, () => "111"),
                (5, () => "555")
            );

            Console.WriteLine($"matched={matched}");

            //更自由的形式，第一个 lambda 相当于 if
            matched = MatchOne(
                (() => a == 1, () => "111"),
                (() => a == 5, () => "555")
            );

            Console.WriteLine($"matched={matched}");


            Console.ReadKey();
        }
    }

虽然括号略多，不过还是很好玩的吧。

Have fun!