AggregateException.Handle(Func<Exception,Boolean>) Méthode

Définition

Appelle un gestionnaire sur chaque Exception contenue dans cette AggregateException.

public void Handle (Func<Exception,bool> predicate);

Paramètres

predicate
Func<Exception,Boolean>

Prédicat à exécuter pour chaque exception. Le prédicat accepte comme argument la Exception à traiter et retourne un booléen pour indiquer si l’exception a été gérée.

Exceptions

L’argument predicate a la valeur null.

Une exception contenue dans cette AggregateException n’a pas été gérée.

Exemples

En règle générale, un gestionnaire d’exceptions qui intercepte une AggregateException exception utilise une foreach boucle (en C#) ou For Each une boucle (dans Visual Basic) pour gérer chaque exception de sa InnerExceptions collection. Au lieu de cela, l’exemple suivant utilise la Handle méthode pour gérer chaque exception et rethrows uniquement les exceptions qui ne sont pas CustomException des instances.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var task1 = Task.Run( () => { throw new CustomException("This exception is expected!"); } );

      try {
          task1.Wait();
      }
      catch (AggregateException ae)
      {
         // Call the Handle method to handle the custom exception,
         // otherwise rethrow the exception.
         ae.Handle(ex => { if (ex is CustomException)
                             Console.WriteLine(ex.Message);
                          return ex is CustomException;
                        });
      }
   }
}

public class CustomException : Exception
{
   public CustomException(String message) : base(message)
   {}
}
// The example displays the following output:
//        This exception is expected!

Voici un exemple plus complet qui utilise la Handle méthode pour fournir une gestion spéciale pour une UnauthorizedAccessException énumération de fichiers.

using System;
using System.IO;
using System.Threading.Tasks;

public class Example2
{
    public static void Main()
    {
        // This should throw an UnauthorizedAccessException.
       try {
           var files = GetAllFiles(@"C:\");
           if (files != null)
              foreach (var file in files)
                 Console.WriteLine(file);
        }
        catch (AggregateException ae) {
           foreach (var ex in ae.InnerExceptions)
               Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
        }
        Console.WriteLine();

        // This should throw an ArgumentException.
        try {
           foreach (var s in GetAllFiles(""))
              Console.WriteLine(s);
        }
        catch (AggregateException ae) {
           foreach (var ex in ae.InnerExceptions)
               Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
        }
    }

    static string[] GetAllFiles(string path)
    {
       var task1 = Task.Run( () => Directory.GetFiles(path, "*.txt",
                                                      SearchOption.AllDirectories));

       try {
          return task1.Result;
       }
       catch (AggregateException ae) {
          ae.Handle( x => { // Handle an UnauthorizedAccessException
                            if (x is UnauthorizedAccessException) {
                                Console.WriteLine("You do not have permission to access all folders in this path.");
                                Console.WriteLine("See your network administrator or try another path.");
                            }
                            return x is UnauthorizedAccessException;
                          });
          return Array.Empty<String>();
       }
   }
}
// The example displays the following output:
//       You do not have permission to access all folders in this path.
//       See your network administrator or try another path.
//
//       ArgumentException: The path is not of a legal form.

Remarques

Chaque appel du predicate retour a la valeur true ou false pour indiquer si l’objet Exception a été géré. Après tous les appels, si des exceptions n’ont pas été gérées, toutes les exceptions non gérées seront placées dans un nouveau AggregateException qui sera levée. Sinon, la Handle méthode retourne simplement. Si des appels de l’exception predicate lèvent une exception, il arrête le traitement de plus d’exceptions et propage immédiatement l’exception levée en l’état.

S’applique à

Produit Versions
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7
.NET Framework 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP 10.0