Question

我想生成一个可观察的文件，这样可以随时取消文件名的发现。为了这个例子，取消在1秒内自动进行。

这是我目前的代码：

class Program
{
    static void Main()
    {
        try
        {
            RunAsync(@"\\abc\xyz").GetAwaiter().GetResult();
        }
        catch (Exception exc)
        {
            Console.Error.WriteLine(exc);
        }
        Console.Write("Press Enter to exit");
        Console.ReadLine();
    }

    private static async Task RunAsync(string path)
    {
        var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
        await GetFileSource(path, cts);
    }

    private static IObservable<string> GetFileSource(string path, CancellationTokenSource cts)
    {
        return Observable.Create<string>(obs => Task.Run(async () =>
        {
            Console.WriteLine("Inside Before");
            foreach (var file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories).Take(50))
            {
                cts.Token.ThrowIfCancellationRequested();
                obs.OnNext(file);
                await Task.Delay(100);
            }
            Console.WriteLine("Inside After");
            obs.OnCompleted();
            return Disposable.Empty;
        }, cts.Token))
        .Do(Console.WriteLine);
    }
}

我不喜欢我实施的两个方面（如果还有更多 - 请随时指出）：

我有一个可枚举的文件，但我手动迭代每个文件。我能以某种方式使用ToObservable扩展吗？
我无法弄清楚如何使用传递给cts.Token的{{1}}。不得不使用从外部上下文（Task.Run参数）捕获的cts。对我来说似乎很难看。

这是怎么做的？必须是更好的方式。

Answer 1

我建议您在使用其他运营商时避免使用Observable.Create。

此外，当您在return Disposable.Empty;内执行Observable.Create时，您正在创建一个无法被普通Rx订阅一次性停止的可观察对象。这可能导致内存泄漏和不必要的处理。

最后，抛出异常来结束正常计算是一个坏主意。

有一个很好的清洁解决方案，似乎可以做你想要的：

private static IObservable<string> GetFileSource(string path, CancellationTokenSource cts)
{
    return
        Directory
            .EnumerateFiles(path, "*", SearchOption.AllDirectories)
            .ToObservable()
            .Take(50)
            .TakeWhile(f => !cts.IsCancellationRequested);
}

我唯一没有提到的是Task.Delay(100);。你为什么这样做？

Answer 2

我仍然不相信这确实是一个反应性问题，你要求生产者背压，这实际上是反对Reactive应该如何运作。

话虽如此，如果您打算这样做，您应该意识到，非常细粒度的时间操作应该几乎总是委派给Scheduler而不是尝试与Tasks进行协调和CancellationTokens。所以我会重构看起来像这样：

public static IObservable<string> GetFileSource(string path, Func<string, Task<string>> processor, IScheduler scheduler = null) {

  scheduler = scheduler ?? Scheduler.Default;

  return Observable.Create<string>(obs => 
  {
    //Grab the enumerator as our iteration state.
    var enumerator = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
                              .GetEnumerator();
    return scheduler.Schedule(enumerator, async (e, recurse) =>
    {
      if (!e.MoveNext())
      {
         obs.OnCompleted();
         return;
      }

      //Wait here until processing is done before moving on
      obs.OnNext(await processor(e.Current));

      //Recursively schedule
      recurse(e);
    });
  });

}

然后，使用TakeUntil：

，而不是传入取消令牌

var source = GetFileSource(path, x => {/*Do some async task here*/; return x; })
 .TakeUntil(Observable.Timer(TimeSpan.FromSeconds(1));

您还可以看到async Generate method实现的更高级示例。

什么是生成可取消的文件名可观察文件的Rx.NET方法？

2 个答案: