基于C#的socket编程的TCP异步的实现代码

一、摘要

本篇阐述基于TCP通信协议的异步实现。

二、实验平台

Visual Studio 2010

三、异步通信实现原理及常用方法

3.1 建立连接 

在同步模式中,在服务器上使用Accept方法接入连接请求,而在客户端则使用Connect方法来连接服务器。相对地,在异步模式下,服务器可以使用BeginAccept方法和EndAccept方法来完成连接到客户端的任务,在客户端则通过BeginConnect方法和EndConnect方法来实现与服务器的连接。

BeginAccept在异步方式下传入的连接尝试,它允许其他动作而不必等待连接建立才继续执行后面程序。在调用BeginAccept之前,必须使用Listen方法来侦听是否有连接请求,BeginAccept的函数原型为:

BeginAccept(AsyncCallback AsyncCallback, Ojbect state)

参数:

AsyncCallBack:代表回调函数

state:表示状态信息,必须保证state中包含socket的句柄

使用BeginAccept的基本流程是:

(1)创建本地终节点,并新建套接字与本地终节点进行绑定;

(2)在端口上侦听是否有新的连接请求;

(3)请求开始接入新的连接,传入Socket的实例或者StateOjbect的实例。

参考代码:

//定义IP地址
IPAddress local = IPAddress.Parse("127.0,0,1");
IPEndPoint iep = new IPEndPoint(local,13000);
//创建服务器的socket对象
Socket server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
server.Bind(iep);
server.Listen(20);
server.BeginAccecpt(new AsyncCallback(Accept),server);

当BeginAccept()方法调用结束后,一旦新的连接发生,将调用回调函数,而该回调函数必须包括用来结束接入连接操作的EndAccept()方法。

该方法参数列表为 Socket EndAccept(IAsyncResult iar)

下面为回调函数的实例:

void Accept(IAsyncResult iar)
{
 //还原传入的原始套接字
 Socket MyServer = (Socket)iar.AsyncState;
 //在原始套接字上调用EndAccept方法,返回新的套接字
 Socket service = MyServer.EndAccept(iar);
}

至此,服务器端已经准备好了。客户端应通过BeginConnect方法和EndConnect来远程连接主机。在调用BeginConnect方法时必须注册相应的回调函数并且至少传递一个Socket的实例给state参数,以保证EndConnect方法中能使用原始的套接字。下面是一段是BeginConnect的调用:

Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp)
IPAddress ip=IPAddress.Parse("127.0.0.1");
IPEndPoint iep=new IPEndPoint(ip,13000);
socket.BeginConnect(iep, new AsyncCallback(Connect),socket);

EndConnect是一种阻塞方法,用于完成BeginConnect方法的异步连接诶远程主机的请求。在注册了回调函数后必须接收BeginConnect方法返回的IASynccReuslt作为参数。下面为代码演示:

void Connect(IAsyncResult iar)
{
 Socket client=(Socket)iar.AsyncState;
 try
 {
  client.EndConnect(iar);
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
 finally
 {

 }
}

除了采用上述方法建立连接之后,也可以采用TcpListener类里面的方法进行连接建立。下面是服务器端对关于TcpListener类使用BeginAccetpTcpClient方法处理一个传入的连接尝试。以下是使用BeginAccetpTcpClient方法和EndAccetpTcpClient方法的代码:

public static void DoBeginAccept(TcpListener listner)
{
 //开始从客户端监听连接
 Console.WriteLine("Waitting for a connection");
 //接收连接
 //开始准备接入新的连接,一旦有新连接尝试则调用回调函数DoAcceptTcpCliet
 listner.BeginAcceptTcpClient(new AsyncCallback(DoAcceptTcpCliet), listner);
}

//处理客户端的连接
public static void DoAcceptTcpCliet(IAsyncResult iar)
{
 //还原原始的TcpListner对象
 TcpListener listener = (TcpListener)iar.AsyncState;

 //完成连接的动作,并返回新的TcpClient
 TcpClient client = listener.EndAcceptTcpClient(iar);
 Console.WriteLine("连接成功");
}

代码的处理逻辑为:

(1)调用BeginAccetpTcpClient方法开开始连接新的连接,当连接视图发生时,回调函数被调用以完成连接操作;

(2)上面DoAcceptTcpCliet方法通过AsyncState属性获得由BeginAcceptTcpClient传入的listner实例;

(3)在得到listener对象后,用它调用EndAcceptTcpClient方法,该方法返回新的包含客户端信息的TcpClient。

BeginConnect方法和EndConnect方法可用于客户端尝试建立与服务端的连接,这里和第一种方法并无区别。下面看实例:

public void doBeginConnect(IAsyncResult iar)
{
 Socket client=(Socket)iar.AsyncState;
 //开始与远程主机进行连接
 client.BeginConnect(serverIP[0],13000,requestCallBack,client);
 Console.WriteLine("开始与服务器进行连接");
}
private void requestCallBack(IAsyncResult iar)
{
 try
 {
  //还原原始的TcpClient对象
  TcpClient client=(TcpClient)iar.AsyncState;
  //
  client.EndConnect(iar);
  Console.WriteLine("与服务器{0}连接成功",client.Client.RemoteEndPoint);
 }
 catch(Exception e)
 {
  Console.WriteLine(e.ToString());
 }
 finally
 {

 }
}

以上是建立连接的两种方法。可根据需要选择使用。

3.2 发送与接受数据

在建立了套接字的连接后,就可以服务器端和客户端之间进行数据通信了。异步套接字用BeginSend和EndSend方法来负责数据的发送。注意在调用BeginSend方法前要确保双方都已经建立连接,否则会出异常。下面演示代码:

private static void Send(Socket handler, String data)
{
 // Convert the string data to byte data using ASCII encoding.
 byte[] byteData = Encoding.ASCII.GetBytes(data);
 // Begin sending the data to the remote device.
 handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar)
{
 try
 {
  // Retrieve the socket from the state object.
  Socket handler = (Socket)ar.AsyncState;
  // Complete sending the data to the remote device.
  int bytesSent = handler.EndSend(ar);
  Console.WriteLine("Sent {0} bytes to client.", bytesSent);
  handler.Shutdown(SocketShutdown.Both);
  handler.Close();
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
}

接收数据是通过BeginReceive和EndReceive方法:

private static void Receive(Socket client)
{
 try
 {
  // Create the state object.
  StateObject state = new StateObject();
  state.workSocket = client;
  // Begin receiving the data from the remote device.
  client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
}
private static void ReceiveCallback(IAsyncResult ar)
{
 try
 {
  // Retrieve the state object and the client socket
  // from the asynchronous state object.
  StateObject state = (StateObject)ar.AsyncState;
  Socket client = state.workSocket;
  // Read data from the remote device.
  int bytesRead = client.EndReceive(ar);
  if (bytesRead > 0)
  {
   // There might be more data, so store the data received so far.  

   state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
   // Get the rest of the data.
   client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
  }
  else
  {
   // All the data has arrived; put it in response.
   if (state.sb.Length > 1)
   {
    response = state.sb.ToString();
   }
   // Signal that all bytes have been received.
   receiveDone.Set();
  }
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
}

上述代码的处理逻辑为:

(1)首先处理连接的回调函数里得到的通讯套接字client,接着开始接收数据;

(2)当数据发送到缓冲区中,BeginReceive方法试图从buffer数组中读取长度为buffer.length的数据块,并返回接收到的数据量bytesRead。最后接收并打印数据。

除了上述方法外,还可以使用基于NetworkStream相关的异步发送和接收方法,下面是基于NetworkStream相关的异步发送和接收方法的使用介绍。

NetworkStream使用BeginRead和EndRead方法进行读操作,使用BeginWreite和EndWrete方法进行写操作,下面看实例:

static void DataHandle(TcpClient client)
{
 TcpClient tcpClient = client;
 //使用TcpClient的GetStream方法获取网络流
 NetworkStream ns = tcpClient.GetStream();
 //检查网络流是否可读
 if(ns.CanRead)
 {
 //定义缓冲区
 byte[] read = new byte[1024];
 ns.BeginRead(read,0,read.Length,new AsyncCallback(myReadCallBack),ns);
 }
 else
 {
 Console.WriteLine("无法从网络中读取流数据");
 }
}

public static void myReadCallBack(IAsyncResult iar)
{
 NetworkStream ns = (NetworkStream)iar.AsyncState;
 byte[] read = new byte[1024];
 String data = "";
 int recv;

 recv = ns.EndRead(iar);
 data = String.Concat(data, Encoding.ASCII.GetString(read, 0, recv));

 //接收到的消息长度可能大于缓冲区总大小,反复循环直到读完为止
 while (ns.DataAvailable)
 {
  ns.BeginRead(read, 0, read.Length, new AsyncCallback(myReadCallBack), ns);
 }
 //打印
 Console.WriteLine("您收到的信息是" + data);
}

3.3 程序阻塞与异步中的同步问题

.Net里提供了EventWaitHandle类来表示一个线程的同步事件。EventWaitHandle即事件等待句柄,他允许线程通过操作系统互发信号和等待彼此的信号来达到线程同步的目的。这个类有2个子类,分别为AutoRestEevnt(自动重置)和ManualRestEvent(手动重置)。下面是线程同步的几个方法:

(1)Rset方法:将事件状态设为非终止状态,导致线程阻塞。这里的线程阻塞是指允许其他需要等待的线程进行阻塞即让含WaitOne()方法的线程阻塞;

(2)Set方法:将事件状态设为终止状态,允许一个或多个等待线程继续。该方法发送一个信号给操作系统,让处于等待的某个线程从阻塞状态转换为继续运行,即WaitOne方法的线程不在阻塞;

(3)WaitOne方法:阻塞当前线程,直到当前的等待句柄收到信号。此方法将一直使本线程处于阻塞状态直到收到信号为止,即当其他非阻塞进程调用set方法时可以继续执行。

public static void StartListening()
{
 // Data buffer for incoming data.
 byte[] bytes = new Byte[1024];
 // Establish the local endpoint for the socket.
 // The DNS name of the computer
 // running the listener is "host.contoso.com".
 //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
 //IPAddress ipAddress = ipHostInfo.AddressList[0];
 IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
 IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
 // Create a TCP/IP socket.
 Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
 // Bind the socket to the local
 //endpoint and listen for incoming connections.
 try
 {
  listener.Bind(localEndPoint);
  listener.Listen(100);
  while (true)
  {
   // Set the event to nonsignaled state.
   allDone.Reset();
   // Start an asynchronous socket to listen for connections.
   Console.WriteLine("Waiting for a connection...");
   listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
   // Wait until a connection is made before continuing.
   allDone.WaitOne();
  }
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
 Console.WriteLine("\nPress ENTER to continue...");
 Console.Read();
}

上述代码的逻辑为:

(1)试用了ManualRestEvent对象创建一个等待句柄,在调用BeginAccept方法前使用Rest方法允许其他线程阻塞;

(2)为了防止在连接完成之前对套接字进行读写操作,务必要在BeginAccept方法后调用WaitOne来让线程进入阻塞状态。

当有连接接入后系统会自动调用会调用回调函数,所以当代码执行到回调函数时说明连接已经成功,并在函数的第一句就调用Set方法让处于等待的线程可以继续执行。

四、实例

下面是一个实例,客户端请求连接,服务器端侦听端口,当连接建立之后,服务器发送字符串给客户端,客户端收到后并回发给服务器端。

服务器端代码:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
// State object for reading client data asynchronously
public class StateObject
{
 // Client socket.
 public Socket workSocket = null;
 // Size of receive buffer.
 public const int BufferSize = 1024;
 // Receive buffer.
 public byte[] buffer = new byte[BufferSize];
 // Received data string.
 public StringBuilder sb = new StringBuilder();
}
public class AsynchronousSocketListener
{
 // Thread signal.
 public static ManualResetEvent allDone = new ManualResetEvent(false);
 public AsynchronousSocketListener()
 {
 }
 public static void StartListening()
 {
  // Data buffer for incoming data.
  byte[] bytes = new Byte[1024];
  // Establish the local endpoint for the socket.
  // The DNS name of the computer
  // running the listener is "host.contoso.com".
  //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
  //IPAddress ipAddress = ipHostInfo.AddressList[0];
  IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
  IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
  // Create a TCP/IP socket.
  Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
  // Bind the socket to the local
  //endpoint and listen for incoming connections.
  try
  {
   listener.Bind(localEndPoint);
   listener.Listen(100);
   while (true)
   {
    // Set the event to nonsignaled state.
    allDone.Reset();
    // Start an asynchronous socket to listen for connections.
    Console.WriteLine("Waiting for a connection...");
    listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
    // Wait until a connection is made before continuing.
    allDone.WaitOne();
   }
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
  Console.WriteLine("\nPress ENTER to continue...");
  Console.Read();
 }
 public static void AcceptCallback(IAsyncResult ar)
 {
  // Signal the main thread to continue.
  allDone.Set();
  // Get the socket that handles the client request.
  Socket listener = (Socket)ar.AsyncState;
  Socket handler = listener.EndAccept(ar);
  // Create the state object.
  StateObject state = new StateObject();
  state.workSocket = handler;
  handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
 }
 public static void ReadCallback(IAsyncResult ar)
 {
  String content = String.Empty;
  // Retrieve the state object and the handler socket
  // from the asynchronous state object.
  StateObject state = (StateObject)ar.AsyncState;
  Socket handler = state.workSocket;
  // Read data from the client socket.
  int bytesRead = handler.EndReceive(ar);
  if (bytesRead > 0)
  {
   // There might be more data, so store the data received so far.
   state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
   // Check for end-of-file tag. If it is not there, read
   // more data.
   content = state.sb.ToString();
   if (content.IndexOf("<EOF>") > -1)
   {
    // All the data has been read from the
    // client. Display it on the console.
    Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);
    // Echo the data back to the client.
    Send(handler, content);
   }
   else
   {
    // Not all data received. Get more.
    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
   }
  }
 }
 private static void Send(Socket handler, String data)
 {
  // Convert the string data to byte data using ASCII encoding.
  byte[] byteData = Encoding.ASCII.GetBytes(data);
  // Begin sending the data to the remote device.
  handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
 }
 private static void SendCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the socket from the state object.
   Socket handler = (Socket)ar.AsyncState;
   // Complete sending the data to the remote device.
   int bytesSent = handler.EndSend(ar);
   Console.WriteLine("Sent {0} bytes to client.", bytesSent);
   handler.Shutdown(SocketShutdown.Both);
   handler.Close();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 public static int Main(String[] args)
 {
  StartListening();
  return 0;
 }
}

客户端代码:

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
// State object for receiving data from remote device.
public class StateObject
{
 // Client socket.
 public Socket workSocket = null;
 // Size of receive buffer.
 public const int BufferSize = 256;
 // Receive buffer.
 public byte[] buffer = new byte[BufferSize];
 // Received data string.
 public StringBuilder sb = new StringBuilder();
}
public class AsynchronousClient
{
 // The port number for the remote device.
 private const int port = 11000;
 // ManualResetEvent instances signal completion.
 private static ManualResetEvent connectDone = new ManualResetEvent(false);
 private static ManualResetEvent sendDone = new ManualResetEvent(false);
 private static ManualResetEvent receiveDone = new ManualResetEvent(false);
 // The response from the remote device.
 private static String response = String.Empty;
 private static void StartClient()
 {
  // Connect to a remote device.
  try
  {
   // Establish the remote endpoint for the socket.
   // The name of the
   // remote device is "host.contoso.com".
   //IPHostEntry ipHostInfo = Dns.Resolve("user");
   //IPAddress ipAddress = ipHostInfo.AddressList[0];
   IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
   IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
   // Create a TCP/IP socket.
   Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
   // Connect to the remote endpoint.
   client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
   connectDone.WaitOne();
   // Send test data to the remote device.
   Send(client, "This is a test<EOF>");
   sendDone.WaitOne();
   // Receive the response from the remote device.
   Receive(client);
   receiveDone.WaitOne();
   // Write the response to the console.
   Console.WriteLine("Response received : {0}", response);
   // Release the socket.
   client.Shutdown(SocketShutdown.Both);
   client.Close();
   Console.ReadLine();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void ConnectCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the socket from the state object.
   Socket client = (Socket)ar.AsyncState;
   // Complete the connection.
   client.EndConnect(ar);
   Console.WriteLine("Socket connected to {0}", client.RemoteEndPoint.ToString());
   // Signal that the connection has been made.
   connectDone.Set();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void Receive(Socket client)
 {
  try
  {
   // Create the state object.
   StateObject state = new StateObject();
   state.workSocket = client;
   // Begin receiving the data from the remote device.
   client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void ReceiveCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the state object and the client socket
   // from the asynchronous state object.
   StateObject state = (StateObject)ar.AsyncState;
   Socket client = state.workSocket;
   // Read data from the remote device.
   int bytesRead = client.EndReceive(ar);
   if (bytesRead > 0)
   {
    // There might be more data, so store the data received so far.  

    state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
    // Get the rest of the data.
    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
   }
   else
   {
    // All the data has arrived; put it in response.
    if (state.sb.Length > 1)
    {
     response = state.sb.ToString();
    }
    // Signal that all bytes have been received.
    receiveDone.Set();
   }
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void Send(Socket client, String data)
 {
  // Convert the string data to byte data using ASCII encoding.
  byte[] byteData = Encoding.ASCII.GetBytes(data);
  // Begin sending the data to the remote device.
  client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
 }
 private static void SendCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the socket from the state object.
   Socket client = (Socket)ar.AsyncState;
   // Complete sending the data to the remote device.
   int bytesSent = client.EndSend(ar);
   Console.WriteLine("Sent {0} bytes to server.", bytesSent);
   // Signal that all bytes have been sent.
   sendDone.Set();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 public static int Main(String[] args)
 {
  StartClient();
  return 0;
 }
}

五、实验结果

图1 服务器端界面
图2 客户端界面

时间: 2016-11-08

Android使用socket创建简单TCP连接的方法

本文实例讲述了Android使用socket创建简单TCP连接的方法.分享给大家供大家参考,具体如下: 不管是在Java还是Android编程中,通信都是及其重要的一部分.有连接的socket编程,重要性自然毋庸置疑. 这里以一个简单的demo演示一个最基本的socket编程. 先写服务端.服务端是Java代码.笔者懒得装eclipse等编程软件,就是直接notepad编程,dos运行的.服务端一般是新建一个绑定端口的serversocket,监听客户端请求(死循环监听).当接收到客户端消息时,

Python实现TCP协议下的端口映射功能的脚本程序示例

1 端口映射 举个例子来说明一下端口映射的作用. 有A.B.C三台计算机,A.B互通,B.C互通,但是A.C不通,这个时候在C上开了一个Web服务,如何让A访问C的Web服务? 最简单有效的办法就是在B上开一个端口映射服务,然后让A访问B的某个端口,B将这个端口上的所有流量全部转发到C的Web服务端口上,同时将C上Web服务返回的流量也全部转发给A.这样对A来说,以B为跳板,实现了间接访问C上Web服务的目的. 2 实现流程 端口映射的原理并不复杂,本文以TCP为例介绍一下实现过程,简单画了个时

Python实现TCP/IP协议下的端口转发及重定向示例

首先,我们用webpy写一个简单的网站,监听8080端口,返回"Hello, EverET.org"的页面. 然后我们使用我们的forwarding.py,在80端口和8080端口中间建立两条通信管道用于双向通信. 此时,我们通过80端口访问我们的服务器. 浏览器得到: 然后,我们在forwarding.py的输出结果中可以看到浏览器和webpy之间的通信内容. 代码: #!/usr/bin/env python import sys, socket, time, threading

linux抵御DDOS攻击 通过iptables限制TCP连接和频率

cc攻击一到就有点兵临城下的感觉,正确的设置防护规则可以做到临危不乱,这里给出一个iptables对ip进行连接频率和并发限制,限制单ip连接和频率的设置规则的介绍 #单个IP在60秒内只允许新建20个连接,这里假设web端口就是80, 复制代码 代码如下: iptables -I  INPUT -i eth1 -p tcp -m tcp –dport 80 -m state –state NEW -m recent –update –seconds 60 –hitcount 20 –name

Python简单实现TCP包发送十六进制数据的方法

本文实例讲述了Python简单实现TCP包发送十六进制数据的方法.分享给大家供大家参考,具体如下: 举例: 0x12, 0x34可以直接拼成 "\x12\x34". 客户端代码示例: #-*- encoding: utf-8 -*- import json import socket import sys import binascii reload(sys) sys.setdefaultencoding('utf-8') if __name__=="__main__&quo

C++ boost::asio编程-同步TCP详解及实例代码

boost::asio编程-同步TCP boost.asio库是一个跨平台的网络及底层IO的C++编程库,它使用现代C++手法实现了统一的异步调用模型. boost.asio库支持TCP.UDP.ICMP通信协议. 下面介绍同步TCP模式: 大家好!我是同步方式! 我的主要特点就是执着!所有的操作都要完成或出错才会返回,不过偶的执着被大家称之为阻塞,实在是郁闷~~(场下一片嘘声),其实这样 也是有好处的,比如逻辑清晰,编程比较容易. 在服务器端,我会做个socket交给acceptor对象,让它

Java Socket编程实例(四)- NIO TCP实践

一.回传协议接口和TCP方式实现: 1.接口: import java.nio.channels.SelectionKey; import java.io.IOException; public interface EchoProtocol { void handleAccept(SelectionKey key) throws IOException; void handleRead(SelectionKey key) throws IOException; void handleWrite(

C#基于TCP协议的服务器端和客户端通信编程的基础教程

运行在TCP之上常见的网络应用协议有比如HTTP.FTP.SMTP.POP3.IMAP. TCP是TCP/IP体系中最重要的传输协议,它提供全双工和可靠交付的服务,是大多数应用协议工作的基础. TCP是一种面向连接(连接导向)的,可靠的,基于字节流的传输层通信协议. TCP的工作过程 建立连接 传输数据 连接的终止 TCP的主要特点 1.TCP是面向连接的协议 2.是端到端的通信.每个TCP连接只能有两个端点,而且只能一对一通信,不能点对多的 的直接通信 3.高可靠性 4.全双工方式传输 5.数

C++ boost::asio编程-异步TCP详解及实例代码

C++ boost::asio编程-异步TCP 大家好,我是异步方式 和同步方式不同,我从来不花时间去等那些龟速的IO操作,我只是向系统说一声要做什么,然后就可以做其它事去了.如果系统完成了操作, 系统就会通过我之前给它的回调对象来通知我. 在ASIO库中,异步方式的函数或方法名称前面都有"async_ " 前缀,函数参数里会要求放一个回调函数(或仿函数).异步操作执行 后不管有没有完成都会立即返回,这时可以做一些其它事,直到回调函数(或仿函数)被调用,说明异步操作已经完成. 在ASI

linux下2个检查tcp连接的命令

1 检测web服务器的链接数量及状态: netstat -ant|awk '{print $5 "\t" $6}'|grep "::ffff:"|sed -e 's/::ffff://' -e 's/:[0-9]*//' |sort|uniq -c| sort -rn|head -10 结果: 122 125.162.71.199 TIME_WAIT 99 79.119.125.43 TIME_WAIT 81 125.167.243.77 TIME_WAIT 75

Java Socket编程实例(三)- TCP服务端线程池

一.服务端回传服务类: import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.util.logging.Level; import java.util.logging.Logger; public class EchoProtocol implements Runnable { private static f

java实现一个简单TCPSocket聊天室功能分享

本文实例为大家分享了java实现TCPSocket聊天室功能的相关代码,供大家参考,具体内容如下 1.TCPserver.java import java.net.*; import java.io.*; import java.util.*; import java.util.concurrent.*; public class TCPserver{ private static final int SERVERPORT = 8888; private ServerSocket MyServe

nodejs实现的一个简单聊天室功能分享

今天我来实现一个简单的聊天室,后台用nodejs, 客户端与服务端通信用socket.io,这是一个比较成熟的websocket框架. 初始工作 1.安装express, 用这个来托管socket.io,以及静态页面,命令npm install express --save,--save可以使包添加到package.json文件里. 2.安装socket.io,命令npm install socket.io --save. 编写服务端代码 首先我们通过express来托管网站,并附加到socke

ASP建立一个简单的聊天室

经过一个阶段的asp学习,下面我们结合所学过的内容建立一个最简单的聊天室,虽然很简单,但是大家可以通过它来掌握一个聊天室建立的基本过程,并且可以不断的完善其功能. 下面介绍其主要步骤: 1,添加Global.asa文件里面的代码.这部分代码主要处理Application_onStart事件,在此事件中,定义了一个有15个元素的数据,并把它赋给了一个Application对象的属性.Global.asa文件的内容如下. <SCRIPT LANGUAGE="VBScript" RUN

Java SE实现多人聊天室功能

本文实例为大家分享了Java SE实现多人聊天室功能的具体代码,供大家参考,具体内容如下 实现功能: 1.实现用户注册上线,下线 2.实现群聊和私聊功能 3.实现统计当前在线人数 实现思路: 1.首先,要实现服务端与客户端之间的连接 这里是使用套接字建立TCP连接: (1)服务器端先实例化一个描述服务器端口号的ServerSocket对象 (2)客户端要创建Socket对象来连接指定的服务器端 (3)服务器端调用ServerSocket类的accept()方法来监听连接到服务器端的客户端信息 (

java编程实现多人聊天室功能

本文实例为大家分享了java实现多人聊天室的具体代码,供大家参考,具体内容如下 程序源代码及运行截图: server.java //server.java package Socket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; impor

js编写简单的聊天室功能

这个聊天室写的特别简易,比较适合刚开始学习js的同学借鉴,当然,写的不好,也希望诸位大神可以进行批评改正. 聊天室要求: 1.不能发空消息 2.敏感字***显示 3.图片替换 开心,尴尬 4.显示聊天内容和时间 5.每发一条信息,随机显示名称,先把一些名称定义到array里面 <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> &

Android编写简单的聊天室应用

最近写了一个简单的聊天室应用,可以发送表情,更改头像这些功能.主要技术点就是怎样把表情图片放到textview等Ui控件中展示.这里废话不多说,下面是效果图: 这里主要讲下怎样把文本替换到表情,先说下思路,首先我们的图片是保存在本地资源目录drawable中而所有的资源文件都是R这个类来管理,所以我们可以利用正则表达式找出图片id包装成ImageSpan然后把ImageSpan放到SpannableString中,最后把SpannableString放入edittext中,下面是源码: pack

用PHP+MySQL搭建聊天室功能实例代码

下面,以一个简单的聊天室设计为例,介绍PHP+MySQL在网页开发中的应用 1.总体设计 1.1 构思与规划: 聊天室的基本原理,就是把每个连上同一网页的用户传送的发言数据储存起来,然后将所有的发言数据传给每一用户.也就是说,用数据库汇集每个人的发言,并将数据库中的数据传给每一个人就实现了聊天室的功能. 1.2 表设计 首先使用MySQL建立表chat用来储存用户的发言: 复制代码 代码如下: mysql> CREATE TABLE chat -> (chtime DATATIME, ->

Python实现基于C/S架构的聊天室功能详解

本文实例讲述了Python实现基于C/S架构的聊天室功能.分享给大家供大家参考,具体如下: 一.课程介绍 1.简介 本次项目课是实现简单聊天室程序的服务器端和客户端. 2.知识点 服务器端涉及到asyncore.asynchat和socket这几个模块,客户端用到了telnetlib.wx.time和thread这几个模块. 3.所需环境 本次课中编写客户端需要用到wxPython,它是一个GUI工具包,请先使用下面的命令安装: $ sudo apt-get install python-wxt

Java基于UDP协议实现简单的聊天室程序

最近比较闲,一直在抽空回顾一些Java方面的技术应用. 今天没什么事做,基于UDP协议,写了一个非常简单的聊天室程序. 现在的工作,很少用到socket,也算是对Java网络编程方面的一个简单回忆. 先看一下效果: 实现的效果可以说是非常非常简单,但还是可以简单的看到一个实现原理.  "聊天室001"的用户,小红和小绿相互聊了两句,"聊天室002"的小黑无人理会,在一旁寂寞着. 看一下代码实现: 1.首先是消息服务器的实现,功能很简单: •将客户端的信息(进入了哪一