3

CreateRegistryObservable私が取り組んでいる次のクラスのメソッドではIDisposable、次の行で割り当てられたものをきれいに破棄する方法を理解するのに苦労しています。これの問題は、宣言された配列変数を {null} 初期化でキャプチャするデリゲートActionとして割り当てられたものから参照していて、呼び出しによって返されるものの代入が呼び出し時に反映されないことです。このアクションの。スケジューラをきれいに破棄するにはどうすればよいですか?onCompleteSchedule()

scheduler[0] = Scheduler.CurrentThread.Schedule(iterator);

public class RegistryKeyMonitor<T> : IObservable<T>
{
    private readonly RegistryKey _registryKey;
    private readonly string _name;
    private readonly TimeSpan _timeSpan;
    private readonly ILog _logger = LogManager.GetLogger("RegistryKeyMonitor");

    public RegistryKeyMonitor(RegistryKey registryKey, string name, TimeSpan timeSpan)
    {
        _registryKey = registryKey;
        _name = name;
        _timeSpan = timeSpan;
    }

    public IDisposable Subscribe(IObserver<T> observer)
    {
        var sub =CreateRegistryObservable(_registryKey, _name, _timeSpan)
            //.Catch(Observable.Empty<object>())
            .Where(obj => obj != null)
            .Cast<T>();
        return sub.Subscribe(observer);

    }

    private IObservable<object> CreateValueChangeObservable(RegistryKey registryKey, string name, object initialValue, 
        TimeSpan timeSpan, CancellationToken token)
    {
        return Observable.Create<object>(o =>
            {
                var scheduler = Scheduler.Immediate;

                Action<object, Action<object, TimeSpan>> iterator = (current, self) =>
                    {
                        try
                        {
                            if (token.IsCancellationRequested) 
                            {   
                                o.OnCompleted();
                                return;
                            }
                            var value = registryKey.GetValue(name);
                            _logger.DebugFormat("{0} == registryKey.GetValue(name)", value);
                            if (current == null && value != null ||
                                current != null && !current.Equals(value))
                            {
                                _logger.DebugFormat("passing data {0}", value);
                                o.OnNext(value);
                            }
                            else
                                self(value, timeSpan);
                        }
                        catch (Exception e)
                        {
                            o.OnError(e);
                        }
                    };

                return scheduler.Schedule(initialValue, timeSpan, iterator);
            });
    }

    public IObservable<object> CreateRegistryObservable(RegistryKey registryKey, string name, TimeSpan timeSpan)
    {

        return Observable.Create<object>(o =>
            {
                var cancel = new CancellationDisposable();

                return new CompositeDisposable(cancel, 
                    NewThreadScheduler.Default.Schedule(() =>
                        {
                            IDisposable[] scheduler = {null};
                            var currentStateSubscription = new SerialDisposable();
                            object currentValue = null;

                            Action<Action> iterator = self =>
                                currentStateSubscription.Disposable =
                                CreateValueChangeObservable(registryKey, name, currentValue,
                                                            timeSpan, cancel.Token)
                                    .Subscribe(value =>
                                    {
                                        currentValue = value;
                                        self();
                                        o.OnNext(value);
                                    },
                                    o.OnError, 
                                    ()=> {
                                            currentStateSubscription.Dispose();
                                            scheduler[0].Dispose();
                                    }
                                    );
                            scheduler[0] = Scheduler.CurrentThread.Schedule(iterator);
                    }));
            });
    }
}
4

1 に答える 1

0

私はちょうどそれを自分で考え出しました、それは次のとおりです。

public IObservable<object> CreateRegistryObservable(RegistryKey registryKey, string name, TimeSpan timeSpan)
    {

        return Observable.Create<object>(o =>
            {
                var cancel = new CancellationDisposable();

                var currentStateSubscription = new SerialDisposable();

                object currentValue = null;

                return new CompositeDisposable(cancel, NewThreadScheduler.Default.Schedule(
                    self => currentStateSubscription.Disposable =
                        CreateValueChangeObservable(registryKey, name, currentValue,
                                                    timeSpan, cancel.Token)
                            .Subscribe(value =>
                            {
                                currentValue = value;
                                self();
                                o.OnNext(value);
                            },
                            o.OnError, 
                            currentStateSubscription.Dispose
                            )
                    ));
            });
    }
于 2013-09-22T15:37:50.980 に答える