Question

我们正在使用Reactive处理一系列项目。处理的一部分是可配置的流水线，其转换项目（T→＆gt; U，例如int - ＆gt; char在一个普通的情况下）。例如，我们的天真实现看起来像

// simple base class, implements IObserver and IObservable which is
// equivalent to ISubject<T,U>
public abstract class ObservableTask<T, U> : IObserver<T>, IObservable<U>
{
    // NOTE: stateful, blech
    private readonly Subject<U> observable = new Subject<U>();

    public void OnCompleted() { }
    public void OnError(Exception error) { }
    public void OnNext(T value) { observable.OnNext(Process(value)); }
    public IDisposable Subscribe(IObserver<U> observer) 
    {
        return observable.Subscribe(observer);
    }
    public abstract U Process(T value);
}

// trivial implementation of a transform task, transforms an
// input of type int into an output of type char
public class TransformTask : ObservableTask<int, char>
{
    public override char Process(int value)
    {
        Console.WriteLine("Transform '{0}'", value);
        return (char)(value + 64);
    }
}

// trivial report, does not transform but performs IO-bound
// task and passes value to any other subsequent subscribers
public class ReportTask : ObservableTask<char, char>
{
    public override char Process(char value)
    {
        Console.WriteLine("Report '{0}'", value);
        return value;
    }
}

// simple harness that produces desired output/behaviour
public static class ObservableTasks
{
    public static void ChainThings()
    {
        Console.WriteLine("begin observable tasks");

        // NOTE: would use config/reflection to assemble pipe;
        // here we use concrete instances for demonstration only
        TransformTask a = new TransformTask();
        ReportTask b = new ReportTask();

        int[] numbers = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };
        var s = numbers.ToObservable().Publish();
        a.Subscribe(b);
        s.Subscribe(a);
        s.Connect();
        Console.WriteLine("begin observable tasks");
    }
}

上述模型有许多好处;也就是说，我们可以直观地开发工作单元，并创建一个简单的框架来组合任何类型的管道。

但是，如上所述，我们的内部Subject<T,U>是faux-pas。我在使用Observable上的工厂方法时没有太多运气。*模仿前面的行为（即创建一个Observable供订阅者订阅并在元素到达时调用）。

transforming sequences的唯一其他引用稍后，并引用Linq用法。从理论上讲，我们可以适应这样的事情

public class TransformTask
{
    public char Select(int value)
    {
        Console.WriteLine("Transform '{0}'", value);
        return (char)(value + 64);
    }
}

public class ReportTask
{
    public char Select(char value)
    {
        Console.WriteLine("Report '{0}'", value);
        return value;
    }
}

public static class SelectTasks
{
    public static void ChainThings()
    {
        Console.WriteLine("begin select tasks");
        TransformTask a = new TransformTask();
        ReportTask b = new ReportTask();
        int[] numbers = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };

        // in theory we could build this up dynamically 
        // with expression trees
        var s = numbers.
            ToObservable().
            Select(a.Select).
            Select(b.Select).
            Publish();

        // empty subscription?
        s.Subscribe(value => { });
        s.Connect();
        Console.WriteLine("end select tasks");
    }

}

再次，一些好处和成本。通过比较更容易实现，但基础设施将更加困难（可观察的动态表达式构造）。

首先，任何人都可以解决类似的问题并且能够分享一些见解吗？

其次，（我对Reactive和函数式编程很陌生）是变换和＆＃34;行为＆＃34; （即Bind TransformTask和Observer ReportTask）绝对不同，Select应该用于一个而Subscribe（观察者）用于另一个？

Answer 1

我不确定你是否需要主题......

您可能希望转换整个observable，而不是将自己局限于映射，因此您可以使用这样的接口......

public interface IStep<T, TResult>
{
    public IObservable<TResult> Transform(IObservable<T> source);
}

一旦存在，您可以定义一些扩展方法（仅为了方便起见）以帮助使用该步骤，如此...

public static class ObservableExtensions
{
    public static IObservable<TResult> Let(this IObservable<T> source, Func<IObservable<T>, IObservable<TResult>> let)
    {
        return let(source);
    }

    public static IObservable<TResult> Let(this IObservable<T> source, IStep<T, TResult> step)
    {
      return source.Let(step.Transform);
    }
}

然后你可以像这样定义你的步骤......

public class TransformStep : IStep<int, char>
{
    public IObservable<char> Transform(IObservable<int> source)
    {
        return source.Map(IntToChar); 
    }

    public char IntToChar(int value)
    {
        return (char)(value + 64);
    }
}

public class ReportStep : IStep<char, char>
{
    private readonly Logger logger;

    public ReporterStep(Logger logger)
    {
      this.logger = logger;
    }

    public IObservable<char> Transform(IObservable<char> source)
    {
        return source.Do(Report);
    }

    public void Report(char value)
    {
        logger.Log("Report '{0}'", value);
    }
}

并以或多或少的统一方式使用它们......

Observable.Return<int>(10)
  .Let(new TransformStep())
  .Let(new ReportStep(logger))
  .Subscribe();

这样，与每个步骤相关联的所有逻辑都可以在步骤的内部，并且您只需简单地序列化/反序列化，然后将它们链接在一起。

如何在不使用内部主题<t，u> </t，u> </t，u>的情况下链接变换的ISubject <t，u>

1 个答案: