Пример #1
0
 /// <summary>
 /// 将本对象属性复制到另一个ResultMsg对象
 /// </summary>
 /// <param name="target"></param>
 public virtual ResultMsg <TT> CopyTo <TT>(ResultMsg <TT> target)
 {
     target.StatusCode = this.StatusCode;
     target.Status     = this.Status;
     target.Msg        = this.Msg;
     if (typeof(TT) is T)
     {
         target.ResultObj = (TT)(object)this.ResultObj;
         target.ErrorObj  = this.ErrorObj;
     }
     return(target);
 }
Пример #2
0
        /// <summary>
        /// 服务接口请求
        /// </summary>
        /// <typeparam name="RequestT"></typeparam>
        /// <typeparam name="ResponseT"></typeparam>
        /// <param name="apiName"></param>
        /// <param name="data"></param>
        /// <param name="responseTIsEntity">返回的ResponseT是实体</param>
        /// <returns></returns>
        public static ResultMsg <Result> RequestServer <RequestT>(String apiPath, RequestT data)
        {
            ResultMsg <Result> resultMsg = new ResultMsg <Result>();

            ResultMsg <String> result = null;

            if (data is HttpReqEntity)
            {
                var    tmp = data as HttpReqEntity;
                String url = apiPath;
                result = HttpHelper.Http(url, tmp);
            }
            else
            {
                String strData = String.Empty;
                if (null != data)
                {
                    strData = JsonFormatter.Serialize(data);
                }
                result = RequestServer(apiPath, HttpMethod.POST, strData);
            }

            if (result.Status == ResultStatus.Success)
            {
                if (!String.IsNullOrEmpty(result.ResultObj))
                {
                    Result tmp = JsonFormatter.Deserialize <Result>(result.ResultObj);
                    if (tmp == null)
                    {
                        resultMsg.SetFailure("数据请求错误,返回对象为空!");
                    }
                    else
                    {
                        resultMsg.ResultObj = tmp;
                        resultMsg.Msg       = result.ResultObj;
                    }
                }
                else
                {
                    resultMsg.SetFailure("数据请求错误,返回对象为空!");
                }
            }
            else
            {
                resultMsg.SetFailure(result.Msg);
            }

            return(resultMsg);
        }
Пример #3
0
        /// <summary>
        /// 服务接口请求
        /// </summary>
        /// <param name="apiPath">接口方法地址路径地址</param>
        /// <param name="method">post/get/put</param>
        /// <param name="data">请求信息</param>
        /// <returns></returns>
        public static ResultMsg <String> RequestServer(String apiPath, HttpMethod method, String data)
        {
            String             url    = apiPath.ToLower().StartsWith("http://") ? apiPath : String.Format("{0}/{1}", "http://", apiPath);
            ResultMsg <String> result = new ResultMsg <String>(ResultStatus.Failure,
                                                               String.Format("请求服务失败,可能地址不对!地址:{0}", url));

            if (method == HttpMethod.POST)
            {
                result = HttpHelper.Post(data, url);
            }
            else
            {
                result = HttpHelper.Http(url, data, null, method);
            }
            return(result);
        }
Пример #4
0
        /// <summary>
        /// 请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="data">请求数据</param>
        /// <param name="cookie">附加请求COOKIE</param>
        /// <param name="method">请求方式</param>
        /// <returns></returns>
        public static ResultMsg <string> Http(string url, string data, string cookie, HttpMethod method)
        {
            ResultMsg <string> result = new ResultMsg <string>();

            ResultMsg <HttpResEntity> resultMsg = Http(url, data, url, method, TIMEOUT);

            if (resultMsg.Status == ResultStatus.Success)
            {
                result.ResultObj = resultMsg.ResultObj.Bodys;
            }
            else
            {
                result.SetFailure(resultMsg.Msg);
            }

            return(result);
        }
Пример #5
0
        /// <summary>
        /// Get请求
        /// </summary>
        /// <param name="url">请求的地址</param>
        /// <param name="timeout">允许超时间,单位(秒)</param>
        /// <returns></returns>
        public static ResultMsg <string> Get(string url, int timeout)
        {
            ResultMsg <string> result = new ResultMsg <string>();

            ResultMsg <HttpResEntity> resultMsg = Http(url, null, null, HttpMethod.GET, TIMEOUT);

            if (resultMsg.Status == ResultStatus.Success)
            {
                result.ResultObj = resultMsg.ResultObj.Bodys;
            }
            else
            {
                result.SetFailure(resultMsg.Msg);
            }

            return(result);
        }
Пример #6
0
        /// <summary>
        /// 聚合查询传感数据
        /// </summary>
        /// <returns></returns>
        public ResultMsg <SensorDataInfoDTO> GroupingSensorDatas(SensorDataJuHeQryPagingParas query, string token = null)
        {
            var result = new ResultMsg <SensorDataInfoDTO>();

            var vry = TokenVerify(ref token);

            if (!vry.IsSuccess())
            {
                vry.CopyTo(result);
                return(result);
            }

            //1、先定义该API接口路径,可以从http://api.nlecloud.com/页面的得知
            String apiPath = String.Format("{0}/{1}/grouping", mApiHost, NLECloudAPIUrl.DatasOfSensorUrl);

            //2、根据该API接口 的请求参数中 得知需要创建个URI Parameters String类型参数,所以该参数直接跟在apiPath中
            apiPath  = apiPath.Replace("{deviceid}", query.DeviceID.ToString());//将API地址中的{gatewayTag}替换成真实设备标识
            apiPath += string.Format("?{0}&{1}", "GroupBy=" + query.GroupBy, "Func=" + query.Func);
            apiPath += string.Format("&{0}&{1}&{2}", "ApiTags=" + query.ApiTags, "StartDate=" + query.StartDate, "EndDate=" + query.EndDate);
            //3、由于调用该API需要Token,所以我们定义了一个通用的对象HttpReqEntity,在AccessToken当成头部请求信息提交过去
            HttpReqEntity req = new HttpReqEntity();

            req.Method = HttpMethod.GET;
            req.Headers.Add("AccessToken", token);

            //4、定义该API接口返回的对象
            result = RequestAPIHelper.RequestServer <HttpReqEntity, SensorDataInfoDTO>(apiPath, req);

            if (result.IsSuccess() && result.ResultObj != null && result.ResultObj.DataPoints != null)
            {
                foreach (SensorDataAddDTO p in result.ResultObj.DataPoints)
                {
                    if (p.PointDTO != null)
                    {
                        foreach (var w in p.PointDTO)
                        {
                            ValueConvertToByteAry(w.Value);
                        }
                    }
                }
            }

            return(result);
        }
Пример #7
0
        /// <summary>
        /// 批量查询设备最新数据
        /// </summary>
        /// <param name="devids">设备ID用逗号隔开, 限制100个设备 </param>
        /// <param name="token"></param>
        /// <returns></returns>
        public ResultMsg <IEnumerable <DeviceSensorDataDTO> > GetDevicesDatas(String devids, String token = null)
        {
            var result = new ResultMsg <IEnumerable <DeviceSensorDataDTO> >();

            var vry = TokenVerify(ref token);

            if (!vry.IsSuccess())
            {
                vry.CopyTo(result);
                return(result);
            }

            //1、先定义该API接口路径,可以从http://api.nlecloud.com/页面的得知
            String apiPath = String.Format("{0}/{1}", mApiHost, NLECloudAPIUrl.DevicesDatasUrl);

            //2、根据该API接口的请求参数中 得知需要创建个URI Parameters String类型参数,所以该参数直接跟在apiPath中
            //apiPath = apiPath.Replace("{projectId}", projectId.ToString());//将API地址中的{projectid}替换成真实项目ID
            apiPath += string.Format("?{0}", "devIds=" + devids);
            //3、由于调用该API需要Token,所以我们定义了一个通用的对象HttpReqEntity,在AccessToken当成头部请求信息提交过去
            HttpReqEntity req = new HttpReqEntity();

            req.Method = HttpMethod.GET;
            req.Headers.Add("AccessToken", token);

            //4、定义该API接口返回的对象
            result = RequestAPIHelper.RequestServer <HttpReqEntity, IEnumerable <DeviceSensorDataDTO> >(apiPath, req);

            if (result.IsSuccess() && result.ResultObj != null)
            {
                foreach (DeviceSensorDataDTO p in result.ResultObj)
                {
                    if (p.Datas != null)
                    {
                        foreach (SensorDataDTO w in p.Datas)
                        {
                            w.Value = ValueConvertToByteAry(w.Value);
                        }
                    }
                }
            }

            return(result);
        }
Пример #8
0
        /// <summary>
        /// 查询传感数据
        /// </summary>
        /// <returns></returns>
        public ResultMsg <SensorDataInfoDTO> GetDatasOfSensors(DatasFuzzyQryPagingParas query, string token = null)
        {
            var result = new ResultMsg <SensorDataInfoDTO>();

            #region --ToUse--
            //if (String.IsNullOrEmpty(txtToken))
            //if (!vry.IsSuccess())
            //{
            //    vry.CopyTo(result);
            //    return result;
            //}
            #endregion

            //1、先定义该API接口路径,可以从http://api.nlecloud.com/页面的得知
            String apiPath = String.Format("{0}/{1}", mApiHost, NLECloudAPIUrl.DatasOfSensorUrl);

            //2、根据该API接口 的请求参数中 得知需要创建个URI Parameters String类型参数,所以该参数直接跟在apiPath中
            apiPath  = apiPath.Replace("{deviceid}", query.deviceId.ToString());//将API地址中的{gatewayTag}替换成真实设备标识
            apiPath += string.Format("?{0}&{1}&{2}&{3}&{4}&{5}", "deviceId=" + query.deviceId, "Method=" + query.Method, "TimeAgo=" + query.TimeAgo, "Sort=" + query.Sort, "PageSize=" + query.PageSize, "PageIndex=" + query.PageIndex);
            //3、由于调用该API需要Token,所以我们定义了一个通用的对象HttpReqEntity,在AccessToken当成头部请求信息提交过去
            HttpReqEntity req = new HttpReqEntity();
            req.Method = HttpMethod.GET;
            req.Headers.Add("AccessToken", token);

            //4、定义该API接口返回的对象
            result = RequestAPIHelper.RequestServer <HttpReqEntity, SensorDataInfoDTO>(apiPath, req);

            if (result.IsSuccess() && result.ResultObj != null && result.ResultObj.DataPoints != null)
            {
                result.ResultObj.DataPoints.ForEach(p =>
                {
                    if (p.PointDTO != null)
                    {
                        foreach (var w in p.PointDTO)
                        {
                            ValueConvertToByteAry(w.Value);
                        }
                    }
                });
            }

            return(result);
        }
Пример #9
0
        /// <summary>
        /// 用户登录(同时返回AccessToken)
        /// </summary>
        /// <param name="submitData">登录参数对象</param>
        /// <returns></returns>
        public ResultMsg <AccountLoginResultDTO> UserLogin(AccountLoginDTO submitData)
        {
            var result = new ResultMsg <AccountLoginResultDTO>();

            //难证
            if (submitData.Account.Trim() == "" || submitData.Password.Trim() == "")
            {
                return(result.SetFailure("请输入登录用户名和密码!"));
            }

            //1、先定义该API接口路径,可以从http://api.nlecloud.com页面的 帐号API接口 中的 用户登录得知
            String apiPath = String.Format("{0}/{1}", mApiHost, NLECloudAPIUrl.UserLoginUrl);

            //2、定义该API接口返回的对象,初始化为空
            result = RequestAPIHelper.RequestServer <AccountLoginDTO, AccountLoginResultDTO>(apiPath, submitData);

            if (result.IsSuccess())
            {
                this.mToken = result.ResultObj.AccessToken;
            }
            return(result);
        }
Пример #10
0
        /// <summary>
        /// 模糊查询传感器
        /// </summary>
        /// <param name="deviceId">设备ID</param>
        /// <param name="apiTags">传感标识名</param>
        /// <param name="token"></param>
        /// <returns></returns>
        public ResultMsg <IEnumerable <SensorBaseInfoDTO> > GetSensors(Int32 deviceId, String apiTags = "", String token = null)
        {
            var result = new ResultMsg <IEnumerable <SensorBaseInfoDTO> >();

            //验证
            var vry = PrimaryKeyVerify(deviceId, ref token);

            if (!vry.IsSuccess())
            {
                vry.CopyTo(result);
                return(result);
            }

            //1、先定义该API接口路径,可以从http://api.nlecloud.com/页面的得知
            String apiPath = String.Format("{0}/{1}", mApiHost, NLECloudAPIUrl.SensorsOfDeviceUrl);

            //2、根据该API接口的请求参数中 得知需要创建个URI Parameters String类型参数,所以该参数直接跟在apiPath中
            apiPath  = apiPath.Replace("{deviceid}", deviceId.ToString());//将API地址中的{deviceId}替换成真实设备ID
            apiPath += string.Format("?{0}", "apitags=" + apiTags);
            //3、由于调用该API需要Token,所以我们定义了一个通用的对象HttpReqEntity,在AccessToken当成头部请求信息提交过去
            HttpReqEntity req = new HttpReqEntity();

            req.Method = HttpMethod.GET;
            req.Headers.Add("AccessToken", token);

            //4、定义该API接口返回的对象
            result = RequestAPIHelper.RequestServer <HttpReqEntity, IEnumerable <SensorBaseInfoDTO> >(apiPath, req);

            if (result.IsSuccess() && result.ResultObj != null)
            {
                foreach (SensorBaseInfoDTO w in result.ResultObj)
                {
                    ValueConvertToByteAry(w.Value);
                }
            }

            return(result);
        }
Пример #11
0
        /// <summary>
        /// 查询单个设备
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="token"></param>
        /// <returns></returns>
        public ResultMsg <DeviceInfoDTO> GetDeviceByDeviceId(int deviceId, string token = null)
        {
            var result = new ResultMsg <DeviceInfoDTO>();

            //验证
            var vry = PrimaryKeyVerify(deviceId, ref token);

            if (!vry.IsSuccess())
            {
                vry.CopyTo(result);
                return(result);
            }

            //1、先定义该API接口路径,可以从http://api.nlecloud.com/页面的得知
            String apiPath = String.Format("{0}/{1}", mApiHost, NLECloudAPIUrl.DeviceUrl);

            //2、根据该API接口的请求参数中 得知需要创建个URI Parameters String类型参数,所以该参数直接跟在apiPath中
            apiPath = apiPath.Replace("{deviceId}", deviceId.ToString());//将API地址中的{projectid}替换成真实项目ID

            //3、由于调用该API需要Token,所以我们定义了一个通用的对象HttpReqEntity,在AccessToken当成头部请求信息提交过去
            HttpReqEntity req = new HttpReqEntity();

            req.Method = HttpMethod.GET;
            req.Headers.Add("AccessToken", token);

            //4、定义该API接口返回的对象
            result = RequestAPIHelper.RequestServer <HttpReqEntity, DeviceInfoDTO>(apiPath, req);
            if (result.IsSuccess() && result.ResultObj != null && result.ResultObj.Sensors != null)
            {
                result.ResultObj.Sensors.ForEach(w =>
                {
                    w.Value = ValueConvertToByteAry(w.Value);
                });
            }

            return(result);
        }
Пример #12
0
        /// <summary>
        /// 查询单个传感器
        /// </summary>
        /// <param name="deviceId">设备ID</param>
        /// <param name="apiTag">传感标识名</param>
        /// <param name="token"></param>
        /// <returns></returns>
        public ResultMsg <SensorBaseInfoDTO> GetSensorInfo(Int32 deviceId, String apiTag, String token = null)
        {
            var result = new ResultMsg <SensorBaseInfoDTO>();

            //验证
            var vry = PrimaryKeyVerify(deviceId, ref token);

            if (!vry.IsSuccess())
            {
                vry.CopyTo(result);
                return(result);
            }

            //1、先定义该API接口路径,可以从http://api.nlecloud.com/页面的得知
            String apiPath = String.Format("{0}/{1}", mApiHost, NLECloudAPIUrl.SensorOfDeviceUrl);

            //2、根据该API接口的请求参数中 得知需要创建个URI Parameters String类型参数,所以该参数直接跟在apiPath中
            apiPath = apiPath.Replace("{deviceid}", deviceId.ToString()).Replace("{apitag}", apiTag);//将API地址中的{projectid}替换成真实项目ID

            //3、由于调用该API需要Token,所以我们定义了一个通用的对象HttpReqEntity,在AccessToken当成头部请求信息提交过去
            HttpReqEntity req = new HttpReqEntity();

            req.Method = HttpMethod.GET;
            req.Headers.Add("AccessToken", token);

            //4、定义该API接口返回的对象
            result = RequestAPIHelper.RequestServer <HttpReqEntity, SensorBaseInfoDTO>(apiPath, req, (json) =>
            {
                var qry = new ResultMsg <SensorBaseInfoDTO>();
                if (String.IsNullOrEmpty(json))
                {
                    return(qry.SetFailure("数据请求错误,返回对象为空!"));
                }

                JObject jObject = JObject.Parse(json);
                if (jObject["ResultObj"].HasValues && jObject["ResultObj"].SelectToken("Groups") != null)
                {
                    switch (jObject["ResultObj"]["Groups"].ToString())
                    {
                    case "1":
                        {
                            var tmp       = JsonFormatter.Deserialize <ResultMsg <SensorInfoDTO> >(json);
                            qry.ResultObj = tmp.ResultObj;
                        }
                        break;

                    case "2":
                        {
                            var tmp       = JsonFormatter.Deserialize <ResultMsg <ActuatorInfoDTO> >(json);
                            qry.ResultObj = tmp.ResultObj;
                        }
                        break;

                    case "3":
                        {
                            var tmp       = JsonFormatter.Deserialize <ResultMsg <CameraInfoDTO> >(json);
                            qry.ResultObj = tmp.ResultObj;
                        }
                        break;
                    }
                    return(qry);
                }
                else
                {
                    return(qry.SetFailure("数据请求错误,返回对象为空!"));
                }
            });

            if (result.IsSuccess() && result.ResultObj != null)
            {
                result.ResultObj.Value = ValueConvertToByteAry(result.ResultObj.Value);
            }

            return(result);
        }
Пример #13
0
        /// <summary>
        /// 请求
        /// </summary>
        /// <param name="data">POST时的数据</param>
        /// <param name="url">地址</param>
        /// <param name="timeout">超时时间秒</param>
        /// <returns>返回HttpResEntity</returns>
        private static ResultMsg <HttpResEntity> webRequest(string url, HttpReqEntity data, int timeout)
        {
            ResultMsg <HttpResEntity> ret      = new ResultMsg <HttpResEntity>();
            HttpWebRequest            request  = null;
            HttpWebResponse           response = null;

            if (timeout <= 0)
            {
                timeout = TIMEOUT;
            }
            TimeoutTask timeoutTask = new TimeoutTask(
                delegate
            {
                try
                {
                    request             = (HttpWebRequest)WebRequest.Create(url);
                    request.ContentType = string.IsNullOrEmpty(data.ContentType) ? "application/json" : data.ContentType;
                    request.Method      = data.Method.ToString();


                    if (data.Headers != null && data.Headers.Count > 0)
                    {
                        request.Headers.Add(data.Headers);
                    }

                    Encoding encoding = data.Encoding == null ? Encoding.UTF8 : data.Encoding;
                    //if (data.Method != HttpMethod.GET)
                    {
                        if (!string.IsNullOrEmpty(data.Datas))
                        {
                            byte[] requestData    = encoding.GetBytes(data.Datas);
                            request.ContentLength = requestData.Length;
                            using (Stream newStream = request.GetRequestStream())
                            {
                                newStream.Write(requestData, 0, requestData.Length);
                            };
                        }
                        else
                        {
                            request.ContentLength = 0;
                        }
                    }

                    if (!string.IsNullOrEmpty(data.Cookies))
                    {
                        CookieContainer co = new CookieContainer();
                        string server      = GetHost(url, true);
                        co.SetCookies(new Uri("http://" + server), data.Cookies);
                        request.CookieContainer = co;
                    }

                    //Thread.Sleep(31000);
                    response = (HttpWebResponse)request.GetResponse();
                    HttpResEntity resEntity = new HttpResEntity();
                    using (StreamReader receiveStream = new StreamReader(response.GetResponseStream(), encoding))
                    {
                        resEntity.Bodys   = receiveStream.ReadToEnd();
                        resEntity.Cookies = response.Headers.Get("Set-Cookie");
                        resEntity.Headers = response.Headers;

                        ret.SetSuccess(resEntity);
                    };
                }
                catch (Exception ex)
                {
                    ret.SetFailure(String.Format("请求出错\r请求地址:{0}\r可能原因:{1}", url, ex.Message));
                }
                finally
                {
                    CloseRequest(request, response);
                }
            },
                delegate//超时后处理事件
            {
                CloseRequest(request, response);
                ret.SetFailure(string.Format("请求出错\r请求地址:{0}\r可能原因:{1}", url, "连接超时了,网络不通或服务端无响应"));
            });

            if (timeoutTask.Wait(timeout * 1000))//不超时
            {
                return(ret);
            }

            return(ret);
        }
Пример #14
0
        /// <summary>
        /// 服务接口请求
        /// </summary>
        /// <typeparam name="RequestT"></typeparam>
        /// <typeparam name="ResponseT"></typeparam>
        /// <param name="apiName"></param>
        /// <param name="data"></param>
        /// <param name="responseTIsEntity">指定的ResponseT是实体,不是ResultMsgT"></param>
        /// <returns></returns>
        public static ResultMsg <ResponseT> RequestServer <RequestT, ResponseT>(String apiPath, RequestT data, bool responseTIsEntity = true)
        {
            ResultMsg <ResponseT> resultMsg = new ResultMsg <ResponseT>();

            ResultMsg <String> result = null;

            if (data is HttpReqEntity)
            {
                var    tmp = data as HttpReqEntity;
                String url = apiPath;
                result = HttpHelper.Http(url, tmp);
            }
            else
            {
                String strData = String.Empty;
                if (null != data)
                {
                    strData = JsonFormatter.Serialize(data);
                }
                result = RequestServer(apiPath, HttpMethod.POST, strData);
            }

            if (result.Status == ResultStatus.Success)
            {
                if (!String.IsNullOrEmpty(result.ResultObj))
                {
                    //返回服务器原始对象
                    if (!responseTIsEntity)
                    {
                        ResponseT tmp = JsonFormatter.Deserialize <ResponseT>(result.ResultObj);
                        if (tmp == null)
                        {
                            resultMsg.SetFailure("数据请求错误,返回对象为空!");
                        }
                        else
                        {
                            ResultMsg <ResponseT> serverResult = tmp as ResultMsg <ResponseT>;
                            if (serverResult != null)
                            {
                                serverResult.CopyTo <ResponseT>(resultMsg);
                            }
                            else
                            {
                                resultMsg.SetFailure("解析JSON数据失败,返回对象不正确!");
                            }
                        }
                    }
                    else
                    {
                        ResultMsg <ResponseT> tmp = JsonFormatter.Deserialize <ResultMsg <ResponseT> >(result.ResultObj);
                        if (tmp == null)
                        {
                            resultMsg.SetFailure("数据请求错误,返回对象为空!");
                        }
                        else
                        {
                            resultMsg = tmp;
                            if (String.IsNullOrEmpty(resultMsg.Msg))
                            {
                                resultMsg.Msg = result.ResultObj;
                            }
                        }
                    }
                }
                else
                {
                    resultMsg.SetFailure("数据请求错误,返回对象为空!");
                }
            }
            else
            {
                resultMsg.SetFailure(result.Msg);
            }

            return(resultMsg);
        }
Пример #15
0
        /// <summary>
        /// 服务接口请求
        /// </summary>
        /// <typeparam name="RequestT"></typeparam>
        /// <typeparam name="ResponseT"></typeparam>
        /// <param name="apiPath"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public static ResultMsg <ResponseT> RequestServer <RequestT, ResponseT>(String apiPath, RequestT data, Func <String, ResultMsg <ResponseT> > succCallback = null)
        {
            ResultMsg <ResponseT> resultMsg = new ResultMsg <ResponseT>();

            ResultMsg <String> result = null;

            if (data is HttpReqEntity)
            {
                var    tmp = data as HttpReqEntity;
                String url = apiPath;
                result = HttpHelper.Http(url, tmp);
            }
            else
            {
                String strData = String.Empty;
                if (null != data)
                {
                    strData = JsonFormatter.Serialize(data);
                }
                result = RequestServer(apiPath, HttpMethod.POST, strData);
            }

            if (result.Status == ResultStatus.Success)
            {
                if (succCallback != null)
                {
                    return(succCallback(result.ResultObj));
                }
                else
                {
                    if (!String.IsNullOrEmpty(result.ResultObj))
                    {
                        Type type = typeof(ResponseT);
                        if (type == ResultMsgT || type == ResultT)
                        {
                            ResponseT tmp = JsonFormatter.Deserialize <ResponseT>(result.ResultObj);
                            if (tmp == null)
                            {
                                resultMsg.SetFailure("数据请求错误,返回对象为空!");
                            }
                            else
                            {
                                resultMsg.ResultObj = tmp;
                            }
                        }
                        else
                        {
                            ResultMsg <ResponseT> tmp = JsonFormatter.Deserialize <ResultMsg <ResponseT> >(result.ResultObj);
                            if (tmp == null)
                            {
                                resultMsg.SetFailure("数据请求错误,返回对象为空!");
                            }
                            else
                            {
                                resultMsg = tmp;
                            }
                        }
                    }
                    else
                    {
                        resultMsg.SetFailure("数据请求错误,返回对象为空!");
                    }
                }
            }
            else
            {
                resultMsg.SetFailure(result.Msg);
            }

            return(resultMsg);
        }