Add a new Disposable Extention.

src/Avalonia.Animation/Animator`1.cs

@@ -1,10 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using Avalonia.Animation.Utils;
 using Avalonia.Collections;
 using Avalonia.Data;
+using Avalonia.Reactive;
+
 
 namespace Avalonia.Animation
 {
@@ -38,10 +41,10 @@ namespace Avalonia.Animation
                 VerifyConvertKeyFrames();
 
             return match.DistinctUntilChanged()
-                        .Select(x => x ? RunKeyFrames(animation, control, onComplete) : null)
-                        .Buffer(2, 1)
-                        .Where(x => x.Count > 1)
-                        .Subscribe(x => x[0]?.Dispose());
+                        .ObserveOn(Avalonia.Threading.AvaloniaScheduler.Instance)
+                        .Select(x => x ? RunKeyFrames(animation, control, onComplete) : Disposable.Empty)
+                        .DisposeCurrentOnNext()
+                        .Subscribe();
         }
 
         /// <summary>

src/Avalonia.Base/Reactive/DisposeOnNextObservable.cs

@@ -0,0 +1,40 @@
+using System;
+using Avalonia.Threading;
+
+namespace Avalonia.Reactive
+{
+    public class DisposeOnNextObservable<T> : LightweightObservableBase<T>, IObserver<T> where T : IDisposable
+    {
+        private IDisposable lastValue;
+
+        private void ValueNext(T value)
+        {
+            this.PublishNext(value);
+            lastValue?.Dispose();
+            lastValue = value;
+        }
+
+        public void OnCompleted()
+        {
+            this.PublishCompleted();
+        }
+
+        public void OnError(Exception error)
+        {
+            this.PublishError(error);
+        }
+
+        void IObserver<T>.OnNext(T value)
+        {
+            ValueNext(value);
+        }
+ 
+        protected override void Initialize()
+        {
+        }
+
+        protected override void Deinitialize()
+        {
+        }
+    }
+}

src/Avalonia.Base/Reactive/ObservableEx.cs

@@ -22,6 +22,20 @@ namespace Avalonia.Reactive
             return new SingleValueImpl<T>(value);
         }
 
+        /// <summary>
+        /// Disposes the current <see cref="IDisposable"/> and saves the next.
+        /// </summary>
+        /// <typeparam name="T">The type of the value.</typeparam>
+        /// <param name="observable">The source <see cref="IObservable{T}"/>.</param>
+        /// <returns>The observable.</returns>
+        public static IObservable<T> DisposeCurrentOnNext<T>(this IObservable<T> observable)
+            where T : IDisposable
+        {
+            var subject = new DisposeOnNextObservable<T>();
+            observable.Subscribe(subject);
+            return subject;
+        }
+
         private class SingleValueImpl<T> : IObservable<T>
         {
             private T _value;
@@ -30,7 +44,6 @@ namespace Avalonia.Reactive
             {
                 _value = value;
             }
-
             public IDisposable Subscribe(IObserver<T> observer)
             {
                 observer.OnNext(_value);
@@ -38,4 +51,4 @@ namespace Avalonia.Reactive
             }
         }
     }
-}
+}