Есть ли способ прослушать, что в Reactive Extensions не возникают события?

Вот весь код, показывающий, как приведенный выше код можно перенести в WPF. Похоже, что здесь есть пробел в общении, поэтому я создал все приложение wpf, чтобы доказать это.

<Window x:Class="StackoverFlow_23764884.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel>
        <HeaderedContentControl Header="When checked, spellcheck is enabled (emulated)">
            <CheckBox x:Name="spellChecking" IsChecked="True" IsEnabled="False"/>
        </HeaderedContentControl>

        <HeaderedContentControl Header="Type here to see the Spellcheck enable and disable">
            <RichTextBox x:Name="meh" Width="400" Height="300" />
        </HeaderedContentControl>
    </StackPanel>
</Window>

И код позади:

using System;
using System.Reactive.Linq;
using System.Windows;
using System.Windows.Controls;

namespace StackoverFlow_23764884
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            var source = meh.ObserveTextChanged();
            var disableSpellcheck = source.Select(_ => false);
            var enableSpellcheck = source.Select(_ => Observable.Timer(TimeSpan.FromSeconds(1)))
                                         .Switch()
                                         .Select(_ => true);

            disableSpellcheck.Merge(enableSpellcheck)
                             .DistinctUntilChanged()
                             .ObserveOnDispatcher()
                             .Subscribe(isEnabled => spellChecking.IsChecked=isEnabled);
        }

    }

    public static class ObEx
    {
        public static IObservable<EventArgs> ObserveTextChanged(this RichTextBox rtb)
        {
            return Observable.FromEventPattern<TextChangedEventHandler, EventArgs>(
                h => rtb.TextChanged += h,
                h => rtb.TextChanged -= h)
                .Select(ep => ep.EventArgs);
        }
    }
}

Я вытащил пакет nuget Rx-WPF, чтобы вытащить все остальное, необходимое для кода. Это .NET 4.5.

Это пример, чтобы показать, как решить проблему. т. е. я не рекомендую использовать .ObserveOnDispatcher(), я не рекомендую писать код программной части, и я знаю, что установка IsEnabled для флажка фактически не выполняет проверку орфографии. Я надеюсь, что этого достаточно, чтобы аудитория воссоздала свое реальное решение.

Я надеюсь, что это поможет.

Отличный вопрос.

Вероятно, есть много способов решить эту проблему, но вот один из них, с которым вы можете работать. Сначала нам нужна исходная наблюдаемая последовательность. Вероятно, это событие нажатия клавиши или изменение свойства, которое было преобразовано в наблюдаемую последовательность с использованием FromEvent или какой-либо другой фабрики/преобразования или, возможно, ReactiveUI.

В этом примере я буду использовать Observable.Interval(TimeSpan.FromSeconds(0.25)).Take(4); в качестве замены исходной последовательности (просто для подтверждения концепции).

Далее нам нужно решить, когда нам нужно отключить функцию (Проверка орфографии?). Это когда исходная последовательность дает значение.

var disableSpellcheck = source.Select(_=>false);

Затем нам нужно решить, когда нам нужно снова включить эту функцию. Это когда в исходной последовательности была 1 секунда тишины. Один трюк, который вы можете сделать, чтобы реализовать это, состоит в том, чтобы создать односекундный таймер для каждого события из источника. При создании нового таймера отмените предыдущий. Вы можете сделать это, создав вложенную наблюдаемую последовательность и используя Switch для отмены предыдущих внутренних последовательностей при создании новой.

var enableSpellcheck = source.Select(_=>Observable.Timer(TimeSpan.FromSeconds(1)))
      .Switch()
      .Select(_=>true);

Теперь мы хотим объединить эти две последовательности и отправить результат в метод, который включает/отключает эту функцию.

Observable.Merge(disableSpellcheck, enableSpellcheck)
          .Subscribe(isEnabled=>SetFlag(isEnabled));

Однако, как отмечалось выше, этот вызов SetFlag(false) каждый раз, когда исходная последовательность возвращает значение. Это легко решается с помощью оператора DistinctUntilChanged().

Окончательный пример кода (LinqPad) выглядит следующим образом:

void Main()
{
    //Change this to be the keypress/propertychagned event. The type T doesn't matter we ignore it
    var typing = Observable.Interval(TimeSpan.FromSeconds(0.25)).Take(4);
var silence = Observable.Timer(TimeSpan.FromSeconds(1)).IgnoreElements();
var source = typing.Concat(silence).Concat(typing);

    var disableSpellcheck = source.Select(_=>false);
    var enableSpellcheck = source.Select(_=>Observable.Timer(TimeSpan.FromSeconds(1)))
        .Switch()
        .Select(_=>true);

    Observable.Merge(disableSpellcheck, enableSpellcheck)
            .DistinctUntilChanged()
            .Subscribe(isEnabled=>SetFlag(isEnabled));

}

// Define other methods and classes here
public void SetFlag(bool flag)
{
    flag.Dump("flag");
}

Я верю этому примеру с Throttle решает аналогичную проблему.

Так что что-то в этом роде может сработать и для вас:

var throttled = observable.Throttle(TimeSpan.FromMilliseconds(1000));
using (throttled.Subscribe(x => RestoreThing())) {}

Я не мастер RX, но я создал пример приложения WinForms, которое, кажется, работает. На форме у меня есть textBox1 и button1 и все.

Вот код:

public Form1()
        {
            InitializeComponent();

            var observable = Observable.FromEventPattern(
                s => textBox1.TextChanged += s, s => textBox1.TextChanged -= s)
                //make sure we are on the UI thread
                .ObserveOn(SynchronizationContext.Current)
                //immediately set it to false
                .Do(_ => UpdateEnabledStatus(false))
                //throttle for one second
                .Throttle(TimeSpan.FromMilliseconds(1000))
                //again, make sure on UI thread
                .ObserveOn(SynchronizationContext.Current)
                //now re-enable
                .Subscribe(_ => UpdateEnabledStatus(true));
        }

        private void UpdateEnabledStatus(bool enabled)
        {
            button1.Enabled = enabled;
        }

Это работает так, как вы хотите, и не вызывает метод UpdateEnabledStatus каждую секунду, по крайней мере, в моем тестировании.