posted by Polity

posted by Charles

Had been watching Rx "from the distance" for quite a time, but now I decided to really get hands on.

So, re Challenge1: my first go on it yielded considerably less and more concise code for events than for Observables! I just could not see how this ought to illustrate the (better) composability of Observables; it seemed rather to the contrary... oops.

Then I realized that my simple-minded solution for events was way off spec (or what I think is the intended semantics) - while with Observables it all comes out just as it should be automatically.

However, the problem with the challenge at hand is IMHO that the "test case" in Program.cs does not surface any of the relevant bits. That is, I think, because it only tests the case where there is one subscriber for changes in length. Therefore I'd like to propose the following as expected output:

            // Expected Output:
            // *** Events ***
            // The
            // Reactive
            // Extensions
/*  *  */   // 1: 10
            // are
/*  *  */   // 1: 3
/*  +  */   // new
/*  +  */   // and          // verify: there is NO change in length!
/*  *  */   // 1: 13
/*  +  */   // 2: 13        // verify: 2nd handler gets notified, too!
/*  +  */   // 2: 1
            // *** Observables ***
            // The
            // Reactive
            // Extensions
/*  *  */   // 1: 10
            // Extensions
            // are
/*  *  */   // 1: 3
/*  +  */   // new
/*  +  */   // and          // verify: there is NO change in length!
/*  *  */   // 1: 13
/*  +  */   // 2: 13        // verify: 2nd handler gets notified, too!
/*  +  */   // 2: 1

...produced by the this test code:

            Console.WriteLine("*** Events ***");
            var events = new Events();
            Action<string> textHandler = text => Console.WriteLine(text);
/*  *  */   Action<int> lengthHandler1 = length => Console.WriteLine("1: " + length);
/*  +  */   Action<int> lengthHandler2 = length => Console.WriteLine("2: " + length);
            events.TextChanged += textHandler;
            events.OnTextChanged("The");
            events.OnTextChanged("Reactive");
/*  *  */   events.LengthChanged += lengthHandler1;
            events.OnTextChanged("Extensions");
            events.OnTextChanged("are");
/*  +  */   events.LengthChanged += lengthHandler2;
/*  +  */   events.OnTextChanged("new");
/*  +  */   events.OnTextChanged("and");
            events.TextChanged -= textHandler;
            events.OnTextChanged("compositional");
/*  *  */   events.LengthChanged -= lengthHandler1;
            events.OnTextChanged("!");
/*  +  */   events.LengthChanged -= lengthHandler2;

            Console.WriteLine("*** Observables ***");
            var observables = new Observables();
            var textChangedSubscription = observables.TextChanged.Subscribe(text => Console.WriteLine(text));
            observables.OnTextChanged("The");
            observables.OnTextChanged("Reactive");
/*  *  */   var lengthSubscription1 = observables.LengthChanged.Subscribe(length => Console.WriteLine("1: " + length));
            observables.OnTextChanged("Extensions");
            observables.OnTextChanged("are");
/*  +  */   var lengthSubscription2 = observables.LengthChanged.Subscribe(length => Console.WriteLine("2: " + length));
/*  +  */   observables.OnTextChanged("new");
/*  +  */   observables.OnTextChanged("and");
            textChangedSubscription.Dispose();
            observables.OnTextChanged("compositional");
            lengthSubscription1.Dispose();
            observables.OnTextChanged("!");
/*  +  */   lengthSubscription2.Dispose();

The prefixed comments denote my changes/additions relative to the original. Besides the additional length-change subscriber I have added the new text-change events "new" and "and" after "are", which both should NOT yield a length-change event. The whole point of this is that the stream of events as such should really be independent of the subscribers, particularly:

a) which / how many subscribers there are and

b) *when* a particular subscriber actually did subscribe.

***Note that the above test case still does not account for the one case where we have both,

a) a length-change subscriber that subscribed even before the very first *text-change* event (missing in test case, SHOULD see an event since (no text ~ length 0) != (some text ~ length > 0)

b) a length-change subscriber that subscribed right in between the text-change events of "are" and "new" (present in test case, should NOT see an event since "are" and "new" are both three characters long)

The problem I'm seeing there is that in the event solution you can get either a) or b) to see the right thing(s), but not both - whereas, again, with Observables you get it right for both just naturally. That is, at least given the restriction that the original [Events|Observables].OnTextChanged(string) firing method may not be changed, I'm not even sure if it's possible at all to get it completely right with only events.

Well, and there we're back at compositionality: adding a new kind of event (stream) should really only require an additive change.

So that's what I wanted to share; this my train of thought felt somewhat educational to me. Sorry for that it all got soo lengthy

___

p.s.: please do try yourself a solution for *** based on events-only, it's one of those things which you deem "definitely doable" at first glance but find yourself utterly puzzled at when having to actually do it. At least that's what applies to me.

posted by limes

Great job guys!

posted by stacyh

posted by N2Cheval

namespace IntroductionToRx
{
    class Events
    {
        public event Action<string> TextChanged;
        private event Action<int> lenChanged;
        private int lastLen;

        public virtual void OnTextChanged(string text)
        {
            var t = TextChanged;
            if (t != null)
                t(text);
            if (lastLen != text.Length)
            {
                lastLen = text.Length;
                OnLenChanged(text.Length);
            }
        }
        public virtual void OnLenChanged(int len)
        {
            var t = lenChanged;
            if (t != null)
                t(len);
        }
        public event Action<int> LengthChanged
        {
            add
            {
                lenChanged = (Action<int>)Delegate.Combine(lenChanged, value);
            }
            remove
            {
                lenChanged = (Action<int>)Delegate.Remove(lenChanged, value);
            }
        }
    }
}

namespace IntroductionToRx
{
    class Observables
    {
        ISubject<string> textChanged = new Subject<string>();
        int lastLen;

        public virtual void OnTextChanged(string text)
        {
            textChanged.OnNext(text);
        }

        public IObservable<string> TextChanged { get { return textChanged; } }

        public IObservable<int> LengthChanged
        {
            get
            { // Compose new "event" by filtering existing event.
                return textChanged.Where(s => s.Length != lastLen).Do(s=>lastLen=s.Length).Select(s=>s.Length);
            }
        }
    }
}

Output
======================
*** Events ***
The
Reactive
Extensions
10
are
3
13
*** Observables ***
The
Reactive
Extensions
10
are
3
13

posted by staceyw

posted by phulsmeijer

posted by jyates

1) Your LengthChanged event is always fired after textchanged, even if Length does not change. So it fires too much.

2) The challenge had a template to follow and not remove getter/setter (i.e. Add, Remove) on the new event afaict.

posted by staceyw

Nice code, but your Event-Handler Code never prints the final "13", because when the textHandler gets removed, the lenChanged event never gets fired again.

Here is my code, I'm not really happy with it - but anyway:

  class Events {
    public event Action<string> TextChanged;

    public virtual void OnTextChanged(string text) {
      var t = TextChanged;
      if (t != null) {
        t(text);
      }
    }

    private int lastLength;
    private Action<int> Length;

    public event Action<int> LengthChanged {
      add {
        Length += value;
        TextChanged += (s => {
          if (s.Length != lastLength) {
            var l = Length;
            if (l != null) l(s.Length);
            lastLength = s.Length;
          }
        });
      }
      remove {
        Length -= value;
      }
    }
  }

posted by Kurator

class Events {
        public event Action<string> TextChanged;

        public virtual void OnTextChanged(string text) {
            var t = TextChanged;
            if (t != null)
                t(text);
        }

        private event Action<string> lc; //lengthChanged
        public event Action<int> LengthChanged {
            add {
                lc += x => { Console.WriteLine(x == null ? 0 : x.Length); };
                TextChanged += lc;
            }
            remove {
                TextChanged -= lc;
            }
        }
    }

class Observables {
        ISubject<string> textChanged = new Subject<string>();

        public virtual void OnTextChanged(string text) {
            textChanged.OnNext(text);
        }

        public IObservable<string> TextChanged { get { return textChanged; } }

        public IObservable<int> LengthChanged {
            get {
                return textChanged.Select(s => s == null ? 0 : s.Length);
            }
        }
    }

posted by N2Cheval

posted by c t

posted by staceyw

The only complication comes from the fact that you have to unsubscribe the proper subscription (not just the last one), otherwise code would be almost as simple and short as observable version is:

private Dictionary<Action<int>, Action<string>> actions = new Dictionary<Action<int>, Action<string>>();

        public event Action<int> LengthChanged
        {
            add
            {
                Action<string> action = text => value(text == null ? 0 : text.Length);
                actions.Add(value, action);
                TextChanged += action;
            }
            remove
            {
                Action<string> action;
                if (actions.TryGetValue(value, out action))
                {
                    actions.Remove(value);
                    TextChanged -= action;
                }
            }
        }

posted by wiertmir

posted by jyates

But calling TextChanged is up to publisher. So publisher would not call if not changed. Changing that behavior was not part of the challenge as I read it.  Was fun series in any event (pun intended). 

posted by staceyw

private Action<string> LengthHandler;

        public event Action<int> LengthChanged
        {
            add
            {
                if (LengthHandler == null)
                    LengthHandler = text => value(text.Length);
                TextChanged += LengthHandler;
            }
            remove
            {
                TextChanged -= LengthHandler;
            }

        }

and

public IObservable<int> LengthChanged { get { return textChanged.Select(x => x.Length); } }

posted by decrypted

class Events
    {
        public event Action<string> TextChanged;
        private event Action<int> TextLengthChanged;

        private int _lastlen = 0;

        public virtual void OnTextChanged(string text)
        {
            var t = TextChanged;
            if (t != null)
                t(text);
            OnLengthChange((text ?? String.Empty).Length);
        }

        private void OnLengthChange(int len)
        {
          if (len != _lastlen)
          {
            var t = TextLengthChanged;
            if (t != null)
            {
              t(len);
            }
            _lastlen = len;
          }
        }

        public event Action<int> LengthChanged
        {
            add
            {
              TextLengthChanged += value;
            }
            remove
            {
              TextLengthChanged -= value;
            }
        }
    }

    class Observables
    {
        ISubject<string> textChanged = new Subject<string>();

        public virtual void OnTextChanged(string text)
        {
            textChanged.OnNext(text);
        }

        public IObservable<string> TextChanged { get { return textChanged; } }

        public IObservable<int> LengthChanged
        {
            get
            {
              return textChanged.Select(s => (s ?? String.Empty).Length);
            }
        }
    }

posted by cbae

posted by IanG

 class Events
    {
        private string m_LastString = string.Empty;

        public event Action<string> TextChanged;

        private Action<string> m_ToAttachToTextChanged;
        private Action<int> m_LengthChanged;
        
        public Events()
        {
            m_ToAttachToTextChanged = text => {
                if (m_LastString.Length != (text ?? "").Length) {
                    m_LengthChanged((text ?? "").Length);
                }
                m_LastString = text ?? "";
            };
        }

        public virtual void OnTextChanged(string text)
        {
            var t = TextChanged;
            if (t != null)
                t(text);
        }

        public event Action<int> LengthChanged
        {
            add
            {
                m_LengthChanged += value;
                TextChanged += m_ToAttachToTextChanged;
            }
            remove
            {
                m_LengthChanged -= value;
                TextChanged -= m_ToAttachToTextChanged;
            }
        }
    }

posted by ValentinKuzub

posted by ada

Oct 14, 2011 at 5:50 PM

Events code is implemented correctly by Kurator and Valentinkuzub.

Kurator's implementation leaks memory as it adds a new delegate (lambda) to TextChanged on each call to add_LengthChanged without removing it in remove_LengthChanged. Valentinkuzub's implementation is nice even though it does some unnecessary work by updating the m_LastString variable multiple times if more than one subscriber registers with LengthChanged. staceyw's implementation for Events is fine too as far as I can tell.

Oct 14, 2011 at 5:50 PM

Observable is implemented correctly by staceyw.

All others are wrong regardless of whether they give the correct output.

staceyw's implementation of Observable breaks down as soon as more than one observer subscribes to LengthChanged. The state of the (shared) lastLen variable is modified when the first subscriber receives the next string. So depending on evaluation order other subscribers may not see the change as for them the value is filtered out in the Where expression. jyates revised solution on the other hand:

 return TextChanged.Select(s => s == null ? 0 : s.Length).DistinctUntilChanged();     

 looks perfect imho.

posted by andreas_f

class Events
    {
        private int m_LastLength;
        public event Action<string> TextChanged;
        private Action<int> m_LengthChanged;

        public Events()
        {
            TextChanged += s =>
                               {
                                   var length = (s ?? string.Empty).Length;
                                   if (length != m_LastLength)
                                   {
                                       m_LastLength = length;
                                       m_LengthChanged(length);
                                   }
                               };
        }
        
        public virtual void OnTextChanged(string text)
        {
            var t = TextChanged;
            if (t != null)
                t(text);
        }

        public event Action<int> LengthChanged
        {
            add { m_LengthChanged += value; }
            remove { m_LengthChanged -= value; }
        }
    }

posted by andreas_f