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 = 200;
                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('=');
                            string key = kvPair[0];
                            string value = HttpUtility.UrlDecode(kvPair[1]);
                            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[0], "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服务器来挂在的程序，