La Extensión .Net Reactive proporciona a los desarrolladores un conjunto de funcionalidades para implementar un modelo de programación reactiva para desarrolladores .Net y así hacer la gestión de eventos más sencilla y expresiva mediante acciones declarativas. Aunque los pilares clave del escalado reactivo son las interfaces IObserver e IObservables, como desarrollador a menudo no necesitas implementar estas interfaces tú mismo. La biblioteca soporta el tipo incorporado Subject<T>, que implementa interfaces y soporta muchas funciones.
Los temas son la base para los diferentes temas disponibles en la biblioteca, y hay otros temas: <T>ReplaySubject,<T> BehaviorSubject y <T>AsyncSubject. Es útil entender las diferencias esenciales entre ellas y cómo utilizarlas para aprovechar mejor la biblioteca.
En este artículo, compararemos al<T> Sujeto y a su hermano, intentando ilustrar las diferencias entre su comportamiento.
Asunto<T>
Como se mencionó antes, Subject<T> es la base de los temas disponibles, proporcionando una forma sencilla de usar la biblioteca sin tener que implementar tú mismo las interfaces IObservable<T> e IObserver<T>. A continuación se muestra una sencilla demostración del tipo de tema.
En el código anterior, creamos una <T>instancia de Subject y, dado que implementa<T> IObserver e IObserverable<T>, usamos la misma instancia para suscribirse y publicar el valor en IObserver. Otro punto importante a destacar aquí es cómo usamos la sobrecarga del método Subscribe para aceptar acciones como entrada. Esto se hará para cada valor publicado, en este caso imprimiendo el número en la consola.
Intentemos mostrar los valores publicados y los valores que IObserver (en esta Acción<T>) imprime en la consola en la siguiente imagen. Esto nos ayudará a comparar fácilmente a los hermanos restantes y sus variantes.
La primera línea representa el valor publicado y la segunda línea representa el valor recibido por el IObserver. Además, hemos añadido una línea para indicar en qué momento el observador se suscribe al flujo durante la ejecución. Esta línea está representada por una línea punteada vertical.
En el código anterior, notamos que el observador se suscribía al flujo de datos antes de publicar el primer valor. La imagen muestra la línea de Suscriptor situada antes del primer elemento. Como puedes ver en la línea de salida, esto no afecta a la salida (en este punto).
Pero, ¿qué pasa si el observador solo suscribe a los datos después de que algunos valores ya han sido publicados? ¿Esto tiene algún impacto en los datos recibidos por los observadores? Antes de mirar la salida, escribamos primero el mismo código.
En el código anterior, podemos observar que el observador se suscribe al flujo de datos solo después de que se publiquen dos valores (1 y 2). Como era de esperar, esto hará que los observadores no reciban los datos publicados antes de llamar al método de suscripción. Como se muestra en la figura de abajo.
¿Y si quieres leer todos los valores publicados, incluso si el observador se suscribe tarde? Aquí es donde<T> entra ReplaySubject.
ReplaySubject<T>
ReplaySubject<T> almacena en caché los valores y los reproduce para suscriptores posteriores. Esto es útil para evitar las condiciones de la carrera. Cambiemos el código anterior para usar<T> ReplaySubject y veamos cómo afecta a lo que recibe el observador.
Como se muestra en el código anterior,<T> <T>apenas hay cambios en el código, salvo que ahora usamos ReplaySubject en lugar de subject. El siguiente diagrama ilustra el impacto en los datos recibidos por el observador.
Como se muestra en la imagen, el valor almacenado en caché ahora se reproduce al suscriptor incluso si este se suscribe más tarde. Por supuesto, esta función útil tiene un precio. Esta implementación almacenará en caché todos los valores publicados por el suscriptor, lo que puede causar problemas de memoria defectuosa cuando la cantidad de datos es significativamente mayor.
Sin embargo, ReplaySubject<T> tiene más de una forma de resolver este problema. Para este ejemplo, veremos dos ejemplos que usan restricciones de tamaño y tiempo para limitar el valor almacenado en caché.
En el primer caso, usaremos el tamaño de la caché para limitar su valor. <T>El constructor de ReplaySubject proporciona una sobrecarga, que acepta un entero que representa el tamaño del búfer de caché (conteo máximo de elementos). En nuestro ejemplo, cambiemos el código para limitar el tamaño de la caché a 1.
Fíjate en cómo usamos <T>la sobrecarga del constructor de ReplaySubject para proporcionar el tamaño de la caché como 1. Esto limita la caché y garantiza que solo se almacene en caché un elemento y se sustituya por uno nuevo tan pronto como se publique. El impacto del cambio se muestra a continuación.
Otra forma de limitar la caché es limitar el tiempo del elemento almacenado en caché, o dicho de otro modo, proporcionar un tiempo de caducidad para dicho elemento.
Vamos a escribir código para ilustrar ese ejemplo.
Similar al código anterior, usamos<T> la sobrecarga del constructor ReplaySubject para especificar el tiempo de caducidad de los elementos en la caché. Para demostrar nuestro caso, introdujimos un retraso entre la publicación de valores.
Como tarda 1200 ms completos en que el observador se suscriba, cualquier elemento que supere los 1000 ms de expiración será eliminado de la caché. En este ejemplo, esto hará que el valor 1 se elimine de la caché y no se reproducirá a los suscriptores que se reproducen tarde. Como se muestra en la figura de abajo.
Hay <T>otras sobrecargas para ReplaySubject que ofrecen más flexibilidad y ajustan finamente los valores en caché, pero para ejemplos, mantendremos los dos ejemplos ya mencionados arriba.
ComportamientoSujeto<T>
BehaviourSubject <T>es muy similar a<T> ReplaySubject en que ayuda a almacenar en caché los valores. Pero hay una diferencia significativa. BehaviourSubject<T> almacena en caché solo el último valor publicado. Antes de profundizar en esto, vamos a escribir algo de código.
Si el<T> BehaviourSubject solo almacena en caché un único valor (que es el último que se conoce), ¿en qué se diferencia de un ReplaySubject de tamaño 1<T>? El siguiente diagrama refleja claramente la situación del código anterior.
Sin embargo, esto no es del todo cierto. Hay dos diferencias importantes que hay que entender aquí. La primera es la presencia de impagos. Obstemos que en el código anterior, <T>proporcionamos el valor 0 como predeterminado en el constructor de BehaviourSubject. Si no existe ningún valor en la caché (o dicho de otro modo, no se publicó ningún dato antes de que el observador se suscribiera), se devolverá el valor por defecto. Esto es diferente de ReplaySubject, que tiene un tamaño de 1<T>, y que no tiene ningún valor. El siguiente código y una representación visual de la secuencia demuestran este comportamiento.
La segunda diferencia es cómo se<T> comportan BehaviorSubject y<T> ReplaySubject al suscribirse a una secuencia completada. Cuando te suscribes tras completarlo, el BehaviorSubject <T> no tendrá valor, como se muestra en el código a continuación.
Los suscriptores tienen garantizado que no recibirán ningún valor porque las suscripciones ocurren después de completarse.
Sin embargo, <T>este es el caso de ReplaySubject. No hay garantía de que el observador no reciba ningún valor, como se muestra en el código siguiente.
Como se muestra en el código anterior, la caché tiene un tamaño 1 y, aunque la suscripción se llame tras completar la llamada, la caché permanecerá (hasta que se cumpla la condición de caducidad), por lo que en este caso se recibirá el último valor publicado.
AsyncSubject<T>
<T>AsyncSubject es el último hermano del Subject que exploraremos en este artículo<T>, y es muy similar a los dos anteriores (ReplaySubject y BehaviourSubject) en que también almacena en caché los resultados. Pero, de nuevo, hay una diferencia significativa. AsyncSubject publica el último valor en caché solo si la secuencia está marcada como completa <T> (almacena en caché solo un valor, el último).
Considera el siguiente código.
Esto generará un valor para el observador que indica que la secuencia se marca como el último valor publicado antes de la finalización: valor 4. Como se muestra en la figura de abajo.
¿Pero qué ocurre si saltamos la llamada que marca la secuencia como completada? Vamos a comentar la línea y a intentarlo de nuevo.
Esto no genera datos para el observador porque AsyncSubject<T> publica los resultados solo después de que la secuencia se marca como completada.
Esta es una diferencia significativa que cualquiera que use <T>AsyncSubject debería tener en cuenta.
conclusión
Este artículo demuestra <T>las diferencias entre los distintos hermanos del Sujeto y algunas de sus variaciones. A menudo es útil ser consciente de estas diferencias sutiles, ya que pueden mostrar un comportamiento distinto al que esperabas si no te das cuenta.
Enlace original:El inicio de sesión del hipervínculo es visible.
|
Publicado en 27/1/2024 12:17:19
|
|
|
|
Propietario|
Publicado en 27/1/2024 12:19:47
|
