NewEvt2Rx.cs

using Codeplex.Reactive;
using System;
using System.Reactive;
using System.Reactive.Subjects;
using System.Windows;
using System.Windows.Interactivity;
using System.Reactive.Linq;

namespace WpfApplication1
{
    public class EventToReactive2 : TriggerAction<FrameworkElement>
    {
        private Subject<object> source = new Subject<object>();

        private IDisposable d;

        public IEventToReactiveConverter Converter
        {
            get { return (IEventToReactiveConverter)GetValue(ConverterProperty); }
            set { SetValue(ConverterProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Converter.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ConverterProperty =
            DependencyProperty.Register("Converter", typeof(IEventToReactiveConverter), typeof(EventToReactive2), new PropertyMetadata(new DefaultEventToReactiveConverter()));



        public bool IgnoreEventArgs
        {
            get { return (bool)GetValue(IgnoreEventArgsProperty); }
            set { SetValue(IgnoreEventArgsProperty, value); }
        }

        // Using a DependencyProperty as the backing store for IgnoreEventArgs.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IgnoreEventArgsProperty =
            DependencyProperty.Register("IgnoreEventArgs", typeof(bool), typeof(EventToReactive2), new PropertyMetadata(false));




        public IReactiveProperty ReactiveProperty
        {
            get { return (IReactiveProperty)GetValue(ReactivePropertyProperty); }
            set { SetValue(ReactivePropertyProperty, value); }
        }

        // Using a DependencyProperty as the backing store for ReactiveProperty.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ReactivePropertyProperty =
            DependencyProperty.Register("ReactiveProperty", typeof(IReactiveProperty), typeof(EventToReactive2), new PropertyMetadata(null));

        protected override void OnAttached()
        {
            base.OnAttached();
            this.Converter.AssociateObject = this.AssociatedObject;
            this.d = this.Converter.Execute(this.source).Subscribe(x => this.ReactiveProperty.Value = x);
        }

        protected override void Invoke(object parameter)
        {
            if (!this.IgnoreEventArgs)
            {
                source.OnNext(parameter);
            }
            else
            {
                source.OnNext(Unit.Default);
            }
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();
            this.d.Dispose();
        }
    }

    public interface IEventToReactiveConverter
    {
        FrameworkElement AssociateObject { get; set; }
        IObservable<object> Execute(IObservable<object> source);
    }

    public abstract class EventToReactiveConverter<TSource, TResult> : IEventToReactiveConverter
    {

        public FrameworkElement AssociateObject { get; set; }

        public IObservable<object> Execute(IObservable<object> source)
        {
            return this.Execute(source.OfType<TSource>()).Select(x => (object)x);
        }

        protected abstract IObservable<TResult> Execute(IObservable<TSource> source);
    }

    class DefaultEventToReactiveConverter : IEventToReactiveConverter
    {
        public FrameworkElement AssociateObject { get; set; }
        public IObservable<object> Execute(IObservable<object> source)
        {
            return source;
        }
    }
}