Método TSource> Observable.ToList<

Artigo
06/28/2011

Cria uma lista com base em uma sequência observável.

Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)

Sintaxe

'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
O tipo de fonte.

Parâmetros

source
Tipo: System.IObservable<TSource>
A sequência observável de origem para a qual obter uma lista de elementos.

Valor Retornado

Tipo: System.IObservable<IList<TSource>>
Uma lista de uma sequência observável.

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 IObservable<TSource>. 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 ToList pega todos os itens na sequência e os coloca em uma lista. Em seguida, a lista é retornada como uma sequência observável (IObservable<IList<TSource>>). O valor retornado desse operador difere do operador correspondente em IEnumerable para manter o comportamento assíncrono.

Exemplos

O exemplo a seguir usa o operador Generate para gerar uma sequência simples de inteiros (1-10). Em seguida, o operador ToList é usado para converter essa sequência em uma lista. O método IList.Add é usado para 9999 na lista resultante antes de cada item na lista ser gravado na janela do console.

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();
    }
  }
}

A saída a seguir foi gerada com o código de exemplo.

1
2
3
4
5
6
7
8
9
10
9999

Press ENTER to exit...

Consulte Também

Referência

Classe Observável

System.Reactive.Linq Namespace

Compartilhar via