C#

using (OdbcConnection connexion = new OdbcConnection(con_source))
using (OdbcCommand command = connexion.CreateCommand())
{
    command.CommandText = "select max(date) from thisdet;";
    object result = command.ExecuteScalar();
    if(result != null)
    {
        DateTime resultDate = (DateTime)result;
        // do something with resultDate here
    }
    else
    {
        // no max(date) found
    }
}

Kenneth Haugland wrote:

My question is simply, is this really all that is required to create a WeakEvent Listener with Rx?

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

    private static void HandleEvent(WeakSubscriber target, EventPattern<NotifyCollectionChangedEventArgs> item)
    {
        target.HandleEvent(item);
    }

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

Kenneth Haugland wrote:

I'm really confused as the ObservePropertyChange method subscribes to the event, seemingly, in the normal strong reference way.

Kenneth Haugland wrote:

I also have sort of a side question

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.