C# 文件监控系统反应式编程

我正在使用C#。我不熟悉反应式编程。 使用反应式编程，我想创建一个文件夹监控系统，如果文件夹a包含任何文件，它将调用该系统。如果是，它将抓取该文件并对其进行处理，然后将其移动到文件夹B中。 比方说，文件夹A首先是空的。用户将一些文件实时添加到文件夹A中。系统检测到新文件已添加&它将逐个或同时处理该文件。 我无法理解我应该使用什么Create或Interval，在这之后我的处理代码将被写在哪里

---

请帮帮我这应该很近了：

var query =
    Observable
        .Using(
            () =>
            {
                var fsw = new FileSystemWatcher(@"C:\A");
                fsw.EnableRaisingEvents = true;
                return fsw;
            },
            fsw => Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                h => fsw.Created += h,
                h => fsw.Created -= h))
        .Delay(TimeSpan.FromSeconds(0.1));


query
    .Subscribe(x => File.Move(x.EventArgs.FullPath, Path.Combine(@"C:\B", x.EventArgs.Name)));

var查询=
可观察
.使用(
() =>
{
var fsw=newfilesystemwatcher（@“C:\A”）；
fsw.EnableRaisingEvents=true；
返回fsw；
},
fsw=>Observable.FromEventPattern(
h=>fsw.Created+=h，
h=>fsw.Created-=h））
.延迟（时间跨度从秒（0.1））；
查询
.Subscribe（x=>File.Move（x.EventArgs.FullPath，Path.Combine（@“C:\B”，x.EventArgs.Name））；

这应该非常接近：

var query =
    Observable
        .Using(
            () =>
            {
                var fsw = new FileSystemWatcher(@"C:\A");
                fsw.EnableRaisingEvents = true;
                return fsw;
            },
            fsw => Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                h => fsw.Created += h,
                h => fsw.Created -= h))
        .Delay(TimeSpan.FromSeconds(0.1));


query
    .Subscribe(x => File.Move(x.EventArgs.FullPath, Path.Combine(@"C:\B", x.EventArgs.Name)));

var查询=
可观察
.使用(
() =>
{
var fsw=newfilesystemwatcher（@“C:\A”）；
fsw.EnableRaisingEvents=true；
返回fsw；
},
fsw=>Observable.FromEventPattern(
h=>fsw.Created+=h，
h=>fsw.Created-=h））
.延迟（时间跨度从秒（0.1））；
查询
.Subscribe（x=>File.Move（x.EventArgs.FullPath，Path.Combine（@“C:\B”，x.EventArgs.Name））；
FileSystemWatcher
的最小值相对较小（默认为8 KB，最大值为64 KB），如果在短时间内发生突发文件系统更改，则很容易超过该值，并且
FileSystemWatcher
的事件处理程序执行任何耗时的操作。政府建议：

使事件处理代码尽可能短

超出缓冲区的后果是严重的：所有缓冲通知都将丢失。在大多数情况下，如果不是完全不可接受的话，这应该是非常不可取的。因此，在事件调用的同一线程上同步执行重文件移动操作是需要避免的。实现理想异步的一种简单方法是在处理程序和订阅代码之间注入
延迟。一种更复杂的方法是将传入的通知排队，并按顺序或以有限的并发性处理每个文件。运算符既可用于排队，也可用于并发控制。下面是一个例子：

IObservable<Unit> query = Observable
    .Using(() =>
        {
            var fsw = new FileSystemWatcher(@"C:\A");
            fsw.EnableRaisingEvents = true;
            return fsw;
        },
        fsw => Observable.FromEventPattern<FileSystemEventHandler,
            FileSystemEventArgs>(h => fsw.Created += h, h => fsw.Created -= h)
    )
    .Delay(TimeSpan.FromSeconds(0.1))
    .Select(x => Observable.Defer(() => Observable.Start(() =>
    {
        File.Move(x.EventArgs.FullPath, Path.Combine(@"C:\B", x.EventArgs.Name));
    })))
    .Merge(maxConcurrent: 2);

var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));

Task<Unit> task = query.ToTask(cts.Token); // Start the file-watching

IObservable查询=可观察
.使用（（）=>
{
var fsw=newfilesystemwatcher（@“C:\A”）；
fsw.EnableRaisingEvents=true；
返回fsw；
},
fsw=>Observable.FromEventPattern（h=>fsw.Created+=h，h=>fsw.Created-=h）
)
.延迟（时间跨度从秒（0.1））
.选择（x=>Observable.Defer（（）=>Observable.Start（（）=>
{
Move（x.EventArgs.FullPath，Path.Combine（@“C:\B”，x.EventArgs.Name））；
})))
.合并（最大并发数：2）；
var cts=新的CancellationTokenSource（TimeSpan.FromSeconds（30））；
任务=query.ToTask（cts.Token）；//启动文件监视

Observable.Defer
+
Observable.Start
组合用作异步
Observable.fromsync
的同步等价物（因为
File.Move
方法是同步的）

它是Enigmativity的一个修改版本。
FileSystemWatcher
有一个相对较小的值（默认情况下为8 KB，最大值为64 KB），如果在短时间内发生突发文件系统更改，则很容易超过该值，
FileSystemWatcher
的事件处理程序执行任何耗时的操作。政府建议：

使事件处理代码尽可能短

超出缓冲区的后果是严重的：所有缓冲通知都将丢失。在大多数情况下，如果不是完全不可接受的话，这应该是非常不可取的。因此，在事件调用的同一线程上同步执行重文件移动操作是需要避免的。实现理想异步的一种简单方法是在处理程序和订阅代码之间注入
延迟。一种更复杂的方法是将传入的通知排队，并按顺序或以有限的并发性处理每个文件。运算符既可用于排队，也可用于并发控制。下面是一个例子：

IObservable<Unit> query = Observable
    .Using(() =>
        {
            var fsw = new FileSystemWatcher(@"C:\A");
            fsw.EnableRaisingEvents = true;
            return fsw;
        },
        fsw => Observable.FromEventPattern<FileSystemEventHandler,
            FileSystemEventArgs>(h => fsw.Created += h, h => fsw.Created -= h)
    )
    .Delay(TimeSpan.FromSeconds(0.1))
    .Select(x => Observable.Defer(() => Observable.Start(() =>
    {
        File.Move(x.EventArgs.FullPath, Path.Combine(@"C:\B", x.EventArgs.Name));
    })))
    .Merge(maxConcurrent: 2);

var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));

Task<Unit> task = query.ToTask(cts.Token); // Start the file-watching

IObservable查询=可观察
.使用（（）=>
{
var fsw=newfilesystemwatcher（@“C:\A”）；
fsw.EnableRaisingEvents=true；
返回fsw；
},
fsw=>Observable.FromEventPattern（h=>fsw.Created+=h，h=>fsw.Created-=h）
)
.延迟（时间跨度从秒（0.1））
.选择（x=>Observable.Defer（（）=>Observable.Start（（）=>
{
Move（x.EventArgs.FullPath，Path.Combine（@“C:\B”，x.EventArgs.Name））；
})))
.合并（最大并发数：2）；
var cts=新的CancellationTokenSource（TimeSpan.FromSeconds（30））；
任务=query.ToTask（cts.Token）；//启动文件监视

Observable.Defer
+
Observable.Start
组合用作异步
Observable.fromsync
的同步等价物（因为
File.Move
方法是同步的）

这是Enigmativity的一个修改版本。
如果你能分享到目前为止的进展，那将是非常棒的。看看这个课程。如果你能分享到目前为止的进展，那将是非常棒的。看看这个课程。它很接近，但还没有实现，因为你从来没有启动过
FileSystemWatcher
（使用
EnableRaisingEvents
属性）。@Evk-这次我测试了它。为什么要延迟