AggregateException.Handle(Func<Exception,Boolean>) Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Threading.Tasks.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vyvolá obslužnou rutinu pro každý Exception z nich obsažených AggregateException.

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

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

member this.Handle : Func<Exception, bool> -> unit

Public Sub Handle (predicate As Func(Of Exception, Boolean))

Parametry

predicate: Func<Exception,Boolean>

Predikát, který se má provést pro každou výjimku. Predikát přijímá jako argument, který Exception se má zpracovat, a vrátí logickou hodnotu, která označuje, jestli byla výjimka zpracována.

Výjimky

ArgumentNullException

Argument predicate má hodnotu null.

AggregateException

Nebyla zpracována výjimka obsažená touto AggregateException výjimkou.

Příklady

Obvykle obslužná rutina výjimky, která zachytí AggregateException výjimku, používá smyčku (v jazyce C#) nebo For Each smyčku foreach (v Visual Basic) ke zpracování každé výjimky v kolekciInnerExceptions. Místo toho následující příklad používá metodu Handle pro zpracování každé výjimky a pouze znovu načítá výjimky, které nejsou CustomException instancemi.

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!

open System
open System.Threading.Tasks

type CustomException(message) =
    inherit Exception(message)

let task1 =
    Task.Run(fun () -> raise (CustomException "This exception is expected!"))

try
    task1.Wait()
with
| :? AggregateException as ae ->
    // Call the Handle method to handle the custom exception,
    // otherwise rethrow the exception.
    ae.Handle (fun ex ->
        if ex :? CustomException then
            printfn $"{ex.Message}"

        ex :? CustomException)

// The example displays the following output:
//        This exception is expected!

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim task1 = Task.Run(Sub() Throw New CustomException("This exception is expected!"))

      Try
         task1.Wait()
      Catch ae As AggregateException
         ' Call the Handle method to handle the custom exception,
         ' otherwise rethrow the exception.
         ae.Handle(Function(e)
                      If TypeOf e Is CustomException Then
                         Console.WriteLine(e.Message)
                      End If
                      Return TypeOf e Is CustomException
                   End Function)
      End Try
   End Sub
End Module

Class CustomException : Inherits Exception
   Public Sub New(s As String)
      MyBase.New(s)
   End Sub
End Class
' The example displays the following output:
'       This exception is expected!

Následuje kompletní příklad, který používá metodu Handle k poskytování speciálního zpracování při UnauthorizedAccessException výčtu souborů.

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.

open System
open System.IO
open System.Threading.Tasks

let getAllFiles path =
    let task1 =
        Task.Run(fun () -> Directory.GetFiles(path, "*.txt", SearchOption.AllDirectories))

    try
        task1.Result
    with
    | :? AggregateException as ae ->
        ae.Handle (fun x ->
            // Handle an UnauthorizedAccessException
            if x :? UnauthorizedAccessException then
                printfn "You do not have permission to access all folders in this path."
                printfn "See your network administrator or try another path."

            x :? UnauthorizedAccessException)

        Array.empty

// This should throw an UnauthorizedAccessException.
try
    let files = getAllFiles @"C:\"
    
    if not (isNull files) then
        for file in files do
            printfn $"{file}"
with
| :? AggregateException as ae ->
    for ex in ae.InnerExceptions do
        printfn $"{ex.GetType().Name}: {ex.Message}"

printfn ""

// This should throw an ArgumentException.
try
    for s in getAllFiles "" do
        printfn $"{s}"
with
| :? AggregateException as ae ->
    for ex in ae.InnerExceptions do
        printfn $"{ex.GetType().Name}: {ex.Message}"

// 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 empty. (Parameter 'path')

Imports System.IO
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        ' This should throw an UnauthorizedAccessException.
       Try
           Dim files = GetAllFiles("C:\")
           If files IsNot Nothing Then
              For Each file In files
                 Console.WriteLine(file)
              Next
           End If
        Catch ae As AggregateException
           For Each ex In ae.InnerExceptions
               Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
           Next
        End Try
        Console.WriteLine()

       ' This should throw an ArgumentException.
        Try
           For Each s In GetAllFiles("")
              Console.WriteLine(s)
           Next
        Catch ae As AggregateException
           For Each ex In ae.InnerExceptions
               Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
           Next
        End Try
        Console.WriteLine()
    End Sub

    Function GetAllFiles(ByVal path As String) As String()
       Dim task1 = Task.Run( Function()
                                Return Directory.GetFiles(path, "*.txt",
                                                          SearchOption.AllDirectories)
                             End Function)
       Try
          Return task1.Result
       Catch ae As AggregateException
          ae.Handle( Function(x)
                        ' Handle an UnauthorizedAccessException
                        If TypeOf x Is UnauthorizedAccessException Then
                            Console.WriteLine("You do not have permission to access all folders in this path.")
                            Console.WriteLine("See your network administrator or try another path.")
                        End If
                        Return TypeOf x Is UnauthorizedAccessException
                     End Function)
       End Try
       Return Array.Empty(Of String)()
    End Function
End Module
' 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.

Poznámky

Každé vyvolání predicate vrátí hodnotu true nebo false, která označuje, jestli Exception byla zpracována. Po všech vyvolání budou všechny neošetřené výjimky vloženy do nové AggregateException výjimky, které budou vyvolán. Handle V opačném případě metoda jednoduše vrátí. Pokud vyvolání predicate výjimky vyvolá výjimku, zastaví se zpracování všech dalších výjimek a okamžitě rozšíří vyvolanou výjimku tak, jak je.

Platí pro