用Socket来简单实现IIS服务器

    刚刚接触ASP.NET编程，为了更好的屡清楚服务器的处理过程，就用Socket模拟服务器来处理请求。用Socket来模拟服务器的时候，同样是自己来封装一些对应的类文件。包括 HttpRequest、HttpResponse、HttpContext、HttpApplication、IHttpHandel。主要的执行流程是：先用Socket来创建一个简单的服务器，进行监听，当监听到请求后将请求交给处理程序去处理，应用程序中根据请求的是静态资源还是动态资源做出不同的处理。然后通过Socket对象将响应类容给发送回去。这只是为了更好的了解服务器的处理，进行了一个简单的模拟，程序中有很多的bug，但是能够实现基本的功能

HttpRequest类

主要包含几个主要的属性：请求方式，请求地址，请求协议的版本号

    public class HttpRequest
    {
        public HttpRequest (string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return;
            }
            string head = str.Replace("
", "$").Split('$')[0];
            string[] heads = head.Split(' ');
            Method = heads.Length>1? heads[0]:"";
            //得到请求的绝对路径
            Url = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), heads.Length>1? heads[1].Substring(1):heads[0]);
            Protocol = heads.Length > 1 ? heads[2] : "";

        }

        public string Method { get; set; }
        public string Url { get; set; }
        public string Protocol { get; set; }
    }

HttpResponse类

包含响应头和响应体，在网络上传输的是二进制文件，故将这两个属性定义为byte[]，中间还包含其他的一些属性。其中响应长度是动态的，在处理程序里面设置

    public class HttpResponse
    {
        public HttpResponse (HttpRequest request)
        {
            this.request = request;
            Type = GetType(Path.GetExtension(request.Url));
        }

        private HttpRequest request;
        private string Type { get; set; }
        public int Length { get; set; }
        public byte[] Head {
            get
            {

                //                -----响应报文------------
                //HTTP/1.1 200 OK
                //Connection: keep-alive
                //Date: Thu, 26 Jul 2007 14:00:02 GMT
                //Server: Microsoft-IIS/6.0
                //X-Powered-By: ASP.NET
                //Content-Length: 190
                //Content-Type: text/html
                //Set-Cookie: ASPSESSIONIDSAATTCSQ=JOPPKDCAMHHBEOICJPGPBJOB; path=/
                //Cache-control: private 
                ////--空行--
                //响应体(正文)

                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("{0} {1}
", request.Protocol, "200 OK");
                sb.AppendLine("Date:" + DateTime.Now.ToString());
                sb.AppendLine("Server:QIGANG-PC");
                sb.AppendLine("Content-Length:" + Length);
                sb.AppendLine("Content-Type:" + Type);
                sb.AppendLine();
                return Encoding.UTF8.GetBytes(sb.ToString());


            }
        }
        public byte[] Body { get; set; }

    ///根据请求来得到响应的类型
        private string GetType (string ext)
        {
            string type1 = "text/html;charset=utf-8";
            switch (ext)//mime-type
            {
                case ".aspx":
                case ".html":
                case ".htm":
                    type1 = "text/html;charset=utf-8";
                    break;
                case ".png":
                    type1 = "image/png";
                    break;
                case ".gif":
                    type1 = "image/gif";
                    break;
                case ".jpg":
                case ".jpeg":
                    type1 = "image/jpeg";
                    break;
                case ".css":
                    type1 = "text/css";
                    break;
                case ".js":
                    type1 = "application/x-javascript";
                    break;
                default:
                    type1 = "text/plain;charset=gbk";
                    break;
            }
            return type1;
        }
    }

HttpContext类

在这个类里面简单的封装了两个成员对象，就是HttpRequest和HttpResponse两个成员，其它的就从简了

    public class HttpContext
    {
        public HttpContext (string str)
        {
            Request = new HttpRequest(str);
            Response = new HttpResponse(Request);
        }
        public HttpRequest Request { get; set; }
        public HttpResponse Response { get; set; }
    }

IHttpHandel接口

由于在客户端请求的数据中可能请求的是一个动态网页，这是就需要交给.NET Framework 来进行处理，为了方便处理，故要求所有的动态网页都需要实现一个接口，只有实现了这个接口的程序才能够被浏览器给请求到

    public interface IHttpHandel
    {
        void ProcessRequest (HttpContext context);
    }

服务器端Socket程序

在这主要是启动一个Socket对象，来进行连接的监听，然后把监听到的对象交给处理程序 HttpApplication进行处理

        private void button1_Click (object sender, EventArgs e)
        {
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socket.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 22822));
            socket.Listen(10);
            Thread thread = new Thread((obj) =>
            {
                Socket server = obj as Socket;
                while (true)
                {
                    Socket client = server.Accept();
                    Thread cth = new Thread((obj2) =>
                    {
                        Socket cSocket = obj2 as Socket;

                        byte[] by = new byte[cSocket.Available];
                        cSocket.Receive(by, 0, by.Length, SocketFlags.None);
            //拿到请求头文件
                        string str = Encoding.UTF8.GetString(by);

                        /*--------- 调用请求处理函数进行处理 ---------*/
                        HttpContext context = new HttpContext(str);
                        HttpApplication app = new HttpApplication(context, cSocket);
                    });
                    cth.IsBackground = true;
                    cth.Start(client);
                }
            });
            thread.IsBackground = true;
            thread.Start(socket);
        }

HttpApplication类

这个类需要传递一个参数，上下文对象。然后进行请求的解析，根据请求的是静态资源还是动态资源去进行不同的处理。如果是静态资源就直接冲磁盘文件中读取返回，如果是动态资源，就交给对应的类。当然前提是请求的资源名称就对应了一个类文件。

    public class HttpApplication
    {
    //构造函数
        public HttpApplication (HttpContext context,Socket socket)
        {
            string url =context.Request.Url;
            if(string.IsNullOrEmpty(url)){
                return;
            }
            string ext = Path.GetExtension(url);
        //请求的是动态资源文件
            if (ext == ".aspx")
            {
        //下面的代码中也就没有进行错误的处理了，主要是模拟，没有考虑其他的情况
        //拿到请求资源的文件名(不包含后缀)
                string cs = Path.GetFileNameWithoutExtension(url);
        //得到当前程序的程序集
                Assembly ass = Assembly.GetExecutingAssembly();
        //拿到请求的文件对应的类
                Type type = ass.GetType(ass.GetName().Name + "." + cs, true, true);
        //创建对象，进行调用
                IHttpHandel handel = Activator.CreateInstance(type) as IHttpHandel;
                handel.ProcessRequest(context);
        //上面几句话可以合并到一起，拿到程序集后直接CreateInstance();
            }
            else if (ext == ".ashx")
            {
            }
            else//访问静态资源
            {
               //直接从磁盘中读取请求的资源文件
                byte[] by = File.ReadAllBytes(url);
                context.Response.Length = by.Length;
                context.Response.Body = by;

            }
            socket.Send(context.Response.Head);
            socket.Send(context.Response.Body);
        }
    }

整个请求的模型基本上就差不多完成了，如果是请求的动态文件b.aspx，那么这个b.cs文件需要实现IHttpHandel接口，同时在规定的方法里面进行处理，代码如下：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IIS_Two
{
    public class b:IHttpHandel

    {
        public void ProcessRequest (HttpContext context)
        {
        //读取模板HTML文件
            string html = File.ReadAllText("temp.html");
            string temp = "<table border='1'>{0}</table>";
        //读取文本文件类容，拼接一个table表格
            using (StreamReader reader = new StreamReader("1.txt"))
            {
                string str = "";
                List<string> list = new List<string>();
                while ((str = reader.ReadLine()) != null)
                {
                    string[] strs = str.Split(':');
                    list.Add("<tr><td>" + strs[0] + "</td><td>" + strs[1] + "</td></tr>");

                }
                temp = string.Format(temp, string.Join("", list));
            }
        //模板内容的替换
            html = html.Replace("$body", temp);
            byte[] by = Encoding.UTF8.GetBytes(html);
            context.Response.Length = by.Length;
            context.Response.Body = by;
        }
    }
}

附上b.cs中用到的一个HTML模板和一个txt文件

<!DOCTYPE html>

<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="utf-8" />
    <title></title>
</head>
<body>
    $body
</body>
</html>

aaa:22
bbb:23
ccc:18

整个简单的模拟就完成了，bug很多，这不重要。如果请求一个简单的html页面或者是jpg等图片都能够成功，当然这些文件要存在代码中所写的目录下面才行