Articles of system.reactive

Come finestra / buffer IObservable in chunks basato su un Func

Data una class: class Foo { DateTime Timestamp {get; set;} } … e un IObservable , con un Timestamp incrementato in modo monotono , come posso generare un IObservable<IList> suddiviso in elenchi in base a tali Timestamp ? Cioè ogni IList dovrebbe avere cinque secondi di eventi, o qualsiasi altra cosa. So che posso usare […]

La differenza tra Rx Throttle (…) .ObserveOn (scheduler) e Throttle (…, scheduler)

Ho il codice seguente: IDisposable subscription = myObservable.Throttle(TimeSpan.FromMilliseconds(50), RxApp.MainThreadScheduler) .Subscribe(_ => UpdateUi()); Come previsto, UpdateUi() verrà sempre eseguito sul thread principale. Quando cambio il codice in IDisposable subscription = myObservable.Throttle(TimeSpan.FromMilliseconds(50)) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => UpdateUi()); UpdateUI() verrà eseguito in un thread in background. Perché non è Throttle(…).ObserveOn(scheduler) equivalente a Throttle(…, scheduler) ?

Learning Rx: Come usare. Scan sull’output di .Window per una sequenza osservabile di valori bool

Ho una sequenza di veri valori falsi come questo var alternatingTrueFalse = Observable.Generate( true, _ => true, x => !x, x => x, _ => TimeSpan.FromMilliseconds(new Random().Next(2000))) .Take(20).Publish(); alternatingTrueFalse.Connect(); var buffered = alternatingTrueFalse .Buffer(TimeSpan.FromMilliseconds(500)) .Subscribe(x => Console.WriteLine($”{TimeStamp} {string.Join(“,”, x)}”)); Voglio guardare la sequenza in termini di windows / buffer di 500 ms (max). Se c’è […]

Come utilizzare l’interfaccia utente retriggers per triggersre un’azione diversa in seguito a un clic del pulsante con un clic sul pulsante premere (tenere premuto)

Sto cercando di implementare un controllo dell’interfaccia utente in cui l’utente può fare clic su un pulsante per spostare un elemento di un po ‘o tenere premuto il pulsante e far muovere la cosa mentre si tiene premuto il pulsante. Diciamo che ho Task StartMove() , Task StopMove() e Task MoveStep() . Il clic del […]

Come ottenere l’ultimo valore da un object ReplaySubject prima del completamento

Ho bisogno di un modo per afferrare l’elemento più recente aggiunto a un object Replay che soddisfi determinati criteri. Il seguente codice di esempio fa quello che mi serve per farlo ma non sembra l’approccio corretto: static void Main(string[] args) { var o = new ReplaySubject(); o.OnNext(“blueberry”); o.OnNext(“chimpanzee”); o.OnNext(“abacus”); o.OnNext(“banana”); o.OnNext(“apple”); o.OnNext(“cheese”); var latest = […]

Acceleratore solo se è soddisfatta una condizione specifica

Ho un osservabile a cui mi sto iscrivendo. Questo obbiettivo restituirà un object che ha una proprietà chiamata ActivationType che può essere impostata più volte. Quello che sto cercando di ottenere è registrare un messaggio ogni volta che ActivationType è impostato su “Type1”. Tuttavia, se ActivationType è impostato su “Tipo2”, registrare il messaggio solo una […]

Timeout di estensioni reattive che non interrompe la sequenza?

Sto cercando di rendere un IObservable che restituisce true se un messaggio UDP è stato ricevuto negli ultimi 5 secondi e se si verifica un timeout, viene restituito un falso. Finora ho questo: public IObservable GettingUDPMessages(IPEndPoint localEP) { var udp = BaseComms.UDPBaseStringListener(localEP) .Where(msg => msg.Data.Contains(“running”)) .Select(s => true); return Observable .Timeout(udp, TimeSpan.FromSeconds(5)) .Catch(Observable.Return(false)); } I […]

Come posso ottenere un IObservable per inviare il valore più recente al momento della sottoscrizione

Di solito quando ti iscrivi alle modifiche di un valore sei anche interessato a conoscere il valore iniziale. Voglio che il mio IObservable memorizzi il valore più recente (o iniziale) e spinga quel valore alla sottoscrizione. Quando uso eventi semplici, spesso finisco con il codice che sembra x.SomeEvent += SomeEventHandler; SomeEventHandler(x, EventArgs.Empty); Usando IObservable speravo […]

I “IObservable intermedi” senza gli utenti finali vengono tenuti in memoria per tutta la vita del IObservable di root

Ad esempio, considera questo: public IDisposable Subscribe(IObserver observer) { return eventStream.Where(e => e is T).Cast().Subscribe(observer); } eventStream è una fonte di eventi longeva. Un client di breve durata utilizzerà questo metodo per iscriversi per un certo periodo di tempo, quindi annulla l’iscrizione chiamando Dispose sul reso restituibile. Tuttavia, sebbene eventStream esista ancora e debba essere […]

Rx Framework: esegue un’azione sul timeout senza interrompere la sequenza osservabile originale

Data una sorgente osservabile, generata dal polling dello stato (cambiamenti di a) di un dispositivo di basso livello … // observable source metacode: IObservable source = Observable.Interval(TimeSpan.FromSeconds(0.5)) .Select(tick => new DeviceState(_device.ReadValue())) .DistinctUntilChanged(); … e un consumatore che aggiorna l’interfaccia utente … // UI metacode: service.GetObservableDeviceStates() .Subscribe(state => viewModel.CurrentState = state.ToString()); … Ho bisogno di eseguire […]