C# Asynchronous Server - Client bağlantı kopması algılama

Başlatan quarko, 30 Ekim 2018, 21:43:46

quarko

C# ta asenkron server uygulaması yapmaya çalışıyorum. Örnek olarak şu asenkron server sınıf örneğini kullanıyorum. Amacım client bağlantıyı kapattığı zaman server ın bunu algılaması. Bu konuda yardımcı olabilir misiniz ?

Kod Seç
using System;  
using System.Net;  
using System.Net.Sockets;  
using System.Text;  
using System.Threading;  

// State object for reading client data asynchronously  
public class StateObject {  
    
// Client  socket.  
    
public Socket workSocket null;  
    
// Size of receive buffer.  
    
public const int BufferSize 1024;  
    
// Receive buffer.  
    
public byte[] buffer = new byte[BufferSize];  
// Received data string.  
    
public StringBuilder sb = new StringBuilder();    
}  

public class 
AsynchronousSocketListener {  
    
// Thread signal.  
    
public static ManualResetEvent allDone = new ManualResetEvent(false);  

    public 
AsynchronousSocketListener() {  
    }  

    public static 
void StartListening() {  
        
// Establish the local endpoint for the socket.  
        // The DNS name of the computer  
        // running the listener is "host.contoso.com".  
        
IPHostEntry ipHostInfo Dns.GetHostEntry(Dns.GetHostName());  
        
IPAddress ipAddress ipHostInfo.AddressList[0];  
        
IPEndPoint localEndPoint = new IPEndPoint(ipAddress11000);  

        
// Create a TCP/IP socket.  
        
Socket listener = new Socket(ipAddress.AddressFamily,  
            
SocketType.StreamProtocolType.Tcp );  

        
// Bind the socket to the local endpoint and listen for incoming connections.  
        
try {  
            
listener.Bind(localEndPoint);  
            
listener.Listen(100);  

            while (
true) {  
                
// Set the event to nonsignaled state.  
                
allDone.Reset();  

                
// Start an asynchronous socket to listen for connections.  
                
Console.WriteLine("Waiting for a connection...");  
                
listener.BeginAccept(   
                    new 
AsyncCallback(AcceptCallback),  
                    
listener );  

                
// Wait until a connection is made before continuing.  
                
allDone.WaitOne();  
            }  

        } catch (
Exception e) {  
            
Console.WriteLine(e.ToString());  
        }  

        
Console.WriteLine("\nPress ENTER to continue...");  
        
Console.Read();  

    }  

    public static 
void AcceptCallback(IAsyncResult ar) {  
        
// Signal the main thread to continue.  
        
allDone.Set();  

        
// Get the socket that handles the client request.  
        
Socket listener = (Socketar.AsyncState;  
        
Socket handler listener.EndAccept(ar);  

        
// Create the state object.  
        
StateObject state = new StateObject();  
        
state.workSocket handler;  
        
handler.BeginReceivestate.buffer0StateObject.BufferSize0,  
            new 
AsyncCallback(ReadCallback), state);  
    }  

    public static 
void ReadCallback(IAsyncResult ar) {  
        
String content String.Empty;  

        
// Retrieve the state object and the handler socket  
        // from the asynchronous state object.  
        
StateObject state = (StateObjectar.AsyncState;  
        
Socket handler state.workSocket;  

        
// Read data from the client socket.   
        
int bytesRead handler.EndReceive(ar);  

        if (
bytesRead 0) {  
            
// There  might be more data, so store the data received so far.  
            
state.sb.Append(Encoding.ASCII.GetString(  
                
state.buffer0bytesRead));  

            
// Check for end-of-file tag. If it is not there, read   
            // more data.  
            
content state.sb.ToString();  
            if (
content.IndexOf("<EOF>") > -1) {  
                
// All the data has been read from the   
                // client. Display it on the console.  
                
Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",  
                    
content.Lengthcontent );  
                
// Echo the data back to the client.  
                
Send(handlercontent);  
            } else {  
                
// Not all data received. Get more.  
                
handler.BeginReceive(state.buffer0StateObject.BufferSize0,  
                new 
AsyncCallback(ReadCallback), state);  
            }  
        }  
    }  

    private static 
void Send(Socket handlerString data) {  
        
// Convert the string data to byte data using ASCII encoding.  
        
byte[] byteData Encoding.ASCII.GetBytes(data);  

        
// Begin sending the data to the remote device.  
        
handler.BeginSend(byteData0byteData.Length0,  
            new 
AsyncCallback(SendCallback), handler);  
    }  

    private static 
void SendCallback(IAsyncResult ar) {  
        try {  
            
// Retrieve the socket from the state object.  
            
Socket handler = (Socketar.AsyncState;  

            
// Complete sending the data to the remote device.  
            
int bytesSent handler.EndSend(ar);  
            
Console.WriteLine("Sent {0} bytes to client."bytesSent);  

            
handler.Shutdown(SocketShutdown.Both);  
            
handler.Close();  

        } catch (
Exception e) {  
            
Console.WriteLine(e.ToString());  
        }  
    }  

    public static 
int Main(String[] args) {  
        
StartListening();  
        return 
0;  
    }  
}
"Aslanlar kendi hikayelerini yazmadıkça, avcıların kahramanlık hikayelerini dinlemek zorundayız."

tunayk

CLient bağlantıyı kapattığında, sizin Asenkron Okuma işleminin sonlanır ve CallBack çağrılır.Burada  IAsyncResult nesnesinden aldığınız soket null olarak geri döner.  Bundan sonrası artık size kalmış.
Zaten null olarak geldiği için aynı şekilde yeni bir okuma işlemi başlatamazsınız.

quarko

Stackoverflow da şöyle bir method buldum ama. Yeterli sıklıkta soket için isConnected ile sorgularsak soketin durumunu algılanabilir galiba.

Kod Seç
    public static bool IsConnected(this Socket socket)
    {
        try
        {
            return !(
socket.Poll(1SelectMode.SelectRead) && socket.Available == 0);
        }
        catch (
SocketException) { return false; }
    }

Fakat bu hoşuma gitmedi. Client soketi kapattığında alacağımız async callback nerede ve nasıl olmalı ?
"Aslanlar kendi hikayelerini yazmadıkça, avcıların kahramanlık hikayelerini dinlemek zorundayız."

tunayk

Sizin yapıyı kendi client uygulamam ile test ettim. Connection bağlı olduğu sürece her veri gönderildiğinde, ReadCallBack normal olarak işini yapıyor ve burada BytesToRead >0 olarak gerçekleniyor. Eğer client'tan bağlantıyı kapatırsam, yine buraya düşüyor ancak bu defa BytesToRead 0 olarak geliyor.  Bu da 2 anlama geliyor; Ya Client bağlantıyı kapattı, veya ReadTimeout Süresi aşıldı. Sizin yapılandırmada zaten bir timeout tanımlanmadığı için bu durumu bağlantı kesildi olarak değerlendirmenizde sakınca yok.



quarko

Anladım hocam. Benzer şekilde readcallback i şu şekilde düzenleyip işimi çözdüm. Teşekkür ederim.

Kod Seç
    public static void ReadCallback(IAsyncResult ar)
    {
      
String content String.Empty;

      
// Retrieve the state object and the handler socket from the asynchronous state object.
      
StateObject state = (StateObject)ar.AsyncState;
      
Socket handler state.workSocket;

      if (
handler != null && !handler.Poll(1SelectMode.SelectRead) && handler.Connected && handler.Available == 0)
      {
        
// Read data from the client socket. 
        
int bytesRead handler.EndReceive(ar);

        if (
bytesRead 0)
        {
          
state.sb.Append(Encoding.ASCII.GetString(state.buffer0bytesRead));

          
content state.sb.ToString();

          if (
content.IndexOf("<EOF>") > -1)
          {
            
// All the data has been read from the 
            // client. Display it on the console.

            //Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);
            
Console.WriteLine("Received Data : {0}"content);

            
// Echo the data back to the client.
            //Send(handler, content);

            
state.sb.Clear();
            
state.workSocket handler;
            
handler.BeginReceive(state.buffer0StateObject.BufferSize0, new AsyncCallback(ReadCallback), state);
          }
        }
      }
      else
      {
        if (
handler.Connected)
        {
          
// Client are offline will be detected here
          
IPEndPoint localEndPoint handler.LocalEndPoint as IPEndPoint;
          
Console.WriteLine(String.Format("IP Client: {0}:{1} disconnected"localEndPoint.AddresslocalEndPoint.Port));

          
handler.Shutdown(SocketShutdown.Both);
          
handler.Close();
        }
        {
          
// Server are offline will be detected here
        
}
      }
    }
"Aslanlar kendi hikayelerini yazmadıkça, avcıların kahramanlık hikayelerini dinlemek zorundayız."