title: ReactiveUI: IObservable.Transform() does not forward Notifications
body: <p>In the sniplet below, it seems like <code>transform(x =&gt; x.Bar.Baz)</code> only forwards changes if items in <code>sl2</code> are added or removed, but not if th value of <code>Baz</code> is changed. Is this expected behaviour? How to change it, that all modifications are found in <code>transformed</code>?</p>
  
  <pre><code>SourceList&lt;FooClass&gt; sl2 = new SourceList&lt;FooClass&gt;();    
  sl2.Connect()
          .Transform(x =&gt; x.Bar.Baz)
          .Bind(out ReadOnlyObservableCollection&lt;String&gt; transformed)
          .Subscribe( x=&gt; { Console.WriteLine("CHANGE from Subscribe"); } );
  </code></pre>
  
  <p>The full code reads as. Running example also available on <a href="https://github.com/BerndGit/ReactivUI_Test_GH/tree/master/ReactivUI_Test" rel="nofollow noreferrer">GitHub</a></p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.Collections.ObjectModel;
  using System.Collections.Specialized;
  using DynamicData;
  using DynamicData.Binding;
  using ReactiveUI;
  using ReactiveUI.Fody.Helpers;
  
  namespace ReactivUI_Test
  {
      class BarClass : ReactiveObject
      {
          [Reactive] public String Baz { get; set; } = "";
  
          public BarClass(String b) { Baz = b; }
          public BarClass() { Baz = "!!!"; }
  
          public override String ToString() { return Baz.ToString(); }
      }
  
  
  
      class FooClass : ReactiveObject
      {
          [Reactive] public BarClass Bar { get; set; } = new BarClass();
  
          public override String ToString() { return Bar.ToString(); }
      }
  
  
      class ViewModel: ReactiveObject
      {
          [Reactive] FooClass Foo { get; set; } = new FooClass();
  
          void PrintList&lt;T&gt; (IEnumerable&lt;T&gt; items)
          {
              foreach (T item in items)
              {
                  Console.WriteLine(item.ToString());
              }
          }
  
          public ViewModel()
          {
  
  
              Console.WriteLine("===  ===");
  
              SourceList&lt;FooClass&gt; sl2 = new SourceList&lt;FooClass&gt;();
  
              FooClass fo1 = new FooClass() { Bar = new BarClass("Hello ") };
              FooClass fo2 = new FooClass() { Bar = new BarClass("World ") };
              FooClass fo3 = new FooClass() { Bar = new BarClass("Out ") };
              FooClass fo4 = new FooClass() { Bar = new BarClass("There ") };
              FooClass fo5 = new FooClass() { Bar = new BarClass("!!!!!!") };
  
              sl2.Add(fo1);
              sl2.Add(fo2);
              sl2.Add(fo3);
              sl2.Add(fo4);
  
  
              sl2.Connect()
                  .Transform(x =&gt; x.Bar.Baz)
                  .Bind(out ReadOnlyObservableCollection&lt;String&gt; transformed)
                  .Subscribe( x=&gt; { Console.WriteLine("CHANGE from Subscribe"); } );
  
              Console.WriteLine("=== Start ===");
  
              ((INotifyCollectionChanged)transformed).CollectionChanged += 
                  new NotifyCollectionChangedEventHandler(( s,e) =&gt; Console.WriteLine("CHANGE from Event Handler"));
  
  
              Console.WriteLine("sl2: ");
              PrintList&lt;FooClass&gt;(sl2.Items);
  
              Console.WriteLine("transformed: ");
              PrintList&lt;String&gt;(transformed);
  
  
              Console.WriteLine("=== Send to Space ===");
              fo2.Bar.Baz = "Space";
  
              Console.WriteLine("sl2: ");
              PrintList&lt;FooClass&gt;(sl2.Items);
  
              Console.WriteLine("transformed: ");
              PrintList&lt;String&gt;(transformed);      
  
              Console.WriteLine("=== Add !!!! ===" );
  
              sl2.Add(fo5);
  
              Console.WriteLine("sl2: ");
              PrintList&lt;FooClass&gt;(sl2.Items);
  
              Console.WriteLine("transformed: ");
              PrintList&lt;String&gt;(transformed);
  
              Console.WriteLine("===  ===");
  
              Console.WriteLine("Finish");
              Console.ReadLine();
  
          }
      }
  
  
      class Program 
      {
          static void Main(string[] args)
          {
              ViewModel vm = new ViewModel();
          }
      }
  }
  </code></pre>
  
  <p>The output is not what I have hoped for. It seems that <code>.Transform(x =&gt; x.Bar.Baz)</code> only forwards updates items are added or removed from the list 'sl2'. If there are value changes of <code>Bar.Baz</code>, these changes are not forwaded to <code>transformed</code>.</p>
  
  <p>My Output is:</p>
  
  <pre><code>===  ===
  CHANGE from Subscribe
  === Start ===
  sl2:
  Hello
  World
  Out
  There
  transformed:
  Hello
  World
  Out
  There
  === Send to Space ===
  sl2:
  Hello
  Space
  Out
  There
  transformed:
  Hello
  World      &lt;--- I would have hoped to have 'Space' here
  Out
  There
  === Add !!!! ===
  CHANGE from Event Handler   &lt;-- I would have hoped that event handlers are triggered at World-&gt;Space
  CHANGE from Subscribe       &lt;-- I would have hoped that event handlers are triggered at World-&gt;Space
  sl2:
  Hello
  Space
  Out
  There
  !!!!!!
  transformed:
  Hello
  World    &lt;--- I would have hoped to have 'Space' here
  Out
  There
  !!!!!!
  ===  ===
  Finish
  </code></pre>
  
  <p>Note that:
  (1) in <code>transformed</code> the change of World->Space is never done. In <code>sl2</code> this change is done.</p>
  
  <p>(2) The CollectionChangedEvent is only triggered after adding of in Item added.</p>
  
  <p>My question:</p>
  
  <p>How to ensure that <code>transform()</code> sets the correct notifications?</p>
  
  <p><strong>Update</strong></p>
  
  <p>Based on the of Funk answer below, this should be fixed by:</p>
  
  <pre><code>sl2.Connect()
     .AutoRefresh(x =&gt; x.Bar.Baz)
     .Transform(x =&gt; x.Bar.Baz)
     ...
  </code></pre>
  
  <p>However this does not change the output. </p>