标签: reactive-programming

从Stream生成IObservable <String>的首选方法

作为我们的应用程序的一部分(现在生产大约4个月),我们有一个来自外部设备的数据流,我们将其转换为IObservable

到目前为止,我们一直在使用以下方法来生成它,并且它一直运行良好.

IObservable<string> ObserveStringStream(Stream inputStream)
{
    var streamReader = new StreamReader(inputStream);
    return Observable
            .Create<string>(observer => Scheduler.ThreadPool
            .Schedule(() => ReadLoop(streamReader, observer)));
}

private void ReadLoop(StreamReader reader, IObserver<string> observer)
{
    while (true)
    {
        try
        {
            var line = reader.ReadLine();
            if (line != null)
            {
                observer.OnNext(line);
            }
            else
            {
                observer.OnCompleted();
                break;
            }
        }
        catch (Exception ex)
        {
            observer.OnError(ex);
            break;
        }
    }
}
Run Code Online (Sandbox Code Playgroud)

昨晚我想知道是否有办法使用yield return语法来实现相同的结果并想出了这个:

IObservable<string> ObserveStringStream(Stream inputStream)
{
    var streamReader = new StreamReader(inputStream);
    return ReadLoop(streamReader)
            .ToObservable(Scheduler.ThreadPool);
}

private IEnumerable<string> ReadLoop(StreamReader reader) …
Run Code Online (Sandbox Code Playgroud)

c# reactive-programming system.reactive

8
推荐指数
1
解决办法
2595
查看次数

rxjava和clojure异步神秘:期货承诺和代理人,哦,我的

我提前为本说明的长度道歉.我花了相当多的时间把它做得更短,而且这个小到我能得到它.

我有一个谜,非常感谢你的帮助.这个谜团来自于observer我在Clojure中写的一个rxjava的行为,这个rxjava来自于几个简单observable的在线样本.

一个observable同步onNext向其观察者的处理程序发送消息,我所谓的原则观察者表现得如预期的那样.

另一个observable异步在另一个线程上通过Clojure执行相同的操作future.完全相同的观察者不会捕获发布到其上的所有事件onNext; 它似乎在尾部丢失了随机数量的消息.

在等待promised onCompleted的到期和等待发送给agent收集器的所有事件的到期之间存在有意的争用.如果promise获胜,我希望看到false的onCompleted,并在一个很短可能队列agent.如果agent获胜,我希望看到true的onCompleted,所有的消息来自agent的队列.我不希望的一个结果是true来自onCompletedAND的短队列agent.但是,墨菲没有睡觉,而这正是我所看到的.我不知道垃圾收集是否有问题,或者是否有一些内部排队到Clojure的STM,或者我的愚蠢,或者完全不同的东西.

我在这里以自包含形式的顺序呈现源代码,以便可以直接运行lein repl.有三个cermonials可以解决问题:首先,leiningen项目文件,project.clj声明依赖于0.9.0Netflix的rxjava版本:

(defproject expt2 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure               "1.5.1"]
                 [com.netflix.rxjava/rxjava-clojure "0.9.0"]]
  :main expt2.core)
Run Code Online (Sandbox Code Playgroud)

现在,命名空间和Clojure要求以及Java导入:

(ns expt2.core
  (:require clojure.pprint) …
Run Code Online (Sandbox Code Playgroud)

clojure netflix reactive-programming rx-java

8
推荐指数
1
解决办法
978
查看次数

React中的onFocus气泡

jsfiddle:https://jsfiddle.net/leiming/5e6rtgwd/

class Sample extends React.Component {

  onInputFocus(event) {
    console.log('react input focus')
  }

  onSpanFocus(event) {
    console.log('react span focus')
      // event.stopPropagation()
  }

  render() {
    return ( <span onFocus = {this.onSpanFocus}>
      react input: <input type="text"
      onFocus = {this.onInputFocus} />
      </span> )
  }
}

ReactDOM.render( < Sample / > ,
  document.getElementById('container')
);
Run Code Online (Sandbox Code Playgroud)
<div id="container">
  <!-- This element's contents will be replaced with your component. -->
</div>

<div>
  <span onfocus="(function(){console.log('normal span')})()">
  normal input:<input type="text" onfocus="(function(){console.log('normal input focus')})()">
</span>
</div>
Run Code Online (Sandbox Code Playgroud)

jsfiddle:https://jsfiddle.net/leiming/5e6rtgwd/

使用反应, …

html5 reactive-programming reactjs

8
推荐指数
1
解决办法
4981
查看次数

RXJava - 一个接一个地运行多个observable(比如concat,但每个observable都有onCompleted)

有没有办法实现以下目标:

我有3个类型的观察者Observable<MyData>.我想要的是:

  • 运行第一个可观察的
  • 观察onCompleted第一个观察者
  • 运行第二个observable
  • 观察onCompleted第二个可观测量
  • 运行第三个observable
  • 观察onCompleted第三个可观测量

这可以用,concat但我只能观察到最后一次onCompleted.

难看的解决方案

我知道,我可以实现这一目标,如果我onCompleted从前一个事件中开始下一个可以理解的话.

题

即使使用任意数量的可观察量,还有其他方法可以实现这一点吗?我想避免从onCompleted事件中将这一切联系在一起,因为这看起来非常丑陋,链接越深,它就越不清楚......

编辑 - UseCase

  • 首先,我想发出代表我的应用程序上次启动时加载的数据的数据(我将数据序列化为光盘)=>原因是,我想要一个非常快速的应用程序启动
  • 然后我想要第二次数据加载,以在空状态下加载最新数据
  • 然后我想要第三次加载数据来加载最新数据的缺失深层数据

我想不断更新UI,我想知道,每个级别的数据加载完成

android reactive-programming rx-java

8
推荐指数
2
解决办法
6413
查看次数

RxJava:如果最后一个任务完成,如何每5秒执行一次任务

我正在使用RxJava.我必须每5秒执行一次特定的任务.通过使用"Observable.Interval"方法完美地工作.但是,我还有以下约束:如果最后一个任务没有完成,则不能执行新任务.在这种情况下,新任务只有在最后一个完成时才需要执行.

我无法弄清楚如何使用RxJava做到这一点.

所有的想法都会非常感激^^

谢谢阅读.

reactive-programming rx-java rx-android reactivex

8
推荐指数
2
解决办法
4819
查看次数

Rx distinctUntilChanged允许在事件之间的可配置时间之后重复

我们暂时考虑以下代码

Rx.Observable.merge(
  Rx.Observable.just(1),
  Rx.Observable.just(1).delay(1000)
).distinctUntilChanged()
  .subscribe(x => console.log(x))
Run Code Online (Sandbox Code Playgroud)

我们希望1只记录一次.但是,如果我们想要允许重复一个值,如果它的最后一次发射是可配置的时间量呢?我的意思是记录两个事件.

例如,拥有如下内容会很酷

Rx.Observable.merge(
  Rx.Observable.just(1),
  Rx.Observable.just(1).delay(1000)
).distinctUntilChanged(1000)
  .subscribe(x => console.log(x))
Run Code Online (Sandbox Code Playgroud)

其中distinctUntilChanged()接受某种超时以允许重复下一个元素.然而,这样的事情不存在,我想知道是否有人知道通过使用高级操作员实现这一点的优雅方式,而不会弄乱需要处理状态的过滤器

javascript reactive-programming rxjs rxjs5

8
推荐指数
1
解决办法
1159
查看次数

每当另一个Observable发射时,跳过源中的下一个发射的运算符

我有一个用例,每当另一个通知者Observable发出时,我都需要Observable跳过其下一个发出。

source:    |---X---X---X---X---X---X---X---X---X---X--|>
notifier:  |-------------X---------X----------X-------|>
result:    |---X---X---X-------X---X-------X-------X--|>
Run Code Online (Sandbox Code Playgroud)

基本上,我希望有一个叫做的运算符skipNextWhen,它以可观察的方式接收通知程序,并跳过源中的下一个发射。

我尝试使用使用pausable运算符的实现(使用来重新实现switchMap),但无法使其正常工作。

停顿的

import { Observable } from 'rxjs/Observable';
import { Subject } from 'rxjs/Subject';
import 'rxjs/add/observable/never';
import 'rxjs/add/operator/startWith';

declare module 'rxjs/Observable' {
    interface Observable<T> {
        pausable: typeof pausable;
    }
}

function pausable<T>(notifier: Observable<boolean>): Observable<T> {
    return notifier.startWith(false).switchMap((paused) => {
        if (paused) {
            return Observable.never();
        } else {
            const source = new Subject();
            this.subscribe(source);
            return source;
        }
    });
}

Observable.prototype.pausable = pausable;
Run Code Online (Sandbox Code Playgroud)

skipNextWhen.ts

import { Observable } …
Run Code Online (Sandbox Code Playgroud)

reactive-programming rxjs rxjs5

8
推荐指数
2
解决办法
625
查看次数

Spring 5 Reactive WebSockets:推荐使用

我一直在学习Spring 5 WebFlux,反应式编程和websockets.我看过Josh Long的Spring Tips:Spring Framework 5的Reactive WebSockets.其通过WebSocket连接从服务器将数据发送到客户端的代码使用一个Spring集成IntegrationFlow一个发布到PublishSubcribeChannel其中有一个自定义MessageHandler订阅了它,是以消息时,它转换为一个对象,然后将其转化成JSON和发射到FluxSink从提供给Flux.create()的回调函数,用于发送给WebSocketConnection.

我想知道是否使用IntegrationFlow和PublishSubscribeChannel是将事件从后台进程推送到客户端的推荐方法,或者在这个特定示例中是否更方便(监视文件系统).我想如果你能控制后台进程,你可以让它FluxSink直接发射吗?

我正在考虑类似于以下的用例:

  • 机器学习过程,其进度受到监控
  • 更新发送给玩家的游戏世界状态
  • 聊天室/团队协作软件
  • ...

spring reactive-programming websocket spring-webflux

8
推荐指数
1
解决办法
1198
查看次数

.subscribe和.drive有什么区别

我是反应式编程的新手,这是我正在尝试的

.驾驶

searchController.rx.text
        .asDriver()
        .drive(onNext: { (element) in
            print(element)
        }).disposed(by: disposeBag)
Run Code Online (Sandbox Code Playgroud)

.订阅

searchController.rx.text
        .asObservable()
        .subscribe(onNext: { (element) in
            print(element)
        }).disposed(by: disposeBag)
Run Code Online (Sandbox Code Playgroud)

这两个区块的工作完全一样,什么是使用的目的.drive了.subscribe?在这情况下,我们应该使用.drive过.subscribe?

任何帮助将不胜感激

reactive-programming rx-swift reactivex

8
推荐指数
1
解决办法
1710
查看次数

RxJava - 何时以及为何使用Observable.share()

我见过这样的照片:

Observable<String> nameChanges = nameDataSource.changes().share();

// One subscriber
autoUnsubscribe(nameChanges.subscribe(() -> { ... }));

// Another subscriber
autoUnsubscribe(nameChanges.map(...).filter(...).subscribe(...));

// autoUnsubscribe is called when the UI is torn down
Run Code Online (Sandbox Code Playgroud)

我的问题是:

为什么每当我想在多个地方收听Observable时都需要调用share()?


为什么不是share()所有observable的默认行为?

如果上面的代码即使没有相同的工作也会很好.share().我不需要考虑何时需要共享Observable,何时不需要.

是出于性能原因,因为拥有一个订户是一个特殊情况,可以更有效地处理?

从文档中我不清楚:

share()返回一个新的ObservableSource,它可以多播(共享)原始的ObservableSource.只要至少有一个观察者,这个ObservableSource就会被订阅并发出数据.

在此输入图像描述

android reactive-programming rx-java rx-java2

8
推荐指数
1
解决办法
2608
查看次数