Observable.ToObservable<TSource,> méthode (IEnumerable<TSource>, IScheduler)
Convertit une séquence énumérable en séquence observable avec une source et un planificateur spécifiés.
Namespace:System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'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.
Paramètres de type
- TSource
Type de la source.
Paramètres
- source
Type : System.Collections.Generic.IEnumerable<TSource>
Séquence énumérable à convertir en séquence observable.
- scheduler
Type : System.Reactive.Concurrency.IScheduler
Planificateur sur lequel exécuter l’énumération de la séquence d’entrée.
Valeur de retour
Type : System.IObservable<TSource>
Séquence observable dont les éléments sont extraits de la séquence énumérable donnée.
Remarque sur l'utilisation
Dans Visual Basic et C#, vous pouvez appeler cette méthode en tant que méthode instance sur n’importe quel objet de type IEnumerable<TSource>. Lorsque vous utilisez la syntaxe des méthodes d'instance pour appeler cette méthode, omettez le premier paramètre. Pour plus d'informations, consultez ou .
Notes
L’opérateur ToObservable crée une séquence observable à partir d’un objet qui prend en charge l’interface IEnumerable. Un paramètre de planificateur est fourni avec cet opérateur pour autoriser différentes options de planification pour le traitement nécessaire à la création de la séquence observable. Par exemple, vous pouvez planifier le traitement d’énumération qui est nécessaire pour se produire sur un autre thread.
Exemples
Cet exemple crée une séquence observable de chaînes (chaîne> IObservable<) à partir de la chaîne> IEnumerable<exposée par le tableau de chaînes retourné par le System.IO. Méthode Directory.GetDirectories. Le planificateur ThreadPoolScheduler est passé pour le paramètre planificateur à l’opérateur ToObservable. Cela entraîne l’exécution de l’énumération sur un thread à partir du pool de threads .NET. Par conséquent, le thread main ne sera pas bloqué.
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 sortie suivante a été générée à l’aide de l’exemple de code.
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