C# - Aplikacje Klient, Serwer

W tym poście chciałbym przedstawić dwie aplikacje, jedna działa jako klient druga jako serwer. Każda z nich działa na jako aplikacja konsolowa.

Aplikacja Serwer konsola:

Procedurę uruchomienia należy rozpocząć od postawienia serwera. W funkcji tworzy się nowe połączenie o podanych parametrach. Następnie ustanawia się maksymalną liczbę akceptowalnych połączeń.Ostatnim elementem jest utworzenie tzw. callbacka, który będzie wywoływany w momencie otrzymania danych.

1. private static void SetupServer()
2. {
3.     IPAddress setIp = IPAddress.Any;                        /* Pass any Ip adress into variable */
5.     Console.WriteLine(@"Start setting up server...");
7.     serverSocket.ExclusiveAddressUse = true;                 /* No other socket can't bing to selected port */
8.     serverSocket.LingerState = new LingerOption(true, 10);   /* The socket will linger for 10 seconds after calling                                                             Socket.Close */
9.     serverSocket.NoDelay = true;                             /* Disable the Nagle Algorithm for this tcp socket */
10.     serverSocket.ReceiveBufferSize = 8192;                   /* Set the receive buffer size to 8k */
11.     serverSocket.ReceiveTimeout = 1000;
12.     serverSocket.Ttl = 42;                                   /* Set the Time To Live (TTL) to 42 router hops */
14.     serverSocket.Bind(new IPEndPoint(setIp, port));         /* Connect with define port and set IP */
15.     serverSocket.Listen(15);                                 /* Max connection that can wait in queue */
17.     serverSocket.BeginAccept(AcceptCallback, null);         /* Begins an asynchronous operation to accept
18.                                                                        an incoming connection attempt */
19.     Console.WriteLine(@"Server setup complete");            
20. }

Zamknięcie serwera odbywa się za pomocą tej funkcji. Sprawdza ona wszystkie uruchomione połączenia.

1. private static void CloseAllSockets()
2. {
3.      foreach (Socket socket in clientSockets)
4.      {
5.         socket.Shutdown(SocketShutdown.Both);   /* Block sending and receiving */
6.         /*
7.            or
8.            socket.Close();
9.         */
10.       }
11.       Console.WriteLine(@"All sockets has been closed");
12. }

Akceptowanie połączenia oraz odbieranie wiadomości wykonane jest na callbackach.

Akceptacja połączenia:

1. private static void AcceptCallback(IAsyncResult AR)
2. {
3.     Socket socket;
4.     try{
5.         socket = serverSocket.EndAccept(AR);                    /* Asynchronously accepts an incoming connection attempt
6.                                                                    and creates a new Socket to handle remote host communication. */
7.     }
8.     catch (ObjectDisposedException ex){
9.           Console.WriteLine(@"Caught: {0}", ex.Message);  
10.           return;
11.     }
13.     clientSockets.Add(socket);                                  /* Add new connection*/
15.     /* Begins to asynchnous receive data */
16.     socket.BeginReceive(buffer, 0, bufferSize, SocketFlags.None, ReceiveCallback, socket);   /* Get data */
17.     Console.WriteLine(@"Client connected...");
18.     serverSocket.BeginAccept(AcceptCallback, null);             /* Begins asonchronyous operation for
19.                                                                    accepting try for connection */
20. }

Odebranie oraz dekodowanie wiadomości:

1. private static void ReceiveCallback(IAsyncResult AR)
2. {
3.     Socket recDataCurrentConnection = (Socket)AR.AsyncState;
4.     int received;
6.     try{
7.       received = recDataCurrentConnection.EndReceive(AR);
8.     }
9.     catch (SocketException ex){
10.         Console.WriteLine(@"Client disconnected" + ex);
11.         recDataCurrentConnection.Close();  /* Only close connection don't need to shutdown communication */
12.         clientSockets.Remove(recDataCurrentConnection);   /* Remove client from socket list */
13.         return;      /* Exit from function */
14.      }
16.      byte[] recBuf = new byte[received];
17.      Array.Copy(buffer, recBuf, received);
19.      string text = Encoding.ASCII.GetString(recBuf);
20.      Console.WriteLine(@"Received Message: " + text);
22.      if (text.ToLower() == "time"){
23.         Console.WriteLine("Send time:");
24.         byte[] data = Encoding.ASCII.GetBytes(DateTime.Now.ToLongTimeString());
25.         recDataCurrentConnection.Send(data);
26.         Console.WriteLine("Message send to client:");
27.      }
28.      else if (text.ToLower() == "date") {
29.         Console.WriteLine("Send date:");
30.         byte[] data = Encoding.ASCII.GetBytes(DateTime.Now.ToLongDateString());
31.         recDataCurrentConnection.Send(data);
32.         Console.WriteLine("Message send to client:");
33.      }
34.      else if (text.ToLower() == "ip local"){
35.         Console.WriteLine("Send local ip:");
36.         byte[] data = Encoding.ASCII.GetBytes(GetLocalIPAddress());
37.         recDataCurrentConnection.Send(data);
38.         Console.WriteLine("Message send to client:");
39.      }
40.      else if (text.ToLower() == "close"){
41.         recDataCurrentConnection.Shutdown(SocketShutdown.Both);
42.         recDataCurrentConnection.Close();
43.         clientSockets.Remove(recDataCurrentConnection);
44.         Console.WriteLine("Client disconnected");
45.         return;
46.      }
47.      else{
48.         Console.WriteLine("Text is an invalid request");
49.         byte[] data = Encoding.ASCII.GetBytes("Invalid request");
50.         recDataCurrentConnection.Send(data);
51.         Console.WriteLine("Warning Sent");
52.      }
54.      recDataCurrentConnection.BeginReceive(buffer, 0, bufferSize,
55.      SocketFlags.None, ReceiveCallback, recDataCurrentConnection);
56. }

Jedna z akceptowalnych połączeń pozwala na wyświetlenie w odpowiedzi ustawionego adresu IP:

1. private static string GetLocalIPAddress()
2. {
3.     var host = Dns.GetHostEntry(Dns.GetHostName());
4.     foreach (var ip in host.AddressList)
5.     {
6.        if (ip.AddressFamily == AddressFamily.InterNetwork)
7.        {
8.             return ip.ToString();
9.        }
10.     }
11.     throw new Exception("Local IP Address Not Found!");
12. }

Funkcja główna wygląda następująco:

Aplikacja Klient konsola:

W tym przypadku wykonywane jest połączenie z serwerem przy użyciu następującej funkcji:

1. private static byte ConnectToServer()
2. {
3.     int connectAttempt = 0;             /* Number of connection attempts before good connection */
5.     while (!ClientSocket.Connected)         /* Wait for establish connection, block before connection will be set */
6.     {
7.        try{
8.           connectAttempt++;           /* Add variable for next connection */
9.           Console.WriteLine(@"Connection attempts: " + connectAttempt);
10.           ClientSocket.Connect(IPAddress.Loopback, port);     /* Set IPLoopback (127.0.0.1) to remote IP */
11.        }
12.        catch (SocketException ex){
13.           Console.Clear();
14.           Console.WriteLine("Error: {0}", ex.Message);    /* Console clear and display error message */
15.        }
17.        if(connectAttempt == 100) {
18.           Console.Clear();
19.           Console.WriteLine(@"Can't connect to server: " + connectAttempt);
20.           CloseSocket();
21.           return 0;
22.        }
23.      }
25.      if(ClientSocket.Connected){
26.         Console.Clear();
27.         Console.WriteLine(@"Connected");
28.      }
30.      return 1;
31. }

Funkcja wykonuje 100 prób połączenia. Jeśli uda się wykonać połączenie to funkcja zwraca jeden i przechodzi do dalszej części programu. Inaczej zwraca zero i program kończy działanie.

Odłączenie klienta od serwera wygląda następująco:

1. private static void CloseSocket()
2. {
3.     SendString("close");                         /* Send close dat to server*/
4.     ClientSocket.Shutdown(SocketShutdown.Both);  /* Block communication */
5.     ClientSocket.Close();                        /* Close client */
6.     Environment.Exit(0);                            
7. }

Funkcje obsługujące dane wyglądają następująco:

1. private static void RequestLoop()
2. {
3.     Console.WriteLine(@"Close command disconnect client from server");
5.     while (true){
6.       SendRequest();          /* Wait for sending command to server */
7.       ReceiveResponse();
8.     }
9. }
10. private static void SendRequest()
11. {
12.     Console.Write("Send a command: ");
13.     string request = Console.ReadLine();    /* Read command */
14.     SendString(request);                    /* Send data to server */
16.     if (request.ToLower() == "close"){
17.        CloseSocket();                      /* Close socket */
18.     }
19. }
20. private static void SendString(string text)
21. {
22.     byte[] buffer = Encoding.ASCII.GetBytes(text);
23.     /* Send data to server, no flags is use to establish communication */
24.     ClientSocket.Send(buffer, 0, buffer.Length, SocketFlags.None);
25. }
26. private static void ReceiveResponse()
27. {
28.     var buffer = new byte[8196];
29.     int received = ClientSocket.Receive(buffer, SocketFlags.None);  /* Receive data */
31.     if (received == 0){
32.        Console.WriteLine(@"No data was received");
33.     }
34.     else{
35.         var data = new byte[received];
36.         Array.Copy(buffer, data, received);
37.         string text = Encoding.ASCII.GetString(data);
38.         Console.WriteLine(text);
39.     }                                      
40. }

W pętli while przygotowywane są wiadomości do wysłania, następnie w kolejnej funkcji są one odbierane i przetwarzane tak aby je wyświetlić w konsoli. Do wysyłania użyta jest metodasocketu send, odbieranie obsługiwane jest przez receive. Wysłanie przez klienta wiadomości close powoduje odłączenie klienta od serwera oraz jego wyłączenie.

Main prezentuje się następująco:

1. private const int port = 1001;      /* Port for connection with server */
2. /*
3. *   InterNetwork: Address for IP in version 4
4. *   Stream: Support two way connection-based byte wihout duplication of data
5. *   ProtocolType: Transmission Control Protocol
6. */
7. private static readonly Socket ClientSocket = new Socket
8.     (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
10. static void Main()
11. {
12.   Console.Title = @"Client TCP";          /* Console window title */
14.   /* Connect client to server */
15.   if (1 == ConnectToServer()){
16.      RequestLoop();      /* Loop for establish communication */
17.      CloseSocket();      /* Close communication */
18.   }
19. }