TCP Server/Client Socket.Connected gibt immer true

  • C#

Es gibt 5 Antworten in diesem Thema. Der letzte Beitrag () ist von Bluespide.

    TCP Server/Client Socket.Connected gibt immer true

    Hallo,

    ich habe mir einen TCP Server und Client gebaut und es funktioniert sehr gut und auch total stabil es fehlt wirklich nur mehr
    ein kleiner Schritt und dann ist alles in Ordnung :)

    Wenn sich ein Client mit meinem Server verbindet, dann wird der Client in eine List of <ClientData>gesteckt aber dort bleibt er für immer drin
    auch wenn der client disconnected.

    Ich gehe mit einem Timer jede Sekunde durch die Liste und Frag mit

    C#-Quellcode

    1. ClientData.clientSocket.Connected
    ab ob der Client noch da ist aber obwohl
    die Client-Anwendung nicht mehr läuft bekomm ich true zurück.


    Server:

    C#-Quellcode

    1. static void ListenThread()
    2. {
    3. for (;;)
    4. {
    5. listenerSocket.Listen(0);
    6. _clients.Add(new ClientData(listenerSocket.Accept()));
    7. }
    8. }
    10. public static void Data_IN(object cSocket)
    11. {
    12. Socket clientSocket = (Socket)cSocket;
    13. byte[] Buffer;
    14. int readBytes;
    16. for (;;)
    17. {
    18. try
    19. {
    20. Buffer = new byte[clientSocket.SendBufferSize];
    21. readBytes = clientSocket.Receive(Buffer);
    23. if (readBytes > 0)
    24. {
    25. Packet packet = new Packet(Buffer);
    26. DataManager(packet);
    27. }
    28. }
    29. catch (SocketException e)
    30. {
    31. MessageBox.Show("A client dced");
    32. }
    33. }
    34. }


    C#-Quellcode

    1. Interessante Stellen von der ClientData Klasse
    2. class ClientData
    3. {
    4. public Socket clientSocket;
    5. public Thread clientThread;
    6. public string temporaryIdentifier;
    7. public string clientIdentifier;
    9. public ClientData()
    10. {
    11. this.temporaryIdentifier = Guid.NewGuid().ToString();
    12. clientThread = new Thread(ServerForm.Data_IN);
    13. clientThread.Start(this.clientSocket);
    14. SendRegistrationPacket();
    15. }
    17. public ClientData(Socket clientSocket)
    18. {
    19. this.clientSocket = clientSocket;
    21. this.temporaryIdentifier = Guid.NewGuid().ToString();
    22. clientThread = new Thread(ServerForm.Data_IN);
    23. clientThread.Start(this.clientSocket);
    24. SendRegistrationPacket();
    25. }
    26. }





    Client:

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Linq;
    7. using System.Text;
    8. using System.Threading.Tasks;
    9. using System.Windows.Forms;
    10. using ServerData;
    11. using System.Net;
    12. using System.Net.Sockets;
    13. using System.IO;
    14. using System.Threading;
    15. using Microsoft.Win32;
    17. namespace Client
    18. {
    19. public partial class ClientForm : Form
    20. {
    21. public static Socket master;
    22. public static string temporaryIdentifier;
    23. public static string clientIdentifier;
    25. public ClientForm()
    26. {
    27. InitializeComponent();
    29. clientIdentifier = GetUniqueIdentifierFromRegistry();
    30. }
    32. private void button1_Click(object sender, EventArgs e)
    33. {
    34. string ip = textBox1.Text;
    35. master = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    36. IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(ip), 4242);
    38. try
    39. {
    40. master.Connect(ipe);
    42. Thread t = new Thread(Data_IN);
    43. t.Start();
    44. } catch
    45. {
    46. MessageBox.Show("Verbindung zum Server fehlgeschlagen.");
    47. Application.Exit();
    48. }
    49. }
    51. static void Data_IN()
    52. {
    53. byte[] Buffer;
    54. int readBytes;
    56. while (master.Connected)
    57. {
    58. try
    59. {
    60. Buffer = new byte[master.SendBufferSize];
    61. readBytes = master.Receive(Buffer);
    63. if (readBytes > 0)
    64. {
    65. DataManager(new Packet(Buffer));
    66. }
    67. } catch(SocketException e)
    68. {
    69. MessageBox.Show("Verbindung zum Server getrennt");
    70. Application.Exit();
    71. }
    72. }
    73. }
    75. static void DataManager(Packet p)
    76. {
    77. switch (p.packetType)
    78. {
    79. case (PacketType.Registration):
    80. temporaryIdentifier = p.Gdata[0];
    81. p.senderID = temporaryIdentifier;
    82. p.Gdata.RemoveAt(0);
    84. p.Gdata.Add(clientIdentifier);
    85. master.Send(p.ToBytes());
    86. break;
    87. case (PacketType.RegistrationSuccess):
    88. p.senderID = temporaryIdentifier;
    89. master.Send(p.ToBytes());
    90. break;
    91. case (PacketType.RegistrationFailed):
    92. MessageBox.Show(p.Gdata[0].ToString());
    93. Application.Exit();
    94. break;
    95. }
    96. }
    98. private string GetUniqueIdentifierFromRegistry()
    99. {
    101. return "GEHEIMEID";
    102. }
    104. private void ClientForm_FormClosing(object sender, FormClosingEventArgs e)
    105. {
    106. master.Disconnect(false);
    107. master.Close();
    108. }
    109. }
    110. }

    msdn schrieb:

    Connected Gets a value that indicates whether a Socket is connected to a remote host as of the last Send or Receive operation.

    msdn.microsoft.com/en-us/libra….connected(v=vs.110).aspx
    Dies bedeutet, das anhand der letzten Operation festgelegt wird, ob der Socket aktiv ist.

    Lösung:
    Sende, bevor der Client schließt, eine Nachricht an den Server, sodass dieser ebenfalls den Socket schließen kann. Damit sparst du dir auch das Polling der Property.

    Bau dir in deiner Client Klasse des Servers eine DateTime Property, die den Zeitpunkt der letzten Aktion (Senden/Empfangen) beherbergt.
    Nun baust du dir nen System.Timers.Timer der alle X Minuten über die Liste Iteriert. Hat eine Verbindung länger als Y Minuten nichts mehr Gesendet oder Empfangen, wird sie gelöscht.

    Dafür hatte ich mir auch mal eine Extension geschrieben

    C#-Quellcode

    1. ​public static bool IsConnected(this TcpClient client) {
    2. try {
    3. return !(client.Client.Poll(0, SelectMode.SelectRead) && client.Client.Receive(new byte[1], SocketFlags.Peek) == 0);
    4. } catch { return false; }
    5. }