Método Observable.Where TSource> (IObservable<TSource>, Func<TSource, Boolean>)<

Filtra los elementos de una secuencia observable en función de un predicado.

Espacio de nombres:System.Reactive.Linq
Ensamblaje: System.Reactive (en System.Reactive.dll)

Sintaxis

'Declaration
<ExtensionAttribute> _
Public Shared Function Where(Of TSource) ( _
    source As IObservable(Of TSource), _
    predicate As Func(Of TSource, Boolean) _
) As IObservable(Of TSource)

'Usage
Dim source As IObservable(Of TSource)
Dim predicate As Func(Of TSource, Boolean)
Dim returnValue As IObservable(Of TSource)

returnValue = source.Where(predicate)

public static IObservable<TSource> Where<TSource>(
    this IObservable<TSource> source,
    Func<TSource, bool> predicate
)

[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<TSource>^ Where(
    IObservable<TSource>^ source, 
    Func<TSource, bool>^ predicate
)

static member Where : 
        source:IObservable<'TSource> * 
        predicate:Func<'TSource, bool> -> IObservable<'TSource>

JScript does not support generic types and methods.

Parámetros de tipo

TSource
Origen del tipo.

Parámetros

source
Tipo: System.IObservable<TSource>
Secuencia observable cuyos elementos se van a filtrar.

predicate
Tipo: System.Func<TSource, Boolean>
Función para probar cada elemento de origen para una condición.

Valor devuelto

Tipo: System.IObservable<TSource>
Secuencia observable que contiene elementos de la secuencia de entrada que cumplen la condición.

Nota sobre el uso

En Visual Basic y C#, puede llamar a este método como método de instancia en cualquier objeto de tipo IObservable<TSource>. Cuando emplee la sintaxis del método de instancia para llamar a este método, omita el primer parámetro. Para obtener más información, vea o .

Comentarios

El operador Where permite definir una función de predicado para probar cada elemento de una secuencia. Cada elemento de la secuencia de origen que hace que la función de predicado devuelva false se filtra de la secuencia resultante.

Ejemplos

En el ejemplo siguiente se usa el operador Where con una consulta integerada de lenguaje (LINQ) para filtrar la secuencia de enteros para que solo se produzcan enteros incluso para la secuencia.

using System;
using System.Reactive.Linq;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*********************************************************************************************//
      //*** The mainSequence produces a new long integer from the Interval operator every sec.    ***//
      //*********************************************************************************************//

      var mainSequence = Observable.Interval(TimeSpan.FromSeconds(1));


      //*********************************************************************************************//
      //*** This LINQ statement uses the Where operator to filter the integers in the sequence so ***//
      //*** that only the even integers are returned.                                             ***//
      //***                                                                                       ***//
      //*** you could also call the method explicitly. For example...                             ***//
      //***                                                                                       ***//
      //*** var seqWhereEven = mainSequence.Where(x => x % 2 == 0);                               ***//
      //***                                                                                       ***//
      //*********************************************************************************************//

      var seqWhereEven = from i in mainSequence
                         where i % 2 == 0 
                         select i;


      //*********************************************************************************************//
      //*** Create a subscription and write each of the even integers to the console window.      ***//
      //*********************************************************************************************//

      seqWhereEven.Subscribe(x => Console.WriteLine(x)); 
      Console.ReadLine();
    }
  }
}

El código de ejemplo generó la siguiente salida.