套接字编程实现信息传输

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

namespace TcpServer
{
    class Program
    {
        static void Main(string[] args)
        {
            Server server = new Server();
            server.StartUp();

            while(true)
            {
                string str = Console.ReadLine();
                server.SendAll(str);
            }
        }
    }

    public class Server
    {
        //配置相关
        private string _ip = "192.168.30.16";
        private int _port = 10000;
        //服务器套接字
        private Socket _server;
        //接受客户端连接的线程，因为Accept是一个阻塞线程的方法，而且此方法还需要循环执行
        private Thread _acceptClientConnectThread;
        //所有已经连接的客户端
        private List<Socket> _clientList = new List<Socket>();

        /// <summary>
        /// 启动服务器 = 建立流式套接字 + 配置本地地址
        /// </summary>
        public void StartUp()
        {
            try
            {
                //建立套接字 ， 寻址方案，套接字类型，协议类型
                _server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //_server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

                //配置本地地址
                EndPoint endPoint = new IPEndPoint(GetIpv4(NetworkInterfaceType.Ethernet), _port);
                _server.Bind(endPoint);
                //监听和接受客户端请求
                _server.Listen(30);
                //开启一个接受连接的线程
                _acceptClientConnectThread = new Thread(AcceptClientConnect);
                _acceptClientConnectThread.Start();

                Console.WriteLine("{0}:{1} StartUp...", _ip, _port);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

        /// <summary>
        /// 接受客户端连接
        /// </summary>
        public void AcceptClientConnect()
        {
            while(true)
            {
                try
                {
                    //接受客户端连接
                    Socket clientSocket = _server.Accept();
                    //维护一个客户端在线列表
                    _clientList.Add(clientSocket);

                    //获取客户端的网络地址标识
                    IPEndPoint clientEndPoint = clientSocket.RemoteEndPoint as IPEndPoint;
                    //输出一下地址和端口
                    Console.WriteLine("{0}：{1} Connect...", clientEndPoint.Address.ToString(), clientEndPoint.Port);

                    //接受客户端消息的线程
                    Thread acceptClientMsg = new Thread(AcceptMsg);
                    acceptClientMsg.Start(clientSocket);
                }
                catch(Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }
        }

        /// <summary>
        /// 接受消息
        /// </summary>
        public void AcceptMsg(object obj)
        {
            //强转为Socket类型
            Socket client = obj as Socket;
            //字节数组 接受传来的信息  1024 * 64
            byte[] buffer = new byte[client.ReceiveBufferSize];

            //获取客户端的网络地址标识
            IPEndPoint clientEndPoint = client.RemoteEndPoint as IPEndPoint;

            try
            {
                while (true)
                {
                    //接受消息
                    int len = client.Receive(buffer);
                    string str = Encoding.UTF8.GetString(buffer, 0, len);
                    Console.WriteLine("Receive {0} : {1}   ：{2}", clientEndPoint.Address.ToString(), _port, str);
                }
            }
            catch(SocketException e)
            {
                Console.WriteLine(e.Message);
                _clientList.Remove(client);
            }

        }

        /// <summary>
        /// 给某一个客户端发送消息
        /// </summary>
        public void Send(string str,Socket client)
        {
            try
            {
                //string => byte[]
                byte[] strBytes = Encoding.UTF8.GetBytes(str);
                client.Send(strBytes);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

        /// <summary>
        /// 发送给所有人
        /// </summary>
        public void SendAll(string str)
        {
            for (int i = 0; i < _clientList.Count; i++)
            {
                Send(str, _clientList[i]);
            }
        }

        /// <summary>
        /// 获取Ip地址
        /// </summary>
        public IPAddress GetIpv4(NetworkInterfaceType type)
        {
            NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
            for (int i = 0; i < networkInterfaces.Length; i++)
            {
                if(type == networkInterfaces[i].NetworkInterfaceType && networkInterfaces[i].OperationalStatus == OperationalStatus.Up)
                {
                    UnicastIPAddressInformationCollection ips = networkInterfaces[i].GetIPProperties().UnicastAddresses;
                    foreach (UnicastIPAddressInformation item in ips)
                    {
                        if(item.Address.AddressFamily == AddressFamily.InterNetwork)
                        {
                            return item.Address;
                        }
                    }
                }
            }
            return null;
        }


        /// <summary>
        /// 关闭套接字
        /// </summary>
        public void Close()
        {
            if(_clientList.Count > 0)
            {
                for (int i = 0; i < _clientList.Count; i++)
                {
                    _clientList[i].Close();
                }
            }
            _clientList.Clear();

            _server.Close();

            _acceptClientConnectThread.Abort();
        }
    }
}

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

namespace TcpClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Client client = new Client();
            client.StartUp();

            while (true)
            {
                string str = Console.ReadLine();
                client.Send(str);
            }         
        }
    }

    public class Client
    {
        private Socket _client;
        private Thread _acceptServerMsg;

        public void StartUp()
        {
            try
            {
                _client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //客户端连接
                _client.Connect("192.168.30.16", 10000);

                //接受消息的线程
                _acceptServerMsg = new Thread(AcceptServerMsg);
                _acceptServerMsg.Start();
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

        public void AcceptServerMsg()
        {
            byte[] buffer = new byte[1024 * 64];

            while(true)
            {
                try
                {
                    int len = _client.Receive(buffer);
                    string str = Encoding.UTF8.GetString(buffer, 0, len);
                    Console.WriteLine("Reveive Msg From Server : {0}", str);
                }
                catch(Exception e)
                {
                    Console.WriteLine(e.Message);
                }

            }
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        public void Send(string str)
        {
            try
            {
                //string => byte[]
                byte[] strBytes = Encoding.UTF8.GetBytes(str);
                _client.Send(strBytes);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }

        }

        /// <summary>
        /// 关闭套接字
        /// </summary>
        public void Close()
        {
            if (_client.Connected)
            {
                _client.Close();
            }

            _acceptServerMsg.Abort();
        }
    }
}