TCP Socket_C#

服务端代码（Server.cs）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.Net;

namespace socket
{
    class Server
    {
        // 通知一个或多个正在等待的线程已发生事件。
        ManualResetEvent manager = new ManualResetEvent(false);
        ManualResetEvent reviceManager = new ManualResetEvent(false);

        // 负责监听的套接字
        private Socket socketServer;

        /// <summary>
        /// 启动服务
        /// </summary>
        public void CreateSocketService()
        {
            try
            {
                // 获取IP
                var address =  IPAddress.Parse("127.0.0.1");
                // 创建一个包含ip port 的网络节点对象
                Int32 Port = 12306;
                var ipPoint = new IPEndPoint(address, Port);
                // 创建一个套接字socket,参数(IP4寻址协议,流式连接,使用TCP协议传输数据)
                socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                // 将负责监听的套接字绑定到唯一的IP和端口上
                socketServer.Bind(ipPoint);
                // 设置监听队列的长度，同时100个队列
                socketServer.Listen(100);
                // 线程开始监听客户端的请求
                Thread threadService = new Thread(StartSocketService);
                // 设置线程为后台线程
                threadService.IsBackground = true;
                // 启动线程
                threadService.Start();
                // 显示消息
                ShowMsg("服务器监听开启成功!");
            }
            catch (Exception e)
            {
                ShowMsg(e.Message);
            }
        }

        /// <summary>
        /// 启动服务监听
        /// </summary>
        //private void StartSocketService()
        public void StartSocketService()
        {
            while (true)
            {
                try
                {
                    // 将事件状态设置为非终止状态，导致线程阻止
                    manager.Reset();
                    // 开始监听客户端的连接请求
                    var args = new SocketAsyncEventArgs();
                    args.Completed += args_Completed;
                    socketServer.AcceptAsync(args);
                    // 阻止当前线程，直到当前 WaitHandle 收到信号。
                    manager.WaitOne();
                }
                catch (Exception ex)
                {
                    ShowMsg(ex.Message);
                    break;
                }
            }
        }

        public void args_Completed(object sender, SocketAsyncEventArgs e)
        {
            // 监听完成客户端的请求,一但监听到返回新的套接字
            var clientSocket = e.AcceptSocket;
            // 启动线程获取客户端发来的消息
            if (clientSocket == null) return;
            // 这部分为接收消息
            var t = new Thread(GetClientMsg);
            // 设置线程为后台线程
            t.IsBackground = true;
            // 启动线程
            t.Start(clientSocket);
            // 显示信息
            ShowMsg(clientSocket.RemoteEndPoint + "上线了");
            // 将事件状态设置为终止状态，允许一个或多个等待线程继续
            manager.Set();
        }              

        void ShowMsg(string message)
        {
            // 显示消息
             //txtConneMsg.AppendText("\r\n" + DateTime.Now + "\r\n\r\n" + message + "\r\n");
             Console.WriteLine("\r\n" + DateTime.Now + "\r\n\r\n" + message + "\r\n");
        }

        private void GetClientMsg(object socket)
        {
            var socketClient = socket as Socket;
            if (socketClient == null) return;
            while (true)
            {
                try
                {
                    reviceManager.Reset();
                    var bytes = new byte[1024 * 1024 * 4];
                    var receiveArgs = new SocketAsyncEventArgs();
                    //设置缓冲区
                    receiveArgs.SetBuffer(bytes, 0, bytes.Length);
                    receiveArgs.Completed += receiveArgs_Completed;
                    //开始异步接收
                    socketClient.ReceiveAsync(receiveArgs);
                    reviceManager.WaitOne();
                }
                catch (Exception ex)
                {
                    //显示异常消息
                    ShowMsg(ex.Message);
                }
            }
        }

        void receiveArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            var socketClient = sender as Socket;
            var bytes = e.Buffer;
            ShowMsg(socketClient.RemoteEndPoint + "说:" + System.Text.Encoding.UTF8.GetString(bytes));
            reviceManager.Set();
        }

    }
}

客户端代码（Client.cs）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.Net;

namespace socket
{
    class Client
    {
        private Socket socketClient;  // 客户端套接字
        private Thread threadClient;  // 客户端线程

        /// <summary>
        /// 创建套接字连接到服务端
        /// </summary>
        //private void CreateSocketConnection()
        public void CreateSocketConnection()
        {
            try
            {
                // 创建一个客户端的套接字 参数(IP4寻址协议,流连接方式,TCP数据传输协议)
                socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                // 获取IP
                IPAddress address = IPAddress.Parse("127.0.0.1");
                //创建一个包含IP和端口号的网络节点对象
                Int32 Port = 12306;
                IPEndPoint ipPoint = new IPEndPoint(address, Port);
                // 连接服务端
                socketClient.Connect(ipPoint);
                // 创建一个线程,接受服务端发来的数据
                threadClient = new Thread(ReceiveService);
                // 设置线程为后台线程
                threadClient.IsBackground = true;
                // 启动线程连接服务端
                threadClient.Start();
                // 显示消息
                ShowMsg("与服务器" + address.ToString() + ":" + Port.ToString() + "成功建立连接！");

            }
            catch (Exception)
            {
                ShowMsg( "服务器未启动！");
            }
        }

        //private void ReceiveService()
        public void ReceiveService()
        {
            while (true)
            {
                try
                {
                    var b = new byte[1024 * 1024 * 4];
                    int length = socketClient.Receive(b);
                    var msg = System.Text.Encoding.UTF8.GetString(b, 0, length);
                    ShowMsg(socketClient.RemoteEndPoint.ToString() + "对您: " + msg);
                }
                catch (Exception ex)
                {
                    ShowMsg(ex.Message);
                    break;
                }
            }
        }

        public void ShowMsg(string msg)
        {
            //txtConneMsg.AppendText("\r\n" + DateTime.Now + "\r\n\r\n" + msg + "\r\n");
            Console.WriteLine("\r\n" + DateTime.Now + "\r\n\r\n" + msg + "\r\n");
        }

        /// <summary>
        /// 发送数据到服务端
        /// </summary>
        public void Send()
        {
            if (socketClient == null)
            {

                ShowMsg("服务器未启动！");
                return;
            }
            //byte[] b = System.Text.Encoding.UTF8.GetBytes(txtSend.Text.Trim());
            string txtSend = "Hello";
            byte[] b = System.Text.Encoding.UTF8.GetBytes(txtSend);
            // 客户端向服务器发送消息
            socketClient.Send(b);
            //清空文本
            ShowMsg("您对" + socketClient.RemoteEndPoint.ToString() + "说：" + txtSend);
            txtSend = "";
        }
        
    }
}

异步模式（SocketExtension.cs）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;

namespace SocketAsyncOpWithTimeOut
{
    public static class SocketExtension
    {

        public static int EndReceive2(IAsyncResult ar)
        {
            var result = ar as AsyncResultWithTimeout;
            result.AsyncWaitHandle.WaitOne();

            return result.ReceivedCount;
        }

        public static AsyncResultWithTimeout BeginReceive2
        (
            this Socket socket,
            int timeout,
            byte[] buffer,
            int offset,
            int size,
            SocketFlags flags,
            AsyncCallback callback,
            object state
        )
        {
            var result = new AsyncResultWithTimeout(callback, state);

            var stateInfo = new StateInfo(result, socket);

            socket.BeginReceive(buffer, offset, size, flags, ReceiveCb, state);

            var registeredWaitHandle =
                ThreadPool.RegisterWaitForSingleObject(
                    result.AsyncWaitHandle,
                    WatchTimeOut,
                    stateInfo, // 作为state传递给WatchTimeOut
                    timeout,
                    true);

            // stateInfo中保存RegisteredWaitHandle，以方便在WatchTimeOut
            // 中unregister.
            stateInfo.RegisteredWaitHandle = registeredWaitHandle;

            return result;
        }

        private static void WatchTimeOut(object state, bool timeout)
        {
            var stateInfo = state as StateInfo;
            // 设置的timeout前，操作未完成，则设置为操作Timeout
            if (timeout)
            {
                stateInfo.AsycResult.SetTimeout();
            }

            // 取消之前注册的WaitOrTimerCallback
            stateInfo.RegisteredWaitHandle.Unregister(
                stateInfo.AsycResult.AsyncWaitHandle);
        }

        private static void ReceiveCb(IAsyncResult result)
        {
            var state = result.AsyncState as StateInfo;
            var asyncResultWithTimeOut = state.AsycResult;
            var count = state.Socket.EndReceive(result);
            state.AsycResult.SetResult(count);
        }
    }


    public class StateInfo
    {
        public StateInfo(AsyncResultWithTimeout result, Socket socket)
        {
            this.AsycResult = result;
            this.Socket = socket;
        }

        public Socket Socket { get; private set; }
        public AsyncResultWithTimeout AsycResult { get; private set; }
        public RegisteredWaitHandle RegisteredWaitHandle { get; set; }
    }

    public class AsyncResultWithTimeout : IAsyncResult
    {
        private ManualResetEvent m_waitHandle = new ManualResetEvent(false);
        public AsyncResultWithTimeout(AsyncCallback cb, object state)
        {
            this.AsyncState = state;
            this.Callback = cb;
        }

        #region IAsyncResult

        public object AsyncState { get; private set; }
        public WaitHandle AsyncWaitHandle { get { return m_waitHandle; } }
        public bool CompletedSynchronously { get { return false; } }
        public bool IsCompleted { get; private set; }

        #endregion

        public AsyncCallback Callback { get; private set; }
        public int ReceivedCount { get; private set; }
        public bool TimedOut { get; private set; }
        public void SetResult(int count)
        {
            this.IsCompleted = true;
            this.ReceivedCount = count;
            this.m_waitHandle.Set();

            if (Callback != null) Callback(this);
        }

        public void SetTimeout()
        {
            this.TimedOut = true;
            this.IsCompleted = true;
            this.m_waitHandle.Set();
        }
    }
}

异步模式测试代码（Program.cs）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;

namespace SocketAsyncOpWithTimeOut
{
    public static class SocketExtension
    {

        public static int EndReceive2(IAsyncResult ar)
        {
            var result = ar as AsyncResultWithTimeout;
            result.AsyncWaitHandle.WaitOne();

            return result.ReceivedCount;
        }

        public static AsyncResultWithTimeout BeginReceive2
        (
            this Socket socket,
            int timeout,
            byte[] buffer,
            int offset,
            int size,
            SocketFlags flags,
            AsyncCallback callback,
            object state
        )
        {
            var result = new AsyncResultWithTimeout(callback, state);

            var stateInfo = new StateInfo(result, socket);

            socket.BeginReceive(buffer, offset, size, flags, ReceiveCb, state);

            var registeredWaitHandle =
                ThreadPool.RegisterWaitForSingleObject(
                    result.AsyncWaitHandle,
                    WatchTimeOut,
                    stateInfo, // 作为state传递给WatchTimeOut
                    timeout,
                    true);

            // stateInfo中保存RegisteredWaitHandle，以方便在WatchTimeOut
            // 中unregister.
            stateInfo.RegisteredWaitHandle = registeredWaitHandle;

            return result;
        }

        private static void WatchTimeOut(object state, bool timeout)
        {
            var stateInfo = state as StateInfo;
            // 设置的timeout前，操作未完成，则设置为操作Timeout
            if (timeout)
            {
                stateInfo.AsycResult.SetTimeout();
            }

            // 取消之前注册的WaitOrTimerCallback
            stateInfo.RegisteredWaitHandle.Unregister(
                stateInfo.AsycResult.AsyncWaitHandle);
        }

        private static void ReceiveCb(IAsyncResult result)
        {
            var state = result.AsyncState as StateInfo;
            var asyncResultWithTimeOut = state.AsycResult;
            var count = state.Socket.EndReceive(result);
            state.AsycResult.SetResult(count);
        }
    }


    public class StateInfo
    {
        public StateInfo(AsyncResultWithTimeout result, Socket socket)
        {
            this.AsycResult = result;
            this.Socket = socket;
        }

        public Socket Socket { get; private set; }
        public AsyncResultWithTimeout AsycResult { get; private set; }
        public RegisteredWaitHandle RegisteredWaitHandle { get; set; }
    }

    public class AsyncResultWithTimeout : IAsyncResult
    {
        private ManualResetEvent m_waitHandle = new ManualResetEvent(false);
        public AsyncResultWithTimeout(AsyncCallback cb, object state)
        {
            this.AsyncState = state;
            this.Callback = cb;
        }

        #region IAsyncResult

        public object AsyncState { get; private set; }
        public WaitHandle AsyncWaitHandle { get { return m_waitHandle; } }
        public bool CompletedSynchronously { get { return false; } }
        public bool IsCompleted { get; private set; }

        #endregion

        public AsyncCallback Callback { get; private set; }
        public int ReceivedCount { get; private set; }
        public bool TimedOut { get; private set; }
        public void SetResult(int count)
        {
            this.IsCompleted = true;
            this.ReceivedCount = count;
            this.m_waitHandle.Set();

            if (Callback != null) Callback(this);
        }

        public void SetTimeout()
        {
            this.TimedOut = true;
            this.IsCompleted = true;
            this.m_waitHandle.Set();
        }
    }
}

百度Tcp包测试代码（TestSocketTcp.cs）

        #region Test Socket.Tcp

        private static void TestSocketTcp()
        {
            // 取得预保存的文件名 
            string fileName = "test.txt"; 
            // 远程主机 
            string hostName = "www.baidu.com"; 
            // 端口 
            int port = Int32.Parse("80"); 
            // 得到主机信息 
            IPHostEntry ipInfo = Dns.GetHostEntry(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) 
            { 
                Console.WriteLine("连接错误" + se.Message);
            } 
            // 发送给远程主机的请求内容串 
            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) 
            { 
                Console.WriteLine("发送错误:" + ce.Message);
            } 
            // 声明接收返回内容的字符串 
            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) 
            { 
                Console.WriteLine("文件创建/写入错误:"+ fe.Message);
            } 
            // 禁用Socket 
            socket.Shutdown(SocketShutdown.Both); 
            // 关闭Socket 
            socket.Close();
        }
        #endregion

 

参考文献：

http://www.cnblogs.com/gaobing/p/3860127.html

http://blog.csdn.net/hartkevin/article/details/5220536

http://www.csharpwin.com/csharpspace/13263r8436.shtml