C#

Sascha Lefèvre wrote:

The trick here is that there's that WeakSubscriber-object which only you hold a strong reference to. The only other reference is a WeakReference in the observable-subscription-object. When you drop your strong reference to it (and a GC occurred), the next event will "trigger" the else-branch with subscription.Dispose() which then causes the strong reference from the collection-eventhandlers to also be dropped.

private class WeakSubscriber
{
    public void Subscribe(ObservableCollection<object> collection)
    {
        collection.ObserveCollectionChanged().SubscribeWeakly(this, HandleEvent);
    }

    private void HandleEvent(WeakSubscriber target, EventPattern<NotifyCollectionChangedEventArgs> item)
    {
        Console.WriteLine("Event received by Weak subscription");
    }
}

public static IObservable<EventPattern<NotifyCollectionChangedEventArgs>> ObserveCollectionChanged(this INotifyCollectionChanged collection)
{
    return Observable.FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(
            handler => (sender, e) => handler(sender, e),
            handler => collection.CollectionChanged += handler,
            handler => collection.CollectionChanged -= handler);
}

Kenneth Haugland wrote:

I also have sort of a side question, and that is how do I enable to write an Expression in the code that allows me to write:
ObservePropertyChanged(Myclass, s => s.MyPropertyInMyClass)

using System;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Reactive;
using System.Reactive.Linq;
using System.Reflection;

namespace RxPropertyChanged
{
    class A : NotifierBase
    {
        public string ID { get; set; }

        public string Name
        {
            get { return name; }
            set { SetProperty(ref name, value); }
        }

        private string name;
    }

    class WeakPropertyChangedSubscriber<TTarget, TProperty>
        where TTarget : INotifyPropertyChanged
    {
        private Action<EventPattern<PropertyChangedEventArgs>> EventAction;

        public WeakPropertyChangedSubscriber(TTarget target, Expression<Func<TTarget, TProperty>> propertyExpr, Action<EventPattern<PropertyChangedEventArgs>> eventAction)
        {
            EventAction = eventAction;
            target.FromPropertyChanged(propertyExpr).SubscribeWeakly(this, HandleEvent);
        }

        private static void HandleEvent(WeakPropertyChangedSubscriber<TTarget, TProperty> subscriber, EventPattern<PropertyChangedEventArgs> item)
        {
            subscriber.EventAction(item);
        }
    }

    public static class IObservableExtensions
    {
        public static IObservable<EventPattern<PropertyChangedEventArgs>> FromPropertyChanged<TTarget, TProperty>(this TTarget target, Expression<Func<TTarget, TProperty>> propertyExpr)
            where TTarget : INotifyPropertyChanged
        {
            var propertyInfo = (propertyExpr.Body as MemberExpression)?.Member as PropertyInfo;

            if (propertyInfo == null)
                throw new ArgumentException("The specified expression does not reference a property.", nameof(propertyExpr));

            return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
                    eventHandler => (s, e) => eventHandler(s, e),
                    //            short for:
                    //eventHandler =>
                    //{
                    //    PropertyChangedEventHandler h = (s, e) => eventHandler(s, e);
                    //    return h;
                    //},
                    propertyChangedEventHandler => target.PropertyChanged += propertyChangedEventHandler,
                    propertyChangedEventHandler => target.PropertyChanged -= propertyChangedEventHandler)
                .Where(evt => evt.EventArgs.PropertyName == propertyInfo.Name);
        }

        public static IDisposable SubscribeWeakly<TEventPattern, TSubscriber>(this IObservable<TEventPattern> observable, TSubscriber subscriber, Action<TSubscriber, TEventPattern> onNext)
            where TSubscriber : class
        {
            if (onNext.Target != null)
                throw new ArgumentException("onNext must refer to a static method, or else the subscription will still hold a strong reference to target");

            var reference = new WeakReference(subscriber);

            IDisposable subscription = null;
            subscription = observable.Subscribe(item =>
            {
                var currentTarget = reference.Target as TSubscriber;
                if (currentTarget != null)
                {
                    onNext(currentTarget, item);
                }
                else
                {
                    Console.WriteLine("subscription.Dispose()");
                    subscription.Dispose();
                }
            });

            return subscription;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            A a1 = new A() { ID = "a1" };
            A a2 = new A() { ID = "a2" };

            Action<A, EventPattern<PropertyChangedEventArgs>> eventAction = (obj, evt) => Console.WriteLine($"{obj.ID}.{evt.EventArgs.PropertyName} = {obj.Name}");

            var subscriberA1 = new WeakPropertyChangedSubscriber<A, string>(a1, x => x.Name, evt => eventAction(a1, evt));
            var subscriberA2 = new WeakPropertyChangedSubscriber<A, string>(a2, x => x.Name, evt => eventAction(a2, evt));

            a1.Name = "name1.1";
            a2.Name = "name2.1";

            subscriberA1 = null;

            GC.Collect();
            Console.WriteLine("Full collection completed");

            a1.Name = "name1.2";
            a2.Name = "name2.2";

            Console.Read();
        }
    }
}

public static IObservable<EventPattern<PropertyChangedEventArgs>> ObservePropertyChanged<TSource,TProperty>(this TSource collection, Expression<Func<TSource, TProperty>> propertyExpr) where TSource : INotifyPropertyChanged
{
    Contract.Requires(collection != null);
    Contract.Requires(propertyExpr != null);

    var body = propertyExpr.Body as MemberExpression;

    if (body == null)
        throw new ArgumentException("The specified expression does not reference a property.", "property");

    var propertyInfo = body.Member as PropertyInfo;

    if (propertyInfo == null)
        throw new ArgumentException("The specified expression does not reference a property.", "property");

    string propertyName = propertyInfo.Name;

    return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
            handler => (sender, e) => handler(sender, e),
            handler => collection.PropertyChanged += handler,
            handler => collection.PropertyChanged -= handler)
            .Where(evt => evt.EventArgs.PropertyName == propertyName);
}

Kenneth Haugland wrote:

This should greatly reduce typing errors (and enable intellisence) compared to requesting a string of the property name only.

Kenneth Haugland wrote:

I assume that TProperty is basically just the result that returns an unidentified object?

Sascha Lefèvre wrote:

to ensure (at runtime) that the expression is "pointing" at a property

    internal class WeakPropertyChangedSubscriber
    {
        public WeakPropertyChangedSubscriber(object WeakClass, IObservable<EventPattern<PropertyChangedEventArgs>> observable,ref IDisposable Result, Action<EventPattern<PropertyChangedEventArgs>> eventAction)
        {
            Result = observable.InternalSubscribeToWeakPropertyChange(eventAction, WeakClass, WeakPropertyChangedSubscriber.HandleEvent);
        }

        public static void HandleEvent(Action<EventPattern<PropertyChangedEventArgs>> subscriber, object reffing, EventPattern<PropertyChangedEventArgs> item)
        {
        subscriber(item);
        }
    }

    public static IDisposable SubscribeWeakly<T>(this IObservable<T> observable, object WeakClass, Action<EventPattern<PropertyChangedEventArgs>> onNext)
    {
        IDisposable Result = null;
        IObservable<EventPattern<PropertyChangedEventArgs>> ObservableCast = (IObservable<EventPattern<PropertyChangedEventArgs>>)observable;
        WeakPropertyChangedSubscriber WeakReferanceChanged = new WeakPropertyChangedSubscriber(WeakClass, ObservableCast, ref Result, onNext);
        return Result;
    }

    private static IDisposable InternalSubscribeToWeakPropertyChange<TEventPattern, TSubscriber, TWeakReferance>(this IObservable<TEventPattern> observable, TSubscriber subscriber, TWeakReferance refing, Action<TSubscriber, TWeakReferance, TEventPattern> onNext)
where TSubscriber : class where TWeakReferance : class
    {
        if (onNext.Target != null)
            throw new ArgumentException("onNext must refer to a static method, or else the subscription will still hold a strong reference to target");

        var reference = new WeakReference(refing);

        IDisposable subscription = null;
        subscription = observable.Subscribe(item =>
        {
            var currentTarget = reference.Target as TWeakReferance;
            if (currentTarget != null)
            {
                onNext(subscriber,currentTarget, item);
            }
            else
            {
                Console.WriteLine("subscription.Dispose()");
                subscription.Dispose();
            }
        });
        return subscription;
    }

var er = ObservableEx.Observe(C, o => o.Name).SubscribeWeakly(C,arg => PropertyChanged(arg.Sender, arg.EventArgs));
C.Name = "test";
C = null;
GC.Collect();
C = new ViewModelB();
C.Name = "2";

return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
  h => h.Invoke,
  h => h.PropertyChanged += h,
  h => h.PropertyChanged -= h)
.Where(evt => evt.EventArgs.PropertyName == the_property_name_you_are_watching)
.Select(evt => getter(target)).Subscribe(changedHandler);

IDisposable DisposableEvent;
...

    DisposableEvent = Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
        h => MyClass.PropertyChanged += h,
        h => MyClass.PropertyChanged -= h)
        .Where(evt => evt.EventArgs.PropertyName == "Name")
        .Subscribe(arg => PropertyChanged(arg.Sender, arg.EventArgs));

...


private void PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    // Unsubscribe to the event
    DisposableEvent.Dispose();
}

Kenneth Haugland wrote:

The last Select(evt => getter(target)) I simpy dont understand at all.

Richard Deeming wrote:

The Select converts the returned value to an IObservable<TResult>, where TResult is the type of the property you're observing. It does this by ignoring the EventArgs, and retrieving the current value of the property instead.

Richard Deeming wrote:

NB: Since it doesn't use a WeakReference, the returned object will keep the target alive, which could potentially cause a memory leak.

IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(
    Func<Action<TEventArgs>, TDelegate> conversion, 
    Action<TDelegate> addHandler, 
    Action<TDelegate> removeHandler);

void Invoke(EventArgs e);

void Invoke(object sender, EventArgs e);

d => (sender, e) => d(e)

private sealed class TheClosure
{
    public Action<EventArgs> TheActionToCall;
    
    public void TheEventHandler(object sender, EventArgs e)
    {
        TheActionToCall(e);
    }
}

private static EventHandler Conversion(Action<EventArgs> d)
{
    TheClosure closure = new TheClosure();
    closure.TheActionToCall = d;
    return closure.TheEventHandler;
}

...

Func<Action<EventArgs>, EventHandler> conversion = Conversion;
return Observable.FromEvent<EventHandler, EventArgs>(conversion, ...).Select(ignored => getter(target));

return Observable.FromEvent<EventHandler, EventArgs>(
    propertyChangedHandler =>
    {
        EventHandler handler = (s, e) => propertyChangedHandler(e);
        return handler;
    },
    h => propertyDescriptor.AddValueChanged(target, h),
    h => propertyDescriptor.RemoveValueChanged(target, h))
    .Select(x => propertyExpr.Compile()(target));

return Observable.FromEvent<EventHandler, EventArgs>(
    propertyChangedHandler => (s, e) => propertyChangedHandler(e),
    h => propertyDescriptor.AddValueChanged(target, h),
    h => propertyDescriptor.RemoveValueChanged(target, h))
    .Select(x => propertyExpr.Compile()(target));

public static class ObservableEx
{
    public static IObservable<TResult> FromPropertyChanged<T, TResult>(T target, Expression<Func<T, TResult>> property)
    {
        Contract.Requires(target != null);
        Contract.Requires(property != null);

        var body = property.Body as MemberExpression;

        if (body == null)
            throw new ArgumentException("The specified expression does not reference a property.", "property");

        var propertyInfo = body.Member as PropertyInfo;

        if (propertyInfo == null)
            throw new ArgumentException("The specified expression does not reference a property.", "property");

        string propertyName = propertyInfo.Name;

        var propertyDescriptor = (from p in TypeDescriptor.GetProperties(target).Cast<PropertyDescriptor>()
                                  where string.Equals(p.Name, propertyName, StringComparison.Ordinal)
                                  select p)
              .Single();

        if (!propertyDescriptor.SupportsChangeEvents)
            throw new ArgumentException("The specified property does not support change events.", "property");

        var getter = property.Compile();

        return from e in Observable.FromEvent<EventHandler, EventArgs>(
            propertyChangedHandler => (s, e) => propertyChangedHandler(e),
          h => propertyDescriptor.AddValueChanged(target, h),
          h => propertyDescriptor.RemoveValueChanged(target, h))
               select getter(target);
    }
}