Question

我需要知道如何分发聚合更新...

假设我有一个Id的IObservable和一个产生永无止境的消息流（5-10,000 /秒）的值。现在我想计算很多聚合（例如总和）以定期间隔分配给其他系统 - 假设每个聚合每10秒钟。聚合基于元组的Id（字符串），但可能会分成多个聚合（聚合定义应包含哪些ID - 因此将重叠）。

将会有几千个聚合定义，所以有人对如何解决这个问题有任何想法吗？

概念上：

public struct Update
{
    public string Id { get; }

    public int Value { get; }
}

public class Aggregate
{
    Dictionary<string, Update> latestValues = new Dictionary<string, Update>();

    public void AddUpdate(Update update)
    {
        latestValues[update.Id] = update;
    }

    public int CalculateSum()
    {
        return latestValues.Values.Select(v => v.Value).Sum();
    }
}

更新：

问题的目的是简化真正的问题 - 也许我没做那么好的工作 - 对不起。假设我有多个产生温度的IOT设备，并定期报告此温度（更新流）。然后，不同的用户可以选择查看设备子集的聚合（例如，平均）值。因此，一个客户可能希望查看设备1,2和3的平均值，而另一个客户可能希望查看设备2,3和4的平均值等（聚合定义）

Answer 1

我认为你问的是如何用Rx创建实时阅读模型*。

鉴于我可以从你的问题中猜出，我认为你希望能够使用每条更新消息更新一些当前状态。对于CalculateSum方法，您无法将所有邮件的Value属性加起来，因为有些属性会更新/覆盖现有值。

因此，假设GroupBy看起来像你的朋友。如果您首先将可观察的值序列拆分为子序列，则可以划分并解决问题。

input.GroupBy(i=>i.Id)

如果我们只考虑属于同一个Id的单个值流，那么每个值的总和应该是多少？

-1--1--2-

在这个简单的例子中，答案总是直接传递的价值。即。

input  -1--1--2-
result -1--1--2-

然而，当我们看两个产生值的序列时，它会变得稍微难以计算

inputA  -1-1-2--------
inputB  --1-2-2-3-5-2-
result  -122344-5-7-4-

在这里，我们需要查看序列中每个值的delta，并将该delta推送到结果中。这可以看作是这样的

inputA  -1-1-2--------
 delta  -1-0-1--------

inputB  --1-2-2-3-5-2-
 delta  --1-1-0-1-2-(-3)-

result  -122344-5-7-4-

要创建这种delta投影，您可以编写类似

的内容

input.Scan(new { CurrentValue = 0, Delta = 0 }, (acc, cur) => new { CurrentValue = cur, Delta = cur - acc.CurrentValue }))
    .Select(acc => acc.Delta);

将代码放在一起可能如下所示：

void Main()
{
    var testScheduler = new TestScheduler();
    var input = testScheduler.CreateColdObservable<Update>(
        ReactiveTest.OnNext(010, new Update("a", 1)),       //1
        ReactiveTest.OnNext(020, new Update("b", 1)),       //2
        ReactiveTest.OnNext(030, new Update("c", 3)),       //5
        ReactiveTest.OnNext(040, new Update("a", 1)),       //5
        ReactiveTest.OnNext(050, new Update("b", 2)),       //6
        ReactiveTest.OnNext(060, new Update("a", 2)),       //7
        ReactiveTest.OnNext(070, new Update("b", 2)),       //7
        ReactiveTest.OnNext(080, new Update("b", 3)),       //8
        ReactiveTest.OnNext(090, new Update("b", 5)),       //10
        ReactiveTest.OnNext(100, new Update("b", 2))        //7

    );

    var currentSum = input.GroupBy(i => i.Id)
        .SelectMany(grp => grp.Scan(new { CurrentValue = 0, Delta = 0 }, (acc, cur) => new { CurrentValue = cur.Value, Delta = cur.Value - acc.CurrentValue }))
        .Select(acc => acc.Delta)
        .Scan((acc, cur) => acc + cur);

    var observer = testScheduler.CreateObserver<int>();
    var subscription = currentSum.Subscribe(observer);
    testScheduler.Start();
    subscription.Dispose();

    ReactiveAssert.AreElementsEqual(new[]
        {
            ReactiveTest.OnNext(010, 1),
            ReactiveTest.OnNext(020, 2),
            ReactiveTest.OnNext(030, 5),
            ReactiveTest.OnNext(040, 5),
            ReactiveTest.OnNext(050, 6),
            ReactiveTest.OnNext(060, 7),
            ReactiveTest.OnNext(070, 7),
            ReactiveTest.OnNext(080, 8),
            ReactiveTest.OnNext(090, 10),
            ReactiveTest.OnNext(100, 7)}
        ,
        observer.Messages);
}

// Define other methods and classes here
public struct Update
{
    public Update(string id, int value)
    {
        Id = id;
        Value = value;
    }
    public string Id { get; }

    public int Value { get; }
}

如果要创建多个聚合，则每个新聚合只是上面的查询。您可以通过在分组后共享/发布序列来进行优化，但我首先要确保分析需要这样做。

* CQRS / ES术语中的读取模型。

将可观察数据聚合到多个存储桶

1 个答案: