Има ли начин да чуете, че няма събития, които се повдигат в 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);
        }
    }
}

Изтеглих пакета Rx-WPF nuget ще изтегли всичко останало, необходимо за кода. Това е .NET 4.5.

Това е пример, който показва как да решите проблема. т.е. не препоръчвам използването на .ObserveOnDispatcher(), не препоръчвам писане на код отзад и знам, че настройката IsEnabled в квадратче за отметка не е всъщност извършване на проверка на правописа. Надявам се, че това е достатъчно за публиката, за да пресъздаде тяхното действително решение.

Все пак се надявам да помогне.

Страхотен въпрос.

Вероятно има много начини за решаване на това, но ето един, с който можете да работите. Първо имаме нужда от наблюдаемата последователност на източника. Това вероятно е събитие с натискане на клавиш или събитие, променено на свойството, което е преобразувано в последователност за наблюдение с помощта на FromEvent или някаква друга фабрика/преобразуване или може би ReactiveUI.

В този пример ще използвам Observable.Interval(TimeSpan.FromSeconds(0.25)).Take(4); като заместител на изходната последователност (само за да докажа концепцията).

След това трябва да решим кога трябва да деактивираме функцията (SpellCheck?). Това е, когато изходната последователност дава стойност.

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");
}

source yourscript.sh

Вярвам в този пример с 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 всяка секунда, поне при моето тестване.