Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Inicializa una nueva instancia de la clase BehaviorSubject<T> que crea un asunto que almacena en caché su último valor y comienza con el valor especificado.
Espacio de nombres:System.Reactive.Subjects
Ensamblaje: System.Reactive (en System.Reactive.dll)
Sintaxis
'Declaration
Public Sub New ( _
value As T _
)
'Usage
Dim value As T
Dim instance As New BehaviorSubject(value)
public BehaviorSubject(
T value
)
public:
BehaviorSubject(
T value
)
new :
value:'T -> BehaviorSubject
public function BehaviorSubject(
value : T
)
Parámetros
- value
Tipo: T
Valor inicial enviado a los observadores cuando el sujeto todavía no ha recibido ningún otro valor.
Observaciones
Un BehaviorSubject almacena en búfer el último elemento que publicó a través de su interfaz IObservable. Si no se ha publicado ningún elemento a través de su interfaz IObservable, el elemento inicial proporcionado en el constructor es el elemento almacenado en búfer actualmente. Cuando se realiza una suscripción a la interfaz IObservable de BehaviorSubject, la secuencia publicada comienza con el elemento almacenado en búfer actualmente.
Ningún elemento se almacena en búfer ni se publica desde un BehaviorSubject una vez que su interfaz IObserver recibe una finalización.
Ejemplos
En este ejemplo se muestra el objeto BehaviorSubject. En el ejemplo se usa el operador Interval para publicar un entero en una secuencia entera cada segundo. El operador Take completará la secuencia después de publicar 10 enteros. Esta es la secuencia a la que se suscribe behaviorSubject.
Se crean dos suscripciones para la interfaz IObservable de BehaviorSubject para mostrar cómo publica los datos.
Suscripción n.º 1 : esta suscripción se iniciará al principio y mostrará el valor inicial almacenado en búfer del constructor (-9) en la secuencia.
Suscripción n.º 2 : esta suscripción se iniciará después de 5 segundos de suspensión. Esta suscripción muestra que la secuencia comienza con el elemento almacenado en búfer actualmente.
using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Threading;
namespace Example
{
class Program
{
static void Main()
{
//********************************************************************************************************//
//*** A subject acts similar to a proxy in that it acts as both a subscriber and a publisher ***//
//*** It's IObserver interface can be used to subscribe to multiple streams or sequences of data. ***//
//*** The data is then published through it's IObservable interface. ***//
//*** ***//
//*** A BehaviorSubject buffers the last item it published through its IObservable interface. If no ***//
//*** item has been published through its IObservable interface then the initial item provided in the ***//
//*** constructor is the current buffered item. When a subscription is made to the BehaviorSubject's ***//
//*** IObservable interface, the sequence published begins with the currently buffered item. ***//
//*** ***//
//*** No items are buffered or published from a BehaviorSubject once its IObserver interface receives ***//
//*** a completion. ***//
//*** ***//
//*** In this example, we use the Interval operator to publish an integer to a integer sequence every ***//
//*** second. The sequence will be completed by the Take operator after 10 integers are published. ***//
//*** This will be the sequence that the BehaviorSubject subscribes to. ***//
//*** ***//
//*** We will create 2 subscriptions to the BehaviorSubject's IObservable interface to show how it ***//
//*** publishes it's data. ***//
//*** ***//
//*** Subscription #1 : This subscription will start at the very beginning and will show the initial ***//
//*** buffered value from the constructor (-9) in the sequence. ***//
//*** ***//
//*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts ***//
//*** with the currently buffered item. ***//
//********************************************************************************************************//
BehaviorSubject<long> myBehaviorSubject = new BehaviorSubject<long>((-9));
Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(10).Subscribe(myBehaviorSubject);
//********************************************************************************************************//
//*** Subscription #1 : This subscription will start at the very beginning and will show the initial ***//
//*** buffered value from the constructor (-9) in the sequence. ***//
//********************************************************************************************************//
EventWaitHandle wait1 = new EventWaitHandle(false, EventResetMode.ManualReset);
myBehaviorSubject.Subscribe(x => Console.WriteLine("Subscription #1 observes : " + x),
() =>
{
Console.WriteLine("Subscription #1 completed.");
wait1.Set();
});
//********************************************************************************************************//
//*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts ***//
//*** with the currently buffered item. ***//
//********************************************************************************************************//
Thread.Sleep(5000);
EventWaitHandle wait2 = new EventWaitHandle(false, EventResetMode.ManualReset);
myBehaviorSubject.Subscribe(x => Console.WriteLine("{0,30}Subscription #2 observes : {1}", " ", x),
() =>
{
Console.WriteLine("{0,30}Subscription #2 completed.", " ");
wait2.Set();
});
//**************************************************//
// *** Wait for completion on both subscriptions ***//
//**************************************************//
WaitHandle.WaitAll(new WaitHandle[] { wait1, wait2 });
myBehaviorSubject.Dispose();
Console.WriteLine("\nPress ENTER to exit...");
Console.ReadLine();
}
}
}
En la salida siguiente del código de ejemplo se muestran las suscripciones superpuestas.
Subscription #1 observes : -9
Subscription #1 observes : 0
Subscription #1 observes : 1
Subscription #1 observes : 2
Subscription #1 observes : 3
Subscription #1 observes : 4
Subscription #2 observes : 4
Subscription #1 observes : 5
Subscription #2 observes : 5
Subscription #1 observes : 6
Subscription #2 observes : 6
Subscription #1 observes : 7
Subscription #2 observes : 7
Subscription #1 observes : 8
Subscription #2 observes : 8
Subscription #1 observes : 9
Subscription #2 observes : 9
Subscription #1 completed.
Subscription #2 completed.
Press ENTER to exit...