使用自定义隐式转换快速创建失败Result

　　系统要求方法都返回 Result 结果，通常我们会如此定义一个 Result

    public class Result<T>
    {
        public virtual int Code { get; set; }

        public virtual T Data { get; set; }

        public virtual string Message { get; set; }
    }

    public class Result : Result<object>
    {
        // 快速创建成功结果
        public static Result<T> Success<T>(T data)
        {
            return new Result<T>() { Data = data };
        }

        // 快速创建失败结果
        public static Result<T> Fail<T>(int code, string message)
        {
            return new Result<T>() { Code = code, Message = message };
        }
    }

　　得益于C#强大的类型推断，我们可以非常简单的返回成功或失败结果

    public Result<User> GetUser(int userId)
    {
        User user = null; // Read from database
        if (user == null)
        {
            return Result.Fail<User>(400, "用户不存在");  // 需要手动指明 User，有点烦
        }
        else
        {
            return Result.Success(user);
        }
    }

　　成功的时候，Success() 方法可以自动推断出Data为 User 类；

　　但是失败的时候，必须手动的指明Data为 User 类，虽然仅仅多敲了几个字母，但我还是想简化，因为失败时，Data根本不需要赋值，也不在乎Data 的类型。

　　C# 可以使用 Implicit 自定义隐式转换，可以将 Result 自动隐式转换转换为 Result<T>，考虑到我们只需要在失败的时候才转换，所以我定义了一个  FailResult

    public class FailResult : Result
    {
    }

    public class Result<T>
    {
        // 新增加的隐式转换
        public static implicit operator Result<T>(FailResult failResult)
        {
            return new Result<T>() { Code = failResult.Code, Message = failResult.Message };
        }
    }

    public class Result : Result<object>
    {
        // 新增加的方法
        public static FailResult Fail(int code, string message)
        {
            return new FailResult() { Code = code, Message = message };
        }
    }

　　这样的话，不论时成功还是失败，我们都不需要指定Data 的类型了

    public Result<User> GetUser(int userId)
    {
        User user = null; // Read from database
        if (user == null)
        {
            return Result.Fail(400, "用户不存在"); // 不用指明 <User> 了
        }
        else
        {
            return Result.Success(user);
        }
    }

　　心细的朋友会发现，这种 Result.Fail 其实是先 new 一个 FailResult，然后编译器再 new 一个 Result<T>, 事实上多创建了一个无用的实例，但我觉得对于CLR而言这种开销可以忽略不记。

　　

　　下面是完整的代码：

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }

        public Result<User> GetUser(int userId)
        {
            User user = null; // Read from database
            if (user == null)
            {
                return Result.Fail(400, "用户不存在"); // 不用指明 <User> 了
                //return Result.Fail<User>(400, "用户不存在");
            }
            else
            {
                return Result.Success(user);
            }
        }
    }

    public class Result<T>
    {
        public virtual int Code { get; set; }

        public virtual T Data { get; set; }

        public virtual string Message { get; set; }


        public static implicit operator Result<T>(FailResult failResult)
        {
            return new Result<T>() { Code = failResult.Code, Message = failResult.Message };
        }
    }

    public class Result : Result<object>
    {
        public static Result<T> Success<T>(T data)
        {
            return new Result<T>() { Data = data };
        }

        public static Result<T> Fail<T>(int code, string message)
        {
            return new Result<T>() { Code = code, Message = message };
        }

        public static FailResult Fail(int code, string message)
        {
            return new FailResult() { Code = code, Message = message };
        }
    }

    public class FailResult : Result 
    { 
    }

    public class User
    { 
    }
}