Método Observable.ToList<TSource>

Crea una lista a partir de una secuencia observable.

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

Sintaxis

'Declaration
<ExtensionAttribute> _
Public Shared Function ToList(Of TSource) ( _
    source As IObservable(Of TSource) _
) As IObservable(Of IList(Of TSource))

'Usage
Dim source As IObservable(Of TSource)
Dim returnValue As IObservable(Of IList(Of TSource))

returnValue = source.ToList()

public static IObservable<IList<TSource>> ToList<TSource>(
    this IObservable<TSource> source
)

[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<IList<TSource>^>^ ToList(
    IObservable<TSource>^ source
)

static member ToList : 
        source:IObservable<'TSource> -> IObservable<IList<'TSource>> 

JScript does not support generic types and methods.

Parámetros de tipo

• TSource
  Tipo de origen.

Parámetros

• source
  Tipo: System.IObservable<TSource>
  Secuencia observable de origen para la que se obtiene una lista de elementos.

Valor devuelto

Tipo: System.IObservable<IList<TSource>>
Una lista de una secuencia observable.

Nota sobre el uso

En Visual Basic y C#, puede llamar a este método como un 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 .

Observaciones

El operador ToList toma todos los elementos de la secuencia y los coloca en una lista. A continuación, la lista se devuelve como una secuencia observable (IObservable<IList<TSource>>). El valor devuelto de este operador difiere del operador correspondiente en IEnumerable para conservar el comportamiento asincrónico.

Ejemplos

En el ejemplo siguiente se usa el operador Generate para generar una secuencia simple de los enteros (1-10). A continuación, el operador ToList se usa para convertir esa secuencia en una lista. El método IList.Add se usa para 9999 en la lista resultante antes de que cada elemento de la lista se escriba en la ventana de la consola.

using System;
using System.Reactive.Linq;
using System.Collections;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*********************************************//
      //*** Generate a sequence of integers 1-10  ***//
      //*********************************************//

      var obs = Observable.Generate(1,            // Initial state value
                                    x => x <= 10, // The termination condition. Terminate generation when false (the integer squared is not less than 1000)
                                    x => ++x,     // Iteration step function updates the state and returns the new state. In this case state is incremented by 1 
                                    x => x);      // Selector function determines the next resulting value in the sequence. The state of type in is squared.


      //***************************************************************************************************//
      //*** Convert the integer sequence to a list. Use the IList.Add() method to add 9999 to the list  ***//
      //***************************************************************************************************//

      var obsList = obs.ToList();

      obsList.Subscribe(x => 
      {
        x.Add(9999);

        //****************************************//
        //*** Enumerate the items in the list  ***//
        //****************************************//

        foreach (int val in x)
        {
          Console.WriteLine(val);
        }
      });

      Console.WriteLine("\nPress ENTER to exit...\n");
      Console.ReadLine();
    }
  }
}

La salida siguiente se generó con el código de ejemplo.

1
2
3
4
5
6
7
8
9
10
9999

Press ENTER to exit...

Consulte también

Referencia

Observable (clase)

Espacio de nombres System.Reactive.Linq