一、HTTP协议的作用原理

WWW是以Internet作为传输媒介的一个应用系统，WWW网上最基本的传输单位是Web网页。WWW的工作基于客户机/服务器计算模型，由Web 浏览器(客户机)和Web服务器(服务器)构成，两者之间采用超文本传送协议（HTTP）进行通信。HTTP协议是基于TCP/IP协议之上的协议，是Web浏览器和Web服务器之间的应用层协议，是通用的、无状态的、面向对象的协议。HTTP协议的作用原理包括四个步骤：

连接：Web浏览器与Web服务器建立连接，打开一个称为socket（套接字）的虚拟文件，此文件的建立标志着连接建立成功。

请求：Web浏览器通过socket向Web服务器提交请求。HTTP的请求一般是GET或POST命令（POST用于FORM参数的传递）。GET命令的格式为：

GET 路径/文件名 HTTP/1.0

文件名指出所访问的文件，HTTP/1.0指出Web浏览器使用的HTTP版本。

应答：Web浏览器提交请求后，通过HTTP协议传送给Web服务器。Web服务器接到后，进行事务处理，处理结果又通过HTTP传回给Web浏览器，从而在Web浏览器上显示出所请求的页面。

例：假设客户机与www.mycomputer.com:8080/mydir/index.html建立了连接，就会发送GET命令：GET /mydir/index.html HTTP/1.0。主机名为www.mycomputer.com的Web服务器从它的文档空间中搜索子目录mydir的文件index.html。如果找到该文件，Web服务器把该文件内容传送给相应的Web浏览器。

为了告知 Web浏览器传送内容的类型，Web服务器首先传送一些HTTP头信息，然后传送具体内容（即HTTP体信息），HTTP头信息和HTTP体信息之间用一个空行分开。

常用的HTTP头信息有：

① HTTP 1.0 200 OK

这是Web服务器应答的第一行，列出服务器正在运行的HTTP版本号和应答代码。代码“200 OK”表示请求完成。

② MIME_Version:1.0

它指示MIME类型的版本。

③ content_type:类型

这个头信息非常重要，它指示HTTP体信息的MIME类型。如：content_type:text/html指示传送的数据是HTML文档。

④ content_length:长度值

它指示HTTP体信息的长度（字节）。

关闭连接：当应答结束后，Web浏览器与Web服务器必须断开，以保证其它Web浏览器能够与Web服务器建立连接。

二、C#实现Web服务器功能的程序设计

根据上述HTTP协议的作用原理，实现GET请求的Web服务器程序的方法如下：

创建TcpListener类对象，监听某端口（任意输入闲置端口 如：8080 ）。

等待、接受客户机连接到该端口，得到与客户机连接的socket;

从与socket关联的输入流中读取一行客户机提交的请求信息，请求信息的格式为：GET 路径/文件名 HTTP/1.0

从请求信息中获取请求类型。如果请求类型是GET，则从请求信息中获取所访问的HTML文件名。没有HTML文件名时，则以index.html作为文件名；

如果HTML文件存在，则打开HTML文件，把HTTP头信息和HTML文件内容通过socket传回给Web浏览器，然后关闭文件。否则发送错误信息给Web浏览器；

关闭与相应Web浏览器连接的socket字。

实现的代码如下：
//webserver.cs//

namespace cnnbsun.webserver
{
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading ;

class MyWebServer
{
private TcpListener myListener ;
private int port = 8080 ; // 选者任何闲置端口

//开始兼听端口
//同时启动一个兼听进程
public MyWebServer()
{
try
{
//开始兼听端口
myListener = new TcpListener(port) ;
myListener.Start();
Console.WriteLine(“Web Server Running… Press ^C to Stop…”);
//同时启动一个兼听进程 ‘‘StartListen’’
Thread th = new Thread(new ThreadStart(StartListen));
th.Start() ;

}
catch(Exception e)
{
Console.WriteLine(“兼听端口时发生错误 :” +e.ToString());
}
}
public void SendHeader(string sHttpVersion, string sMIMEHeader, int iTotBytes, string sStatusCode, ref Socket mySocket)
{
String sBuffer = “”;

if (sMIMEHeader.Length == 0 )
{
sMIMEHeader = “text/html”; // 默认 text/html
}

sBuffer = sBuffer + sHttpVersion + sStatusCode + “\r\n”;
sBuffer = sBuffer + “Server: cx1193719-b\r\n”;
sBuffer = sBuffer + "Content-Type: " + sMIMEHeader + “\r\n”;
sBuffer = sBuffer + “Accept-Ranges: bytes\r\n”;
sBuffer = sBuffer + "Content-Length: " + iTotBytes + “\r\n\r\n”;

Byte[] bSendData = Encoding.ASCII.GetBytes(sBuffer);

SendToBrowser( bSendData, ref mySocket);

Console.WriteLine("Total Bytes : " + iTotBytes.ToString());

}

public void SendToBrowser(String sData, ref Socket mySocket)
{
SendToBrowser (Encoding.ASCII.GetBytes(sData), ref mySocket);
}

public void SendToBrowser(Byte[] bSendData, ref Socket mySocket)
{
int numBytes = 0;

try
{
if (mySocket.Connected)
{
if (( numBytes = mySocket.Send(bSendData, bSendData.Length,0)) == -1)
Console.WriteLine(“Socket Error cannot Send Packet”);
else
{
Console.WriteLine(“No. of bytes send {0}” , numBytes);
}
}
else
Console.WriteLine(“连接失败…”);
}
catch (Exception e)
{
Console.WriteLine("发生错误 : {0} ", e );

}
}
public static void Main()
{
MyWebServer MWS = new MyWebServer();
}
public void StartListen()
{
int iStartPos = 0;
String sRequest;
String sDirName;
String sRequestedFile;
String sErrorMessage;
String sLocalDir;
/注意设定你自己的虚拟目录/
String sMyWebServerRoot = “E:\MyWebServerRoot\”; //设置你的虚拟目录
//
String sPhysicalFilePath = “”;
String sFormattedMessage = “”;
String sResponse = “”;

while(true)
{
//接受新连接
Socket mySocket = myListener.AcceptSocket() ;

Console.WriteLine (“Socket Type " +mySocket.SocketType );
if(mySocket.Connected)
{
Console.WriteLine(”\nClient Connected!!\n==================\nCLient IP {0}\n",mySocket.RemoteEndPoint) ;

Byte[] bReceive = new Byte[1024] ;
int i = mySocket.Receive(bReceive,bReceive.Length,0) ;

//转换成字符串类型
string sBuffer = Encoding.ASCII.GetString(bReceive);

//只处理"get"请求类型
if (sBuffer.Substring(0,3) != “GET” )
{
Console.WriteLine(“只处理get请求类型…”);
mySocket.Close();
return;
}

// 查找 “HTTP” 的位置
iStartPos = sBuffer.IndexOf(“HTTP”,1);

string sHttpVersion = sBuffer.Substring(iStartPos,8);

// 得到请求类型和文件目录文件名
sRequest = sBuffer.Substring(0,iStartPos - 1);

sRequest.Replace("\","/");

//如果结尾不是文件名也不是以"/“结尾则加”/"
if ((sRequest.IndexOf(".") <1) && (!sRequest.EndsWith("/")))
{
sRequest = sRequest + “/”;
}

//得带请求文件名
iStartPos = sRequest.LastIndexOf("/") + 1;
sRequestedFile = sRequest.Substring(iStartPos);

//得到请求文件目录
sDirName = sRequest.Substring(sRequest.IndexOf("/"), sRequest.LastIndexOf("/")-3);

//获取虚拟目录物理路径
sLocalDir = sMyWebServerRoot;

Console.WriteLine("请求文件目录 : " + sLocalDir);

if (sLocalDir.Length == 0 )
{
sErrorMessage = “

Error!! Requested Directory does not exists

”;
SendHeader(sHttpVersion, “”, sErrorMessage.Length, " 404 Not Found", ref mySocket);
SendToBrowser(sErrorMessage, ref mySocket);
mySocket.Close();
continue;
}

if (sRequestedFile.Length == 0 )
{
// 取得请求文件名
sRequestedFile = “index.html”;
}

/
// 取得请求文件类型（设定为text/html）
/

String sMimeType = “text/html”;

sPhysicalFilePath = sLocalDir + sRequestedFile;
Console.WriteLine("请求文件: " + sPhysicalFilePath);

if (File.Exists(sPhysicalFilePath) == false)
{
sErrorMessage = “

404 Error! File Does Not Exists…

”;
SendHeader(sHttpVersion, “”, sErrorMessage.Length, " 404 Not Found", ref mySocket);
SendToBrowser( sErrorMessage, ref mySocket);

Console.WriteLine(sFormattedMessage);
}

else
{
int iTotBytes=0;

sResponse ="";

FileStream fs = new FileStream(sPhysicalFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);

BinaryReader reader = new BinaryReader(fs);
byte[] bytes = new byte[fs.Length];
int read;
while((read = reader.Read(bytes, 0, bytes.Length)) != 0)
{
sResponse = sResponse + Encoding.ASCII.GetString(bytes,0,read);

iTotBytes = iTotBytes + read;

}
reader.Close();
fs.Close();

SendHeader(sHttpVersion, sMimeType, iTotBytes, " 200 OK", ref mySocket);
SendToBrowser(bytes, ref mySocket);
//mySocket.Send(bytes, bytes.Length,0);

}
mySocket.Close();
}
}
}

}

}

///结束

将文件编译成EXE文件，就实现了简单的WEB服务器功能！
可以设定一个虚拟目录，进行测试！
asp.net提供承载asp.net的方法。详细可以看这个例子： http://www.asp.net/Projects/Cassini/Download/Default.aspx?tabindex=0&tabid=1 ;

转载于:https://www.cnblogs.com/ymhtp/archive/2005/12/04/290518.html

1. Api接口的定义：
API应用程序编程接口是一些预先定义的接口，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
操作系统想了一个很好的办法，它预先把这些复杂的操作写在一个函数里面，编译成一个组件（一般是动态链接库），随操作系统一起发布，并配上说明文档，程序员只需要简单地调用这些函数就可以完成复杂的工作，让编程变得简单有趣。这些封装好的函数，就叫做API(Application Programming Interface)，即应用程序编程接口。简单的来说，就是别人写好的代码，或者编译好的程序，封装成标准接口服务，提供给你使用， 就叫做API。使用了别人代码服务（或者程序）中的某个函数、类、对象，就叫做API接口调用。
 
2. WebApi的定义：
Web: 网站网页。
Api: 接口，应用程序编程接口，开发人员封装的属性和方法。
WebAPI: 提供给不同客户端（跨平台客户端）调用网页的应用程序编程接口。
Web API，一般指基于HTTP协议的编程接口，接口一般定义为HTTP或HTTPS：请求方法、请求路径、参数、响应数据格式、响应HTTP Code等。至于HTTP Server，可以用Java、.Net、Nodejs等各种框架实现，Http Server属于Web API的实现，有时候也会指Web Service接口。
 
3. 使用WebAPI的场景与前景：
Web API最重要的是可以构建面向各种客户端的服务。另外与WCF REST Service不同在于，Web API利用Http协议的各个方面来表达服务，例如：URI/Request/Content Format，因此就省掉很多配置。
MSFramework.WebApi服务端开发框架应用
 

                                 HTTP://POST和Get 以及Response

4. WebAPI功能：
支持基于Http Verb (GET, POST, PUT, DELETE)的CRUD (create, retrieve, update, delete)操作
通过不同的http动作表达不同的含义，这样就不需要暴露多个API来支持这些基本操作。
请求的回复通过Http Status Code表达不同含义，并且客户端可以通过Accept Header来与服务器协商格式，例如你希望服务器返回JSON格式还是XML格式。 
请求的回复格式支持 JSON，XML，并且可以扩展添加其他格式。WebApi服务器支持Self-Hosting、IIS服务以及Windows Service Hosting三种承载服务方式。
支持大多数MVC功能，例如Routing/Controller/Action Result/Dependency Injection。
 
 
 
5. WebAPI接口搭建三种承载(Hosting)方式
A、C# ASP.NET WebApi服务器搭建详解 - IIS服务承载（IIS 服务）
B、C# ASP.NET WebApi服务器搭建详解 - 自承载（Self Hosting） 
C、C# ASP.NET WebApi服务器搭建详解 - Win服务承载（Windows Service 服务）
 
6. WebAPI服务器部署，Self Hosting + IIS服务 + Win服务 
6.1 部署Self Hosting WebApi服务 
将MSFramework.WebAPI.Demo.SelfHosting项目设为启动项目，直接运行即可。
MSFramework.WebAPI.Demo.SelfHosting项目是个可以直接运行的控制台应用程序。
 
贴图图片-ASPNETWebApi服务器搭建详解部署selfhosting服务
 
 
6.2 部署IIS承载的WebApi服务 
在MSFramework.WebAPI.Demo.IISHosting项目点右键【发布】，弹出发布Web对话框，Publish method 选择【File System】文件系统。
ASPNETWebApi服务器搭建详解部署IIS服务
 
发布文件到一个目录，将目录文件部署到IIS服务器，参考下文。
  
 
6.3 部署Windows服务承载的WebApi服务器 
在debug目录下建立一个用于安装win服务的批处理命令程序，如：_安装服务.bat，以管理员身份运行即可安装。
 _安装服务.bat
dos command:
path c:\windows\system32;
path %SystemRoot%\Microsoft.NET\Framework\v4.0.30319;
echo "开始卸载服务***************************"
installutil.exe /u %~d0%~p0MSFramework.WebAPI.Demo.WinServiceHosting.exe
echo "开始安装服务**************************"
installutil.exe %~d0%~p0MSFramework.WebAPI.Demo.WinServiceHosting.exe
echo "设置服务自动启动*********************"
sc config MSFramework.WebAPI.Demo.WinServiceHosting start= auto
Net Start MSFramework.WebAPI.Demo.WinServiceHosting
pause;

 

 

ASPNETWebApi服务器搭建详解win服务承载108
 
 
安装完成，打开Windows服务管理器，查看服务状态。
 
 
ASPNETWebApi服务器搭建详解win服务承载109
 
 
C# ASP.NET WebApi服务器搭建详解 - Win服务承载（Windows Service 服务）
 
 
 
 
.NET WebApi开发框架|MVC框架|后端框架|服务端框架-标准版V1.0
 
适用开发 适用开发：快速构建支持多种客户端的服务端程序，支持APP、B/S、C/S跨平台移动终端等。
运行平台 运行平台：Windows + .NET Framework 4.5+.NetCore3.1
开发工具 开发工具：Visual Studio 2019+，C#语言
数据库 数据库：Microsoft SQLServer 2016+(支持多数据库：Oracle/MySql)

WebApi服务端开发框架
 
 
 
7. MSFramework.WebAPI服务端开发框架专业版V1.0 《体系架构图》 
WebApi服务端开发框架-架构图
 
 MSFramework.WebApi 封装多个通用功能，为搭建Web服务端软件提供强大的技术支持。 客户端请求以命令形式传递到服务端的API接口，命令也就是请求的数据包，包含有请求编号、数据签名以及提交的业务数据。服务端接收到请求，首先要进行数据格式分析以及安全检查，比如数据签名、用户令牌或用户账号信息等。检查通过后，系统自动将请求传递到命令处理处理程序，系统将拒绝非法请求，抛出异常或返回错误回应信息给客户端。
 命令处理层即业务逻辑层，主要负责数据校验和提取业务数据，将Request的数据（JSON或XML）文本内容转换为实体对象，最后传递到数据访问层提交到数据库。 数据访问层是整个逻辑处理的最后一个流程，负责将数据模型持久化到数据库。数据层使用开发框架内置的数据更新机制，根据表结构模型自动生成SQL脚本，无论是提交单条或批量数据，无需手工编写SQL脚本，系统自动实现数据的持久化。框架支持其他数据模型，如Entity Framework等。 
 
8. MSFramework.WebAPI服务端开发框架成功案例
C#.NET webapi开发框架成功案例-管家APP项目：
C#.NET webapi开发框架成功案例-TMS系统APP项目
MSFramework webapi服务端框架成功案例-银行底层支付系统+收银助手客户端
MSFramework webapi服务端框架开发微信支付接口成功案例
webapi开发框架成功案例：车货匹配类微信小程序
webapi服务端开发框架成功案例-对接三方支付平台连连支付C#.NET
C#.NET webapi开发框架成功案例-物流行业TMS系统+APP+微信小程序
C#.NET webapi开发框架成功案例-物流行业系统对接卡车系统
webapi开发框架应用电商微信小程序成功案例

 

下载源代码

 

介绍

        我们将学习如何写一个简单的web服务器，用于响应知名的HTTP请求（GET和POST)，用C#发送响应。然后，我们从网络访问这台服务器，这次我们会说“Hello world!”

 

背景

        HTTP协议

        HTTP是服务器和客户机之间的通信协议。它使用TCP/IP协议来发送/接收请求/响应。

        有几个HTTP方法，我们将实现两个：GET和POST。

GET

         当我们将一个地址输入到我们的Web浏览器的地址栏中，按下回车键时，会发生什么情况？（虽然我们使用TCP/IP，但我们不指定端口号，因为HTTP默认使用80端口，我们并不需要指定80）

GET / HTTP/1.1\r\n
Host: okbase.net\r\n
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:14.0) Gecko/20100101 Firefox/14.0.1\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: tr-tr,tr;q=0.8,en-us;q=0.5,en;q=0.3\r\n
Accept-Encoding: gzip, deflate\r\n
Connection: keep-alive\r\n\r\n

 

该GET请求使用TCP/IP通过浏览器向服务器发送，请求的是okbase.net的根目录下的内容。我们可以添加更多的头信息，最基本的信息如下：

GET / HTTP/1.1\r\n
Host: okbase.net\r\n\r\n

 

POST

        POST请求和GET请求类似，在GET请求里，变量加到url的?下面，POST请求，变量加到两行回车的下面，并需要指定内容长度。

POST /index.html HTTP/1.1\r\n
Host: atasoyweb.net\r\n
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:15.0) Gecko/20100101 Firefox/15.0.1\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: tr-tr,tr;q=0.8,en-us;q=0.5,en;q=0.3\r\n
Accept-Encoding: gzip, deflate\r\n
Connection: keep-alive\r\n
Referer: http://okbase.net/\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Content-Length: 35\r\n\r\n
variable1=value1&variable2=value2

        简化版本如下：

POST /index.html HTTP/1.1\r\n
Host: okbase.net\r\n
Content-Length: 35\r\n\r\n
variable1=value1&variable2=value2

 响应

        当服务器接收到一个请求进行解析，并返回一个响应状态代码：

HTTP/1.1 200 OK\r\n
Server: Apache/1.3.3.7 (Unix) (Red-Hat/Linux)\r\n
Content-Length: {content_length}\r\n
Connection: close\r\n
Content-Type: text/html; charset=UTF-8\r\n\r\n
the content of which length is equal to {content_length}

        这是一个响应头，"200 OK"便是一切OK，请求的内容将被返回。状态码有很多，我们经常使用200,501,404。

        “501 Not Implemented”方法未实现。我们将只实现GET和POST。如果通过其它方法请求，我们将发送此代码。

        “404 Not Found”：没有找到请求的内容。

内容类型

        服务器必须指定它们的响应中的内容的类型。有许多内容类型，这些也被称为“MIME（多用途互联网邮件扩展）类型”（因为它们也可以用来识别非ASCII的电子邮件）。以下是在我们的实现中，我们将使用的内容类型：（您可以修改代码并添加更多） 

        text/html
        text/xml
        text/plain
        text/css
        image/png
        image/gif
        image/jpg
        image/jpeg
        application/zip

        如果服务器指定了错误的内容类型的内容会被曲解。例如，如果一台服务器发送纯文本，使用“图像/ png”类型，客户端试图显示的文字图像。

多线程

        如果我们使我们的服务器可以同时响应多个客户端，我们必须为每个请求创建新的线程。因此，每个线程处理一个请求，并退出完成它的使命。（多线程也加快了页面加载，因为如果我们请求一个页面，页面中使用了CSS和图像，每个图像和CSS文件会以GET方式发送请求）。

 

一个简单的Web服务器的实现

        现在，我们准备实现一个简单的Web服务器。首先，让我们来定义变量，我们将使用：

public bool running = false; // Is it running?
 
private int timeout = 8; // Time limit for data transfers.
private Encoding charEncoder = Encoding.UTF8; // To encode string
private Socket serverSocket; // Our server socket
private string contentPath; // Root path of our contents
 
// Content types that are supported by our server
// You can add more...
// To see other types: http://www.webmaster-toolkit.com/mime-types.shtml
private Dictionary<string, string> extensions = new Dictionary<string, string>()
{ 
    //{ "extension", "content type" }
    { "htm", "text/html" },
    { "html", "text/html" },
    { "xml", "text/xml" },
    { "txt", "text/plain" },
    { "css", "text/css" },
    { "png", "image/png" },
    { "gif", "image/gif" },
    { "jpg", "image/jpg" },
    { "jpeg", "image/jpeg" },
    { "zip", "application/zip"}
};

 

启动服务器的方法：

public bool start(IPAddress ipAddress, int port, int maxNOfCon, string contentPath)
{
    if (running) return false; // If it is already running, exit.
 
    try
    {
        // A tcp/ip socket (ipv4)
        serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
                       ProtocolType.Tcp);
        serverSocket.Bind(new IPEndPoint(ipAddress, port));
        serverSocket.Listen(maxNOfCon);
        serverSocket.ReceiveTimeout = timeout;
        serverSocket.SendTimeout = timeout;
        running = true;
        this.contentPath = contentPath;
    }
    catch { return false; }
 
    // Our thread that will listen connection requests
    // and create new threads to handle them.
    Thread requestListenerT = new Thread(() =>
    {
        while (running)
        {
            Socket clientSocket;
            try
            {
                clientSocket = serverSocket.Accept();
                // Create new thread to handle the request and continue to listen the socket.
                Thread requestHandler = new Thread(() =>
                {
                    clientSocket.ReceiveTimeout = timeout;
                    clientSocket.SendTimeout = timeout;
                    try { handleTheRequest(clientSocket); }
                    catch
                    {
                        try { clientSocket.Close(); } catch { }
                    }
                });
                requestHandler.Start();
            }
            catch{}
        }
    });
    requestListenerT.Start();
 
    return true;
}

 

停止服务器的方法

public void stop()
{
    if (running)
    {
        running = false;
        try { serverSocket.Close(); }
        catch { }
        serverSocket = null;
    }
}

最重要的部分代码：

private void handleTheRequest(Socket clientSocket)
{
    byte[] buffer = new byte[10240]; // 10 kb, just in case
    int receivedBCount = clientSocket.Receive(buffer); // Receive the request
    string strReceived = charEncoder.GetString(buffer, 0, receivedBCount);
 
    // Parse method of the request
    string httpMethod = strReceived.Substring(0, strReceived.IndexOf(" "));
 
    int start = strReceived.IndexOf(httpMethod) + httpMethod.Length + 1;
    int length = strReceived.LastIndexOf("HTTP") - start - 1;
    string requestedUrl = strReceived.Substring(start, length);
 
    string requestedFile;
    if (httpMethod.Equals("GET") || httpMethod.Equals("POST"))
        requestedFile = requestedUrl.Split('?')[0];
    else // You can implement other methods...
    {
        notImplemented(clientSocket);
        return;
    }
 
    requestedFile = requestedFile.Replace("/", @"\").Replace("\\..", "");
    start = requestedFile.LastIndexOf('.') + 1;
    if (start > 0)
    {
        length = requestedFile.Length - start;
        string extension = requestedFile.Substring(start, length);
        if (extensions.ContainsKey(extension)) // Do we support this extension?
            if (File.Exists(contentPath + requestedFile)) //If yes check existence of the file
                // Everything is OK, send requested file with correct content type:
                sendOkResponse(clientSocket,
                  File.ReadAllBytes(contentPath + requestedFile), extensions[extension]);
            else
                notFound(clientSocket); // We don't support this extension.
                                        // We are assuming that it doesn't exist.
    }
    else
    {
        // If file is not specified try to send index.htm or index.html
        // You can add more (default.htm, default.html)
        if (requestedFile.Substring(length - 1, 1) != @"\")
            requestedFile += @"\";
        if (File.Exists(contentPath + requestedFile + "index.htm"))
            sendOkResponse(clientSocket,
              File.ReadAllBytes(contentPath + requestedFile + "\\index.htm"), "text/html");
        else if (File.Exists(contentPath + requestedFile + "index.html"))
            sendOkResponse(clientSocket,
              File.ReadAllBytes(contentPath + requestedFile + "\\index.html"), "text/html");
        else
            notFound(clientSocket);
    }
}

 

不同的状态代码的响应：

private void notFound(Socket clientSocket)
{
   
    sendResponse(clientSocket, "<html><head><meta 
        http-equiv=\"Content-Type\" content=\"text/html; 
        charset=utf-8\"></head><body><h2>Atasoy Simple Web 
        Server</h2><div>404 - Not 
        Found</div></body></html>", 
        "404 Not Found", "text/html");
}
 
private void sendOkResponse(Socket clientSocket, byte[] bContent, string contentType)
{
    sendResponse(clientSocket, bContent, "200 OK", contentType);
}


private void notImplemented(Socket clientSocket)
{
    
    sendResponse(clientSocket, "<html><head><meta 
        http-equiv=\"Content-Type\" content=\"text/html; 
        charset=utf-8\">
        </head><body><h2>Atasoy Simple Web 
        Server</h2><div>501 - Method Not 
        Implemented</div></body></html>", 
        "501 Not Implemented", "text/html");
 
}

将响应发送到客户端的方法

// For strings
private void sendResponse(Socket clientSocket, string strContent, string responseCode,
                          string contentType)
{
    byte[] bContent = charEncoder.GetBytes(strContent);
    sendResponse(clientSocket, bContent, responseCode, contentType);
}
 
// For byte arrays
private void sendResponse(Socket clientSocket, byte[] bContent, string responseCode,
                          string contentType)
{
    try
    {
        byte[] bHeader = charEncoder.GetBytes(
                            "HTTP/1.1 " + responseCode + "\r\n"
                          + "Server: Atasoy Simple Web Server\r\n"
                          + "Content-Length: " + bContent.Length.ToString() + "\r\n"
                          + "Connection: close\r\n"
                          + "Content-Type: " + contentType + "\r\n\r\n");
        clientSocket.Send(bHeader);
        clientSocket.Send(bContent);
        clientSocket.Close();
    }
    catch { }
}

 

用法

// to create new one:
Server server = new Server();
// to start it
server.start(ipAddress, port, maxconnections, contentpath);
// to stop it
server.stop();

 

向全世界说"Hello"

        我们简单的Web服务器已准备就绪。现在，我们将从Internet访问它。为了实现这一目标，我们必须将请求从Modem重定向到我们的计算机。如果我们的调制解调器支持UPnP那就很简单。

1. 下载UPnp Port Forwarder ，并运行它。

2. 点击“Search For Devices”按钮。如果您的调制解调器支持UPnP，它会被添加到ComboBox。 

3. 点击“Update List”按钮，列出转发端口。

4. 然后点击“Add New”按钮，填写表格。 

5. 如果选中“IP”复选框，并输入一个IP地址，只有从这个IP的请求将被重定向。所以，千万不要填写。 

6. 内部端口必须等于我们服务器的端口。

7.“ Port”和“ Internal port”可以不相同。

 

 

        这样，所有来自externalip:port的请求都将通过modem转发到我们的电脑上，你可以用http://www.web-sniffer.net/ 来测试连接的有效性，输入外部IP和端口号 http://外部IP:端口号并点击Submit按钮...

 

http://blog.okbase.net/haobao/archive/60.html