.Net Reactive Extension gir utviklere et sett med funksjoner for å implementere en reaktiv programmeringsmodell for .Net-utviklere for å gjøre hendelseshåndtering enklere og mer uttrykksfull ved bruk av deklarative handlinger. Selv om de viktigste hjørnesteinene i reaktiv skalering er IObserver og IObservable-grensesnittene, trenger du som utvikler ofte ikke å implementere disse grensesnittene selv. Biblioteket støtter den innebygde typen Subject<T>, som implementerer grensesnitt og støtter mange funksjoner.
Temaer er grunnlaget for de ulike temaene som er tilgjengelige i biblioteket, og det finnes andre temaer – ReplaySubject<T>, BehaviorSubject<T> og AsyncSubject<T>. Det er nyttig å forstå de grunnleggende forskjellene mellom dem og hvordan man kan bruke dem for å utnytte biblioteket bedre.
I denne artikkelen skal vi sammenligne Subjektet<T> og dets søsken, og prøve å illustrere forskjellene mellom deres atferd.
Tema<T>
Som nevnt tidligere,<T> er Subject grunnlaget for de tilgjengelige temaene, og gir en enkel måte å bruke biblioteket på uten å måtte implementere IObservable<T>- og IObserver-grensesnittene<T> selv. En enkel demonstrasjon av tematypen vises nedenfor.
I koden ovenfor opprettet vi en <T>instans av Subject, og siden den implementerer<T> IObserver og IObserverable<T>, bruker vi samme instans til å abonnere og publisere verdien til IObserver. Et annet viktig poeng å merke seg her er hvordan vi bruker overbelastningen i Subscribe-metoden for å akseptere handlinger som input. Dette gjøres for hver publisert verdi, i dette tilfellet ved å skrive tallet ut til konsollen.
La oss prøve å vise de publiserte verdiene og verdiene som IObserver (i denne <T>handlingen) skriver ut til konsollen i bildet nedenfor. Dette vil hjelpe oss å enkelt sammenligne de gjenværende søsknene og variantene.
Den første linjen representerer den publiserte verdien, og den andre linjen representerer verdien mottatt av IObserveren. I tillegg har vi lagt til en linje som indikerer på hvilket punkt observatøren abonnerer på strømmen under utførelsen. Denne linjen er representert av en vertikal stiplet linje.
I koden ovenfor la vi merke til at observatøren abonnerte på datastrømmen før den første verdien ble publisert. Bildet viser abonnentlinjen plassert foran det første elementet. Som du kan se fra utgangslinjen, har dette ingen effekt på utgangen (på dette tidspunktet).
Men hva om observatøren bare abonnerer på dataene etter at noen verdier allerede er publisert? Har dette noen innvirkning på dataene observatørene mottar? Før vi ser på utdata, la oss skrive samme kode først.
I koden ovenfor kan vi observere at observatøren abonnerer på datastrømmen først etter at to verdier (1 og 2) er publisert. Som man kan forvente, vil dette føre til at observatører ikke mottar data publisert før abonnementsmetoden kalles. Som vist i figuren under.
Hva om du vil lese alle publiserte verdier, selv om observatøren abonnerer sent? Det er her ReplaySubject kommer inn<T> i bildet.
ReplaySubject<T>
ReplaySubject<T> cacher verdier og spiller dem av for senere abonnenter. Dette er nyttig for å unngå løpsforhold. La oss endre den forrige koden til å bruke ReplaySubject<T> og se hvordan det påvirker hva observatøren mottar.
Som vist i koden ovenfor, er det<T> <T>knapt noen endring i koden bortsett fra at vi nå bruker ReplaySubject i stedet for subject. Følgende diagram illustrerer virkningen på dataene observatøren mottar.
Som vist på bildet, spilles den bufrede verdien nå av til abonnenten selv om abonnenten abonnerer senere. Selvfølgelig kommer denne nyttige funksjonen med en pris. Denne implementasjonen vil cache alle verdier publisert av abonnenten, noe som kan føre til dårlige minneproblemer når datamengden er betydelig større.
ReplaySubject<T> har imidlertid mer enn én måte å løse dette problemet på. For eksempelets skyld skal vi se på to eksempler som bruker størrelses- og tidsbegrensninger for å begrense den bufrede verdien.
I det første tilfellet vil vi bruke størrelsen på cachen for å begrense verdien av cachen. <T>ReplaySubjects konstruktør gir en overbelastning, som aksepterer et heltall som representerer størrelsen på cachebufferen (maksimalt antall elementer). I vårt eksempel, la oss endre koden for å begrense cache-størrelsen til 1.
Legg merke til hvordan vi bruker <T>ReplaySubjects konstruktøroverbelastning for å gi størrelsen på cachen som 1. Dette begrenser caching og sikrer at kun ett element caches og erstattes med et nytt element så snart det publiseres. Konsekvensene av endringen vises nedenfor.
En annen måte å begrense caching på er å begrense tiden til det bufrede elementet, eller med andre ord, å gi en utløpstid for det bufrede elementet.
La oss skrive kode for å illustrere det eksempelet.
På samme måte som i forrige kode bruker vi<T> overbelastningen i ReplaySubject-konstruktøren for å spesifisere utløpstiden til elementer i cachen. For å demonstrere vår sak, innførte vi en forsinkelse mellom utgivelsen av verdier.
Siden det tar hele 1200 ms før observatøren abonnerer, vil alle elementer som overstiger 1000 ms utløpstid bli fjernet fra cachen. I dette eksempelet vil dette føre til at verdi 1 fjernes fra cachen og ikke spilles av for sene abonnenter. Som vist i figuren under.
Det <T>finnes andre overbelastninger for ReplaySubject som gir mer fleksibilitet og finjusterer de bufrede verdiene, men for eksempel beholder vi de to eksemplene som allerede er dekket ovenfor.
AtferdSubjekt<T>
BehaviourSubject <T>ligner veldig på ReplaySubject<T> ved at det hjelper cache-verdier. Men det er en betydelig forskjell. BehaviourSubject<T> cacher kun den siste publiserte verdien. Før vi går videre på dette, la oss skrive litt kode.
Hvis BehaviorSubject<T> bare cacher én verdi (som er sist kjent), hvordan skiller den seg fra en ReplaySubject av størrelse 1<T>? Følgende diagram gjenspeiler tydelig situasjonen i koden ovenfor.
Dette er imidlertid ikke helt sant. Det er to viktige forskjeller å forstå her. Den første er tilstedeværelsen av mislighold. Merk at i koden ovenfor <T>gir vi verdien 0 som standard i konstruktøren av BehaviourSubject. Hvis det ikke finnes noen verdi i cachen (eller med andre ord, ingen data ble publisert før observatøren abonnerte), vil standardverdien bli returnert. Dette er forskjellig fra ReplaySubject, som har størrelsen 1<T>, som ikke har noen verdi. Følgende kode og en visuell representasjon av sekvensen demonstrerer denne oppførselen.
Den andre forskjellen er hvordan BehaviorSubject<T> og ReplaySubject<T> oppfører seg når de abonnerer på en fullført sekvens. Når du abonnerer etter fullføring, vil BehaviorSubject <T> ikke ha noen verdi, som vist i koden nedenfor.
Abonnenter er garantert å ikke motta noen verdi fordi abonnementer skjer etter fullføring.
Dette <T>er imidlertid tilfellet med ReplaySubject. Det er ingen garanti for at observatøren ikke vil motta noen verdier, som vist i koden nedenfor.
Som vist i koden ovenfor, er cachen 1 i størrelse, og selv om abonnementet kalles etter at kallet er fullført, vil cachen forbli (til utløpsbetingelsen er oppfylt), så i dette tilfellet vil den siste publiserte verdien bli mottatt.
AsynkrontSubjekt<T>
AsyncSubject <T>er det siste søskenet til Subject som vi skal utforske i denne <T>artikkelen, og det ligner veldig på de to forrige (ReplaySubject og BehaviourSubject) ved at det også cacher resultater. Men igjen er det en betydelig forskjell. AsyncSubject publiserer den siste cachede verdien kun hvis sekvensen er markert som fullført <T> (den cacher kun én verdi, den siste verdien).
Vurder følgende kode.
Dette vil generere en verdi for observatøren som sekvensen markerer som den siste verdien publisert før fullføring – verdi 4. Som vist i figuren under.
Men hva skjer hvis vi hopper over kallet som markerer sekvensen som fullført? La oss kommentere ut linjen og prøve igjen.
Dette genererer ingen data for observatøren fordi AsyncSubject<T> publiserer resultater først etter at sekvensen er markert som fullført.
Dette er en betydelig forskjell som alle som bruker AsyncSubject <T>bør huske på.
konklusjon
Denne artikkelen viser <T>forskjellene mellom de ulike søsknene i Subjektet og noen av dets variasjoner. Det er ofte nyttig å være oppmerksom på disse subtile forskjellene, da de kan vise annerledes atferd enn du forventet hvis du ikke er klar over det.
Original lenke:Innloggingen med hyperkoblingen er synlig.
|
Publisert på 27.01.2024 12:17:19
|
|
|
|
Vert|
Publisert på 27.01.2024 12:19:47
|
