Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

AggregateException.Flatten méthode ()

 

Date de publication : novembre 2016

Aplanit des instances AggregateException dans une nouvelle instance unique.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public AggregateException Flatten()

Valeur de retour

Type: System.AggregateException

Nouvelle AggregateException aplanie.

Si une tâche a une tâche enfant attachée qui lève une exception, cette exception est encapsulée dans une AggregateException exception avant d’être propagée vers la tâche parent, qui encapsule cette exception dans son propre AggregateException exception avant de la propager vers le thread appelant. Dans ce cas, le InnerExceptions propriété de la AggregateException exception est interceptée par le Task.Wait, Task<TResult>.Wait, Task.WaitAny ou Task.WaitAll méthode contient un ou plusieurs AggregateException instances, pas les exceptions d’origine ayant provoqué l’erreur. Pour éviter d’avoir à itérer imbriqués AggregateException des exceptions, vous pouvez utiliser la Flatten méthode pour supprimer tous les imbriqué AggregateException des exceptions, afin que le InnerExceptions propriété retourné AggregateException objet contient les exceptions d’origine.

Méthode récursive aplatit toutes les instances de AggregateException les exceptions qui sont des exceptions internes d’actuel AggregateException instance. Les exceptions internes retournées dans le nouveau AggregateException sont l’union de toutes les exceptions à partir de l’arborescence de l’exception internes ayant pour racine actuel AggregateException instance.

Dans l’exemple suivant, les instances AggregateException imbriquées sont aplaties et gérées en une seule boucle.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var task1 = Task.Factory.StartNew(() => {
                     var child1 = Task.Factory.StartNew(() => {
                        var child2 = Task.Factory.StartNew(() => {
                            // This exception is nested inside three AggregateExceptions.
                            throw new CustomException("Attached child2 faulted.");
                        }, TaskCreationOptions.AttachedToParent);

                        // This exception is nested inside two AggregateExceptions.
                        throw new CustomException("Attached child1 faulted.");
                     }, TaskCreationOptions.AttachedToParent);
      });

      try {
         task1.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.Flatten().InnerExceptions) {
            if (e is CustomException) {
               Console.WriteLine(e.Message);
            }
            else {
               throw;
            }
         }
      }
   }
}

public class CustomException : Exception
{
   public CustomException(String message) : base(message)
   {}
}
// The example displays the following output:
//    Attached child1 faulted.
//    Attached child2 faulted.

Vous pouvez également utiliser la méthode AggregateException.Flatten pour lever à nouveau les exceptions internes de plusieurs instances AggregateException levées par plusieurs tâches dans une seule instance AggregateException, comme le montre l’exemple suivant.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
public class Example
{
   public static void Main()
   {
       try {
          ExecuteTasks();
       }
       catch (AggregateException ae) {
          foreach (var e in ae.InnerExceptions)
             Console.WriteLine("{0}:\n   {1}", e.GetType().Name, e.Message);

       }
   }

   static void ExecuteTasks()
   {
        // Assume this is a user-entered String.
        String path = @"C:\";
        List<Task> tasks = new List<Task>();

        tasks.Add(Task.Run(() => {
                             // This should throw an UnauthorizedAccessEXception.
                              return Directory.GetFiles(path, "*.txt",
                                                        SearchOption.AllDirectories);
                           } ));

        tasks.Add(Task.Run(() => {
                              if (path == @"C:\")
                                 throw new ArgumentException("The system root is not a valid path.");
                              return new String[] { ".txt", ".dll", ".exe", ".bin", ".dat" };
                           } ));

        tasks.Add(Task.Run( () => {
                               throw new NotImplementedException("This operation has not been implemented.");
                           } ));

        try {
            Task.WaitAll(tasks.ToArray());
        }
        catch (AggregateException ae) {
            throw ae.Flatten();
        }
    }
}
// The example displays the following output:
//       UnauthorizedAccessException:
//          Access to the path 'C:\Documents and Settings' is denied.
//       ArgumentException:
//          The system root is not a valid path.
//       NotImplementedException:
//          This operation has not been implemented.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 5.0
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: