Método Observable.ToObservable<TSource> (IEnumerable<TSource>, IScheduler)

Convierte una secuencia enumerable en una secuencia observable con un origen y un programador especificados.

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

Sintaxis

'Declaration
<ExtensionAttribute> _
Public Shared Function ToObservable(Of TSource) ( _
    source As IEnumerable(Of TSource), _
    scheduler As IScheduler _
) As IObservable(Of TSource)

'Usage
Dim source As IEnumerable(Of TSource)
Dim scheduler As IScheduler
Dim returnValue As IObservable(Of TSource)

returnValue = source.ToObservable(scheduler)

public static IObservable<TSource> ToObservable<TSource>(
    this IEnumerable<TSource> source,
    IScheduler scheduler
)

[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<TSource>^ ToObservable(
    IEnumerable<TSource>^ source, 
    IScheduler^ scheduler
)

static member ToObservable : 
        source:IEnumerable<'TSource> * 
        scheduler:IScheduler -> IObservable<'TSource> 

JScript does not support generic types and methods.

Parámetros de tipo

• TSource
  Tipo de origen.

Parámetros

• source
  Tipo: System.Collections.Generic.IEnumerable<TSource>
  Secuencia enumerable que se va a convertir en una secuencia observable.

• scheduler
  Tipo: System.Reactive.Concurrency.IScheduler
  Programador en el que se va a ejecutar la enumeración de la secuencia de entrada.

Valor devuelto

Tipo: System.IObservable<TSource>
Secuencia observable cuyos elementos se extraen de la secuencia enumerable especificada.

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 IEnumerable<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 ToObservable crea una secuencia observable a partir de un objeto que admite la interfaz IEnumerable. Se proporciona un parámetro scheduler con este operador para permitir diferentes opciones de programación para el procesamiento necesario para crear la secuencia observable. Por ejemplo, puede que desee programar el procesamiento de enumeración necesario para que se produzca en otro subproceso.

Ejemplos

En este ejemplo se crea una secuencia observable de cadenas (cadena> IObservable<) a partir de la cadena> IEnumerable<expuesta por la matriz de cadenas devuelta desde el System.IO. Método Directory.GetDirectories. El programador ThreadPoolScheduler se pasa para el parámetro scheduler al operador ToObservable. Esto hará que la enumeración se ejecute en un subproceso desde el grupo de subprocesos de .NET. Por lo tanto, el subproceso principal no se bloqueará.

using System;
using System.IO;
using System.Reactive.Linq;
using System.Reactive.Concurrency;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*********************************************************************************************************************//
      //*** Create a new observable sequence from the IEnumerable<String> exposed by the string array returned from       ***//
      //*** System.IO.Directory.GetDirectories().                                                                         ***//
      //***                                                                                                               ***//
      //*** In this example we use the ThreadPool scheduler to run the enumeration on a thread in the .NET thread pool.   ***//
      //*** This way our main thread is not blocked by the enumeration and we can process user interaction.               ***//
      //*********************************************************************************************************************//

      var fileList = Directory.GetDirectories(@"C:\Program Files");
      var seqfiles = fileList.ToObservable(Scheduler.ThreadPool);


      //*********************************************************************************************************************//
      //*** We subscribe to this sequence with a lambda expression as the action event handler for the OnNext action. It  ***//
      //*** writes each filename to the console window. A action event handler for the OnCompleted action is also         ***//
      //*** provided to inform the user the sequence has ended and prompt for the ENTER key.                              ***//
      //*********************************************************************************************************************//

      Console.WriteLine("\nCreating subscription. Press ENTER to exit...\n");      
      seqfiles.Subscribe(f => Console.WriteLine(f.ToString()));


      //*********************************************************************************************************************//
      //*** Since we used the ThreadPool scheduler when creating the observable sequence, the enumeration is running on a ***//
      //*** thread from the .NET thread pool. So the main thread is not blocked and can terminate the example if the user ***//
      //*** presses ENTER for a long running enumeration.                                                                 ***//
      //*********************************************************************************************************************//

      Console.ReadLine();
    }
  }
}

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

Creating subscription. Press ENTER to exit...

C:\Program Files\Common Files
C:\Program Files\IIS
C:\Program Files\Internet Explorer
C:\Program Files\Microsoft Games
C:\Program Files\Microsoft Help Viewer
C:\Program Files\Microsoft IntelliType Pro
C:\Program Files\Microsoft LifeCam
C:\Program Files\Microsoft Lync
C:\Program Files\Microsoft Office
C:\Program Files\Microsoft SDKs
C:\Program Files\Microsoft Security Client
C:\Program Files\Microsoft SQL Server
C:\Program Files\Microsoft SQL Server Compact Edition
C:\Program Files\Microsoft Sync Framework
C:\Program Files\Microsoft Synchronization Services
C:\Program Files\Microsoft Visual Studio 10.0
C:\Program Files\Microsoft Visual Studio 9.0
C:\Program Files\Microsoft.NET
C:\Program Files\MSBuild
C:\Program Files\Reference Assemblies
C:\Program Files\Uninstall Information
C:\Program Files\Windows Journal
C:\Program Files\Windows Live
C:\Program Files\Windows Mail
C:\Program Files\Windows Media Components
C:\Program Files\Windows Media Player
C:\Program Files\Windows NT
C:\Program Files\Windows Photo Viewer
C:\Program Files\Windows Portable Devices
C:\Program Files\Windows Sidebar
C:\Program Files\Zune

Consulte también

Referencia

Observable (clase)

Sobrecarga toObservable

Espacio de nombres System.Reactive.Linq