c# 网络异步编程

            异步接收客户端连接BeginAcceptTcpClient

   像之前的listener.AcceptTcpClient();的方法，这个是同步方法，意思是当没有客户端连接的时候，这个方法就一直等待。

那么异步方法就是listener.BeginAcceptTcpClient()。这个方法不管有没有客户端连接。都继续执行下去，也就是

不会阻塞当前的线程。

使用异步方法接收客户连接的话，需要定义一个AsyncCallback委托方法，因为异步方法是采用通知的方式接收客户端连接

。

也就是当有一个客户端连接的时候，AsyncCallback委托的方法就会被执行。当然我这里同步异步只是举个例子，

不光是接收客户端连接有异步同步方法。客户连接也有异步BeginConnect方法。但是好像同步方法Connect不会等待啊，像之前的例子。

其实那也只是服务端没开启罢了。如果由于网络速度的原因，连接服务端比较慢的话。那么就可以看得出Connect它是在等待了。

再来看看AsyncCallback委托的定义：

public delegate void AsyncCallback(IAsyncResult ar);

使用异步连接话，那么我们就得定义一个上面那样的方法，IAsyncResult表示异步操作的状态，储存着一些信息。

如 ar.AsyncState储存着一个object，它通过BeginAcceptTcpClient方法的第二个参数state传进来的。

AcceptTcpClient和BeginAcceptTcpClient的使命都是一样的，获得一个客户端连接，如果有一个客户端连接了，那么这个方法也就结束了。AcceptTcpClient这个方法就直接返回客户端对象TcpClient，那么BeginAcceptTcpClient是通过调用EndAcceptTcpClient方法来获取TcpClient的。这个表明一个异步调用结束了。

异步调用结束是在一个客户端连接的时候。因为只有当有客户端连接的时候，回调函数才会被执行。也才会执行EndAcceptTcpClient

所以在回调函数中，调用EndAcceptTcpClient结束异步调用后，如果想再等待下一个客户端连接,必须再次调用BeginAcceptTcpClient方法。就像同步的一样，一个AcceptTcpClient对应着一个客户端，如果想连接第二个客户端，就得再次调用AcceptTcpClient。

来看一个例子吧，把上面的理论用例子来证明。

服务端代码：
using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.NET;

using System.Net.Sockets;

namespace ServerConls

{

    public class Server

    {

        //这个方法被执行，就表明有一个客户端要连接了。

        public static void AcpClientCallback(IAsyncResult ar)

        {

            TcpListener listener = (TcpListener)ar.AsyncState;

            //调用对应的方法EndAcceptTcpClient，获得连接的客户端TcpClient

            TcpClient client=listener.EndAcceptTcpClient(ar);

            //输出客户端信息

            Console.WriteLine("一个客户端连接上了，客户端信息:{0}", client.Client.RemoteEndPoint);

            //再接收一个客户端连接

            AsyncCallback callback = new AsyncCallback(AcpClientCallback);

            listener.BeginAcceptTcpClient(callback, listener);

        }

        public static void Main()

        {

            //绑定IP，监听端口

            IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });

            TcpListener listener = new TcpListener(ip, 9372);

            listener.Start();

            //委托方法

            AsyncCallback callback = new AsyncCallback(AcpClientCallback);

            //接收客户端连接,异步

            listener.BeginAcceptTcpClient(callback, listener);

            //循环输出一些信息

            int i = 0;

            while (true)

            {

                i++;

                Console.WriteLine("输出一些信息:{0}",i);

                //睡眠1.5秒

                System.Threading.Thread.Sleep(1500);

            }

        }

   

    }

     

}

客户端代码：
using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Net;

using System.Net.Sockets;

namespace ClientConls

{

    class Program

    {

        static void Main(string[] args)

        {

            TcpClient client;

            //三个客户端连接

            for (int i = 0; i < 3; i++)

            {

                client = new TcpClient();

                client.Connect("localhost", 9372);

                //睡眠3秒

                System.Threading.Thread.Sleep(3000);

            }

        }

    }

}

这就是异步的好处，如果是同步的话，等待连接的时候，是不能再做其它事情的，也就不能一边输出信息，一边等待连接了。

异步读取数据

套路跟上面的差不多，定义一个委托方法，在里面调用对应的EndRead方法结束异步调用。直接看例子吧

服务端代码：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Net;

using System.Net.Sockets;

namespace ServerConls

{

    public class Server

    {

        public static byte[] buffer = new byte[800];

        public static TcpClient client;

        // 客户端有数据发送过来，就会调用这个方法

        public static void ReadCallback(IAsyncResult ar)

        {

            NetworkStream Stream = (NetworkStream)ar.AsyncState;

            //结束异步读取方法,返回值是读取了多少字节

            int bytesRead = Stream.EndRead(ar);

            String msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);

            Console.WriteLine("\n从{0}上来发来信息：{1}", client.Client.RemoteEndPoint, msg);

            //这次读取BeginRead结束，继续下一次读取

            Stream.BeginRead(buffer, 0, 800, ReadCallback, Stream);

        }

        public static void Main()

        {

            //绑定IP，监听端口

            IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });

            TcpListener listener = new TcpListener(ip, 9372);

            listener.Start();

            //等待一个客户端连接

            client = listener.AcceptTcpClient();

            Console.WriteLine("已经连接到一个客户端！");

            NetworkStream Stream = client.GetStream();

            //异步读取数据

            Stream.BeginRead(buffer, 0, 800, ReadCallback, Stream);

            byte[] sendBuffer;

            //发送数据

            while (true)

            {

                String msg = Console.ReadLine();

                sendBuffer = Encoding.Unicode.GetBytes(msg);

                Stream.Write(sendBuffer, 0, sendBuffer.Length);

            }

        }

    }

客户端代码：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Net;

using System.Net.Sockets;

namespace ClientConls

{

    class Program

    {

        public static byte[] buffer = new byte[800];

        public static TcpClient client;

        //服务端有数据发送过来，就会执行这个方法。

        public static void ReadCallback(IAsyncResult ar)

        {

            NetworkStream Stream = (NetworkStream)ar.AsyncState;

            //结束异步读取方法,返回值是读取了多少字节

            int bytesRead = Stream.EndRead(ar);

            String msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);

            Console.WriteLine("\n从{0}上来发来信息：{1}", client.Client.RemoteEndPoint, msg);

            //这次读取BeginRead结束，继续下一次读取

            Stream.BeginRead(buffer, 0, 800, ReadCallback, Stream);

        }

        static void Main(string[] args)

        {

          //连接服务端

          client = new TcpClient();

          client.Connect("localhost", 9372);

          NetworkStream Stream = client.GetStream();

          //异步读取数据

          Stream.BeginRead(buffer, 0, 800, ReadCallback, Stream);

          byte[] sendBuffer;

          //发送数据

          while (true)

          {

              String msg = Console.ReadLine();

              sendBuffer = Encoding.Unicode.GetBytes(msg);

              Stream.Write(sendBuffer, 0, sendBuffer.Length);

          }

        }

    }

}

 客户端有服务端都是采用异步读取数据的，这样双方发送数据，就可以不按一定的顺序来，可以随时发送。如果是同步的话，那就得按固定的发送接收步骤来了。

异步读取数据的方式，很符合聊天软件的需要。

网络异常处理

网络编程异步处理是很有必要的，比如客户端连接服务端，如果服务端没启动的话，就会产生异常，程序就会非正常结束。如果用异常处理的话，可以规定客户端按自己方式来处理，比如服务端没有开启的话，给用户一个选择，是否重新连接，或者做其它的事，这样也不致于让程序就结束了。

我们先来看一个简单的例子，这个例子实现了当客户端关闭的时候，服务端会给出一个提示，提示客户端已关闭。

客户端：

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Net;

using System.Net.Sockets;

namespace ClientConls

{

    class Program

    {

        static void Main(string[] args)

        {

            TcpClient client = new TcpClient();

            //连接服务端

            client.Connect("localhost", 9372);

            Console.ReadLine();

            client.Close();

        }

    }

}

服务端：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Net;

using System.Net.Sockets;

namespace ServerConls

{

    class Program

    {

        static void Main(string[] args)

        {

            //绑定IP，监听端口

            IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });

            TcpListener listener = new TcpListener(ip, 9372);

            listener.Start();

            TcpClient remoteClient = listener.AcceptTcpClient();

            Console.WriteLine("一个客户端连接了：{0}", remoteClient.Client.RemoteEndPoint);

            //获取数据流

            NetworkStream Stream = remoteClient.GetStream();

            byte[] buffer = new byte[800];

            while (true)

            {

                if (Stream.Read(buffer, 0, 800) == 0)

                {

                    Console.WriteLine("与客户端失去连接：{0}", remoteClient.Client.RemoteEndPoint);

                    break;

                }

            }

            Console.ReadLine();

         

        }

    }

}

上面的例子是在理想的状态下，先开启服务端，然后运行客户端。最后在客户端的控制台下窗口输入几个字符，执行client.Close();语句，那么服务端的Stream.Read就会返回0，从而给出与客户端失去连接的提示。

但如果直接关闭了客户端控制台窗口，服务端的Stream.Read就会产生异常，程序崩溃了。避免这个问题，当然得用异常处理try catch了。

看修改后的例子：

处理服务端异常，检查客户端连接状态

客户端代码同上，不变。

服务端代码：

  class Program

    {

        static void Main(string[] args)

        {

            //绑定IP，监听端口

            IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });

            TcpListener listener = new TcpListener(ip, 9372);

            listener.Start();

            TcpClient remoteClient = listener.AcceptTcpClient();

            Console.WriteLine("一个客户端连接了：{0}", remoteClient.Client.RemoteEndPoint);

            //获取数据流

            NetworkStream Stream = remoteClient.GetStream();

            byte[] buffer = new byte[800];

            while (true)

            {

                try

                {

                    if (Stream.Read(buffer, 0, 800) == 0)

                    {

                        Console.WriteLine("与客户端失去连接：{0}", remoteClient.Client.RemoteEndPoint);

                        break;

                    }

                }

                catch(Exception e)

                {

                    //Connected连接状态为假

                    if (remoteClient.Connected == false)

                        Console.WriteLine("异常中:与客户端失去连接：{0}", remoteClient.Client.RemoteEndPoint);

                    else

                        Console.WriteLine(e.Message);

                }

                 finally

                {

                    //释放资源

                    Stream.Dispose();

                     break;

                }

            }

            Console.ReadLine();

        }

}

那么用try catch解决服务端没开启的问题也是一样，捕捉client.Connect("localhost", 9372);这个语句的异常，然后处理。

另外关于等待客户端连接，读取数据什么的也可以用多线程来实现。这样灵活性就增加了许多。这里就不具体举例了，自己可以去琢磨。