System.Net.Sockets.Socket.AcceptAsync modeli

Question

modelini kullanırken yığın taşması C# ve .NET'in System.Net.Sockets.Socket.AcceptAsync yöntemiyle ilgili olarak, hemen kullanılabilir olan SocketAsyncEventArgs durumunu işlemek için "false" değerinin geri getirilmesi gerekir. Eşzamanlı işlenmiş bağlantıdan. Microsoft (System.Net.Sockets.SocketAsyncEventArgs sınıf sayfasında bulunan), taşıma modellerini uygulayan herhangi bir sistemde kullanılabilecek çok sayıda bekleyen bağlantı varsa yığın taşmasına neden olacak örnekler sağlar.

Bu soruna geçici bir çözüm bulmak için diğer fikirler, Socket.AcceptAsync döndürme değerinin false değerine eşit olması koşuluyla ve (ertelenmiş işleme izin vermek için) değeri bozarsa, işleyici yöntemini çağıran bir döngü oluşturmaktır. işlemin eşzamansız olarak tamamlandığını gösterir (true). Bununla birlikte, bu çözüm aynı zamanda SocketAsyncEventArgs ile ilişkili geri dönüşün Socket.AcceptAsync'a aktarılan geridönüşümün, yöntemin sonunda, Socket.AcceptAsync numaralı aramaya da sahip olduğu ve aynı zamanda anında kullanılabilir, eşzamanlı olarak kabul edilen bağlantılar için bir döngüye sahip olması nedeniyle yığın taşması güvenlik açığına neden olur .

Gördüğünüz gibi, bu oldukça sağlam bir sorundur ve henüz System.Threading.ThreadPool'u içermeyen ve tonlarca başka yöntem ve zamanlama işlemi gerçekleştirmeyen iyi bir çözüm bulmuyorum. Görebildiğim kadarıyla, Socket.AcceptAsync ile ilgili asenkron soket modeli, MSDN'deki örneklerde gösterilenden daha fazlasını gerektirir.

Bağlantıları yürütmek ve özyinelemeyi kullanmadan ayrı iş parçacıkları oluşturmaya gerek kalmadan, Socket.AcceptAsync tarafından eşzamanlı olarak kabul edilen hemen bekleyen bağlantıları işlemek için herkesin temiz ve verimli bir çözümü var mı?

Answer 1

Ben AcceptAsync kullanmak ister ziyade BeginAcceptEndAccept ve ortak eşzamansız modeli doğru şekilde uygulayın, yani tamamlanan işlemler sırasında geri arama iş parçasındaki geri çağrıları engellemek için CompletedSynchronously denetleyin.

gereksinimi ile ilgili AsyncCallBack CompletedSynchronously

---

Düzenleme AcceptAsync kullanmak da bakınız:

MSDN documentation açıkça geri arama senkronize olarak tamamlayan işlemleri için çağrılan ALINMAYACAKTIR söylüyor. Bu, geri çağrının her zaman çağrıldığı ortak async modelinden farklıdır.

G/Ç işlemi beklemedeyse, true değerini döndürür. E parametresindeki SocketAsyncEventArgs.Completed olayı işlemin tamamlanması üzerine yükseltilecektir. G/Ç işlemi 'u eşzamanlı olarak tamamladıysa, döndürür. E parametresi SocketAsyncEventArgs.Completed olay yükseltilmiş edilmez ve bir parametre olarak geçirilen e nesne yöntem çağrısı işleminin sonuç almak için geri döner hemen sonra incelenebilir.

Şu anda bir döngü yığınının taşması sorununu nasıl çözmeyeceğini göremiyorum. Belki de soruna neden olan kodda daha spesifik olabilirsiniz?

---

Düzenleme 2:

static void Main(string[] args) { 
    Socket listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
    listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 4444)); 
    listenSocket.Listen(100); 
    SocketAsyncEventArgs e = new SocketAsyncEventArgs(); 
    e.Completed += AcceptCallback; 
    if (!listenSocket.AcceptAsync(e)) { 
     AcceptCallback(listenSocket, e); 
    } 
    Console.ReadKey(true); 
} 

private static void AcceptCallback(object sender, SocketAsyncEventArgs e) { 
    Socket listenSocket = (Socket)sender; 
    do { 
     try { 
      Socket newSocket = e.AcceptSocket; 
      Debug.Assert(newSocket != null); 
      // do your magic here with the new socket 
      newSocket.Send(Encoding.ASCII.GetBytes("Hello socket!")); 
      newSocket.Disconnect(false); 
      newSocket.Close(); 
     } catch { 
      // handle any exceptions here; 
     } finally { 
      e.AcceptSocket = null; // to enable reuse 
     } 
    } while (!listenSocket.AcceptAsync(e)); 
} 

Answer 2

dikkatle bakmadım ama bu ("yığın dalış" adlı bölüm) yararlı olabilir gibi kokuyor:/

http://blogs.msdn.com/b/mjm/archive/2005/05/04/414793.aspx

Answer 3

Ben: Böyle kod düşünüyorum (sadece AcceptAsync açısından, geri kalanı sadece bunu denemek için bir çalışma uygulamasını almaya oldu) Bu sorunu, yalnızca döngü yerleşimini değiştirerek çözdü. Kabul işleyicisini kendi içinden yinelemeli olarak çağırmak yerine, kodu bir "do-while" döngüsünde "! Socket.AcceptAsync (args)" koşuluyla sarmalamak, yığının taşmasını engeller.

Bunun arkasındaki mantık, diğer bağlantıların rast gelmesini beklemeden eşzamanlı olarak beklemeden önce, hemen kullanılabilen bağlantıların işlenmesi için geri arama iş parçacığını kullanmanızdır. Etkin bir şekilde havuzlanmış bir iş parçacığı kullanıyor.

Yanıtları takdir ediyorum, ancak hiçbiri hiçbiri benimle tıklanmadı ve gerçekten sorunu çözmedi. Ancak, oradaki bir şey benim fikrimi bu düşünceyi ortaya çıkarıyordu. ThreadPool sınıfıyla manuel olarak çalışmayı önler ve yinelemeyi kullanmaz.

Elbette, eğer birisi daha iyi bir çözüme veya hatta bir alternatife sahipse, bunu duyduğuma sevinirim.

Answer 4

newSocket.Send(Encoding.ASCII.GetBytes("Hello socket!")); 
newSocket.Disconnect(false); 
newSocket.Close(); 

Yukarıdaki parçacıkla ilgili sorun, bir sonraki kabul işleminizi engelleyecektir.

daha iyi bir yolu şu şekildedir:

while (true) 
{ 
    if (e.SocketError == SocketError.Success) 
    { 
     //ReadEventArg object user token 
     SocketAsyncEventArgs readEventArgs = m_readWritePool.Pop(); 
     Socket socket = ((AsyncUserToken)readEventArgs.UserToken).Socket = e.AcceptSocket; 

     if (!socket.ReceiveAsync(readEventArgs)) 
     ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessReceiveEx), readEventArgs); . 
    } 
    else 
    { 
     HadleBadAccept(e); 
    } 

    e.AcceptSocket = null; 

    m_maxNumberAcceptedClients.WaitOne(); 
    if (listenSocket.AcceptAsync(e)) 
     break; 
}