Observable.Catch<TSource, Método TException> (IObservable<TSource>, Func<TException, IObservable<TSource>>)
Continua uma sequência observável que é encerrada por uma exceção do tipo especificado com a sequência observável produzida pelo manipulador.
Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)
Sintaxe
'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.
Parâmetros de tipo
- TSource
O tipo de fonte.
- Texception
O tipo da exceção.
Parâmetros
- source
Tipo: System.IObservable<TSource>
A sequência de origem.
- handler
Tipo: System.Func<TException, IObservable<TSource>>
A função de manipulador de exceção, produzindo outra sequência observável.
Valor Retornado
Tipo: System.IObservable<TSource>
Uma sequência observável que contém os elementos da sequência de origem, seguida pelos elementos produzidos pela sequência observável resultante do manipulador, caso ocorra uma exceção.
Observação de uso
No Visual Basic e no C#, você pode chamar esse método como um método de instância em qualquer objeto do tipo TSource>IObservable<. Quando você usar a sintaxe de método de instância para chamar esse método, omita o primeiro parâmetro. Para obter mais informações, consulte ou .
Comentários
O operador catch pode ser usado para introduzir uma sequência adicional na assinatura quando ocorre uma exceção que é do mesmo tipo que a exceção especificada na função de manipulador. Isso é feito pelo operador Catch executando o manipulador de exceção que produz a sequência adicional. Se a sequência de origem for executada até a conclusão sem exceção, o manipulador não será executado. Se a exceção encontrada não for do mesmo tipo especificado na função de manipulador, essa exceção será enviada para o manipulador OnError do observador. O código de exemplo neste tópico demonstra o operador Catch.
Exemplos
O exemplo a seguir demonstra como o operador catch pode ser usado para incluir uma sequência adicional de inteiros com a assinatura se uma exceção for encontrada. Observe que a exceção gerada deve ser do mesmo tipo que a exceção na assinatura da função de manipulador de exceção. Se não for do mesmo tipo, o manipulador OnError para o observador será executado em vez do manipulador de exceção.
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();
}
}
}
Veja a seguir a saída de exemplo do código de exemplo.
==============================================================
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...