C# 控制台或者winform程序开启http的监听状态

  1 public class THttpListener
     {
         HttpListener listerner;
         /// <summary>
         ///
         /// </summary>
         /// <param name="prefixes">格式 http://*/test/ </param>
         /// <param name="authent"></param>
         public THttpListener(string[] prefixes, AuthenticationSchemes authent = AuthenticationSchemes.Anonymous)
         {
             listerner = new HttpListener();
             listerner.AuthenticationSchemes = authent;//指定身份验证 Anonymous匿名访问
             foreach (var item in prefixes)
             {
                 listerner.Prefixes.Add(item);
                 Console.WriteLine(DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + " : HttpListener：" + item);
             }
         }

         public delegate void ResponseEventArges(HttpListenerContext ctx);
         public event ResponseEventArges ResponseEvent;
         AsyncCallback ac = null;

         public void Start()
         {
             if (!listerner.IsListening)
             {
                 listerner.Start();
                 ac = new AsyncCallback(GetContextAsyncCallback);
                 listerner.BeginGetContext(ac, null);
                 Console.WriteLine(DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + " : Start");
             }
         }

         /// <summary>
         /// 停止监听服务
         /// </summary>
         public void Stop()
         {
             listerner.Stop();
         }

         /// <summary>
         /// 收到监听请求回调
         /// </summary>
         /// <param name="ia"></param>
         public void GetContextAsyncCallback(IAsyncResult ia)
         {
             if (ia.IsCompleted)
             {
                 var ctx = listerner.EndGetContext(ia);
                 ctx.Response.StatusCode = ;
                 if (ResponseEvent != null)
                 {
                     ResponseEvent.BeginInvoke(ctx, null, null);
                 }
                 else
                 {
                     System.IO.BinaryWriter br = new System.IO.BinaryWriter(ctx.Response.OutputStream, new UTF8Encoding());
                     br.Write("error: 服务器未处理");
                     ctx.Response.Close();
                     br.Close();
                     br.Dispose();
                 }
             }
             listerner.BeginGetContext(ac, null);
         }

         public Dictionary<string, string> getData(System.Net.HttpListenerContext ctx)
         {
             var request = ctx.Request;
             if (request.HttpMethod == "GET")
             {
                 return getData(ctx, DataType.Get);
             }
             else
             {
                 return getData(ctx, DataType.Post);
             }
         }

         public Dictionary<string, string> getData(System.Net.HttpListenerContext ctx, DataType type)
         {
             var rets = new Dictionary<string, string>();
             var request = ctx.Request;
             switch (type)
             {
                 case DataType.Post:
                     if (request.HttpMethod == "POST")
                     {
                         string rawData;
                         using (var reader = new StreamReader(request.InputStream, request.ContentEncoding))
                         {
                             rawData = reader.ReadToEnd();
                         }
                         string[] rawParams = rawData.Split('&');
                         foreach (string param in rawParams)
                         {
                             string[] kvPair = param.Split('=');
                             ];
                             ]);
                             rets[key] = value;
                         }
                     }
                     break;
                 case DataType.Get:
                     if (request.HttpMethod == "GET")
                     {
                         string[] keys = request.QueryString.AllKeys;
                         foreach (string key in keys)
                         {
                             rets[key] = request.QueryString[key];
                         }
                     }
                     break;
             }
             return rets;
         }

         /// <summary>
         /// 数据提交方式
         /// </summary>
         public enum DataType
         {
             Post,
             Get,
         }

     }

测试调用类

 public class TestHttp
     {
         THttpListener _HttpListener;
         public TestHttp()
         {
             string[] strUrl = new string[] { "http://*/Test/" };
             _HttpListener = new THttpListener(strUrl);
             _HttpListener.ResponseEvent += _HttpListener_ResponseEvent;
             _HttpListener.Start();
         }

         void _HttpListener_ResponseEvent(System.Net.HttpListenerContext ctx)
         {
             //直接获取数据
             Dictionary<string, string> rets = _HttpListener.getData(ctx);
             //获取get数据
             Dictionary<string, string> retGets = _HttpListener.getData(ctx, THttpListener.DataType.Get);
             //获取post数据
             Dictionary<string, string> retPosts = _HttpListener.getData(ctx, THttpListener.DataType.Post);
             ResponseWrite(ctx.Request.AcceptTypes[], "Ret", ctx.Response);
         }

         static void ResponseWrite(string type, string msg, System.Net.HttpListenerResponse response)
         {
             //使用Writer输出http响应代码
             using (System.IO.StreamWriter writer = new System.IO.StreamWriter(response.OutputStream, new UTF8Encoding()))
             {
                 response.ContentType = type + ";charset=utf-8";
                 writer.WriteLine(msg);
                 writer.Close();
                 response.Close();
             }
         }
     }

当我们在服务程序或者后台程序需要开启对http的监听，来获取提交数据，但是又不能web服务器来挂在的程序，