예제 #1
0
파일: CoreClient.cs 프로젝트: clks2001/Wdxx
 /// <summary>
 /// 带服务地址构造函数
 /// </summary>
 /// <param name="serviceUrl">服务地址</param>
 public CoreClient(string serviceUrl)
 {
     ServiceUrl = serviceUrl.TrimEnd('/');
     try
     {
         //获取WSDL
         var wc     = new WebClient();
         var stream = wc.OpenRead(ServiceUrl + "?WSDL");
         wc.Dispose();
         if (stream == null)
         {
             _type = null;
             return;
         }
         var sd        = ServiceDescription.Read(stream);
         var classname = sd.Services[0].Name;
         var sdi       = new ServiceDescriptionImporter();
         sdi.AddServiceDescription(sd, "", "");
         var cn = new CodeNamespace();
         //生成客户端代理类代码
         var ccu = new CodeCompileUnit();
         ccu.Namespaces.Add(cn);
         sdi.Import(cn, ccu);
         var csc = new CSharpCodeProvider();
         //设定编译参数
         var cplist = new CompilerParameters
         {
             GenerateExecutable = false,
             GenerateInMemory   = true
         };
         //动态编译后的程序集不生成可执行文件
         //动态编译后的程序集只存在于内存中,不在硬盘的文件上
         cplist.ReferencedAssemblies.Add("System.dll");
         cplist.ReferencedAssemblies.Add("System.XML.dll");
         cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
         cplist.ReferencedAssemblies.Add("System.Data.dll");
         //编译代理类
         var cr = csc.CompileAssemblyFromDom(cplist, ccu);
         if (cr.Errors.HasErrors)
         {
             var sb = new StringBuilder();
             foreach (CompilerError ce in cr.Errors)
             {
                 sb.Append(ce);
                 sb.Append(Environment.NewLine);
             }
             throw new Exception(sb.ToString());
         }
         //生成代理实例,并调用方法
         var assembly = cr.CompiledAssembly;
         _type = assembly.GetType(classname, true, true);
     }
     catch (Exception e)
     {
         CoreLog.Error(e);
     }
 }
예제 #2
0
 /// <summary>
 /// XML反序列化
 /// </summary>
 public static object XmlToObj(string xmlStr, Type t)
 {
     try
     {
         using (var sr = new StringReader(xmlStr))
         {
             var serializer = new XmlSerializer(t);
             return(serializer.Deserialize(sr));
         }
     }
     catch (Exception e)
     {
         CoreLog.Error(e);
         return(null);
     }
 }
예제 #3
0
 /// <summary>
 /// XML反序列化
 /// </summary>
 public static T XmlToObj <T>(string xmlStr) where T : new()
 {
     try
     {
         using (var sr = new StringReader(xmlStr))
         {
             var serializer = new XmlSerializer(typeof(T));
             return((T)serializer.Deserialize(sr));
         }
     }
     catch (Exception e)
     {
         CoreLog.Error(e);
         return(default(T));
     }
 }
예제 #4
0
 /// <summary>
 /// 将JSON字符串转化为对应类型的对象
 /// </summary>
 /// <param name="json">json字符串</param>
 /// <param name="type"></param>
 /// <returns>转换后的对象</returns>
 public static object JsonDataToObj(string json, Type type)
 {
     try
     {
         using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(json)))
         {
             var deseralizer = new DataContractJsonSerializer(type);
             return(deseralizer.ReadObject(ms));
         }
     }
     catch (Exception e)
     {
         CoreLog.Error(e);
         return(null);
     }
 }
예제 #5
0
        /// <summary>
        /// 接收请求的委托
        /// </summary>
        /// <param name="ar"></param>
        private void Result(IAsyncResult ar)
        {
            //当接收到请求后程序流会走到这里
            //获得context对象
            var context = _httpobj.EndGetContext(ar);

            //继续异步监听
            _httpobj.BeginGetContext(Result, _httpobj);
            var request = context.Request;
            //将发送到客户端的请求响应中的客户端的对象
            var response = context.Response;

            //后台跨域请求,通常设置为配置文件   如果是js的ajax请求,还可以设置跨域的ip地址与参数
            context.Response.AppendHeader("Access-Control-Allow-Origin", "*");
            //后台跨域参数设置,通常设置为配置文件
            //context.Response.AppendHeader("Access-Control-Allow-Headers", "ID,PW");
            //后台跨域请求设置,通常设置为配置文件
            //context.Response.AppendHeader("Access-Control-Allow-Method", "post");
            //告诉客户端返回的ContentType类型为JSON格式,编码为UTF-8
            context.Response.ContentType = "application/json;charset=UTF-8";
            //添加响应头信息
            context.Response.AddHeader("Content-type", "application/json");
            //设置响应的编码格式
            context.Response.ContentEncoding = Encoding.UTF8;
            //处理客户端发送的请求并返回处理信息
            var retData = HandleRequest(request, response) ?? string.Empty;
            //设置客户端返回信息的编码
            var retByteArr = Encoding.UTF8.GetBytes(retData);

            try
            {
                using (var stream = response.OutputStream)
                {
                    //把处理信息返回到客户端
                    stream.Write(retByteArr, 0, retByteArr.Length);
                }
            }
            catch (Exception ex)
            {
                CoreLog.Error("网络异常:" + ex);
            }
        }
예제 #6
0
 /// <summary>
 /// 执行服务器方法
 /// </summary>
 /// <param name="mi">方法</param>
 /// <param name="pos">参数</param>
 /// <returns></returns>
 private string Fun(MethodBase mi, object[] pos)
 {
     try
     {
         //创建实例
         var o = Activator.CreateInstance(_serviceClass);
         //调用方法
         if (mi != null)
         {
             return(CoreConvert.ObjToJsonData(mi.Invoke(o, pos)));
         }
         CoreLog.Error("方法不能为空");
         return(null);
     }
     catch (Exception ex)
     {
         CoreLog.Error("方法:" + mi?.Name + "执行错误:" + ex);
         throw new Exception(ex.Message);
     }
 }
예제 #7
0
 /// <summary>
 /// 将任意类型对象转化为数据JSON字符串
 /// </summary>
 /// <param name="obj">要转换的对象</param>
 /// <returns>json字符串</returns>
 public static string ObjToJsonData(object obj)
 {
     try
     {
         var js    = new DataContractJsonSerializer(obj.GetType());
         var msObj = new MemoryStream();
         //将序列化之后的Json格式数据写入流中
         js.WriteObject(msObj, obj);
         msObj.Position = 0;
         //从0这个位置开始读取流中的数据
         var sr   = new StreamReader(msObj, Encoding.UTF8);
         var json = sr.ReadToEnd();
         sr.Close();
         msObj.Close();
         return(json);
     }
     catch (Exception e)
     {
         CoreLog.Error(e);
         return(null);
     }
 }
예제 #8
0
 /// <summary>
 /// 处理请求
 /// </summary>
 /// <param name="request"></param>
 /// <param name="response"></param>
 /// <returns></returns>
 private string HandleRequest(HttpListenerRequest request, HttpListenerResponse response)
 {
     if (request.HttpMethod.ToUpper() != "POST")
     {
         CoreLog.Error("只支持POST提交");
         return(null);
     }
     if (request.InputStream != null)
     {
         string funName = null;
         //具体要执行的方法
         MethodInfo mi = null;
         //参数
         //这里是有客户端发送的正文本数据流的请求
         try
         {
             var byteList = new List <byte>();
             var byteArr  = new byte[2048];
             int readLen;
             var len = 0;
             //接收客户端传过来的数据并转成字符串类型
             do
             {
                 readLen = request.InputStream.Read(byteArr, 0, byteArr.Length);
                 len    += readLen;
                 byteList.AddRange(byteArr);
             } while (readLen != 0);
             //获取得到数据data
             var data = Encoding.UTF8.GetString(byteList.ToArray(), 0, len);
             //判断是否是WebService模式调用
             object[] objArr;
             //url路径
             var postSegments = request.Url.Segments;
             //根据url路径确定方法名
             if (postSegments.Length < 2)
             {
                 response.StatusDescription = "404";
                 response.StatusCode        = 404;
                 CoreLog.Error("找不到服务方法");
                 return(null);
             }
             funName = postSegments[1].TrimEnd('/');
             //判断是否是WebSrviceSoap模式调用
             if (funName == "WebSrviceSoap")
             {
                 if (string.IsNullOrEmpty(data))
                 {
                     response.StatusDescription = "404";
                     response.StatusCode        = 404;
                     CoreLog.Error("找不到服务方法");
                     return(null);
                 }
                 var sendDatas = (SendData)CoreConvert.JsonDataToObj(data, typeof(SendData));
                 //获取方法名相同的所有方法
                 var mis = _serviceFunArr.Where(f =>
                                                string.Equals(f.Name, sendDatas.Method, StringComparison.CurrentCultureIgnoreCase)).ToList();
                 if (mis.Count == 0)
                 {
                     response.StatusDescription = "404";
                     response.StatusCode        = 404;
                     CoreLog.Error("找不到服务方法");
                     return(null);
                 }
                 //获取参数
                 var dataList = (List <string>)CoreConvert.JsonDataToObj(sendDatas.Datas, typeof(List <string>));
                 //这里为空则没有参数
                 if (dataList == null)
                 {
                     foreach (var m in mis)
                     {
                         var ps = m.GetParameters();
                         if (ps.Length != 0)
                         {
                             continue;
                         }
                         //找到没有参数的方法
                         mi = m;
                         break;
                     }
                     //参数默认值null
                     objArr = null;
                 }
                 else
                 {
                     //这里是参数数组
                     objArr = new object[dataList.Count];
                     foreach (var m in mis)
                     {
                         var ps = m.GetParameters();
                         if (ps.Length != dataList.Count)
                         {
                             continue;
                         }
                         //找到参数数量对应的方法
                         mi = m;
                         for (var i = 0; i < ps.Length; i++)
                         {
                             objArr[i] = CoreConvert.JsonDataToObj(dataList[i], ps[i].ParameterType);
                         }
                     }
                 }
             }
             else
             {
                 //获取方法名相同的所有方法
                 var mis = _serviceFunArr.Where(f => string.Equals(f.Name, funName, StringComparison.CurrentCultureIgnoreCase)).ToList();
                 if (mis.Count == 0)
                 {
                     response.StatusDescription = "404";
                     response.StatusCode        = 404;
                     CoreLog.Error("找不到服务方法");
                     return(null);
                 }
                 //这里为空则没有参数
                 if (string.IsNullOrEmpty(data))
                 {
                     foreach (var m in mis)
                     {
                         var ps = m.GetParameters();
                         if (ps.Length != 0)
                         {
                             continue;
                         }
                         //找到没有参数的方法
                         mi = m;
                         break;
                     }
                     //参数默认值null
                     objArr = null;
                 }
                 else
                 {
                     //获取参数
                     var dataArr = data.Split('&');
                     //这里是参数数组
                     objArr = new object[dataArr.Length];
                     foreach (var m in mis)
                     {
                         var ps = m.GetParameters();
                         if (ps.Length != dataArr.Length)
                         {
                             continue;
                         }
                         //找到参数数量对应的方法
                         mi = m;
                         for (var i = 0; i < ps.Length; i++)
                         {
                             foreach (var d in dataArr)
                             {
                                 //拆分参数字符串 获得方法名和值
                                 try
                                 {
                                     var dArr = d.Split('=');
                                     if (ps[i].Name != dArr[0])
                                     {
                                         continue;
                                     }
                                     objArr[i] = dArr[1];
                                     break;
                                 }
                                 catch (Exception e)
                                 {
                                     CoreLog.Error("参数错误:" + e);
                                     response.StatusDescription = "404";
                                     response.StatusCode        = 404;
                                     return(null);
                                 }
                             }
                         }
                     }
                 }
             }
             return(Fun(mi, objArr));
         }
         catch (Exception ex)
         {
             response.StatusDescription = "404";
             response.StatusCode        = 404;
             CoreLog.Error($"接收数据时发生错误 Url:{request.Url} Method:{funName} err:{ex}");
             return(null);
         }
     }
     response.StatusDescription = "404";
     response.StatusCode        = 404;
     CoreLog.Error("不允许空提交");
     return(null);
 }