利用TCP协议实现通信

 

Socket的TCP通讯

一、 socket的通讯原理

服务器端的步骤如下。

（1）建立服务器端的Socket，开始侦听整个网络中的连接请求。

（2）当检测到来自客户端的连接请求时，向客户端发送收到连接请求的信息，并建立与客户端之间的连接。

（3）当完成通信后，服务器关闭与客户端的Socket连接。

客户端的步骤如下。

（1）建立客户端的Socket，确定要连接的服务器的主机名和端口。

（2）发送连接请求到服务器，并等待服务器的回馈信息。

（3）连接成功后，与服务器进行数据的交互。

（4）数据处理完毕后，关闭自身的Socket连接。

二、 socket的通讯方式

socket通讯方式有两种：同步和异步

同步工作方式:

用TCP协议进行编程时程序执行到发送、接收和监听语句的时候，在未完成工作前不再继续往下执行，即处于阻塞状态，直到该语句完成某个工作后才继续执行下一条语句。

异步工作方式

程序执行到发送、接收和监听语句的时候，不论工作是否完成，都会继续往下执行。

三、 socket的C#实现

1. 1.      同步： 

服务端客户端通信

在与服务端的连接建立以后，我们就可以通过此连接来发送和接收数据。端口与端口之间以流（Stream）的形式传输数据，因为几乎任何对象都可以保存到流中，所以实际上可以在客户端与服务端之间传输任何类型的数据。对客户端来说，往流中写入数据，即为向服务器传送数据；从流中读取数据，即为从服务端接收数据。对服务端来说，往流中写入数据，即为向客户端发送数据；从流中读取数据，即为从客户端接收数据。

 

服务端： 

（1）服务端对端口进行侦听：

服务器端建立一个socket，设置好本机的ip和监听的端口与socket进行绑定，开始监听连接请求，当接收到连接请求后，发送确认，同客户端建立连接，开始与客户端进行通信。

TcpListener listener =new TcpListener(new IPEndPoint(IPAddress.Parse(ip), port));//ip为服务器IP地址，port为监听的端口

Listener.Start();//开启监听

(2)检测来自客户端的连接请求

TcpClient remoteClient = listener.AcceptTcpClient();

//接收客户端  这里体现了同步的含义，如果客户端对该服务端发起连接的时候，程序在这里就会等待（阻塞），直到有客户端的连接请求为止

(3)建立和连接的客户端的数据流（传输数据）

NetworkStream streamToClient = remoteClient.GetStream();

该数据流只要是用来接收和发送数据，同步也分多客户端和单个客户端，如果分的详细一点的话，还有客户端的一条以及多条数据的情况，如果是单个客户端的多条数据的话，连接客户端之后，在建立数据流的前面添加一个循环就可以了，如果是多个客户端的话，在（2）前面加个循环就可以了。为了接收数据的效率，建议不管是同步还是异步，服务端都做成线程，详细见Demo

(4)接收客户端发送过来的数据（用缓存来接收）

byte[] buffer = new byte[BufferSize];  // BufferSize为缓存的大小

 

 int bytesRead;

 

 try

 

 {

 

    lock (streamToClient)//为了保证数据的完整性以及安全性  锁定数据流

 

     {

 

         bytesRead = streamToClient.Read(buffer, 0, BufferSize);

 

}

(5)向连接的客户端发送数据

lock (streamToClient)

 

                      {

 

                      streamToClient.Write(buffer, 0, buffer.Length);//buffer为发送的字符数组                  

 

}

      (6)释放数据流和TcpClient（以便下次的数据以及客户端的收发）

streamToClient.Dispose();//释放数据流中的数据

 

              remoteClient.Close();//释放TcpClient实例

客户端 

（1）   连接服务器

TcpClient tcp = new TcpClient();

 

 

 

tcp.Connect(IP,Port);//根据服务器的IP地址和侦听的端口连接

 

if (tcp.Connected)

 

{

 

//连接成功的消息机制  详细见DEMO

 

ShowGetData("成功连接上了服务器：", this.strIP.Text.ToString());

 

 }

这里需要注意的是，不管是使用有参数的构造函数与服务器连接，或者是通过Connect()方法与服务器建立连接，都是同步方法（或者说是阻塞的，英文叫block）。它的意思是说，客户端在与服务端连接成功、从而方法返回，或者是服务端不存、从而抛出异常之前，是无法继续进行后继操作的。这里还有一个名为BeginConnect()的方法，用于实施异步的连接，这样程序不会被阻塞，可以立即执行后面的操作，这是因为可能由于网络拥塞等问题，连接需要较长时间才能完成。网络编程中有非常多的异步操作，凡事都是由简入难，关于异步操作，我们后面再讨论，现在只看同步操作。

（2）   建立连接服务端的数据流

NetworkStream streamToServer = tcp.GetStream();

（3）   接收和发送数据

//发送字符串

 

        byte[] buffer = Encoding.Unicode.GetBytes(msg); //msg为发送的字符串  

 

        try

 

          {

 

             lock (streamToServer)

 

            {

 

            streamToServer.Write(buffer, 0, buffer.Length);     // 发往服务器

 

             }

 

 

 

          //接收字符串

 

               buffer = new byte[BufferSize];

 

               lock (streamToServer)

 

            {

 

               bytesRead = streamToServer.Read(buffer, 0, BufferSize);

 

            }

 

}

1. 2.      异步 

        相对于同步，异步中的连接，接收和发送数据的方法都不一样，都有一个回调函数，就是即使不能连接或者接收不到数据，程序还是会一直执行下去，如果连接上了或者接到数据，程序会回到这个回调函数的地方重新往下执行。详细见下面：

服务器：

1、 开启侦听接口

private TcpListener listener;               //监听类

 

listener = new TcpListener(new IPEndPoint(IPAddress.Parse(ip), port));

 

listener.Start();//开启侦听，对连接的客户端的数目没有限制

 

或者

 

listener.Start(int i);// 开启侦听，最多只能连接i个客户端数目

2、 接收客户端

                    listener.BeginAcceptSocket(clientConnect, listener);//异步接受客户端的连接请求  clientConnect为连接的回调函数

 

 

/// <summary>

 

        /// 接收回调函数

 

        /// </summary>

 

        /// <param name="ar"></param>

 

        private void clientConnect(IAsyncResult ar)

 

        {

 

            try

 

            {

 

                TcpListener listener = (TcpListener)ar.AsyncState;

 

                //接受客户的连接,得到连接的Socket

 

                Socket client = listener.EndAcceptSocket(ar);

 

 

 

            }

 

            catch { }

 

        }

3、 接收客户端发送的数据

/// <summary>

 

        /// 异步接收数据

 

        /// </summary>

 

        private void receiveData(Socket client)

 

        {

 

                // 调用异步方法 BeginReceive 来告知 socket 如何接收数据

 

                IAsyncResult iar = client.BeginReceive(buffer, 0, BagSize, SocketFlags.None, out errorCode, receiveCallback, buffer);

            }

     }

 

 

 

        /// <summary>

 

        /// 接收数据回调函数

 

        /// </summary>

 

        /// <param name="ar"></param>

 

        private void receiveCallback(IAsyncResult ar)

 

        {         

 

                //接收到的数据长度．

 

                int receLen = 0;

 

                try

 

                {

 

                    receLen = client.EndReceive(ar, out errorCode);               

 

if (receLen > 0)

 

                    {

 

                        OnReceiveData(client);//接收到数据之后的处理函数

 

                    }

 

                }

 

                catch {     }

            }

 

            else { }

 

        }

 

4、接收成功之后，回发数据给客户端

/// <summary>

 

        /// 异步发送报文

 

        /// </summary>

 

        /// <param name="data"></param>

 

        private void OnReceiveData (Socket socket)

 

        {

 

string strLogin = “succeed recived”;

 

byte[] data = Encoding.ASCII.GetBytes(strLogin);

 

         socket.BeginSend(data, 0, data.Length, SocketFlags.None, out errorCode, sendCallBack, socket);//异步发送数据

 

            }

 

            else

 

            { }

 

        }

 

/// <summary>

 

        /// 异步发送回调事件

 

        /// </summary>

 

        /// <param name="ar"></param>

 

        private void sendCallBack(IAsyncResult ar)

 

        {

 

socket.EndSend(ar, out errorCode);

 

          }

客户端 

1、连接服务器

private TcpClient tcpcz = null

 

         tcpcz = new TcpClient()

 

    tcpcz.BeginConnect(ipaddress, Convert.ToInt32(port), new AsyncCallback(ConnectCallback), tcpcz);//根据服务器的IP地址和端口号 异步连接服务器

 

 

        /// <summary>

 

        /// 异步连接的回调函数

 

        /// </summary>

 

        /// <param name="ar"></param>

 

        private void ConnectCallback(IAsyncResult ar)

 

        {

 

            TcpClient t = (TcpClient)ar.AsyncState;

 

            try

 

            {

 

                if (t.Connected)

 

                {

 

                    t.EndConnect(ar);//函数运行到这里就说明连接成功

 

                }

 

                else

 

                {

 

                }

 

            }

 

            catch () {    }

        }

2、发送和接收字符串

              

NetworkStream stream = tcp.GetStream();//创建于服务器连接的数据流

 

 

 

                  //发送字符串

 

                  string strLogin = “this is socket example”;

 

             byte[] data = Encoding.ASCII.GetBytes(strLogin);

 

          stream.BeginWrite(data, 0, data.Length, new AsyncCallback(SendCallback),stream);//异步发送数据

 

                  //接收字符串

 

                byte[] result = new byte[tcp.Available]; // tcp.Available为接受的字符串大小

                  try

                  {

 

                      stream.BeginRead(result, 0, result.Length, new AsyncCallback(ReadCallback), stream);//异步接受服务器回报的字符串

 

                  }

                  catch { }

                  string strResponse = Encoding.ASCII.GetString(result).Trim();//从服务器接受到的字符串

 

              }

 

          }

          catch ()

          {

          }

      }

以上是这一段时间对socket的一些心得，还在不断学习中，如果上面的讲解有什么不到位的或者错误的，可以交流一下

注：该文转自http://www.cnblogs.com/jamesping/articles/2071932.html

看了文章，写了一个小程序，Client能够获取Server的时间，利用了TCP协议实现了通信

客户端：

using System;
using System.Net.Sockets;
using System.Text;

namespace Client
{
    class Program
    {
        private const int portNum = 13;  //服务器端口
        private const string hostName = "192.168.1.120";  //服务器地址
        [STAThread ]

        static void Main(string[] args)
        {
            try
            {
                Console.Write("Try to contect to " + hostName + ":" + portNum.ToString() + "
");
                TcpClient client = new TcpClient(hostName, portNum);
                //从Tcpclient中获取网络流对象
                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());
            }
        }
    }
}

服务器：

using System;
using System.Net.Sockets;
using System.Text;

namespace Server
{
    class Program
    {
        private const int portNum = 13;  //服务器端口
        [STAThread]

        static void Main(string[] args)
        {
            bool done = false;
            TcpListener lisener = new TcpListener(portNum);
            lisener.Start();
            while (!done)
            {
                Console.Write("Waiting for connection...        ");
                //等待客户端连接
                TcpClient client = lisener.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());
                }
            }
            lisener.Stop();
        }
    }
}

本人菜鸟，刚刚接触C#，一点一滴，滴水穿石。