Comment vérifier les erreurs des appels de services Web asynchrones ?

Question

Je développe des services web ASP.Net asmx. Et du côté client, si la demande au serveur renvoie un code d'erreur Http, comme http 500, comment pourrais-je le savoir du côté client des services web (j'utilise le proxy client généré automatiquement en utilisant des références web supplémentaires) ?

Merci d'avance, George

Answer 1

George, puisque vous utilisez des appels WS asynchrones, vous devez implémenter la gestion des exceptions dans la méthode de rappel. Par exemple : Voici l'exemple de code que j'ai développé pour faire une démonstration des délégués asynchrones.

public class TransformDelegateWithCallBack
{
    /// <summary>
    /// Delegate which points to AdapterTransform.ApplyFullMemoryTransformations()
    /// </summary>
    /// <param name="filename">Transformation file name</param>
    /// <param name="rawXml">Raw Xml data to be processed</param>
    /// <param name="count">Variable used to keep a track of no of async delegates</param>
    /// <returns>Transformed XML string</returns>
    public delegate string DelegateApplyTransformations(string filename, string rawXml, int count);

    public ArrayList resultArray;

    //// Declare async delegate and result
    DelegateApplyTransformations delegateApplyTransformation;
    IAsyncResult result;

    /// <summary>
    /// Constructor to initialize the async delegates, results and handles to the no of tabs in excel
    /// </summary>
    public TransformDelegateWithCallBack()
    {
        resultArray = ArrayList.Synchronized(new ArrayList());
    }

    /// <summary>
    /// Invoke the async delegates with callback model
    /// </summary>
    /// <param name="filename">Transformation file name</param>
    /// <param name="rawXml">Raw Xml data to be processed</param>
    /// <param name="count">Variable used to keep a track of no of async delegates</param>
    public void CallDelegates(string fileName, string rawXml, int count)
    {
        try
        {
            AdapterTransform adapterTrans = new AdapterTransform();
            // In the below stmt, adapterTrans.ApplyFullMemoryTransformations is the web method being called
            delegateApplyTransformation = new DelegateApplyTransformations(adapterTrans.ApplyFullMemoryTransformations);
            // The below stmt places an async call to the web method
            // Since it is an async operation control flows immediately to the next line eventually coming out of the current method. Hence exceptions in the web service if any will NOT be caught here.
            // CallBackMethod() is the method that will be called automatically after the async operation is done
            // result is an IAsyncResult which will be used in the CallBackMethod to refer to this delegate
            // result gets passed to the CallBackMethod 
            result = delegateApplyTransformation.BeginInvoke(fileName, rawXml, count, new AsyncCallback(CallBackMethod), null);
        }
        catch (CustomException ce)
        {
            throw ce;
        }
    }

    /// <summary>
    /// Callback method for async delegate
    /// </summary>
    /// <param name="o">By default o will always have the corresponding AsyncResult</param>
    public void CallBackMethod(object o)
    {

        try
        {
            AsyncResult asyncResult = (AsyncResult)o;
            // Now when you do an EndInvoke, if the web service has thrown any exceptions, they will be caught
            // resultString is the value the web method has returned. (Return parameter of the web method)
            string resultString = ((DelegateApplyTransformations)asyncResult.AsyncDelegate).EndInvoke((IAsyncResult)asyncResult);

            lock (this.resultArray.SyncRoot)
            {
                this.resultArray.Add(resultString);
            }
        }
        catch (Exception ex)
        {
            // Handle ex
        }
    }

}

Si votre appel WS lève une exception, elle n'est prise en compte que lorsque vous effectuez un EndInvoke sur l'AsynResult. Si vous utilisez un mécanisme "fire & forget" d'appel WS asynchrone, vous n'appellerez pas EndInvoke et donc l'exception sera perdue. Utilisez donc toujours le mécanisme de rappel lorsque vous avez besoin de récupérer des exceptions. J'espère que cela vous aidera :)

Faites-moi savoir si vous avez d'autres doutes.

Answer 2

Vous pouvez mettre en place un traçage pour vos webservices. Vous trouverez ci-dessous un mode d'emploi tiré du MSDN :

http://msdn.microsoft.com/en-us/library/bb885203.aspx

Si vous avez également accès au serveur, vous pouvez par exemple mettre en place HealthMonitoring qui enregistrera toutes les erreurs qui se produisent du côté du serveur, comme vous avez affiché l'erreur 500 internal server.

Surveillance de la santé - http://msdn.microsoft.com/en-us/library/ms998306.aspx

Vous disposez également du toujours très utile Observateur d'événements si vous pouvez vous connecter à distance ou au serveur.

J'espère que cela vous aidera :

Andrew

Answer 3

Vous pouvez obtenir l'information à partir de e.Response.GetResponseStream(). Comme indiqué précédemment, vous devrez peut-être regarder du côté du serveur pour obtenir des informations plus complètes.

Answer 4

Il s'agit d'un problème fréquemment rencontré car les services Web ont tendance à ne vous envoyer qu'un message HTTP 500 (Internal server error) lorsqu'ils rencontrent une exception non gérée. J'utilise une astuce que j'ai trouvée il y a longtemps. En gros, vous devez pénétrer dans l'exception WebException à l'aide d'un StreamReader pour déterminer la cause première de l'exception.

Exemple de code : (Désolé, je n'avais pas de code C# sous la main. Veuillez utiliser un convertisseur)

Try
  'Hit the webservice.
Catch ex As WebException
  Dim r As HttpWebResponse = CType(ex.Response(), HttpWebResponse)
  Using sr As StreamReader = New StreamReader(r.GetResponseStream())
    Dim err As String = sr.ReadToEnd()
    'Log the error contained in the "err" variable.
  End Using
  Return Nothing
Finally
  'Clean up  
End Try

Peut être converti en utilisant le Convertisseur DeveloperFusion que je recommande vivement.

Answer 5

Voir une question précédente, Un moyen facile de récupérer toutes les exceptions non gérées sur le réseau .

Pour les services web fonctionnant sous IIS, il semblerait que vous deviez attraper les exceptions dans tous les threads en implémentant UnhandledExceptionModule.