我正在常见的场景中工作,我希望访问存储库的子集,而不用担心必须保持更新,例如“获取价格大于 10 的所有订单”。我已经实现了一个解决方案,但有两个问题(列在最后)。
存储库的子集可以通过相当于的东西来实现
var expensiveOrders = Repository.GetOrders().Where(o => o.Price > 10);
但这是一个IEnumerable,不会在原始集合更新时更新。我可以添加 的处理程序CollectionChanged,但如果我们想访问更多子集怎么办?
var expensiveOrdersFromBob = expensiveOrders.Where(o => o.Name == Bob);
Run Code Online (Sandbox Code Playgroud)
我们还必须连接一个集合 - 也为这个集合进行了更改。实时更新的概念让我想到了 Rx,因此我开始构建一个ObservableCache,其中包含ObservableCollection自动更新的项目和用于通知的 RX 流。(该流也是在底层更新缓存的内容。)
class ObservableCache<T> : IObservableCache<T>
{
private readonly ObservableCollection<T> _cache;
private readonly IObservable<Tuple<T, CRUDOperationType>> _updates;
public ObservableCache(IEnumerable<T> initialCache
, IObservable<Tuple<T, CRUDOperationType>> currentStream, Func<T, bool> filter)
{
_cache = new ObservableCollection<T>(initialCache.Where(filter));
_updates = currentStream.Where(tuple => filter(tuple.Item1));
_updates.Subscribe(ProcessUpdate);
}
private void ProcessUpdate(Tuple<T, CRUDOperationType> update)
{
var item …Run Code Online (Sandbox Code Playgroud) c# repository observablecollection reactive-programming system.reactive
我有以下场景:
IObservable<E>E以获得E1错误状态,在这种情况下我需要错误消息M1E1以获得E2错误消息M2还有一个额外的复杂性,因为结果 En 和/或错误消息Mn可能取决于所有值E, E1, ..., En-1- 而不仅仅是En-1。
考虑到所有这些,是否有比我正在使用的更好的模式?
[编辑] 根据要求,我添加了一个完整的工作示例;不幸的是,这使得这篇文章变得相当大。
internal class Program
{
private static void Main()
{
var stream = Enumerable.Range(1, 10).Select(i => new Record { Id = i }).ToObservable();
stream
.Select(it => new ComplexType { Item = it })
.SelectIfOk(Process1)
.SelectIfOk(Process2)
.SelectIfOk(ProcessN)
.Subscribe(DisplayResult);
Console.ReadLine();
}
private static ComplexType Process1(ComplexType data)
{ …Run Code Online (Sandbox Code Playgroud) 考虑一下Joe Cheng 的演讲,他解释了他和他的同事如何在闪亮中实现响应式框架(受到Meteor的启发):

有人可以向我解释一下我将如何去查找自动推断出的反应式对象的依赖项(即列出它们的名称和环境,实际访问它们等)shiny::reactive()?
更具体地说,我想在我的自定义“一站式”功能setShinyReactive(包reactr)中使用该信息,该功能构建在闪亮的功能之上。
它必须以某种方式可以通过这些组件/类之一的方法实现:
shiny::Observable)shiny::Observer)shiny::Context和shiny::ReactiveEnvironment)但我仍然对这方面的实际细节感到困惑。
您可以在这里找到我用于逆向工程工作的闪亮版本的分叉版本。该.Rnw文件代表了我目前的知识状况以及有关实际实施的问题。
shiny::reactive()require(shiny)
## Ensure that shiny let's us do our thing //
shiny_opt <- getOption("shiny.suppressMissingContextError")
if (is.null(shiny_opt) || !shiny_opt) {
options(shiny.suppressMissingContextError = TRUE)
}
a <- 10
shiny::makeReactiveBinding("a")
b <- shiny::reactive(a * 2)
## --> this …Run Code Online (Sandbox Code Playgroud) 我正在学习使用 RxJava 进行反应式编程,并且希望同时使用发出的值,而不会在单个执行线程中阻塞。
Observable
.interval(50, TimeUnit.MILLISECONDS)
.take(5)
.subscribe(new Action1<Long>() {
@Override
public void call(Long counter) {
sleep(1000);
System.out.println("Got: " + counter + " thread : "+ Thread.currentThread().getName());
}
});
sleep(10000);
Run Code Online (Sandbox Code Playgroud)
我会得到这个输出
Got: 0 thread : RxComputationThreadPool-1
Got: 1 thread : RxComputationThreadPool-1
Got: 2 thread : RxComputationThreadPool-1
Got: 3 thread : RxComputationThreadPool-1
Got: 4 thread : RxComputationThreadPool-1
Run Code Online (Sandbox Code Playgroud)
我如何异步处理每个事件?像这样
Got: 0 thread : RxComputationThreadPool-1
Got: 1 thread : RxComputationThreadPool-2
Got: 2 thread : RxComputationThreadPool-3
Got: 3 thread : RxComputationThreadPool-4
Got: 4 thread …Run Code Online (Sandbox Code Playgroud) 这两种方法有什么区别,每种方法的最佳情况是什么?我知道它们都能够附加一个函数来处理 IObservable 的排放,但我并不真正理解除此之外的差异。
编辑
抱歉,我应该指定的。IObservable.Add 的定义在这里:
https://msdn.microsoft.com/en-us/library/ee370414.aspx
也许这只是 F# 的事情。顺便说一句,我正在使用 F#。不是 C#。
f# subscribe reactive-programming system.reactive observable
我创建了一个ParallelFlux然后使用了.sequential(),期望在那时我可以计算或“减少”并行计算的结果。问题似乎是并行线程被触发,没有什么在等待它们。
我已经使用 a 完成了一些工作,CountDownLatch但我认为我不应该这样做。
TL; DR - 我无法打印出此代码的结果:
Flux.range(0, 1000000)
.parallel()
.runOn(Schedulers.elastic())
.sequential()
.count()
.subscribe(System.out::println);
Run Code Online (Sandbox Code Playgroud) java reactor reactive-programming project-reactor spring-webflux
我是 Project reactor 的新手,我正在尝试了解 boundedElastic() 与 parallel() 调度程序之间的区别。文档(https://projectreactor.io/docs/core/release/api/)说 boundedElastic() 用于阻塞任务,parallel() 用于非阻塞任务。为什么 Project reactor 需要解决阻塞场景,因为它们本质上是非阻塞的。有人可以帮我解决一些有关 boundedElastic() 与 parallel() 调度程序的实时用例吗?
我正在编写一个基于 Rx 的单向 UI 流,其中每个状态 reduce 是一个Single. 通常这样的流程已经完成scan(它们需要先前的状态),但是当Single涉及到时它有点棘手。我设法让它像这样工作:
val events = Observable.just("event1", "event2", "event3")
val initialState = Single.just(emptyList<String>())
// given a current state produces next state's Single
val reducer = { currentState: List<String>, event: String ->
Single.fromCallable { /* do work */ currentState.plus(event) }
}
events
.scan(
initialState,
{ currentStateSingle, event ->
val nextStateSingle = currentStateSingle
.flatMap { curState -> reducer(curState, event) }
// cache is required to avoid resubscription
// to all previously …Run Code Online (Sandbox Code Playgroud) 在使用 Spring 5 反应式 API 时,我遇到了已弃用的 MediaType APPLICATION_STREAM_JSON_VALUE,当使用它以一种流的方式显示来自 GET REST 端点的值时,它会在值出现在浏览器上时显示它们。但截至今天,文档指出它已被 APPLICATION_NDJSON_VALUE 取代,如文档中的以下文本所示:
APPLICATION_STREAM_JSON_VALUE 已弃用。从 5.3 开始,因为它源自 W3C Activity Streams 规范,该规范具有更具体的目的,并已被不同的 mime 类型替换。使用 APPLICATION_NDJSON 作为替代或任何其他以行分隔的 JSON 格式(例如 JSON 行、JSON 文本序列)。
当我检查 MediaType APPLICATION_NDJSON_VALUE 的行为时,我观察到当在浏览器上使用 GET API 时,结果不是在浏览器上实时流式传输,而是作为文件下载,您可以稍后查看。但这会以任何方式影响流媒体行为还是完全相同?APPLICATION_NDJSON_VALUE 是否也带来了其他一些意义,或者它只是 APPLICATION_STREAM_JSON_VALUE 的纯粹替代品。如果它只是一个替代品,为什么浏览器的流媒体行为会变成 Flux 下载的结果?或者让我知道我在尝试复制确切行为时是否犯了任何错误?
我创建了一个 observable,它由一个项目通过运行异步方法转换为另一个项目组成。
IObservable<Summary> obs = scanner.Scans
.SelectMany(b => GetAssignment(b))
.SelectMany(b => VerifyAssignment(b))
.SelectMany(b => ConfirmAssignmentData(b))
.SelectMany(b => UploadAsset(b))
.Select(assignment => new Summary())
.Catch(LogException());
Run Code Online (Sandbox Code Playgroud)
我想让这个防故障,所以如果在处理过程中抛出异常,我应该记录异常,但忽略异常并继续下一次扫描(由 推送的下一个项目scanner.Scans)
当前代码捕获任何异常,但一旦抛出异常,序列就会结束。
我怎样才能让它“吞下”异常(记录它),但要继续下一个项目?