WCF Canal Duplex: Vérifier si la fonction de rappel canal est toujours disponible

J'ai le problème suivant. Je suis en train d'écrire un logiciel de chat. Le client/serveur mécanisme est basé sur DualHttpBinding de la WCF. Cela signifie que si un utilisateur envoie un message à tous les clients qui sont dans la salle où le message a été envoyé, sont notifiées par le serveur.

Je veux m'assurer, que si un client de l'application se bloque (whyever), le client objet est retiré de la salle de listes.

Est-il une possibilité de vérifier le rappel du canal de l'état avant d'appeler une opération de rappel? Le problème, c'est que si je l'appelle une opération sur un client qui n'est plus connecté (à cause d'un imprévu crash), le service va s'accrocher.

 public YagzResult SendMessage(Message message)
    {
        foreach (ChatNodeAddress chatNodeAddress in message.Destination)
        {
            ChatNode chatNode = chatProvider.FindChatNode(chatNodeAddress);
            if (chatNode != null)
            {
                User currentUser = CurrentUser;
                foreach (User user in chatNode)
                {
                    //Don't notify the current client. Deadlock!
                    if (!user.Equals(currentUser))
                    {
                        //Get the callback channel here
                        IYagzClient client = GetClientByUser(user);

                        if (client != null)
                        {
                            //--> If the client here called is not any more available,
                            //the service will hang <---
                            client.OnChatMessageReceived(message);
                        }
                    }
                }
            }
            else
            {
                return YagzResult.ChatNodeNotFound;
            }
        }
        return YagzResult.Ok;
    }

Comment puis-je vérifier si un client est toujours à l'écoute? BTW, les opérations dites sur le client sont tous déclarés OneWay et la ConcurrencyMode est réglé à "Plusieurs".

Merci à vous tous!

Accueille,

Simon

OriginalL'auteur Simon | 2009-12-30

  1. 8

    Vous pouvez lancer contrat de rappel à ICommunicationObject et ensuite vérifier l'état de canal.

    OriginalL'auteur Gokhan Demir

  2. 1

    Il y a des événements sur un CommunicationObject (c'est à dire de rappel de canal) pour Fermé et Faillées. Vous pouvez ajouter des gestionnaires de ces et suivre les clients ont encore valide d'un canal disponible.

    Vous pouvez aussi jeter un oeil à la IChannelInitializer classe pour mettre en œuvre le suivi des clients.

    OriginalL'auteur Kwal

  3. 1

    Le principal problème était que je ne voulais pas faire d'exceptions, à l'exception d'un TimeoutException. Mon service a été bloquée pendant 1 min (le délai d'attente j'ai mis), jusqu'à ce que l'exception a été congédié.

    J'ai résolu ce problème grâce à la solution de contournement suivante. Au lieu d'appeler le client de rappel sur le fonctionnement actuel de fil de travail du service, j'ai créé un nouveau thread qui appelle le client de l'opération de rappel et attend une TimeoutException. Si le délai d'attente se produit, l'utilisateur est tout simplement retiré de la salle, dans les listes, il appartenait à.

    Ceci est un extrait de code qui montre comment j'ai fait:

    Au début, j'ai créé une classe qui représente un simple appel pour le client:

    class YagzClientAsyncCall<T>
{
    ///<summary> Gets or sets the parameter of the client callback. </summary>
    ///<value> The parameter. </value>
    T Param { get; set; }

    ///<summary> Gets or sets the client. </summary>
    ///<value> The client. </value>
    IYagzClient Client { get; set; }

    ///<summary> Gets or sets the service. </summary>
    ///<value> The service. </value>
    YagzService Service { get; set; }

    ///<summary> Constructor. </summary>
    ///<remarks> Simon, 30.12.2009. </remarks>
    ///<param name="service"> The service. </param>
    ///<param name="client">  The client. </param>
    ///<param name="param">   The parameter. </param>
    public YagzClientAsyncCall(YagzService service, IYagzClient client, T param)
    {
        Param = param;
        Client = client;
    }

    ///<summary>   
    ///Invokes the client callback. If a timeout exception occurs, 
    ///the client will be removed from clients' list.
    ///</summary>
    ///<remarks> Simon, 30.12.2009. </remarks>
    ///<param name="clientCallback">   The client callback. </param>
    protected void Invoke(Action<T> clientCallback)
    {
        try
        {
            if (clientCallback != null)
            {
                clientCallback(Param);
            }
        }
        catch (TimeoutException)
        {
            //Remove the client and the user
            Service.RemoveClient(Client);
        }
    }

    protected void Invoke(object objCallback)
    {
        Invoke(objCallback as Action<T>);
    }

    public void CallOperationAsync(Action<T> clientCallback)
    {
        ParameterizedThreadStart ts = new ParameterizedThreadStart(this.Invoke);
        Thread t = new Thread(ts);
        t.Start(clientCallback);
    }
}

    Supposons que le code suivant est une partie d'une méthode qui informe tchat clients qu'un nouveau message a été écrit:

    foreach (User user in chatNode)
{
     //Don't notify the current client. Deadlock!
     if (!user.Equals(currentUser))
     {
         IYagzClient client = GetClientByUser(user);

         if (client != null)
         {
             var asyncCall = new YagzClientAsyncCall<Message>(this, client, message);
             asyncCall.CallOperationAsync(client.OnChatMessageReceived);
         }
     }
 }

    Je viens de créer un nouveau YagzClientAsyncCall-Objet et laissez l'opération doit être appelée sur un nouveau thread.

    Alors que cela peut fonctionner, il est en général d'une mauvaise pratique de créer des threads sur demande de ce genre. Vous pourriez vous retrouver avec 1000 indésirables des threads. Mieux avoir bocking collection avec un plus petit nombre fixe de threads de lecture.

    OriginalL'auteur Simon