一个实用返回数据结构

最新推荐文章于 2023-02-11 07:10:26 发布
weixin_34253539
最新推荐文章于 2023-02-11 07:10:26 发布
阅读量321
点赞数
文章标签：数据结构与算法 python 后端
原文链接：https://my.oschina.net/raddleoj/blog/866268
版权
2019独角兽企业重金招聘Python工程师标准>>>
首发，但是写了好久了。
名字不好，下次改成 DataShell
//-----------------------------------------------------------------------
// <filename>resultdata.cs</filename>
// <author>weilai</author>
// <date>2017-3-24</date>
// <remark>返回类型和扩展</remark>
//-----------------------------------------------------------------------

using System;
using System.Collections.Generic;

namespace WL.Busi.Common
{
    #region --包装返回类型--

    /// <summary>
    /// 实验功能
    /// 泛型返回数据，用于包装返回数据
    /// 内设置Success是否成功，时间，信息，版本，泛型返回数据
    /// 增加多个成功，和失败设置，统一设置失败和成功的规则
    /// </summary>
    /// <typeparam name="TResult">具体返回类型</typeparam>
    public class ResultData<TResult>
    {
        #region --初始化函数组--

        /// <summary>
        /// 初始化 <see cref="{TResult}"/> 类的新实例。
        /// 时间版本自动设置
        /// </summary>
        public ResultData()
        {
            this.Time = DateTime.Now;
            this.Version = "0.1";
            this.Info = new List<string>();
            this.Code = 0;
        }

        /// <summary>
        /// 初始化，时间和版本自动设置
        /// </summary>
        /// <param name="successs">是否成功</param>
        /// <param name="r_data">返回数据</param>
        /// <param name="info">信息，无信息可置空</param>
        public ResultData(bool isSuccess, TResult r_data, string info)
            : this()
        {
            this.Success = isSuccess;
            this.Data = r_data;
        }

        /// <summary>
        /// 初始化，时间版本自动设置
        /// </summary>
        /// <param name="successs"></param>
        /// <param name="r_data"></param>
        public ResultData(bool success, TResult r_data)
            : this(success, r_data, string.Empty)
        {
        }

        #endregion --初始化函数组--

        #region --静态初始化--

        /// <summary>
        /// 默认初始化一个成功的返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static ResultData<T> InitDefaultSucceed<T>()
        {
            var t = new ResultData<T>();
            t.Succeed();
            return t;
        }

        /// <summary>
        /// 默认初始化一个成功的返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static ResultData<T> InitDefaultSucceed<T>(T v)
        {
            var t = new ResultData<T>();
            return t.Succeed(v);
        }

        /// <summary>
        /// 默认初始化一个失败的返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static ResultData<T> InitDefaultFailed<T>()
        {
            var t = new ResultData<T>();
            t.Failed();
            return t;
        }

        /// <summary>
        /// 默认初始化一个失败的返回值，并写入 info
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="info"></param>
        /// <returns></returns>
        public static ResultData<T> InitDefaultFailed<T>(string info)
        {
            var t = new ResultData<T>();
            t.Failed(info);
            return t;
        }

        /// <summary>
        /// 默认初始化一个失败的返回值，并写入 info
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="info"></param>
        /// <returns></returns>
        public static ResultData<T> InitDefaultFailed<T>(IList<string> infos)
        {
            var t = new ResultData<T>();
            t.Failed(infos);
            return t;
        }

        #endregion --静态初始化--

        #region --属性组--

        /// <summary>
        /// 获取或设置一个值，该值指示-执行是否成功(true, false)
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// 代码，当前后端约定代码信息后可使用
        /// 默认 0 表示：无意义
        /// </summary>
        public int Code { get; set; }

        /// <summary>
        /// 获取或设置一个值，该值指示-信息，如果出错返回错误信息
        /// </summary>
        public IList<string> Info { get; set; }

        /// <summary>
        /// 获取一个值，该值指示-结果时间
        /// </summary>
        public DateTime Time { get; protected set; }

        /// <summary>
        /// 获取一个值，该值指示-返回版本 目前默认 0.1
        /// </summary>
        public string Version { get; protected set; }

        /// <summary>
        /// 获取或设置一个值，该值指示-返回数据
        /// </summary>
        public TResult Data { get; set; }

        #endregion --属性组--

        #region --方法--

        /// <summary>
        /// 统一设置成功业务
        /// </summary>
        public ResultData<TResult> Succeed()
        {
            this.Success = true;
            this.Code = 1;
            return this;
        }

        /// <summary>
        /// 统一设置成功业务，成功并赋值
        /// </summary>
        /// <param name="data"></param>
        public ResultData<TResult> Succeed(TResult data)
        {
            this.Succeed();
            this.Data = data;
            return this;
        }

        /// <summary>
        /// 统一设置成功业务，成功并赋值
        /// </summary>
        /// <param name="data"></param>
        public ResultData<TResult> Succeed(TResult data, string info)
        {
            this.Succeed();
            this.Data = data;
            this.Info.Add(info);
            return this;
        }

        /// <summary>
        /// 统一设置失败业务
        /// </summary>
        public ResultData<TResult> Failed()
        {
            this.Success = false;
            this.Code = -1;
            return this;
        }

        /// <summary>
        /// 统一设置失败业务，带入错误信息
        /// </summary>
        /// <param name="errorInfo"></param>
        public ResultData<TResult> Failed(string errorInfo)
        {
            this.Failed();
            this.Info.Add(errorInfo);
            return this;
        }

        /// <summary>
        /// 统一设置失败业务，带入一堆错误信息
        /// </summary>
        /// <param name="errorInfo"></param>
        public ResultData<TResult> Failed(IList<string> errorInfo)
        {
            this.Failed();
            foreach (var item in errorInfo)
            {
                this.Info.Add(item);
            }
            return this;
        }

        /// <summary>
        /// 统一设置失败业务，带入错误信息，只返回基本错误信息
        /// </summary>
        /// <param name="error"></param>
        public ResultData<TResult> Failed(Exception error)
        {
            this.Failed();
            this.Info.Add(error.Message);
            return this;
        }

        /// <summary>
        /// 统一设置失败业务，带入错误信息，可自定义错误信息处理委托
        /// </summary>
        /// <param name="error"></param>
        public ResultData<TResult> Failed(Exception error, Func<Exception, string> errorInfoMaker)
        {
            this.Failed();
            this.Info.Add(errorInfoMaker(error));
            return this;
        }

        #endregion --方法--
    }

    #endregion --包装返回类型--

    #region --返回数据创建器--

    /// <summary>
    /// 返回数据创建器
    /// </summary>
    public class ResultDataCreator
    {
        #region --静态初始化--

        /// <summary>
        /// 默认初始化一个成功的返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static ResultData<T> InitDefaultSucceed<T>()
        {
            var t = new ResultData<T>();
            t.Succeed();
            return t;
        }

        /// <summary>
        /// 默认初始化一个成功的返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static ResultData<T> InitDefaultSucceed<T>(T v)
        {
            var t = new ResultData<T>();
            return t.Succeed(v);
        }

        /// <summary>
        /// 默认初始化一个失败的返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static ResultData<T> InitDefaultFailed<T>()
        {
            var t = new ResultData<T>();
            t.Failed();
            return t;
        }

        /// <summary>
        /// 默认初始化一个失败的返回值，并写入 info
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="info"></param>
        /// <returns></returns>
        public static ResultData<T> InitDefaultFailed<T>(string info)
        {
            var t = new ResultData<T>();
            t.Failed(info);
            return t;
        }

        /// <summary>
        /// 默认初始化一个失败的返回值，并写入 info
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="info"></param>
        /// <returns></returns>
        public static ResultData<T> InitDefaultFailed<T>(IList<string> infos)
        {
            var t = new ResultData<T>();
            t.Failed(infos);
            return t;
        }

        #endregion --静态初始化--
    }

    #endregion --返回数据创建器--

    #region --返回结果扩展方法--

    /// <summary>
    /// 结果外壳扩展方法
    /// </summary>
    public static class ResultDataExpand
    {
        #region --用返回类型直接构建一个 成功返回结果--

        /// <summary>
        /// 用返回类型直接构建一个 成功返回结果
        /// </summary>
        /// <typeparam name="TResult">结果实体类型</typeparam>
        /// <param name="self">扩展字符串类型</param>
        /// <returns></returns>
        public static ResultData<TResult> Success<TResult>(this TResult self)
        {
            return ResultDataCreator.InitDefaultSucceed<TResult>(self);
        }

        #endregion --用返回类型直接构建一个 成功返回结果--

        #region --利用指定类型直接创建一个成功结果并附带一个信息--
        /// <summary>
        /// 利用指定类型直接创建一个成功结果并附带一个信息
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="self"></param>
        /// <param name="info"></param>
        /// <returns></returns>
        public static ResultData<TResult> Success<TResult>(this TResult self, string info)
        {
            return ResultDataCreator.InitDefaultSucceed<TResult>(self).Succeed(self, info);
        }
        #endregion --利用指定类型直接创建一个成功结果并附带一个信息--

        #region --用错误信息直接构成一个错误返回信息--
        /// <summary>
        /// 用错误信息直接构成一个错误返回信息
        /// </summary>
        /// <typeparam name="TResult">结果数据实体类型</typeparam>
        /// <param name="self">扩展字符串类型</param>
        /// <returns></returns>
        public static ResultData<TResult> Fail<TResult>(this string self)
        {
            return ResultDataCreator.InitDefaultFailed<TResult>(self);
        }
        #endregion --用错误信息直接构成一个错误返回信息--

        #region --用一组错误信息初始化一个失败结果--

        /// <summary>
        /// 用一组错误信息初始化一个失败结果
        /// </summary>
        /// <typeparam name="TResult">结果实体类型</typeparam>
        /// <param name="self">扩展字符串类型</param>
        /// <returns></returns>
        public static ResultData<TResult> Fail<TResult>(this IList<string> self)
        {
            return ResultDataCreator.InitDefaultFailed<TResult>(self);
        }

        #endregion --用一组错误信息初始化一个失败结果--
    }

    #endregion --返回结果扩展方法--
}
转载于:https://my.oschina.net/raddleoj/blog/866268