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 = ;

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

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

            //更*的形式，第一个 lambda 相当于 if
            matched = MatchOne(
                (() => a == , () => ""),
                (() => a == , () => "")
            );

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

            Console.ReadKey();
        }
    }

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

Have fun!