Observable.Catch<TSource, méthode TException> (IObservable<TSource>, Func<TException, IObservable<TSource>>)
Continue une séquence observable qui se termine par une exception du type spécifié avec la séquence observable produite par le gestionnaire.
Namespace:System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'Declaration
<ExtensionAttribute> _
Public Shared Function Catch(Of TSource, TException As Exception) ( _
source As IObservable(Of TSource), _
handler As Func(Of TException, IObservable(Of TSource)) _
) As IObservable(Of TSource)
'Usage
Dim source As IObservable(Of TSource)
Dim handler As Func(Of TException, IObservable(Of TSource))
Dim returnValue As IObservable(Of TSource)
returnValue = source.Catch(handler)
public static IObservable<TSource> Catch<TSource, TException>(
this IObservable<TSource> source,
Func<TException, IObservable<TSource>> handler
)
where TException : Exception
[ExtensionAttribute]
public:
generic<typename TSource, typename TException>
where TException : Exception
static IObservable<TSource>^ Catch(
IObservable<TSource>^ source,
Func<TException, IObservable<TSource>^>^ handler
)
static member Catch :
source:IObservable<'TSource> *
handler:Func<'TException, IObservable<'TSource>> -> IObservable<'TSource> when 'TException : Exception
JScript does not support generic types and methods.
Paramètres de type
- TSource
Type de la source.
- TException
Type de l'exception.
Paramètres
- source
Type : System.IObservable<TSource>
Séquence source.
- gestionnaire
Type : System.Func<TException, IObservable<TSource>>
Fonction de gestionnaire d’exceptions, produisant une autre séquence observable.
Valeur de retour
Type : System.IObservable<TSource>
Séquence observable contenant les éléments de la séquence source, suivie des éléments produits par la séquence observable résultante du gestionnaire en cas d’exception.
Remarque sur l'utilisation
Dans Visual Basic et C#, vous pouvez appeler cette méthode en tant que méthode instance sur n’importe quel objet de type IObservable<TSource>. Lorsque vous utilisez la syntaxe des méthodes d'instance pour appeler cette méthode, omettez le premier paramètre. Pour plus d'informations, consultez ou .
Notes
L’opérateur catch peut être utilisé pour introduire une séquence supplémentaire dans l’abonnement lorsqu’une exception du même type que celle spécifiée dans la fonction de gestionnaire se produit. Pour ce faire, l’opérateur Catch exécute le gestionnaire d’exceptions qui produit la séquence supplémentaire. Si la séquence source s’exécute jusqu’à l’achèvement sans exception, le gestionnaire n’est pas exécuté. Si l’exception rencontrée n’est pas du même type que celui spécifié dans la fonction de gestionnaire, cette exception est envoyée au gestionnaire OnError de l’observateur. L’exemple de code de cette rubrique illustre l’opérateur Catch.
Exemples
L’exemple suivant montre comment l’opérateur catch peut être utilisé pour inclure une séquence d’entiers supplémentaire avec l’abonnement si une exception est rencontrée. Notez que l’exception levée doit être du même type que l’exception dans la signature de la fonction de gestionnaire d’exceptions. S’il n’est pas du même type, le gestionnaire OnError de l’observateur est exécuté à la place du gestionnaire d’exceptions.
using System;
using System.Collections.Generic;
using System.Reactive.Linq;
namespace Example
{
class Program
{
static void Main()
{
//***********************************************************************************************//
//*** sequence1 is generated from the enumerator returned by the RandomNumSequence function. ***//
//*** It will be combined with sequence2 using the Catch() operator only if there is an ***//
//*** exception thrown in sequence1 that is caught by the Catch() operator. ***//
//***********************************************************************************************//
IObservable<int> sequence1 = RandomNumSequence().ToObservable();
//**************************************************************************************************************************//
//*** In this catch operation, the exception handler for Observable::Catch will not be executed. This is because ***//
//*** sequence1 throws an InvalidOperationException which isn't of the NullReferenceException type specified in the ***//
//*** signature of ExNullRefHandler. ***//
//*** ***//
//*** The InvalidOperationException will be caught by the OnError handler instead. ***//
//**************************************************************************************************************************//
Console.WriteLine("==============================================================");
Console.WriteLine("Calling Catch operator with NullReferenceException handler...");
Console.WriteLine("==============================================================\n");
sequence1.Catch((Func<NullReferenceException, IObservable<int>>)ExNullRefHandler)
.Subscribe(i => Console.WriteLine(i),
(ex) => Console.WriteLine("\nException {0} in OnError handler\nException.Message : \"{1}\"\n\n", ex.GetType().ToString(), ex.Message));
//**************************************************************************************************************************//
//*** In this catch operation, the exception handler will be executed. Because InvalidOperationException thrown by ***//
//*** sequence1 is of the InvalidOperationException type specified in the signature of ExInvalidOpHandler(). ***//
//**************************************************************************************************************************//
Console.WriteLine("================================================================");
Console.WriteLine("Calling Catch operator with InvalidOperationException handler...");
Console.WriteLine("================================================================\n");
sequence1.Catch((Func<InvalidOperationException, IObservable<int>>)ExInvalidOpHandler)
.Subscribe(i => Console.WriteLine(i),
(ex) => Console.WriteLine("\nException {0} in OnError handler\nException.Message : \"{1}\"\n\n", ex.GetType().ToString(), ex.Message));
Console.WriteLine("\nPress ENTER to exit...\n");
Console.ReadLine();
}
//*******************************************************************************************************//
//*** ***//
//*** This method will yield a random sequence of 5 integers then throw an InvalidOperationException. ***//
//*** ***//
//*******************************************************************************************************//
static IEnumerable<int> RandomNumSequence()
{
Random random = new Random();
//************************************************//
//*** Yield an a sequence of 5 random integers ***//
//************************************************//
for (int i = 0; i < 5; i++)
{
yield return random.Next(101);
}
//*********************************************************//
//*** Then throw an InvalidOperationException exception ***//
//*********************************************************//
throw new InvalidOperationException("Some Exception Happened!");
}
//*********************************************************************************************************//
//*** ***//
//*** Simple catch handler for NullReferenceExceptions. This handler looks at the exception message and ***//
//*** returns a sequence of int. ***//
//*** ***//
//*********************************************************************************************************//
static IObservable<int> ExNullRefHandler(NullReferenceException ex)
{
//***********************************************************************************************//
//*** Sequence2 will be part of the resulting sequence if an exception is caught in sequence1 ***//
//***********************************************************************************************//
int[] sequence2 = { 0 };
if (ex.Message == "Some Exception Happened!")
sequence2 = new int[] { 5001, 5002, 5003, 5004 };
return sequence2.ToObservable();
}
//************************************************************************************************************//
//*** ***//
//*** Simple catch handler for InvalidOperationExceptions. This handler looks at the exception message and ***//
//*** returns a sequence of int. ***//
//*** ***//
//************************************************************************************************************//
static IObservable<int> ExInvalidOpHandler(InvalidOperationException ex)
{
//***********************************************************************************************//
//*** Sequence2 will be part of the resulting sequence if an exception is caught in sequence1 ***//
//***********************************************************************************************//
int[] sequence2 = { 0 };
if (ex.Message == "Some Exception Happened!")
sequence2 = new int[] { 1001, 1002, 1003, 1004 };
return sequence2.ToObservable();
}
}
}
Voici un exemple de sortie de l’exemple de code.
==============================================================
Calling Catch operator with NullReferenceException handler...
==============================================================
68
20
17
6
24
Exception System.InvalidOperationException in OnError handler
Exception.Message : "Some Exception Happened!"
================================================================
Calling Catch operator with InvalidOperationException handler...
================================================================
87
29
84
68
23
1001
1002
1003
1004
Press ENTER to exit...