Socket通信简介

　　第一次做CS的程序，关于socket的，通过各种资料的搜索，其实我觉得说白了主要就分为：

　　1、套结的关键字。

　　2、服务器和客户机的远程通信。

　　3、消息的处理。

　　服务器原理：

//把ip地址转换为实例
                IPAddress ipa = IPAddress.Parse("127.0.0.1");
                //监听端口8001
                TcpListener mylsn = new TcpListener(ipa, 8001);
                //开启监听
                mylsn.Start();
                //输出监听成功的信息
                Console.WriteLine("在8001启动服务，等待连接");
                //等待处理接入连接请求
                while (true)
                {
                    Socket mysock = mylsn.AcceptSocket();
                    Console.WriteLine("有连接，连接来自" + mysock.RemoteEndPoint);
                    work w = new work();
                    w.mysock = mysock;
                    w.mylsn = mylsn;
                    Thread t = new Thread(new ThreadStart(w.main));
                    t.Start();
                }

　　class类：

class work
    {
        public Socket mysock;
        public TcpListener mylsn;
        public void main()
        {
            //接收客户端消息
            byte[] data = new byte[100];
            mysock.Receive(data);
            string rt = System.Text.UTF8Encoding.UTF8.GetString(data);
            Console.WriteLine(rt);
            //给客户端发消息
            mysock.Send(UTF8Encoding.UTF8.GetBytes("server callback"));
            //释放资源
            mysock.Close();
            mylsn.Stop();
        }
    }

　　客户机原理：

int port = 8001;
                string host = "127.0.0.1";
                //创建终结点EndPoint
                IPAddress ip = IPAddress.Parse(host);
                IPEndPoint ipe = new IPEndPoint(ip, port);   //把ip和端口转化为IPEndPoint的实例

                //创建Socket并连接到服务器
                Socket c = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);   //  创建Socket
                Console.WriteLine("Connecting...");
                c.Connect(ipe); //连接到服务器

                //向服务器发送信息
                string sendStr = "Hello,this is a socket test";
                byte[] bs = Encoding.ASCII.GetBytes(sendStr);   //把字符串编码为字节

                Console.WriteLine("Send message");
                c.Send(bs, bs.Length, 0); //发送信息

                //接受从服务器返回的信息
                string recvStr = "";
                byte[] recvBytes = new byte[1024];
                int bytes;
                bytes = c.Receive(recvBytes, recvBytes.Length, 0);    //从服务器端接受返回信息
                recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);
                Console.WriteLine("client get message:{0}", recvStr);    //回显服务器的返回信息

                Console.ReadLine();
                //一定记着用完Socket后要关闭
                c.Close();

　　命名空间：System.Net和System.Net.Sockets(通信) System.IO(消息字节处理)

　　到这里，我想通信已经完整的建立了，但是有些小朋友肯定会问，这只是一个简单的客户机和主机的联系，那么，一个主机，N个客户机，又是怎么回事呢，

　　服务器原理：

    private TcpListener myListener;
    myListener = new TcpListener(localAddress, port);
    myListener.Start();

    service.AddItem(string.Format("开始在{0}:{1}监听客户端连接", localAddress, port));
    //创建一个线程监听客户端连接请求
    ThreadStart ts = new ThreadStart(ListenClientConnect);//委托
    Thread myThread = new Thread(ts);
    myThread.Start();
    
    
     private void ListenClientConnect()
        {
            while (true)
            {
                TcpClient newClient = null;
                try
                {
                    //等待用户进入
                    newClient = myListener.AcceptTcpClient();
                }
                catch
                {
                    //当单击“停止监听”或者退出此窗体时AcceptTcpClient()会产生异常
                    //因此可以利用此异常退出循环
                    break;
                }
                //每接受一个客户端连接，就创建一个对应的线程循环接收客户端发来的信息
                ParameterizedThreadStart pts = new ParameterizedThreadStart(ReceiveData);//委托
                Thread threadReceive = new Thread(pts);
                User user = new User(newClient);
                threadReceive.Start(user);
                userList.Add(user);
                service.AddItem(string.Format("{0}进入", newClient.Client.RemoteEndPoint));
                service.AddItem(string.Format("当前连接用户数：{0}", userList.Count));
            }
        }
    
     private void ReceiveData(object obj)
        {
            User user = (User)obj;
            TcpClient client = user.client;
            //是否正常退出接收线程
            bool normalExit = false;
            //用于控制是否退出循环
            bool exitWhile = false;
            while (exitWhile == false)
            {
                //当前要传送的数据
                string receiveString = null;
                try
                {
                    receiveString = user.sr.ReadLine();
                }
                catch (Exception ex)
                {
                    //该客户底层套接字不存在时会出现异常
                    service.AddItem("接收数据失败，原因：" + ex.Message);
                }
                //TcpClient 对象将套接字进行了封装，如果TcpClient对象关闭了，
                //但是底层套接字未关闭，并不产生异常，但是读取的结果为 null
                if (receiveString == null)
                {
                    if (normalExit == false)
                    {
                        //如果停止了监听，Connected 为 false
                        if (client.Connected == true)
                        {
                            service.AddItem(string.Format("与{0}失去联系，已停止接收该用户信息",
                                client.Client.RemoteEndPoint));
                        }
                    }
                    //退出循环
                    break;
                }
                service.AddItem(string.Format("来自{0}:{1}", user.userName, receiveString));
                string[] splitString = receiveString.Split(',');
                string command = splitString[0].ToLower();
                //获取当前传送的数据
                switch (command)
                {
                    default:
                        service.SendToAll(userList, "要发送的数据");
                        break;
                }
            }
            userList.Remove(user);
            client.Close();
            service.AddItem(string.Format("有一个退出，剩余连接用户数：{0}", userList.Count));
        }

　　Service类：

class Service
    {
        private ListBox listbox;
        private delegate void AddItemDelegate(string str);
        private AddItemDelegate addItemDelegate;
        public Service(ListBox listbox)
        {
            this.listbox = listbox;
            addItemDelegate = new AddItemDelegate(AddItem);
        }

        /// <summary>
        /// 在listbox中追加信息
        /// </summary>
        /// <param name="str">要追加的信息</param>
        public void AddItem(string str)
        {
            if (listbox.InvokeRequired)
                listbox.Invoke(addItemDelegate, str);
            else
            {
                listbox.Items.Add(str);
                listbox.SelectedIndex = listbox.Items.Count - 1;
                listbox.ClearSelected();
            }
        }

        /// <summary>
        /// 向某个客户端发送信息
        /// </summary>
        /// <param name="user">指定客户</param>
        /// <param name="str">信息</param>
        public void SendToOne(User user, string str)
        {
            try
            {
                user.sw.WriteLine(str);
                user.sw.Flush();
                AddItem(string.Format("向{0}发送{1}", user.userName, str));
            }
            catch (Exception ex)
            {
                AddItem(string.Format("向{0}发送消息失败，原因：{1}", user.userName, ex.Message));
            }
        }


        /// <summary>
        /// 向所有客户端发送信息
        /// </summary>
        /// <param name="userList">客户列表</param>
        /// <param name="str">信息</param>
        public void SendToAll(List<User> userList, string str)
        {
            for (int i = 0; i < userList.Count; i++)
            {
                SendToOne(userList[i], str);
            }
        }
    }

　　客户机组（list）类：

 /// <summary>
    /// 客户机
    /// </summary>
    class User
    {
        public TcpClient client { get; set; }
        public StreamReader sr { get; private set; }
        public StreamWriter sw { get; private set; }
        public string userName { get; set; }
        public User(TcpClient client)
        {
            this.client = client;
            this.userName = "";
            NetworkStream netStream = client.GetStream();
            sr = new StreamReader(netStream, Encoding.UTF8);
            sw = new StreamWriter(netStream, Encoding.UTF8);
        }
    }

　　其实，现在呢，就是把整个客户机放到一个list里面，而listbox只是为了单纯的显示消息而已

　　客户机原理：

        private TcpClient client = null;
        private StreamWriter sw;
        private StreamReader sr;
        private Service service;
        //是否正常退出接收线程
        private bool normalExit = false;
        
        /// <summary>
        /// 连接服务器
        /// </summary>
        private void GetService()
        {
            try
            {
                client = new TcpClient();
                //服务器IP
                client.Connect(IPAddress.Parse(ConfigurationManager.AppSettings["IP"]), int.Parse(ConfigurationManager.AppSettings["Port"]));
                //获取网络流
                NetworkStream netStream = client.GetStream();
                sr = new StreamReader(netStream, System.Text.Encoding.UTF8);
                sw = new StreamWriter(netStream, System.Text.Encoding.UTF8);
                //信息基本提示
                service = new Service(listBox1, sw);
                //给服务器消息
                service.SendToServer("success");
                //数据处理(服务器消息)
                Thread threadReceive = new Thread(new ThreadStart(ReceiveData));
                threadReceive.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show("与服务器连接失败，原因:" + ex.Message, "提示",
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

        }
        /// <summary>
        /// 接受服务器端的消息
        /// </summary>
        private void ReceiveData()
        {
            bool exitWhile = false;
            while (exitWhile == false)
            {
                string receiveString = null;
                try
                {
                    receiveString = sr.ReadLine();
                }
                catch
                {
                    service.AddItemToListBox("接收数据失败");
                }
                if (receiveString == null)
                {
                    if (normalExit == false)
                    {
                        MessageBox.Show("与服务器失去联系！");
                    }
                    //结束线程
                    break;
                }
                service.AddItemToListBox("收到：" + receiveString);
                string[] splitString = receiveString.Split(',');
                string command = splitString[0].ToLower();
                switch (command)
                {
                    default:
                        GetControl(command);//这里的GetControl是一个处理值的方法，
                        this.Invalidate();
                        break;
                }
            }
            Application.Exit();
        }

　　客户机Service类：

    class Service
    {
        ListBox listbox;
        StreamWriter sw;
        public Service(ListBox listbox, StreamWriter sw)
        {
            this.listbox = listbox;
            this.sw = sw;
        }
        /// <summary>向服务器发送数据</summary>
        public void SendToServer(string str)
        {
            try
            {
                sw.WriteLine(str);
                sw.Flush();
            }
            catch
            {
                AddItemToListBox("发送数据失败");
            }
        }
        delegate void ListBoxDelegate(string str);
        /// <summary>在listbox中追加信息<</summary>
        /// <param name="str">要追加的信息</param>
        public void AddItemToListBox(string str)
        {
            try
            {
                if (listbox.InvokeRequired)
                {
                    ListBoxDelegate d = AddItemToListBox;
                    listbox.Invoke(d, str);
                }
                else
                {
                    listbox.Items.Add(str);
                    listbox.SelectedIndex = listbox.Items.Count - 1;
                    listbox.ClearSelected();
                }
            }
            catch
            {

            }
        }
    }

　　这就是一个完整的socket了，第一次做，肯定很多没有想到的地方，希望大神及时提出宝贵意见。