【现代程序设计】【homework-05】

这次作业的运行效果图：

新建了20个客户端线程，服务器相应开了20个线程接收客户端数据，每一秒输出每一轮的结果

这次作业用c#完成

利用 Socket 类实现了局域网中的客户端和服务器之间的通信

主要设计思路：

对于服务器：

每连接到一个客户端，就新建一个线程用于监听该客户端过来的数据

每一轮新的游戏开始，服务器即向连接到的客户端发送开始游戏的标志

在1.2s内，处理所有接收到的数据，显示结果，并再次发起新的一轮游戏

对于客户端：

每个客户端有个线程来接受服务器的发送的数据

在连接阶段客户端主动向服务器注册

客户端并不主动向服务器发送数据，而是根据服务器发送过来的指令类型，选择是否向服务器发送数据

下面是服务器和客户端用于通信的函数

对于服务器

public static void sendmessage() 向客户端发送数据

private static void ListenClientConnect()：开一个线程监听客户端发送的数据

private static void ReceiveMessage(object clientSocket：处理接受到的客户端数据

对于客户端：

public void SendClientMessage(string smessage)：用于向服务器发送数据

public void connnectserver()：初始阶段连接到服务器

public void ReceiveSMessage()：开一个线程接收服务器发送的数据

下面是完整的代码（c#）：

服务器：

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

 namespace C1
 {

     class ClientData
     {
         public string Mname { get; set; }
         public string Mcode { get; set; }
         public double Mnum { get; set; }
         public bool IsSendNum { get; set; }
         public Socket client { get; set; }
     }

     class NumSeryer
     {

         public static DateTime StartTime =new DateTime();
         public static DateTime EndTime = new DateTime();

         public static List<ClientData> ClientList = new List<ClientData>();

         public static int Nround=;

         private static byte[] result = new byte[];
         private static int myProt = ;   //端口
         static Socket serverSocket;
         public static int nsum;
         static void Main(string[] args)
         {
             //服务器IP地址
             IPAddress ip = IPAddress.Parse("192.168.12.169");
             serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
             serverSocket.Bind(new IPEndPoint(ip, myProt));  //绑定IP地址：端口
             serverSocket.Listen();
             Console.WriteLine("启动监听{0}成功", serverSocket.LocalEndPoint.ToString());
             //通过Clientsoket发送数据

             Thread myThread = new Thread(ListenClientConnect);
             myThread.Start();
             Console.ReadLine();
         }

         /// 监听客户端连接

         /// 

         public static void sendstart()
         {

             for (int i = ; i < Nround; i++)
             {
                 sendmessage();
                 Thread.Sleep();

                 double sum = , ave, jiange = ;
                 int n = , pos = ;

                 foreach (ClientData xx in ClientList)
                 {
                     if (xx.IsSendNum)
                     {
                         sum += xx.Mnum;
                         n++;
                     }
                 }

                 ave = sum / n * 0.618;

                 for (int j = ; j < ClientList.Count; j++)
                 {
                     ClientData xx = ClientList[j];
                     if (xx.IsSendNum && jiange > Math.Abs(xx.Mnum - ave))
                     {
                         jiange = Math.Abs(xx.Mnum - ave); pos = j;
                     }
                 }

                 Console.WriteLine("第{0}轮结果", i);
                 Console.WriteLine("参与客户端数：{0}，G-number：{1}", n, ave);
                 Console.WriteLine("获胜客户端名字:{0},数值：{1}", ClientList[pos].Mname, ClientList[pos].Mnum);
                 Console.WriteLine();
             }
         }

         public static void sendmessage()
         {
             foreach(ClientData xx in ClientList)
             xx.client.Send(Encoding.ASCII.GetBytes("Start"));
         }

         private static void ListenClientConnect()
         {
             while (true)
             {
                 nsum++;

                 StartTime = DateTime.Now;

                 Socket clientSocket=serverSocket.Accept();

                 ClientData _client = new ClientData { client =clientSocket  };

                 ClientList.Add(_client);

                 Thread receiveThread = new Thread(ReceiveMessage);
                 receiveThread.Start(clientSocket);

                 if (nsum >= )
                 {
                     sendstart();
                     //        return;
                 }

             }
         }

         /// <summary>
         /// 接收消息
         /// </summary>
         /// <param name="clientSocket"></param>
         private static void ReceiveMessage(object clientSocket)
          {
             Socket myClientSocket = (Socket)clientSocket;

             while (true)
             {
                 try
                 {
                     //通过clientSocket接收数据
                     int receiveNumber = myClientSocket.Receive(result);

                     string ss = Encoding.ASCII.GetString(result, , receiveNumber);

                     string[] s = ss.Trim().Split('+');

                     double tnum = ;

                     if (s[] == "Regester")
                     {
                         string[] stemp = s[].Trim().Split('-');
                         int index = int.Parse(stemp[]);
                         ClientList[index].Mname = s[];
                         ClientList[index].Mcode = s[];
                         continue;
                     }

                     string tname = s[];
                     tnum = int.Parse(s[]);
                     int n = ClientList.FindIndex(x => x.Mname == s[]);

                     ClientList[n].Mnum = tnum;
                     ClientList[n].IsSendNum = true;
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.Message);
                     myClientSocket.Shutdown(SocketShutdown.Both);
                     myClientSocket.Close();
                     break;
                 }
             }
         }
     }
 }

客户端：

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

 namespace C2
 {
     class client
     {
         public static string ToBeginGame = "Start";
         private static byte[] result = new byte[];
         public string sname { get; set; }
         public string scode { get; set; }

         IPAddress ip = IPAddress.Parse("192.168.12.169");
         Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

         public void Sign_Receive()
         {
             Thread Client_thread = new Thread(new ThreadStart(ReceiveSMessage));
             Client_thread.Start();
         }

         public void ReceiveSMessage()
         {

             //通过clientSocket接收数据
             while (true)
             {

                 int receiveLength = clientSocket.Receive(result);

                 string ss = Encoding.ASCII.GetString(result, , receiveLength);

                 if (ss == ToBeginGame)
                 {
                     SendNum();
                 }
             }

         }

         public void connnectserver()
         {
             try
             {
                 clientSocket.Connect(new IPEndPoint(ip, )); //配置服务器IP与端口
                 Console.WriteLine("连接服务器成功");
             }
             catch
             {
                 Console.WriteLine("连接服务器失败，请按回车键退出！");
                 return;
             }
         }

         public void Regester()
         {
             SendClientMessage("Regester"+"+"+sname + "+" + scode);
         }

         public void SignIn()
         {
             SendClientMessage(sname + "" + scode);
         }

         public void SendNum()
         {
             Random _random = new Random();

             Random r = new Random();

             byte[] buffer = Guid.NewGuid().ToByteArray();
             int iSeed = BitConverter.ToInt32(buffer, );
             r = new Random(iSeed);
             int x;
             x = r.Next();

             SendClientMessage(sname+"+"+x.ToString());
         }

         public void SendClientMessage(string smessage)
         {
                 try
                 {
                     clientSocket.Send(Encoding.ASCII.GetBytes(smessage));
                 }
                 catch
                 {
                     clientSocket.Shutdown(SocketShutdown.Both);
                     clientSocket.Close();
                 }
             }

     }
 }

一个控制台程序，用于生成20个客户端：

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

 namespace C2
 {

     class saaaa
     {
         public static void Main()
         {

             client[] a =new client[];
             for (int i = ; i < ; i++)
             {
                 a[i] = new client { sname = "c-" + i.ToString(), scode = "" };
                 a[i].connnectserver();
                 a[i].Sign_Receive();
                 a[i].Regester();
             }

             Console.ReadLine();
         }
     }
     }