CyberX8/Framework/Common/Net/NetResult.cs

using Aitex.Core.Utilities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Net
{
    public class NetResult
    {
        /// <summary>
        /// 指示本次访问是否成功
        /// </summary>
        public bool IsSuccess { get; set; }

        /// <summary>
        /// 具体的错误描述
        /// </summary>
        public string Message { get; set; } 

        /// <summary>
        /// 具体的错误代码
        /// </summary>
        public int ErrorCode { get; set; } = 10000;
        /// <summary>
        /// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
        /// </summary>
        /// <typeparam name="T">目标数据类型</typeparam>
        /// <param name="result">之前的结果对象</param>
        /// <returns>带默认泛型对象的失败结果类</returns>
        public static NetResult<T> CreateFailedResult<T>(int errorCode, string msg)
        {
            return new NetResult<T>()
            {
                IsSuccess = false,
                ErrorCode = errorCode,
                Message = msg
            };
        }
        /// <summary>
        /// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
        /// </summary>
        /// <typeparam name="T">目标数据类型</typeparam>
        /// <param name="result">之前的结果对象</param>
        /// <returns>带默认泛型对象的失败结果类</returns>
        public static NetResult CreateFailedResult(int errorCode, string msg)
        {
            return new NetResult()
            {
                IsSuccess = false,
                ErrorCode = errorCode,
                Message = msg
            };
        }
        /// <summary>
        /// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
        /// </summary>
        /// <typeparam name="T">目标数据类型</typeparam>
        /// <param name="result">之前的结果对象</param>
        /// <returns>带默认泛型对象的失败结果类</returns>
        public static NetResult CreateFailedResult(NetErrorCode errorCode)
        {
            return new NetResult()
            {
                IsSuccess = false,
                ErrorCode = (int)errorCode,
                Message = EnumUtil.GetEnumDescription(errorCode)
            };
        }
        /// <summary>
        /// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
        /// </summary>
        /// <typeparam name="T">目标数据类型</typeparam>
        /// <param name="result">之前的结果对象</param>
        /// <returns>带默认泛型对象的失败结果类</returns>
        public static NetResult<T> CreateFailedResult<T>(int errorCode,string msg,T data)
        {
            return new NetResult<T>()
            {
                IsSuccess = false,
                ErrorCode = errorCode,
                Message = msg,
                Data = data
            };
        }
        /// <summary>
        /// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
        /// </summary>
        /// <typeparam name="T">目标数据类型</typeparam>
        /// <param name="result">之前的结果对象</param>
        /// <returns>带默认泛型对象的失败结果类</returns>
        public static NetResult<T> CreateFailedResult<T>(NetErrorCode errorCode,  T data)
        {
            return new NetResult<T>()
            {
                IsSuccess = false,
                ErrorCode = (int)errorCode,
                Message = EnumUtil.GetEnumDescription(errorCode),
                Data = data
            };
        }
        /// <summary>
        /// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
        /// </summary>
        /// <typeparam name="T">目标数据类型</typeparam>
        /// <param name="result">之前的结果对象</param>
        /// <returns>带默认泛型对象的失败结果类</returns>
        public static NetResult<T> CreateFailedResult<T>(NetErrorCode errorCode)
        {
            return new NetResult<T>()
            {
                IsSuccess = false,
                ErrorCode = (int)errorCode,
                Message = EnumUtil.GetEnumDescription(errorCode),
            };
        }
        /// <summary>
        /// 创建并返回一个成功的结果对象
        /// </summary>
        /// <returns>成功的结果对象</returns>
        public static NetResult CreateSuccessResult()
        {
            return new NetResult()
            {
                IsSuccess = true,
                ErrorCode = 0,
                Message = ""
            };
        }

        /// <summary>
        /// 创建并返回一个成功的结果对象，并带有一个参数对象
        /// </summary>
        /// <typeparam name="T">参数类型</typeparam>
        /// <param name="value">类型的值对象</param>
        /// <returns>成功的结果对象</returns>
        public static NetResult<T> CreateSuccessResult<T>(T value)
        {
            return new NetResult<T>()
            {
                IsSuccess = true,
                ErrorCode = 0,
                Message = "",
                Data = value
            };
        }
    }

    public class NetResult<T> : NetResult
    {
        public T Data { get; set; }
    }
}