Bonjour,

Je programme un serveur en console avec les sockets asynchrones, mais dit qu'un client envoie quelque chose au serveur il se ferme. Voici mon code :

Module ModGeneral

    Public Ecoute As Socket
    Public Manual As New ManualResetEvent(False)

    Public Class Client
        Public Ip As String
        Public Index As Integer
        Public Socket As Socket
        Public Buffer(BufferSize) As Byte
        Public BufferSize As Integer = 1000
        Public Packet As StringBuilder
    End Class

    Public Sub Main()
        Ecoute = New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
        Ecoute.Bind(New IPEndPoint(IPAddress.Any, 5000))
        Ecoute.Listen(100)

        ReDim Clients(MaximumJoueurs)

        For i As Integer = 0 To MaximumJoueurs
            Clients(i) = New Client
            Clients(i).Socket = New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
        Next

        While True
            Manual.Reset()
            Ecoute.BeginAccept(New AsyncCallback(AddressOf AcceptCallBack), Ecoute)
            Console.WriteLine("En attente d'une connexion entrante...")
            Manual.WaitOne()
        End While

    End Sub

    Public Sub AcceptCallBack(ByVal Result As IAsyncResult)
        For i As Integer = 0 To MaximumJoueurs
            If Not EstConnecte(i) Then
                Clients(i).Socket = Ecoute.EndAccept(Result)
                Clients(i).Index = i
                Clients(i).Ip = Clients(i).Socket.RemoteEndPoint.ToString
                Clients(i).Socket.BeginReceive(Clients(i).Buffer, 0, Clients(i).Buffer.Length, SocketFlags.None, New AsyncCallback(AddressOf ReceiveCallBack), Clients(i))
                Ecoute.BeginAccept(New AsyncCallback(AddressOf AcceptCallBack), Ecoute)
                Console.WriteLine("Une connexion vient d'être acceptée depuis " & Clients(i).Ip & ".")
                Exit For
            End If
        Next
    End Sub

    Public Sub ReceiveCallBack(ByVal Result As IAsyncResult)
        Dim Client As Client = CType(Result.AsyncState, Client)
        Dim Handle As Socket = Client.Socket
        Dim Taille As Integer = Handle.EndReceive(Result)
        Dim Packet As String = String.Empty

        If Taille > 0 Then

            Client.Packet.Append(Encoding.ASCII.GetString(Client.Buffer, 0, Taille))
            Packet = Client.Packet.ToString()

            Console.WriteLine(Packet)

            Client.Socket.BeginReceive(Client.Buffer, 0, Client.Buffer.Length, SocketFlags.None, New AsyncCallback(AddressOf ReceiveCallBack), Client)

        End If

    End Sub

    Public Function EstConnecte(ByVal index As Integer)
        If Clients(index).Socket.Connected Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Sub Envoyer(ByVal index As Integer, ByVal Data As String)
        If EstConnecte(index) Then
            Dim Bytes() As Byte = Encoding.ASCII.GetBytes(Data)
            Clients(index).Socket.BeginSend(Bytes, 0, Bytes.Length, SocketFlags.None, New AsyncCallback(AddressOf SendCallback), Clients(index).Socket)
        End If
    End Sub

    Public Sub SendCallback(ByVal Result As IAsyncResult)
        Dim Client As Socket = CType(Result.AsyncState, Socket)
        Dim Taille As Integer = Client.EndSend(Result)
    End Sub



End Module

Merci d'avance

Il est où le code du client?

Mais sinon, à vue de nez, comme ça, je dirais que c'est parce que, puisqu'un envoi n'est pas bloquant, l'exécution se poursuit et le programme termine en arrivant à la fin du main.

Pourquoi créer "MaximumJoueurs" sockets au début du programme ? Ca ne sert strictement à rien, à part bouffer de la mémoire.
Et d'ailleurs pourquoi utiliser un tableau de taille fixe pour gérer tes clients au lieu d'une collection de taille variable (comme une liste) ?

Ensuite faire un Manual.WaitOne() dans ton main est un peu problématique si tu ne fais jamais de Manual.Set()

Tu t'y prends très mal. Remplace ton tableau à taille fixe par un List<T>, enlève ta boucle infinie et met à la place un Console.Read().
Si tu veux accepter en boucle des clients tout en ayant un nombre max :

If maListeClients.Count >= 500 ' max clients
    ' tu acceptes
End If

' tu relances ici ta fonction BeginAccept pointant sur cette fonction