C# - Biblioteka TCP-Server

W tym poście chciałbym opisać prostą bibliotekę do obsługi TCP Serwer.

[Źródło: https://docs.microsoft.com/en-us/dotnet/]

Biblioteka:

Na samym początku należy zdefiniować nową instancję klasy:

1. tcpServer.TcpServer tcpServerConnection = new tcpServer.TcpServer();

Przy jej tworzeniu inicjalizowane są domyślnymi wartościami:

1. private void SetStartParameters()
2. {
3.     connections = new List<TcpServerConnection>();
4.     listener = null;
6.     listenThread = null;
7.     sendThread = null;
9.     _port = -1;
10.     _maxSendAttempts = 4;
11.     _connectionOpenStatus = false;
12.     _idleTime = 100;
13.     _maxCallbackThreads = 100;
14.     _verifyConnectionInterval = 100;
15.     _encoding = Encoding.ASCII;
17.     _semaphoreSlim = new SemaphoreSlim(0);
18.     _waitingOperationFinish = false;
20.     _activeThreads = 0;
21. }

W celu utworzenie połączenia należy na zdefiniowaną instancję klasy wywołać następujące elementy:

1. public void CreateServer(string connectionIP, int portNumber)
2. {
3.     tcpServerConnection.OnDataAvailable += tcpServer1_OnDataAvailable;
4.     tcpServerConnection.selectedIpAddress = connectionIP;
5.     tcpServerConnection.Port = portNumber;
6.     tcpServerConnection.Close();
7.     tcpServerConnection.Open();
8. }

Powyżej umieściłem przykładową funkcję uruchamiającą takie elementy jak zapisanie zdarzenia wykonywającego operację odebrania danych, zapisanie adresu IP oraz portu, zamknięcie serwera jeśli jest jakiś aktualnie uruchomiony.

Funkcja OnDataAvailable odczytuje dane, gdy jakieś się pojawią. Następnie uruchamia delegata obsługującego odebraną ramkę (funkcja logData).

1. void tcpServer1_OnDataAvailable(tcpServer.TcpServerConnection connection)
2. {
3.     byte[] data = readStream(connection.Socket);
5.     if (data != null)
6.     {
7.         invokeDelegate del = () =>
8.         {
9.             logData(false, data);
10.         };
11.         del.Invoke();
13.         data = null;
14.     }
15. }

Funkcja readStream odczytuje dane przesłane do serwera:

1. static byte[] readStream(TcpClient client)
2. {
3.     NetworkStream stream = client.GetStream();
4.    
5.     if (stream.DataAvailable)
6.     {
7.         byte[] data = new byte[client.Available];
9.         int bytesRead = 0;
10.         try
11.         {
12.             bytesRead = stream.Read(data, 0, data.Length);
13.         }
14.         catch (IOException) { }
16.         if (bytesRead < data.Length)
17.         {
18.             byte[] lastData = data;
19.             data = new byte[bytesRead];
20.             Array.ConstrainedCopy(lastData, 0, data, 0, bytesRead);
21.         }
23.         return data;
24.     }
25.     return null;
26. }

Funkcja zamykająca utworzony serwer wygląda następująco:

1. public void Close()
2. {
3.     if (!_connectionOpenStatus) { return; }
5.     lock (this)
6.     {
7.         _connectionOpenStatus = false;
8.         foreach (TcpServerConnection conn in connections)
9.         {
10.             conn.forceDisconnect();
11.         }
12.         try
13.         {
14.             if (listenThread.IsAlive)
15.             {
16.                 listenThread.Interrupt();
18.                 Thread.Yield();
19.                 if(listenThread.IsAlive)
20.                 {
21.                     listenThread.Abort();
22.                 }
23.             }
24.         }
25.         catch (System.Security.SecurityException) { }
26.      
27.         try
28.         {
29.             if (sendThread.IsAlive)
30.             {
31.                 sendThread.Interrupt();
32.                 Thread.Yield();
33.                 if(sendThread.IsAlive)
34.                 {
35.                     sendThread.Abort();
36.                 }
37.             }
38.         }
39.         catch (System.Security.SecurityException) { }
40.     }
41.     listener.Stop();
43.     lock (connections)
44.     {
45.         connections.Clear();
46.     }
48.     listenThread = null;
49.     sendThread = null;
50.     GC.Collect();
51. }

Funkcja otwierająca serwer:

1. public void Open()
2. {
3.     lock (this)
4.     {
5.         if (_connectionOpenStatus) { return; }
7.         if (_port < 0) { throw new Exception("Port wrong or not set "); }
9.         try
10.         {
11.             if (listener == null)
12.             {
13.                 listener = new TcpListener(IPAddress.Parse(selectedIpAddress), _port);
14.             }
15.             else
16.             {
17.                 listener.Server.Bind(new IPEndPoint(IPAddress.Parse(selectedIpAddress), _port));
18.             }
20.             listener.Start(1);
21.         }
22.         catch (Exception)
23.         {
24.             listener.Stop();
25.             listener = new TcpListener(IPAddress.Parse(selectedIpAddress), _port);
26.             listener.Start(1);
27.         }
29.         _connectionOpenStatus = true;
31.         listenThread = new Thread(new ThreadStart(Listener));
32.         listenThread.Start();
34.         sendThread = new Thread(new ThreadStart(Sender));
35.         sendThread.Start();
36.    }
37. }

Funkcje umożliwiające przesłanie danych:

1. public void Send(string data)
2. {
3.     lock(_semaphoreSlim)
4.     {
5.         foreach (TcpServerConnection connection in connections)
6.         {
7.             connection.sendData(data);
8.         }
10.         Thread.Yield();
12.         if (_waitingOperationFinish)
13.         {
14.             _semaphoreSlim.Release();
15.             _waitingOperationFinish = false;
16.         }
17.     }
18. }
20. public void Send(byte[] data)
21. {
22.     lock (_semaphoreSlim)
23.     {
24.         foreach (TcpServerConnection connection in connections)
25.         {
26.             connection.sendData(data);
27.         }
29.         Thread.Yield();
31.         if (_waitingOperationFinish)
32.         {
33.             _semaphoreSlim.Release();
34.             _waitingOperationFinish = false;
35.         }
36.      }
37. }

Funkcje przesyłające dodają ramkę do listy z danymi do przesłania:

1. public void sendData(string data)
2. {
3.     byte[] array = _encodingType.GetBytes(data);
5.     lock (_messagesToSend)
6.     {
7.         _messagesToSend.Add(array);
8.     }
9. }
11. public void sendData(byte[] arrayToSend)
12. {
13.     lock (_messagesToSend)
14.     {
15.         _messagesToSend.Add(arrayToSend);
16.     }
17. }

W wątku Sendera obsługiwane jest aktywne połączenie z serwerem.

1. private void Sender()
2. {
3.     while (_connectionOpenStatus && _port >= 0)
4.     {
5.         try
6.         {
7.             bool operationStatus = false;
8.             for (int i = 0; i < connections.Count; i++)
9.             {
10.                 if (connections[i].CallbackThread != null)
11.                 {
12.                     try
13.                     {
14.                         connections[i].CallbackThread = null;
15.                         lock (activeThreadsLock)
16.                         {
17.                             _activeThreads--;
18.                         }
19.                     }
20.                     catch (Exception) { }
21.                 }
23.                 if(connections[i].connected() &&      (connections[i].LastVerifyTime.AddMilliseconds(_verifyConnectionInterval) > DateTime.UtcNow || connections[i].verifyConnected()))
24.                 {
25.                     moreWork = moreWork || processConnection(connections[i]);
26.                 }
27.                 else
28.                 {
29.                     lock (connections)
30.                     {
31.                         connections.RemoveAt(i);
32.                         i--;
33.                     }
34.                 }
35.             }
37.             if (!operationStatus)
38.             {
39.                 System.Threading.Thread.Yield();
40.                 lock (_semaphoreSlim)
41.                 {
42.                     foreach (TcpServerConnection conn in connections)
43.                     {
44.                         if (conn.hasMoreWork())
45.                         {
46.                             operationStatus = true;
47.                             break;
48.                         }
49.                     }
50.                  }
51.                  if (!moreWork)
52.                  {
53.                     _waitingOperationFinish = true;
54.                     _semaphoreSlim.Wait(_idleTime);
55.                     _waitingOperationFinish = false;
56.                  }
57.             }
58.         }
59.         catch (Exception e)
60.         {
61.             if (_connectionOpenStatus && OnError != null)
62.             {
63.                 OnError(this, e);
64.             }
65.         }
66.     }
67. }

W wątku listener następuje oczekiwanie na aktywne połączenie klienta z serwerem:

1. private void Listener()
2. {
3.     while (_connectionOpenStatus && _port >= 0)
4.     {
5.         try
6.         {
7.             if (listener.Pending())
8.             {
9.                 TcpClient socket = listener.AcceptTcpClient();
10.                 TcpServerConnection connection= new TcpServerConnection(socket, _encoding);
12.                 if (OnConnect != null)
13.                 {
14.                     lock (activeThreadsLock)
15.                     {
16.                         _activeThreads++;
17.                     }
18.                    
19.                     connection.CallbackThread = new Thread(() =>
20.                     {
21.                         OnConnect(connection);
22.                     });
23.                             conn.CallbackThread.Start();
24.                 }
26.                 lock (connections)
27.                 {
28.                     connections.Add(connection);
29.                 }
30.             }
31.             else
32.             {
33.                 System.Threading.Thread.Sleep(_idleTime);
34.             }
35.         }
36.         catch (Exception e)
37.         {
38.             if (_connectionOpenStatus && OnError != null)
39.             {
40.                 OnError(this, e);
41.             }
42.          }
43.     }
44. }

Po nawiązaniu połączenia zostaje otwarty nowy socket dla klienta.

Biblioteka jest do pobrania z dysku Google pod tym linkiem.