哪有用c#开发socket应用的资料！！！，提供一下，多谢

Question

Microsoft.Net Framework为应用程序访问Internet提供了分层的、可扩展的以及受管辖的网络服务，其名字空间System.Net和System.Net.Sockets包含丰富的类可以开发多种网络应用程序。.Net类采用的分层结构允许应用程序在不同的控制级别上访问网络，开发人员可以根据需要选择针对不同的级别编制程序，这些级别几乎囊括了Internet的所有需要--从socket套接字到普通的请求/响应，更重要的是，这种分层是可以扩展的，能够适应Internet不断扩展的需要。 
   
  抛开ISO/OSI模型的7层构架，单从TCP/IP模型上的逻辑层面上看，.Net类可以视为包含3个层次：请求/响应层、应用协议层、传输层。WebReqeust和WebResponse 代表了请求/响应层，支持Http、Tcp和Udp的类组成了应用协议层，而Socket类处于传输层。可以如下示意： 
   
   
  可见，传输层位于这个结构的最底层，当其上面的应用协议层和请求/响应层不能满足应用程序的特殊需要时，就需要使用这一层进行Socket套接字编程。 
   
  而在.Net中，System.Net.Sockets 命名空间为需要严密控制网络访问的开发人员提供了 Windows Sockets (Winsock) 接口的托管实现。System.Net 命名空间中的所有其他网络访问类都建立在该套接字Socket实现之上，如TCPClient、TCPListener 和 UDPClient 类封装有关创建到 Internet 的 TCP 和 UDP 连接的详细信息；NetworkStream类则提供用于网络访问的基础数据流等，常见的许多Internet服务都可以见到Socket的踪影，如Telnet、Http、Email、Echo等，这些服务尽管通讯协议Protocol的定义不同，但是其基础的传输都是采用的Socket。 
   
  其实，Socket可以象流Stream一样被视为一个数据通道，这个通道架设在应用程序端（客户端）和远程服务器端之间，而后，数据的读取（接收）和写入（发送）均针对这个通道来进行。 
   
  可见，在应用程序端或者服务器端创建了Socket对象之后，就可以使用Send/SentTo方法将数据发送到连接的Socket,或者使用Receive/ReceiveFrom方法接收来自连接Socket的数据； 
   
  针对Socket编程，.NET 框架的 Socket 类是 Winsock32 API 提供的套接字服务的托管代码版本。其中为实现网络编程提供了大量的方法，大多数情况下，Socket 类方法只是将数据封送到它们的本机 Win32 副本中并处理任何必要的安全检查。如果你熟悉Winsock API函数，那么用Socket类编写网络程序会非常容易，当然，如果你不曾接触过，也不会太困难，跟随下面的解说，你会发觉使用Socket类开发windows 网络应用程序原来有规可寻，它们在大多数情况下遵循大致相同的步骤。 
   
  在使用之前，你需要首先创建Socket对象的实例，这可以通过Socket类的构造方法来实现： 
   
  public Socket(AddressFamily addressFamily,SocketType socketType,ProtocolType protocolType); 
   
   
  其中，addressFamily 参数指定 Socket 使用的寻址方案，socketType 参数指定 Socket 的类型，protocolType 参数指定 Socket 使用的协议。 
   
  下面的示例语句创建一个 Socket，它可用于在基于 TCP/IP 的网络（如 Internet）上通讯。 
   
  Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
   
   
  若要使用 UDP 而不是 TCP，需要更改协议类型，如下面的示例所示： 
   
  Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); 
   
   
  一旦创建 Socket，在客户端，你将可以通过Connect方法连接到指定的服务器，并通过Send/SendTo方法向远程服务器发送数据，而后可以通过Receive/ReceiveFrom从服务端接收数据；而在服务器端，你需要使用Bind方法绑定所指定的接口使Socket与一个本地终结点相联，并通过Listen方法侦听该接口上的请求，当侦听到用户端的连接时，调用Accept完成连接的操作，创建新的Socket以处理传入的连接请求。使用完 Socket 后，记住使用 Shutdown 方法禁用 Socket，并使用 Close 方法关闭 Socket。其间用到的方法/函数有： 
   
  Socket.Connect方法:建立到远程设备的连接 
  public void Connect(EndPoint remoteEP)（有重载方法） 
  Socket.Send 方法:从数据中的指示位置开始将数据发送到连接的 Socket。 
  public int Send(byte[], int, SocketFlags);(有重载方法) 
  Socket.SendTo 方法 将数据发送到特定终结点。 
  public int SendTo(byte[], EndPoint);（有重载方法） 
  Socket.Receive方法:将数据从连接的 Socket 接收到接收缓冲区的特定位置。 
  public int Receive(byte[],int,SocketFlags); 
  Socket.ReceiveFrom方法：接收数据缓冲区中特定位置的数据并存储终结点。 
  public int ReceiveFrom(byte[], int, SocketFlags, ref EndPoint); 
  Socket.Bind 方法：使 Socket 与一个本地终结点相关联： 
  public void Bind( EndPoint localEP ); 
  Socket.Listen方法：将 Socket 置于侦听状态。 
  public void Listen( int backlog ); 
  Socket.Accept方法:创建新的 Socket 以处理传入的连接请求。 
  public Socket Accept(); 
  Socket.Shutdown方法:禁用某 Socket 上的发送和接收 
  public void Shutdown( SocketShutdown how ); 
  Socket.Close方法:强制 Socket 连接关闭 
  public void Close(); 
   
   
  可以看出，以上许多方法包含EndPoint类型的参数，在Internet中，TCP/IP 使用一个网络地址和一个服务端口号来唯一标识设备。网络地址标识网络上的特定设备；端口号标识要连接到的该设备上的特定服务。网络地址和服务端口的组合称为终结点，在 .NET 框架中正是由 EndPoint 类表示这个终结点，它提供表示网络资源或服务的抽象，用以标志网络地址等信息。.Net同时也为每个受支持的地址族定义了 EndPoint 的子代；对于 IP 地址族，该类为 IPEndPoint。IPEndPoint 类包含应用程序连接到主机上的服务所需的主机和端口信息，通过组合服务的主机IP地址和端口号，IPEndPoint 类形成到服务的连接点。 
   
  用到IPEndPoint类的时候就不可避免地涉及到计算机IP地址，.Net中有两种类可以得到IP地址实例： 
   
  IPAddress类：IPAddress 类包含计算机在 IP 网络上的地址。其Parse方法可将 IP 地址字符串转换为 IPAddress 实例。下面的语句创建一个 IPAddress 实例： 
   
  IPAddress myIP = IPAddress.Parse("192.168.1.2"); 
   
   
  Dns 类：向使用 TCP/IP Internet 服务的应用程序提供域名服务。其Resolve 方法查询 DNS 服务器以将用户友好的域名（如"host.contoso.com"）映射到数字形式的 Internet 地址（如 192.168.1.1）。Resolve方法 返回一个 IPHostEnty 实例，该实例包含所请求名称的地址和别名的列表。大多数情况下，可以使用 AddressList 数组中返回的第一个地址。下面的代码获取一个 IPAddress 实例，该实例包含服务器 host.contoso.com 的 IP 地址。 
   
  IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com"); 
  IPAddress ipAddress = ipHostInfo.AddressList[0]; 
   

Answer 1

续...............................
  你也可以使用GetHostName方法得到IPHostEntry实例： 
   
  IPHosntEntry hostInfo=Dns.GetHostByName("host.contoso.com") 
   
   
  在使用以上方法时，你将可能需要处理以下几种异常： 
   
  SocketException异常：访问Socket时操作系统发生错误引发 
   
  ArgumentNullException异常：参数为空引用引发 
   
  ObjectDisposedException异常：Socket已经关闭引发 
   
  在掌握上面得知识后，下面的代码将该服务器主机（ host.contoso.com的 IP 地址与端口号组合，以便为连接创建远程终结点： 
   
  IPEndPoint ipe = new IPEndPoint(ipAddress,11000); 
   
   
  确定了远程设备的地址并选择了用于连接的端口后，应用程序可以尝试建立与远程设备的连接。下面的示例使用现有的 IPEndPoint 实例与远程设备连接，并捕获可能引发的异常： 
   
  try { 
   s.Connect(ipe);//尝试连接 
  } 
  //处理参数为空引用异常 
   catch(ArgumentNullException ae) { 
   Console.WriteLine("ArgumentNullException : {0}", ae.ToString()); 
  } 
  //处理操作系统异常 
   catch(SocketException se) { 
   Console.WriteLine("SocketException : {0}", se.ToString()); 
  } 
   catch(Exception e) { 
   Console.WriteLine("Unexpected exception : {0}", e.ToString()); 
  } 
   
   
  需要知道的是：Socket 类支持两种基本模式：同步和异步。其区别在于：在同步模式中，对执行网络操作的函数（如 Send 和 Receive）的调用一直等到操作完成后才将控制返回给调用程序。在异步模式中，这些调用立即返回。 
   
  另外，很多时候，Socket编程视情况不同需要在客户端和服务器端分别予以实现，在客户端编制应用程序向服务端指定端口发送请求，同时编制服务端应用程序处理该请求，这个过程在上面的阐述中已经提及；当然，并非所有的Socket编程都需要你严格编写这两端程序；视应用情况不同，你可以在客户端构造出请求字符串，服务器相应端口捕获这个请求，交由其公用服务程序进行处理。以下事例语句中的字符串就向远程主机提出页面请求： 
   
  string Get = "GET / HTTP/1.1\r\nHost: " + server + "\r\nConnection: Close\r\n\r\n"; 
   
   
  远程主机指定端口接受到这一请求后，就可利用其公用服务程序进行处理而不需要另行编制服务器端应用程序。 
   
  综合运用以上阐述的使用Visual C#进行Socket网络程序开发的知识，下面的程序段完整地实现了Web页面下载功能。用户只需在窗体上输入远程主机名（Dns 主机名或以点分隔的四部分表示法格式的 IP 地址）和预保存的本地文件名，并利用专门提供Http服务的80端口，就可以获取远程主机页面并保存在本地机指定文件中。如果保存格式是.htm格式，你就可以在Internet浏览器中打开该页面。适当添加代码，你甚至可以实现一个简单的浏览器程序。 
   
   
  实现此功能的主要源代码如下： 
   
  //"开始"按钮事件 
  private void button1_Click(object sender, System.EventArgs e) { 
   //取得预保存的文件名 
   string fileName=textBox3.Text.Trim(); 
   //远程主机 
   string hostName=textBox1.Text.Trim(); 
   //端口 
   int port=Int32.Parse(textBox2.Text.Trim()); 
   //得到主机信息 
   IPHostEntry ipInfo=Dns.GetHostByName(hostName); 
   //取得IPAddress[] 
   IPAddress[] ipAddr=ipInfo.AddressList; 
   //得到ip 
   IPAddress ip=ipAddr[0]; 
   //组合出远程终结点 
   IPEndPoint hostEP=new IPEndPoint(ip,port); 
   //创建Socket 实例 
   Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp); 
   try 
   { 
   //尝试连接 
   socket.Connect(hostEP); 
   } 
   catch(Exception se) 
   { 
   MessageBox.Show("连接错误"+se.Message,"提示信息 
   ,MessageBoxButtons.RetryCancel,MessageBoxIcon.Information); 
  } 
  //发送给远程主机的请求内容串 
  string sendStr="GET / HTTP/1.1\r\nHost: " + hostName + 
  "\r\nConnection: Close\r\n\r\n"; 
   //创建bytes字节数组以转换发送串 
   byte[] bytesSendStr=new byte[1024]; 
   //将发送内容字符串转换成字节byte数组 
   bytesSendStr=Encoding.ASCII.GetBytes(sendStr); 
  try 
  { 
  //向主机发送请求 
  socket.Send(bytesSendStr,bytesSendStr.Length,0); 
  } 
  catch(Exception ce) 
   { 
   MessageBox.Show("发送错误:"+ce.Message,"提示信息 
   ,MessageBoxButtons.RetryCancel,MessageBoxIcon.Information); 
   } 
   //声明接收返回内容的字符串 
   string recvStr=""; 
   //声明字节数组，一次接收数据的长度为1024字节 
   byte[] recvBytes=new byte[1024]; 
   //返回实际接收内容的字节数 
   int bytes=0; 
  //循环读取，直到接收完所有数据 
  while(true) 
  { 
  bytes=socket.Receive(recvBytes,recvBytes.Length,0); 
  //读取完成后退出循环 
  if(bytes<=0) 
  break; 
  //将读取的字节数转换为字符串 
  recvStr+=Encoding.ASCII.GetString(recvBytes,0,bytes); 
  } 
  //将所读取的字符串转换为字节数组 
  byte[] content=Encoding.ASCII.GetBytes(recvStr); 
   try 
   { 
   //创建文件流对象实例 
   FileStream fs=new FileStream(fileName,FileMode.OpenOrCreate,FileAccess.ReadWrite); 
  //写入文件 
  fs.Write(content,0,content.Length); 
  } 
  catch(Exception fe) 
   { 
   MessageBox.Show("文件创建/写入错误:"+fe.Message,"提示信息",MessageBoxButtons.RetryCancel,MessageBoxIcon.Information); 
   } 
   //禁用Socket 
   socket.Shutdown(SocketShutdown.Both); 
   //关闭Socket 
   socket.Close(); 
   } 
   } 
   
   
  程序在WindowsXP中文版、.Net Frameworkd 中文正式版、Visual Studio.Net中文正式版下调试通过 
   
   
   
  关于作者 
   
  宋华，96年毕业于承德石油学院电子与电气系计算机应用专业，同年进入中国石油天然气集团公司吐哈油田工作，一直从事网络规划与建设、网站架构与设计，现专门从事Internet应用程序开发及Windows应用程序开发。 
   

Answer 2

TCP协议是一个基本的网络协议，基本上所有的网络服务都是基于TCP协议的，如HTTP,FTP等等，所以要了解网络编程就必须了解基于TCP协议的编程。然而TCP协议是一个庞杂的体系，要彻底的弄清楚它的实现不是一天两天的功夫，所幸的是在.net framework环境下，我们不必要去追究TCP协议底层的实现，一样可以很方便的编写出基于TCP协议进行网络通讯的程序。 
   
  要进行基于TCP协议的网络通讯，首先必须建立同远程主机的连接，连接地址通常包括两部分——主机名和端口，如www.yesky.com:80中，www.yesky.com就是主机名，80指主机的80端口，当然，主机名也可以用IP地址代替。当连接建立之后，就可以使用这个连接去发送和接收数据包，TCP协议的作用就是保证这些数据包能到达终点并且能按照正确的顺序组装起来。 
   
  在.net framework的类库（Class Library）中，提供了两个用于TCP网络通讯的类，分别是TcpClient和TcpListener。由其英文意义显而易见，TcpClient类是基于TCP协议的客户端类，而TcpListener是服务器端，监听(Listen)客户端传来的连接请求。TcpClient类通过TCP协议与服务器进行通讯并获取信息，它的内部封装了一个Socket类的实例，这个Socket对象被用来使用TCP协议向服务器请求和获取数据。因为与远程主机的交互是以数据流的形式出现的，所以传输的数据可以使用.net framework中流处理技术读写。在我们下边的例子中，你可以看到使用NetworkStream类操作数据流的方法。 
   
  在下面的例子中，我们将建立一个时间服务器，包括服务器端程序和客户端程序。服务器端监听客户端的连接请求，建立连接以后向客户端发送当前的系统时间。 
   
  先运行服务器端程序，下面截图显示了服务器端程序运行的状况：   然后运行客户端程序，客户端首先发送连接请求到服务器端，服务器端回应后发送当前时间到客户端，这是客户端程序的截图： 
   
   
   
  发送完成后，服务器端继续等待下一次连接： 
   
   
   
  通过这个例子我们可以了解TcpClient类的基本用法，要使用这个类，必须使用System.Net.Socket命名空间，本例用到的三个命名空间如下： 
   
  using System; 
  using System.Net.Sockets; 
  using System.Text;//从字节数组中获取字符串时使用该命名空间中的类 
   
  首先讨论一下客户端程序，开始我们必须初始化一个TcpClient类的实例： 
   
  TcpClient client = new TcpClient(hostName, portNum); 
   
  然后使用TcpClient类的GetStream()方法获取数据流，并且用它初始化一个NetworkStream类的实例： 
   
  NetworkStream ns = client.GetStream(); 
   
  注意，当使用主机名和端口号初始化TcpClient类的实例时，直到跟服务器建立了连接，这个实例才算真正建立，程序才能往下执行。如果因为网络不通，服务器不存在，服务器端口未开放等等原因而不能连接，程序将抛出异常并且中断执行。 
   
  建立数据流之后，我们可以使用NetworkStream类的Read()方法从流中读取数据，使用Write()方法向流中写入数据。读取数据时，首先应该建立一个缓冲区，具体的说，就是建立一个byte型的数组用来存放从流中读取的数据。Read()方法的原型描述如下： 
   
  public override int Read(in byte[] buffer,int offset,int size) 
   
  buffer是缓冲数组，offset是数据（字节流）在缓冲数组中存放的开始位置，size是读取的字节数目，返回值是读取的字节数。在本例中，简单地使用该方法来读取服务器反馈的信息： 
   
  byte[] bytes = new byte[1024];//建立缓冲区 
  int bytesRead = ns.Read(bytes, 0, bytes.Length);//读取字节流 
   
  然后显示到屏幕上： 
   
  Console.WriteLine(Encoding.ASCII.GetString(bytes,0,bytesRead)); 
   
  最后不要忘记关闭连接： 
   
  client.Close(); 
   
  下面是本例完整的程序清单： 
   
  using System; 
  using System.Net.Sockets; 
  using System.Text; 
   
  namespace TcpClientExample 
  { 
  public class TcpTimeClient 
  { 
  private const int portNum = 13;//服务器端口，可以随意修改 
  private const string hostName = "127.0.0.1";//服务器地址，127.0.0.1指本机 
   
  [STAThread] 
  static void Main(string[] args) 
  { 
  try 
  { 
  Console.Write("Try to connect to "+hostName+":"+portNum.ToString()+"\r\n"); 
  TcpClient client = new TcpClient(hostName, portNum); 
  NetworkStream ns = client.GetStream(); 
  byte[] bytes = new byte[1024]; 
  int bytesRead = ns.Read(bytes, 0, bytes.Length); 
   
  Console.WriteLine(Encoding.ASCII.GetString(bytes,0,bytesRead)); 
   
  client.Close(); 
  Console.ReadLine();//由于是控制台程序，故为了清楚的看到结果，可以加上这句 
   
  } 
  catch (Exception e) 
  { 
  Console.WriteLine(e.ToString()); 
  } 
  } 
  } 
  } 
   
  上面这个例子清晰地演示了客户端程序的编写要点，下面我们讨论一下如何建立服务器程序。这个例子将使用TcpListener类，在13号端口监听，一旦有客户端连接，将立即向客户端发送当前服务器的时间信息。 
   
  TcpListener的关键在于AcceptTcpClient()方法，该方法将检测端口是否有未处理的连接请求，如果有未处理的连接请求，该方法将使服务器同客户端建立连接，并且返回一个TcpClient对象，通过这个对象的GetStream方法建立同客户端通讯的数据流。事实上，TcpListener类还提供一个更为灵活的方法AcceptSocket()，当然灵活的代价是复杂，对于比较简单的程序，AcceptTcpClient()已经足够用了。此外，TcpListener类提供Start()方法开始监听，提供Stop()方法停止监听。 
   
  首先我们使用端口初始化一个TcpListener实例，并且开始在13端口监听： 
   
  private const int portNum = 13; 
  TcpListener listener = new TcpListener(portNum); 
  listener.Start();//开始监听 
   
  如果有未处理的连接请求，使用AcceptTcpClient方法进行处理，并且获取数据流： 
   
  TcpClient client = listener.AcceptTcpClient(); 
  NetworkStream ns = client.GetStream(); 
   
  然后，获取本机时间，并保存在字节数组中，使用NetworkStream.Write()方法写入数据流，然后客户端就可以通过Read()方法从数据流中获取这段信息： 
   
  byte[] byteTime = Encoding.ASCII.GetBytes(DateTime.Now.ToString()); 
  ns.Write(byteTime, 0, byteTime.Length); 
  ns.Close();//不要忘记关闭数据流和连接 
  client.Close(); 
   
  服务器端程序完整的程序清单如下： 
   
  using System; 
  using System.Net.Sockets; 
  using System.Text; 
   
   
  namespace TimeServer 
  { 
  class TimeServer 
  { 
  private const int portNum = 13; 
   
  [STAThread] 
  static void Main(string[] args) 
  { 
  bool done = false; 
  TcpListener listener = new TcpListener(portNum); 
  listener.Start(); 
  while (!done) 
  { 
  Console.Write("Waiting for connection..."); 
  TcpClient client = listener.AcceptTcpClient(); 
   
  Console.WriteLine("Connection accepted."); 
  NetworkStream ns = client.GetStream(); 
   
  byte[] byteTime = Encoding.ASCII.GetBytes(DateTime.Now.ToString()); 
   
  try 
  { 
  ns.Write(byteTime, 0, byteTime.Length); 
  ns.Close(); 
  client.Close(); 
  } 
  catch (Exception e) 
  { 
  Console.WriteLine(e.ToString()); 
  } 
  } 
   
  listener.Stop(); 
  } 
  } 
  } 
   
  把上面两段程序分别编译运行，OK，我们已经用C#实现了基于TCP协议的网络通讯，怎么样？很简单吧！ 
   
  使用上面介绍的基本方法，我们可以很容易的编写出一些很有用的程序，如FTP，电子邮件收发，点对点即时通讯等等，你甚至可以自己编制一个QQ来！ 
  （转自http://www.aspcn.com ）

Answer 3

C#是微软随着VS.net新推出的一门语言。它作为一门新兴的语言，有着C++的强健，又有着VB等的RAD特性。而且，微软推出C#主要的目的是为了对抗Sun公司的Java。大家都知道Java语言的强大功能，尤其在网络编程方面。于是，C#在网络编程方面也自然不甘落后于人。本文就向大家介绍一下C#下实现套接字（Sockets）编程的一些基本知识，以期能使大家对此有个大致了解。首先，我向大家介绍一下套接字的概念。 
  
  
 套接字基本概念： 
  
  
 套接字是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。可以将套接字看作不同主机间的进程进行双向通信的端点，它构成了单个主机内及整个网络间的编程界面。套接字存在于通信域中，通信域是为了处理一般的线程通过套接字通信而引进的一种抽象概念。套接字通常和同一个域中的套接字交换数据（数据交换也可能穿越域的界限，但这时一定要执行某种解释程序）。各种进程使用这个相同的域互相之间用Internet协议簇来进行通信。 
  
  
 套接字可以根据通信性质分类，这种性质对于用户是可见的。应用程序一般仅在同一类的套接字间进行通信。不过只要底层的通信协议允许，不同类型的套接字间也照样可以通信。套接字有两种不同的类型：流套接字和数据报套接字。 
  
  
  
  
 套接字工作原理： 
  
  
 要通过互联网进行通信，你至少需要一对套接字，其中一个运行于客户机端，我们称之为ClientSocket，另一个运行于服务器端，我们称之为ServerSocket。 
  
  
 根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：服务器监听，客户端请求，连接确认。 
  
  
 所谓服务器监听，是服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。 
  
  
 所谓客户端请求，是指由客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。 
  
  
 所谓连接确认，是指当服务器端套接字监听到或者说接收到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，连接就建立好了。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。 
  
  
 C#中的套接字编程实例： 
  
  
 通过向大家简单的介绍套接字的基本概念和实现套接字编程的基本原理，我想大家对套接字编程已有了初步的了解。不过，上面介绍的仅仅是基本概念和原理，要真正运用还是需要一定的工作的。对基本概念和原理的真正理解的最好方法莫过于自己动手做一个实例，下面我就向大家介绍一个很好的用C#实现套接字编程的实例――聊天室程序。 
  
  
 本程序是基于C/S（服务器/客户端）构架的，程序包含一个服务器端的应用程序和一个客户端的应用程序。首先，在服务器上运行服务器端的应用程序，该程序一运行就开始服务器监听。然后，在客户机上就可以打开客户端的应用程序。程序打开后可以与服务器端应用程序进行连接，即进行客户端请求。在连接确认后，客户端用户可以和其他的客户端用户进行聊天。客户端人数没有限制，同时还支持“悄悄话”聊天模式，支持聊天记录。所以这是一个学习套接字编程的相当不错的例子。而且，程序中为了处理每个客户端的信息还用到了多线程机制。在每个客户端与服务器端连接成功后，它们之间就建立一个线程。这样运用了多线程之后，客户端之间就不会相互影响，即使其中一个出了错误也不会影响到另一个。 
  
   下面，我就向大家具体介绍该实例： 
  
  
 服务器端程序： 
  
  
 1  打开VS.net，新建一个C#的模板为“Windows 应用程序”的项目，不妨命名为“ChatServer”。 
 2  布置界面。只需在界面上添加一个ListBox控件即可，该控件主要用于显示客户端的用户的一些信息的。  
 3  服务器端程序的代码编写。 
  
 对于服务器端，主要的作用是监听客户端的连接请求并确认其请求。程序一开始便打开一个StartListening（）线程。 
    
 private void StartListening()     
 { 
 listener = new TcpListener(listenport); 
 listener.Start();   
 while (true) 
 { 
 try 
 { 
 Socket s = listener.AcceptSocket(); 
 clientsocket = s; 
 clientservice = new Thread(new ThreadStart(ServiceClient)); 
 clientservice.Start(); 
 } 
 catch(Exception e) 
 { 
 Console.WriteLine(e.ToString() ); 
 } 
 } 
 } 
  
 该线程是一直处于运行状态的。当服务器端接收到一个来自客户端的连接请求后，它就打开一个ServiceClient（）线程来服务客户端。当一个连接被建立后，每个客户端就被赋予一个属于它自己的套接字。同时，一个Client类的对象被建立。该对象包含了客户端的一些相关信息，该信息被保存在一个数组列表中。Client类如下（也可参见源代码中的Client.cs文件）： 
  
  
 using System; 
 using System.Threading; 
 using System.Net.Sockets; 
 using System.Net;  namespace ChatServer 
 { /// 
  /// Client 的摘要说明。 
  /// 
 public class Client 
 { 
 private Thread clthread; 
 private EndPoint endpoint; 
 private string name; 
 private Socket sock; 
 public Client(string _name, EndPoint _endpoint, Thread _thread, Socket _sock) 
 { 
 // TODO: 在此处添加构造函数逻辑 
 clthread = _thread; 
 endpoint = _endpoint; 
 name = _name; 
 sock = _sock; 
 }  public override string ToString() 
 { 
 return endpoint.ToString()+ " : " + name; 
 }  public Thread CLThread 
 { 
 get{return clthread;} 
 set{clthread = value;} 
 } 
  
 public EndPoint Host 
 { 
 get{return endpoint;} 
 set{endpoint = value;} 
 } 
  
 public string Name 
 { 
 get{return name;} 
 set{name = value;} 
 } 
  
 public Socket Sock 
 { 
 get{return sock;} 
 set{sock = value;} 
 } 
 } 
 }    程序的主体部分应是ServiceClient（）函数。该函数是一个独立的线程，其主要部分是一个while循环。在循环体内，程序处理各种客户端命令。服务器端接收来自客户端的以ASCII码给出的字符串，其中包含了一个“|”形式的分隔符。字符串中“|”以前的部分就是具体的命令，包括CONN、CHAT、PRIV、GONE四种类型。CONN命令建立一个新的客户端连接，将现有的用户列表发送给新用户并告知其他用户有一个新用户加入。CHAT命令将新的信息发送给所有用户。PRIV命令将悄悄话发送给某个用户。GONE命令从用户列表中除去一个已离开的用户并告知其他的用户某某已经离开了。同时，GONE命令可以设置布尔型的变量keepalive为false从而结束与客户端连接的线程。ServiceClient（）函数如下： 
  
 private void ServiceClient() 
 { 
 Socket client = clientsocket; 
 bool keepalive = true; 
 while (keepalive) 
 { 
 Byte[] buffer = new Byte[1024]; 
 client.Receive(buffer); 
 string clientcommand = System.Text.Encoding.ASCII.GetString(buffer); 
 string[] tokens = clientcommand.Split(new Char[]{‘|‘}); 
 Console.WriteLine(clientcommand); 
 if (tokens[0] == "CONN") 
 { 
 for(int n=0; n )
 { 
 Client cl = (Client)clients[n]; 
 SendToClient(cl, "JOIN|" + tokens[1]); 
 } 
 EndPoint ep = client.RemoteEndPoint; 
 Client c = new Client(tokens[1], ep, clientservice, client); 
 clients.Add(c); 
 string message = "LIST|" + GetChatterList() +"\r\n"; 
 SendToClient(c, message); 
 lbClients.Items.Add(c); 
 } 
 if (tokens[0] == "CHAT") 
 { 
 for(int n=0; n 
 { 
 Client cl = (Client)clients[n]; 
 SendToClient(cl, clientcommand);   
 } 
 } 
 if (tokens[0] == "PRIV") 
 { 
 string destclient = tokens[3]; 
 for(int n=0; n 
 { 
 Client cl = (Client)clients[n]; 
 if(cl.Name.CompareTo(tokens[3]) == 0) 
 SendToClient(cl, clientcommand);   
 if(cl.Name.CompareTo(tokens[1]) == 0) 
 SendToClient(cl, clientcommand); 
 } 
 } 
（待续）

Answer 4

这个人信誉分还可以，怎么还不结？对了，CSDN的信誉分考察不对