Merge branch 'master' into update/net31

src/Avalonia.Base/AvaloniaObject.cs

@@ -311,7 +311,10 @@ namespace Avalonia
         /// <param name="property">The property.</param>
         /// <param name="value">The value.</param>
         /// <param name="priority">The priority of the value.</param>
-        public void SetValue<T>(
+        /// <returns>
+        /// An <see cref="IDisposable"/> if setting the property can be undone, otherwise null.
+        /// </returns>
+        public IDisposable SetValue<T>(
             StyledPropertyBase<T> property,
             T value,
             BindingPriority priority = BindingPriority.LocalValue)
@@ -335,8 +338,10 @@ namespace Avalonia
             }
             else if (!(value is DoNothingType))
             {
-                Values.SetValue(property, value, priority);
+                return Values.SetValue(property, value, priority);
             }
+
+            return null;
         }
 
         /// <summary>

src/Avalonia.Base/AvaloniaObjectExtensions.cs

@@ -458,7 +458,10 @@ namespace Avalonia
         /// <param name="property">The property.</param>
         /// <param name="value">The value.</param>
         /// <param name="priority">The priority of the value.</param>
-        public static void SetValue(
+        /// <returns>
+        /// An <see cref="IDisposable"/> if setting the property can be undone, otherwise null.
+        /// </returns>
+        public static IDisposable SetValue(
             this IAvaloniaObject target,
             AvaloniaProperty property,
             object value,
@@ -467,7 +470,7 @@ namespace Avalonia
             target = target ?? throw new ArgumentNullException(nameof(target));
             property = property ?? throw new ArgumentNullException(nameof(property));
 
-            property.RouteSetValue(target, value, priority);
+            return property.RouteSetValue(target, value, priority);
         }
 
         /// <summary>
@@ -478,7 +481,10 @@ namespace Avalonia
         /// <param name="property">The property.</param>
         /// <param name="value">The value.</param>
         /// <param name="priority">The priority of the value.</param>
-        public static void SetValue<T>(
+        /// <returns>
+        /// An <see cref="IDisposable"/> if setting the property can be undone, otherwise null.
+        /// </returns>
+        public static IDisposable SetValue<T>(
             this IAvaloniaObject target,
             AvaloniaProperty<T> property,
             T value,
@@ -490,11 +496,10 @@ namespace Avalonia
             switch (property)
             {
                 case StyledPropertyBase<T> styled:
-                    target.SetValue(styled, value, priority);
+                    return target.SetValue(styled, value, priority);
-                    break;
                 case DirectPropertyBase<T> direct:
                     target.SetValue(direct, value);
-                    break;
+                    return null;
                 default:
                     throw new NotSupportedException("Unsupported AvaloniaProperty type.");
             }

src/Avalonia.Base/AvaloniaProperty.cs

@@ -469,6 +469,15 @@ namespace Avalonia
             return Name;
         }
 
+        /// <summary>
+        /// Uses the visitor pattern to resolve an untyped property to a typed property.
+        /// </summary>
+        /// <typeparam name="TData">The type of user data passed.</typeparam>
+        /// <param name="vistor">The visitor which will accept the typed property.</param>
+        /// <param name="data">The user data to pass.</param>
+        public abstract void Accept<TData>(IAvaloniaPropertyVisitor<TData> vistor, ref TData data)
+            where TData : struct;
+
         /// <summary>
         /// Notifies the <see cref="Changed"/> observable.
         /// </summary>
@@ -496,7 +505,10 @@ namespace Avalonia
         /// <param name="o">The object instance.</param>
         /// <param name="value">The value.</param>
         /// <param name="priority">The priority.</param>
-        internal abstract void RouteSetValue(
+        /// <returns>
+        /// An <see cref="IDisposable"/> if setting the property can be undone, otherwise null.
+        /// </returns>
+        internal abstract IDisposable? RouteSetValue(
             IAvaloniaObject o,
             object value,
             BindingPriority priority);

src/Avalonia.Base/DirectPropertyBase.cs

@@ -1,6 +1,7 @@
 using System;
 using Avalonia.Data;
 using Avalonia.Reactive;
+using Avalonia.Utilities;
 
 #nullable enable
 
@@ -101,6 +102,12 @@ namespace Avalonia
             return (DirectPropertyMetadata<TValue>)base.GetMetadata(type);
         }
 
+        /// <inheritdoc/>
+        public override void Accept<TData>(IAvaloniaPropertyVisitor<TData> vistor, ref TData data)
+        {
+            vistor.Visit(this, ref data);
+        }
+
         /// <inheritdoc/>
         internal override void RouteClearValue(IAvaloniaObject o)
         {
@@ -114,7 +121,7 @@ namespace Avalonia
         }
 
         /// <inheritdoc/>
-        internal override void RouteSetValue(
+        internal override IDisposable? RouteSetValue(
             IAvaloniaObject o,
             object value,
             BindingPriority priority)
@@ -133,6 +140,8 @@ namespace Avalonia
             {
                 throw v.Error!;
             }
+
+            return null;
         }
 
         /// <inheritdoc/>

src/Avalonia.Base/IAvaloniaObject.cs

@@ -65,7 +65,7 @@ namespace Avalonia
         /// <param name="property">The property.</param>
         /// <param name="value">The value.</param>
         /// <param name="priority">The priority of the value.</param>
-        void SetValue<T>(
+        IDisposable SetValue<T>(
             StyledPropertyBase<T> property,
             T value,
             BindingPriority priority = BindingPriority.LocalValue);

src/Avalonia.Base/PropertyStore/ConstantValueEntry.cs

@@ -10,16 +10,20 @@ namespace Avalonia.PropertyStore
     /// <see cref="PriorityValue{T}"/>.
     /// </summary>
     /// <typeparam name="T">The property type.</typeparam>
-    internal class ConstantValueEntry<T> : IPriorityValueEntry<T>
+    internal class ConstantValueEntry<T> : IPriorityValueEntry<T>, IDisposable
     {
+        private IValueSink _sink;
+
         public ConstantValueEntry(
             StyledPropertyBase<T> property,
             T value,
-            BindingPriority priority)
+            BindingPriority priority,
+            IValueSink sink)
         {
             Property = property;
             Value = value;
             Priority = priority;
+            _sink = sink;
         }
 
         public StyledPropertyBase<T> Property { get; }
@@ -28,6 +32,7 @@ namespace Avalonia.PropertyStore
         Optional<object> IValue.Value => Value.ToObject();
         BindingPriority IValue.ValuePriority => Priority;
 
-        public void Reparent(IValueSink sink) { }
+        public void Dispose() => _sink.Completed(Property, this, Value);
+        public void Reparent(IValueSink sink) => _sink = sink;
     }
 }

src/Avalonia.Base/PropertyStore/PriorityValue.cs

@@ -78,8 +78,10 @@ namespace Avalonia.PropertyStore
 
         public void ClearLocalValue() => UpdateEffectiveValue();
 
-        public void SetValue(T value, BindingPriority priority)
+        public IDisposable? SetValue(T value, BindingPriority priority)
         {
+            IDisposable? result = null;
+
             if (priority == BindingPriority.LocalValue)
             {
                 _localValue = value;
@@ -87,10 +89,13 @@ namespace Avalonia.PropertyStore
             else
             {
                 var insert = FindInsertPoint(priority);
-                _entries.Insert(insert, new ConstantValueEntry<T>(Property, value, priority));
+                var entry = new ConstantValueEntry<T>(Property, value, priority, this);
+                _entries.Insert(insert, entry);
+                result = entry;
             }
 
             UpdateEffectiveValue();
+            return result;
         }
 
         public BindingEntry<T> AddBinding(IObservable<BindingValue<T>> source, BindingPriority priority)

src/Avalonia.Base/Reactive/SingleSubscriberObservableBase.cs

@@ -36,7 +36,7 @@ namespace Avalonia.Reactive
             return this;
         }
 
-        void IDisposable.Dispose()
+        public virtual void Dispose()
         {
             Unsubscribed();
             _observer = null;

src/Avalonia.Base/StyledPropertyBase.cs

@@ -5,6 +5,7 @@ using System;
 using System.Diagnostics;
 using Avalonia.Data;
 using Avalonia.Reactive;
+using Avalonia.Utilities;
 
 namespace Avalonia
 {
@@ -169,6 +170,12 @@ namespace Avalonia
             base.OverrideMetadata(type, metadata);
         }
 
+        /// <inheritdoc/>
+        public override void Accept<TData>(IAvaloniaPropertyVisitor<TData> vistor, ref TData data)
+        {
+            vistor.Visit(this, ref data);
+        }
+
         /// <summary>
         /// Gets the string representation of the property.
         /// </summary>
@@ -194,7 +201,7 @@ namespace Avalonia
         }
 
         /// <inheritdoc/>
-        internal override void RouteSetValue(
+        internal override IDisposable RouteSetValue(
             IAvaloniaObject o,
             object value,
             BindingPriority priority)
@@ -203,7 +210,7 @@ namespace Avalonia
 
             if (v.HasValue)
             {
-                o.SetValue<TValue>(this, (TValue)v.Value, priority);
+                return o.SetValue<TValue>(this, (TValue)v.Value, priority);
             }
             else if (v.Type == BindingValueType.UnsetValue)
             {
@@ -213,6 +220,8 @@ namespace Avalonia
             {
                 throw v.Error;
             }
+
+            return null;
         }
 
         /// <inheritdoc/>

src/Avalonia.Base/Utilities/IAvaloniaPropertyVisitor.cs

@@ -0,0 +1,34 @@
+#nullable enable
+
+namespace Avalonia.Utilities
+{
+    /// <summary>
+    /// A visitor to resolve an untyped <see cref="AvaloniaProperty"/> to a typed property.
+    /// </summary>
+    /// <typeparam name="TData">The type of user data passed.</typeparam>
+    /// <remarks>
+    /// Pass an instance that implements this interface to
+    /// <see cref="AvaloniaProperty.Accept{TData}(IAvaloniaPropertyVisitor{TData}, ref TData)"/>
+    /// in order to resolve un untyped <see cref="AvaloniaProperty"/> to a typed
+    /// <see cref="StyledPropertyBase{TValue}"/> or <see cref="DirectPropertyBase{TValue}"/>.
+    /// </remarks>
+    public interface IAvaloniaPropertyVisitor<TData>
+        where TData : struct
+    {
+        /// <summary>
+        /// Called when the property is a styled property.
+        /// </summary>
+        /// <typeparam name="T">The property value type.</typeparam>
+        /// <param name="property">The property.</param>
+        /// <param name="data">The user data.</param>
+        void Visit<T>(StyledPropertyBase<T> property, ref TData data);
+
+        /// <summary>
+        /// Called when the property is a direct property.
+        /// </summary>
+        /// <typeparam name="T">The property value type.</typeparam>
+        /// <param name="property">The property.</param>
+        /// <param name="data">The user data.</param>
+        void Visit<T>(DirectPropertyBase<T> property, ref TData data);
+    }
+}

src/Avalonia.Base/ValueStore.cs

@@ -70,23 +70,25 @@ namespace Avalonia
             return false;
         }
 
-        public void SetValue<T>(StyledPropertyBase<T> property, T value, BindingPriority priority)
+        public IDisposable? SetValue<T>(StyledPropertyBase<T> property, T value, BindingPriority priority)
         {
             if (property.ValidateValue?.Invoke(value) == false)
             {
                 throw new ArgumentException($"{value} is not a valid value for '{property.Name}.");
             }
 
+            IDisposable? result = null;
+
             if (_values.TryGetValue(property, out var slot))
             {
-                SetExisting(slot, property, value, priority);
+                result = SetExisting(slot, property, value, priority);
             }
             else if (property.HasCoercion)
             {
                 // If the property has any coercion callbacks then always create a PriorityValue.
                 var entry = new PriorityValue<T>(_owner, property, this);
                 _values.AddValue(property, entry);
-                entry.SetValue(value, priority);
+                result = entry.SetValue(value, priority);
             }
             else if (priority == BindingPriority.LocalValue)
             {
@@ -95,10 +97,13 @@ namespace Avalonia
             }
             else
             {
-                var entry = new ConstantValueEntry<T>(property, value, priority);
+                var entry = new ConstantValueEntry<T>(property, value, priority, this);
                 _values.AddValue(property, entry);
                 _sink.ValueChanged(property, priority, default, value);
+                result = entry;
             }
+
+            return result;
         }
 
         public IDisposable AddBinding<T>(
@@ -205,21 +210,23 @@ namespace Avalonia
             }
         }
 
-        private void SetExisting<T>(
+        private IDisposable? SetExisting<T>(
             object slot,
             StyledPropertyBase<T> property,
             T value,
             BindingPriority priority)
         {
+            IDisposable? result = null;
+
             if (slot is IPriorityValueEntry<T> e)
             {
                 var priorityValue = new PriorityValue<T>(_owner, property, this, e);
                 _values.SetValue(property, priorityValue);
-                priorityValue.SetValue(value, priority);
+                result = priorityValue.SetValue(value, priority);
             }
             else if (slot is PriorityValue<T> p)
             {
-                p.SetValue(value, priority);
+                result = p.SetValue(value, priority);
             }
             else if (slot is LocalValueEntry<T> l)
             {
@@ -232,7 +239,7 @@ namespace Avalonia
                 else
                 {
                     var priorityValue = new PriorityValue<T>(_owner, property, this, l);
-                    priorityValue.SetValue(value, priority);
+                    result = priorityValue.SetValue(value, priority);
                     _values.SetValue(property, priorityValue);
                 }
             }
@@ -240,6 +247,8 @@ namespace Avalonia
             {
                 throw new NotSupportedException("Unrecognised value store slot type.");
             }
+
+            return result;
         }
 
         private IDisposable BindExisting<T>(

src/Avalonia.Controls/Presenters/TextPresenter.cs

@@ -82,6 +82,7 @@ namespace Avalonia.Controls.Presenters
                 SelectionStartProperty, SelectionEndProperty);
 
             Observable.Merge(
+                TextProperty.Changed,
                 SelectionStartProperty.Changed,
                 SelectionEndProperty.Changed,
                 PasswordCharProperty.Changed
@@ -291,6 +292,8 @@ namespace Avalonia.Controls.Presenters
                 _constraint = _formattedText.Constraint;
                 _formattedText = null;
             }
+
+            InvalidateVisual();
         }
 
         /// <summary>

src/Avalonia.Diagnostics/Diagnostics/ViewModels/TreeNode.cs

@@ -6,6 +6,8 @@ using System.Collections.Specialized;
 using System.Reactive;
 using System.Reactive.Linq;
 using Avalonia.Collections;
+using Avalonia.Controls;
+using Avalonia.LogicalTree;
 using Avalonia.Styling;
 using Avalonia.VisualTree;
 
@@ -22,22 +24,25 @@ namespace Avalonia.Diagnostics.ViewModels
             Type = visual.GetType().Name;
             Visual = visual;
 
-            if (visual is IStyleable styleable)
+            if (visual is IControl control)
             {
+                var removed = Observable.FromEventPattern<LogicalTreeAttachmentEventArgs>(
+                    x => control.DetachedFromLogicalTree += x,
+                    x => control.DetachedFromLogicalTree -= x);
                 var classesChanged = Observable.FromEventPattern<
                         NotifyCollectionChangedEventHandler,
                         NotifyCollectionChangedEventArgs>(
-                    x => styleable.Classes.CollectionChanged += x,
+                        x => control.Classes.CollectionChanged += x,
-                    x => styleable.Classes.CollectionChanged -= x)
+                        x => control.Classes.CollectionChanged -= x)
-                    .TakeUntil(((IStyleable)styleable).StyleDetach);
+                    .TakeUntil(removed);
 
                 classesChanged.Select(_ => Unit.Default)
                     .StartWith(Unit.Default)
                     .Subscribe(_ =>
                     {
-                        if (styleable.Classes.Count > 0)
+                        if (control.Classes.Count > 0)
                         {
-                            Classes = "(" + string.Join(" ", styleable.Classes) + ")";
+                            Classes = "(" + string.Join(" ", control.Classes) + ")";
                         }
                         else
                         {

src/Avalonia.Styling/Avalonia.Styling.csproj

@@ -8,5 +8,4 @@
     <ProjectReference Include="..\Avalonia.Animation\Avalonia.Animation.csproj" />
     <ProjectReference Include="..\Avalonia.Base\Avalonia.Base.csproj" />
   </ItemGroup>
-  <Import Project="..\..\build\Rx.props" />
 </Project>

src/Avalonia.Styling/Controls/NameScopeLocator.cs

@@ -1,11 +1,5 @@
 using System;
-using System.Linq;
 using System.Reactive.Disposables;
-using System.Reactive.Threading.Tasks;
-using System.Reflection;
-using System.Threading.Tasks;
-using Avalonia.LogicalTree;
-using Avalonia.Reactive;
 using Avalonia.Utilities;
 
 namespace Avalonia.Controls

src/Avalonia.Styling/StyledElement.cs

@@ -3,8 +3,6 @@ using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Linq;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
 using Avalonia.Animation;
 using Avalonia.Collections;
 using Avalonia.Controls;
@@ -14,6 +12,8 @@ using Avalonia.Logging;
 using Avalonia.LogicalTree;
 using Avalonia.Styling;
 
+#nullable enable
+
 namespace Avalonia
 {
     /// <summary>
@@ -29,8 +29,8 @@ namespace Avalonia
         /// <summary>
         /// Defines the <see cref="DataContext"/> property.
         /// </summary>
-        public static readonly StyledProperty<object> DataContextProperty =
+        public static readonly StyledProperty<object?> DataContextProperty =
-            AvaloniaProperty.Register<StyledElement, object>(
+            AvaloniaProperty.Register<StyledElement, object?>(
                 nameof(DataContext),
                 inherits: true,
                 notifying: DataContextNotifying);
@@ -38,34 +38,34 @@ namespace Avalonia
         /// <summary>
         /// Defines the <see cref="Name"/> property.
         /// </summary>
-        public static readonly DirectProperty<StyledElement, string> NameProperty =
+        public static readonly DirectProperty<StyledElement, string?> NameProperty =
-            AvaloniaProperty.RegisterDirect<StyledElement, string>(nameof(Name), o => o.Name, (o, v) => o.Name = v);
+            AvaloniaProperty.RegisterDirect<StyledElement, string?>(nameof(Name), o => o.Name, (o, v) => o.Name = v);
         
         /// <summary>
         /// Defines the <see cref="Parent"/> property.
         /// </summary>
-        public static readonly DirectProperty<StyledElement, IStyledElement> ParentProperty =
+        public static readonly DirectProperty<StyledElement, IStyledElement?> ParentProperty =
-            AvaloniaProperty.RegisterDirect<StyledElement, IStyledElement>(nameof(Parent), o => o.Parent);
+            AvaloniaProperty.RegisterDirect<StyledElement, IStyledElement?>(nameof(Parent), o => o.Parent);
 
         /// <summary>
         /// Defines the <see cref="TemplatedParent"/> property.
         /// </summary>
-        public static readonly DirectProperty<StyledElement, ITemplatedControl> TemplatedParentProperty =
+        public static readonly DirectProperty<StyledElement, ITemplatedControl?> TemplatedParentProperty =
-            AvaloniaProperty.RegisterDirect<StyledElement, ITemplatedControl>(
+            AvaloniaProperty.RegisterDirect<StyledElement, ITemplatedControl?>(
                 nameof(TemplatedParent),
                 o => o.TemplatedParent,
                 (o ,v) => o.TemplatedParent = v);
 
         private int _initCount;
-        private string _name;
+        private string? _name;
         private readonly Classes _classes = new Classes();
-        private ILogicalRoot _logicalRoot;
+        private ILogicalRoot? _logicalRoot;
-        private IAvaloniaList<ILogical> _logicalChildren;
+        private IAvaloniaList<ILogical>? _logicalChildren;
-        private IResourceDictionary _resources;
+        private IResourceDictionary? _resources;
-        private Styles _styles;
+        private Styles? _styles;
         private bool _styled;
-        private Subject<IStyleable> _styleDetach = new Subject<IStyleable>();
+        private List<IStyleInstance>? _appliedStyles;
-        private ITemplatedControl _templatedParent;
+        private ITemplatedControl? _templatedParent;
         private bool _dataContextUpdating;
         private bool _notifyingResourcesChanged;
 
@@ -88,12 +88,12 @@ namespace Avalonia
         /// <summary>
         /// Raised when the styled element is attached to a rooted logical tree.
         /// </summary>
-        public event EventHandler<LogicalTreeAttachmentEventArgs> AttachedToLogicalTree;
+        public event EventHandler<LogicalTreeAttachmentEventArgs>? AttachedToLogicalTree;
 
         /// <summary>
         /// Raised when the styled element is detached from a rooted logical tree.
         /// </summary>
-        public event EventHandler<LogicalTreeAttachmentEventArgs> DetachedFromLogicalTree;
+        public event EventHandler<LogicalTreeAttachmentEventArgs>? DetachedFromLogicalTree;
 
         /// <summary>
         /// Occurs when the <see cref="DataContext"/> property changes.
@@ -102,7 +102,7 @@ namespace Avalonia
         /// This event will be raised when the <see cref="DataContext"/> property has changed and
         /// all subscribers to that change have been notified.
         /// </remarks>
-        public event EventHandler DataContextChanged;
+        public event EventHandler? DataContextChanged;
 
         /// <summary>
         /// Occurs when the styled element has finished initialization.
@@ -115,12 +115,12 @@ namespace Avalonia
         /// <see cref="ISupportInitialize"/> is not used, it is called when the styled element is attached
         /// to the visual tree.
         /// </remarks>
-        public event EventHandler Initialized;
+        public event EventHandler? Initialized;
 
         /// <summary>
         /// Occurs when a resource in this styled element or a parent styled element has changed.
         /// </summary>
-        public event EventHandler<ResourcesChangedEventArgs> ResourcesChanged;
+        public event EventHandler<ResourcesChangedEventArgs>? ResourcesChanged;
 
         /// <summary>
         /// Gets or sets the name of the styled element.
@@ -129,20 +129,12 @@ namespace Avalonia
         /// An element's name is used to uniquely identify an element within the element's name
         /// scope. Once the element is added to a logical tree, its name cannot be changed.
         /// </remarks>
-        public string Name
+        public string? Name
         {
-            get
+            get => _name;
-            {
-                return _name;
-            }
 
             set
             {
-                if (String.IsNullOrWhiteSpace(value))
-                {
-                    throw new InvalidOperationException("Cannot set Name to null or empty string.");
-                }
-
                 if (_styled)
                 {
                     throw new InvalidOperationException("Cannot set Name : styled element already styled.");
@@ -190,7 +182,7 @@ namespace Avalonia
         /// The data context is an inherited property that specifies the default object that will
         /// be used for data binding.
         /// </remarks>
-        public object DataContext
+        public object? DataContext
         {
             get { return GetValue(DataContextProperty); }
             set { SetValue(DataContextProperty, value); }
@@ -217,7 +209,7 @@ namespace Avalonia
         {
             get
             {
-                if (_styles == null)
+                if (_styles is null)
                 {
                     _styles = new Styles(this);
                     _styles.ResourcesChanged += ThisResourcesChanged;
@@ -235,7 +227,7 @@ namespace Avalonia
             get => _resources ?? (Resources = new ResourceDictionary());
             set
             {
-                Contract.Requires<ArgumentNullException>(value != null);
+                value = value ?? throw new ArgumentNullException(nameof(value));
 
                 var hadResources = false;
 
@@ -264,7 +256,7 @@ namespace Avalonia
         /// <summary>
         /// Gets the styled element whose lookless template this styled element is part of.
         /// </summary>
-        public ITemplatedControl TemplatedParent
+        public ITemplatedControl? TemplatedParent
         {
             get => _templatedParent;
             internal set => SetAndRaise(TemplatedParentProperty, ref _templatedParent, value);
@@ -306,12 +298,12 @@ namespace Avalonia
         /// <summary>
         /// Gets the styled element's logical parent.
         /// </summary>
-        public IStyledElement Parent { get; private set; }
+        public IStyledElement? Parent { get; private set; }
 
         /// <summary>
         /// Gets the styled element's logical parent.
         /// </summary>
-        ILogical ILogical.LogicalParent => Parent;
+        ILogical? ILogical.LogicalParent => Parent;
 
         /// <summary>
         /// Gets the styled element's logical children.
@@ -322,7 +314,7 @@ namespace Avalonia
         bool IResourceProvider.HasResources => _resources?.Count > 0 || Styles.HasResources;
 
         /// <inheritdoc/>
-        IResourceNode IResourceNode.ResourceParent => ((IStyleHost)this).StylingParent as IResourceNode;
+        IResourceNode? IResourceNode.ResourceParent => ((IStyleHost)this).StylingParent as IResourceNode;
 
         /// <inheritdoc/>
         IAvaloniaReadOnlyList<string> IStyleable.Classes => Classes;
@@ -338,14 +330,11 @@ namespace Avalonia
         /// </remarks>
         Type IStyleable.StyleKey => GetType();
 
-        /// <inheritdoc/>
-        IObservable<IStyleable> IStyleable.StyleDetach => _styleDetach;
-
         /// <inheritdoc/>
         bool IStyleHost.IsStylesInitialized => _styles != null;
 
         /// <inheritdoc/>
-        IStyleHost IStyleHost.StylingParent => (IStyleHost)InheritanceParent;
+        IStyleHost? IStyleHost.StylingParent => (IStyleHost)InheritanceParent;
 
         /// <inheritdoc/>
         public virtual void BeginInit()
@@ -391,20 +380,20 @@ namespace Avalonia
         /// <inheritdoc/>
         void ILogical.NotifyAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e)
         {
-            this.OnAttachedToLogicalTreeCore(e);
+            OnAttachedToLogicalTreeCore(e);
         }
 
         /// <inheritdoc/>
         void ILogical.NotifyDetachedFromLogicalTree(LogicalTreeAttachmentEventArgs e)
         {
-            this.OnDetachedFromLogicalTreeCore(e);
+            OnDetachedFromLogicalTreeCore(e);
         }
 
         /// <inheritdoc/>
         void ILogical.NotifyResourcesChanged(ResourcesChangedEventArgs e) => NotifyResourcesChanged(e);
 
         /// <inheritdoc/>
-        bool IResourceProvider.TryGetResource(object key, out object value)
+        bool IResourceProvider.TryGetResource(object key, out object? value)
         {
             value = null;
             return (_resources?.TryGetResource(key, out value) ?? false) ||
@@ -415,7 +404,7 @@ namespace Avalonia
         /// Sets the styled element's logical parent.
         /// </summary>
         /// <param name="parent">The parent.</param>
-        void ISetLogicalParent.SetParent(ILogical parent)
+        void ISetLogicalParent.SetParent(ILogical? parent)
         {
             var old = Parent;
 
@@ -431,7 +420,7 @@ namespace Avalonia
                     InheritanceParent = parent as AvaloniaObject;
                 }
 
-                Parent = (IStyledElement)parent;
+                Parent = (IStyledElement?)parent;
 
                 if (_logicalRoot != null)
                 {
@@ -462,12 +451,13 @@ namespace Avalonia
                     var e = new LogicalTreeAttachmentEventArgs(newRoot, this, parent);
                     OnAttachedToLogicalTreeCore(e);
                 }
-
+#nullable disable
                 RaisePropertyChanged(
                     ParentProperty,
                     new Optional<IStyledElement>(old),
                     new BindingValue<IStyledElement>(Parent),
                     BindingPriority.LocalValue);
+#nullable enable
             }
         }
 
@@ -480,6 +470,16 @@ namespace Avalonia
             InheritanceParent = parent;
         }
 
+        void IStyleable.StyleApplied(IStyleInstance instance)
+        {
+            instance = instance ?? throw new ArgumentNullException(nameof(instance));
+
+            _appliedStyles ??= new List<IStyleInstance>();
+            _appliedStyles.Add(instance);
+        }
+
+        void IStyleable.DetachStyles() => DetachStyles();
+
         protected virtual void LogicalChildrenCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             switch (e.Action)
@@ -589,7 +589,7 @@ namespace Avalonia
             }
         }
 
-        private static ILogicalRoot FindLogicalRoot(IStyleHost e)
+        private static ILogicalRoot? FindLogicalRoot(IStyleHost e)
         {
             while (e != null)
             {
@@ -658,7 +658,7 @@ namespace Avalonia
             if (_logicalRoot != null)
             {
                 _logicalRoot = null;
-                _styleDetach.OnNext(this);
+                DetachStyles();
                 OnDetachedFromLogicalTree(e);
                 DetachedFromLogicalTree?.Invoke(this, e);
 
@@ -674,7 +674,7 @@ namespace Avalonia
                 }
 
 #if DEBUG
-                if (((INotifyCollectionChangedDebug)_classes).GetCollectionChangedSubscribers()?.Length > 0)
+                if (((INotifyCollectionChangedDebug)Classes).GetCollectionChangedSubscribers()?.Length > 0)
                 {
                     Logger.TryGet(LogEventLevel.Warning)?.Log(
                         LogArea.Control,
@@ -702,6 +702,19 @@ namespace Avalonia
             }
         }
 
+        private void DetachStyles()
+        {
+            if (_appliedStyles is object)
+            {
+                foreach (var i in _appliedStyles)
+                {
+                    i.Dispose();
+                }
+
+                _appliedStyles.Clear();
+            }
+        }
+
         private void ClearLogicalParent(IEnumerable<ILogical> children)
         {
             foreach (var i in children)

src/Avalonia.Styling/Styling/ActivatedObservable.cs

@@ -1,77 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-
-namespace Avalonia.Styling
-{
-    /// <summary>
-    /// An observable which is switched on or off according to an activator observable.
-    /// </summary>
-    /// <remarks>
-    /// An <see cref="ActivatedObservable"/> has two inputs: an activator observable and a 
-    /// <see cref="Source"/> observable which produces the activated value. When the activator 
-    /// produces true, the <see cref="ActivatedObservable"/> will produce the current activated 
-    /// value. When the activator produces false it will produce
-    /// <see cref="AvaloniaProperty.UnsetValue"/>.
-    /// </remarks>
-    internal class ActivatedObservable : ActivatedValue, IDescription
-    {
-        private IDisposable _sourceSubscription;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ActivatedObservable"/> class.
-        /// </summary>
-        /// <param name="activator">The activator.</param>
-        /// <param name="source">An observable that produces the activated value.</param>
-        /// <param name="description">The binding description.</param>
-        public ActivatedObservable(
-            IObservable<bool> activator,
-            IObservable<object> source,
-            string description)
-            : base(activator, AvaloniaProperty.UnsetValue, description)
-        {
-            Contract.Requires<ArgumentNullException>(source != null);
-
-            Source = source;
-        }
-
-        /// <summary>
-        /// Gets an observable which produces the <see cref="ActivatedValue"/>.
-        /// </summary>
-        public IObservable<object> Source { get; }
-
-        protected override ActivatorListener CreateListener() => new ValueListener(this);
-
-        protected override void Deinitialize()
-        {
-            base.Deinitialize();
-            _sourceSubscription.Dispose();
-            _sourceSubscription = null;
-        }
-
-        protected override void Initialize()
-        {
-            base.Initialize();
-            _sourceSubscription = Source.Subscribe((ValueListener)Listener);
-        }
-
-        protected virtual void NotifyValue(object value)
-        {
-            Value = value;
-        }
-
-        private class ValueListener : ActivatorListener, IObserver<object>
-        {
-            public ValueListener(ActivatedObservable parent)
-                : base(parent)
-            {
-            }
-            protected new ActivatedObservable Parent => (ActivatedObservable)base.Parent;
-
-            void IObserver<object>.OnCompleted() => Parent.CompletedReceived();
-            void IObserver<object>.OnError(Exception error) => Parent.ErrorReceived(error);
-            void IObserver<object>.OnNext(object value) => Parent.NotifyValue(value);
-        }
-    }
-}

src/Avalonia.Styling/Styling/ActivatedSubject.cs

@@ -1,110 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Reactive.Subjects;
-
-namespace Avalonia.Styling
-{
-    /// <summary>
-    /// A subject which is switched on or off according to an activator observable.
-    /// </summary>
-    /// <remarks>
-    /// An <see cref="ActivatedSubject"/> extends <see cref="ActivatedObservable"/> to
-    /// be an <see cref="ISubject{Object}"/>. When the object is active then values
-    /// received via <see cref="OnNext(object)"/> will be passed to the source subject.
-    /// </remarks>
-    internal class ActivatedSubject : ActivatedObservable, ISubject<object>, IDescription
-    {
-        private bool _completed;
-        private object _pushValue;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ActivatedSubject"/> class.
-        /// </summary>
-        /// <param name="activator">The activator.</param>
-        /// <param name="source">An observable that produces the activated value.</param>
-        /// <param name="description">The binding description.</param>
-        public ActivatedSubject(
-            IObservable<bool> activator,
-            ISubject<object> source,
-            string description)
-            : base(activator, source, description)
-        {
-        }
-
-        /// <summary>
-        /// Gets the underlying subject.
-        /// </summary>
-        public new ISubject<object> Source
-        {
-            get { return (ISubject<object>)base.Source; }
-        }
-
-        public void OnCompleted()
-        {
-            Source.OnCompleted();
-        }
-
-        public void OnError(Exception error)
-        {
-            Source.OnError(error);
-        }
-
-        public void OnNext(object value)
-        {
-            _pushValue = value;
-
-            if (IsActive == true && !_completed)
-            {
-                Source.OnNext(_pushValue);
-            }
-        }
-
-        protected override void ActiveChanged(bool active)
-        {
-            bool first = !IsActive.HasValue;
-
-            base.ActiveChanged(active);
-
-            if (!first)
-            {
-                Source.OnNext(active ? _pushValue : AvaloniaProperty.UnsetValue);
-            }
-        }
-
-        protected override void CompletedReceived()
-        {
-            base.CompletedReceived();
-
-            if (!_completed)
-            {
-                Source.OnCompleted();
-                _completed = true;
-            }
-        }
-
-        protected override void ErrorReceived(Exception error)
-        {
-            base.ErrorReceived(error);
-
-            if (!_completed)
-            {
-                Source.OnError(error);
-                _completed = true;
-            }
-        }
-
-        private void ActivatorCompleted()
-        {
-            _completed = true;
-            Source.OnCompleted();
-        }
-
-        private void ActivatorError(Exception e)
-        {
-            _completed = true;
-            Source.OnError(e);
-        }
-    }
-}

src/Avalonia.Styling/Styling/ActivatedValue.cs

@@ -1,133 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using Avalonia.Reactive;
-
-namespace Avalonia.Styling
-{
-    /// <summary>
-    /// An value which is switched on or off according to an activator observable.
-    /// </summary>
-    /// <remarks>
-    /// An <see cref="ActivatedValue"/> has two inputs: an activator observable and an
-    /// <see cref="Value"/>. When the activator produces true, the 
-    /// <see cref="ActivatedValue"/> will produce the current value. When the activator 
-    /// produces false it will produce <see cref="AvaloniaProperty.UnsetValue"/>.
-    /// </remarks>
-    internal class ActivatedValue : LightweightObservableBase<object>, IDescription
-    {
-        private static readonly object NotSent = new object();
-        private IDisposable _activatorSubscription;
-        private object _value;
-        private object _last = NotSent;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ActivatedObservable"/> class.
-        /// </summary>
-        /// <param name="activator">The activator.</param>
-        /// <param name="value">The activated value.</param>
-        /// <param name="description">The binding description.</param>
-        public ActivatedValue(
-            IObservable<bool> activator,
-            object value,
-            string description)
-        {
-            Contract.Requires<ArgumentNullException>(activator != null);
-
-            Activator = activator;
-            Value = value;
-            Description = description;
-            Listener = CreateListener();
-        }
-
-        /// <summary>
-        /// Gets the activator observable.
-        /// </summary>
-        public IObservable<bool> Activator { get; }
-
-        /// <summary>
-        /// Gets a description of the binding.
-        /// </summary>
-        public string Description { get; }
-
-        /// <summary>
-        /// Gets a value indicating whether the activator is active.
-        /// </summary>
-        public bool? IsActive { get; private set; }
-
-        /// <summary>
-        /// Gets the value that will be produced when <see cref="IsActive"/> is true.
-        /// </summary>
-        public object Value
-        {
-            get => _value;
-            protected set
-            {
-                _value = value;
-                PublishValue();
-            }
-        }
-
-        protected ActivatorListener Listener { get; }
-
-        protected virtual void ActiveChanged(bool active)
-        {
-            IsActive = active;
-            PublishValue();
-        }
-
-        protected virtual void CompletedReceived() => PublishCompleted();
-
-        protected virtual ActivatorListener CreateListener() => new ActivatorListener(this);
-
-        protected override void Deinitialize()
-        {
-            _activatorSubscription.Dispose();
-            _activatorSubscription = null;
-        }
-
-        protected virtual void ErrorReceived(Exception error) => PublishError(error);
-
-        protected override void Initialize()
-        {
-            _activatorSubscription = Activator.Subscribe(Listener);
-        }
-
-        protected override void Subscribed(IObserver<object> observer, bool first)
-        {
-            if (IsActive == true && !first)
-            {
-                observer.OnNext(Value);
-            }
-        }
-
-        private void PublishValue()
-        {
-            if (IsActive.HasValue)
-            {
-                var v = IsActive.Value ? Value : AvaloniaProperty.UnsetValue;
-
-                if (!Equals(v, _last))
-                {
-                    PublishNext(v);
-                    _last = v;
-                }
-            }
-        }
-
-        protected class ActivatorListener : IObserver<bool>
-        {
-            public ActivatorListener(ActivatedValue parent)
-            {
-                Parent = parent;
-            }
-
-            protected ActivatedValue Parent { get; }
-
-            void IObserver<bool>.OnCompleted() => Parent.CompletedReceived();
-            void IObserver<bool>.OnError(Exception error) => Parent.ErrorReceived(error);
-            void IObserver<bool>.OnNext(bool value) => Parent.ActiveChanged(value);
-        }
-    }
-}

src/Avalonia.Styling/Styling/Activators/AndActivator.cs

@@ -0,0 +1,71 @@
+#nullable enable
+
+using System.Collections.Generic;
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// An aggregate <see cref="IStyleActivator"/> which is active when all of its inputs are
+    /// active.
+    /// </summary>
+    internal class AndActivator : StyleActivatorBase, IStyleActivatorSink
+    {
+        private List<IStyleActivator>? _sources;
+        private ulong _flags;
+        private ulong _mask;
+
+        public int Count => _sources?.Count ?? 0;
+
+        public void Add(IStyleActivator activator)
+        {
+            _sources ??= new List<IStyleActivator>();
+            _sources.Add(activator);
+        }
+
+        void IStyleActivatorSink.OnNext(bool value, int tag)
+        {
+            if (value)
+            {
+                _flags |= 1ul << tag;
+            }
+            else
+            {
+                _flags &= ~(1ul << tag);
+            }
+
+            if (_mask != 0)
+            {
+                PublishNext(_flags == _mask);
+            }
+        }
+
+        protected override void Initialize()
+        {
+            if (_sources is object)
+            {
+                var i = 0;
+
+                foreach (var source in _sources)
+                {
+                    source.Subscribe(this, i++);
+                }
+
+                _mask = (1ul << Count) - 1;
+                PublishNext(_flags == _mask);
+            }
+        }
+
+        protected override void Deinitialize()
+        {
+            if (_sources is object)
+            {
+                foreach (var source in _sources)
+                {
+                    source.Unsubscribe(this);
+                }
+            }
+
+            _mask = 0;
+        }
+    }
+}

src/Avalonia.Styling/Styling/Activators/AndActivatorBuilder.cs

@@ -0,0 +1,43 @@
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// Builds an <see cref="AndActivator"/>.
+    /// </summary>
+    /// <remarks>
+    /// When ANDing style activators, if there is more than one input then creates an instance of
+    /// <see cref="AndActivator"/>. If there is only one input, returns the input directly.
+    /// </remarks>
+    internal struct AndActivatorBuilder
+    {
+        private IStyleActivator? _single;
+        private AndActivator? _multiple;
+
+        public void Add(IStyleActivator? activator)
+        {
+            if (activator == null)
+            {
+                return;
+            }
+
+            if (_single is null && _multiple is null)
+            {
+                _single = activator;
+            }
+            else
+            {
+                if (_multiple is null)
+                {
+                    _multiple = new AndActivator();
+                    _multiple.Add(_single!);
+                    _single = null;
+                }
+
+                _multiple.Add(activator);
+            }
+        }
+
+        public IStyleActivator Get() => _single ?? _multiple!;
+    }
+}

src/Avalonia.Styling/Styling/Activators/IStyleActivator.cs

@@ -0,0 +1,33 @@
+#nullable enable
+
+using System;
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// Defines a style activator.
+    /// </summary>
+    /// <remarks>
+    /// A style activator is very similar to an `IObservable{bool}` but is optimized for the
+    /// particular use-case of activating a style according to a selector. It differs from
+    /// an observable in two major ways:
+    /// 
+    /// - Can only have a single subscription
+    /// - The subscription can have a tag associated with it, allowing a subscriber to index
+    ///   into a list of subscriptions without having to allocate additional objects.
+    /// </remarks>
+    public interface IStyleActivator : IDisposable
+    {
+        /// <summary>
+        /// Subscribes to the activator.
+        /// </summary>
+        /// <param name="sink">The listener.</param>
+        /// <param name="tag">An optional tag.</param>
+        void Subscribe(IStyleActivatorSink sink, int tag = 0);
+
+        /// <summary>
+        /// Unsubscribes from the activator.
+        /// </summary>
+        void Unsubscribe(IStyleActivatorSink sink);
+    }
+}

src/Avalonia.Styling/Styling/Activators/IStyleActivatorSink.cs

@@ -0,0 +1,17 @@
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// Receives notifications from an <see cref="IStyleActivator"/>.
+    /// </summary>
+    public interface IStyleActivatorSink
+    {
+        /// <summary>
+        /// Called when the subscribed activator value changes.
+        /// </summary>
+        /// <param name="value">The new value.</param>
+        /// <param name="tag">The subscription tag.</param>
+        void OnNext(bool value, int tag);
+    }
+}

src/Avalonia.Styling/Styling/Activators/NotActivator.cs

@@ -0,0 +1,16 @@
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// An <see cref="IStyleActivator"/> which inverts the state of an input activator.
+    /// </summary>
+    internal class NotActivator : StyleActivatorBase, IStyleActivatorSink
+    {
+        private readonly IStyleActivator _source;
+        public NotActivator(IStyleActivator source) => _source = source;
+        void IStyleActivatorSink.OnNext(bool value, int tag) => PublishNext(!value);
+        protected override void Initialize() => _source.Subscribe(this, 0);
+        protected override void Deinitialize() => _source.Unsubscribe(this);
+    }
+}

src/Avalonia.Styling/Styling/Activators/OrActivator.cs

@@ -0,0 +1,71 @@
+#nullable enable
+
+using System.Collections.Generic;
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// An aggregate <see cref="IStyleActivator"/> which is active when any of its inputs are
+    /// active.
+    /// </summary>
+    internal class OrActivator : StyleActivatorBase, IStyleActivatorSink
+    {
+        private List<IStyleActivator>? _sources;
+        private ulong _flags;
+        private bool _initializing;
+
+        public int Count => _sources?.Count ?? 0;
+
+        public void Add(IStyleActivator activator)
+        {
+            _sources ??= new List<IStyleActivator>();
+            _sources.Add(activator);
+        }
+
+        void IStyleActivatorSink.OnNext(bool value, int tag)
+        {
+            if (value)
+            {
+                _flags |= 1ul << tag;
+            }
+            else
+            {
+                _flags &= ~(1ul << tag);
+            }
+
+            if (!_initializing)
+            {
+                PublishNext(_flags != 0);
+            }
+        }
+
+        protected override void Initialize()
+        {
+            if (_sources is object)
+            {
+                var i = 0;
+
+                _initializing = true;
+
+                foreach (var source in _sources)
+                {
+                    source.Subscribe(this, i++);
+                }
+
+                _initializing = false;
+                PublishNext(_flags != 0);
+            }
+        }
+
+        protected override void Deinitialize()
+        {
+            if (_sources is object)
+            {
+                foreach (var source in _sources)
+                {
+                    source.Unsubscribe(this);
+                }
+            }
+        }
+    }
+}

src/Avalonia.Styling/Styling/Activators/OrActivatorBuilder.cs

@@ -0,0 +1,45 @@
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// Builds an <see cref="OrActivator"/>.
+    /// </summary>
+    /// <remarks>
+    /// When ORing style activators, if there is more than one input then creates an instance of
+    /// <see cref="OrActivator"/>. If there is only one input, returns the input directly.
+    /// </remarks>
+    internal struct OrActivatorBuilder
+    {
+        private IStyleActivator? _single;
+        private OrActivator? _multiple;
+
+        public int Count => _multiple?.Count ?? (_single is object ? 1 : 0);
+
+        public void Add(IStyleActivator? activator)
+        {
+            if (activator == null)
+            {
+                return;
+            }
+
+            if (_single is null && _multiple is null)
+            {
+                _single = activator;
+            }
+            else
+            {
+                if (_multiple is null)
+                {
+                    _multiple = new OrActivator();
+                    _multiple.Add(_single!);
+                    _single = null;
+                }
+
+                _multiple.Add(activator);
+            }
+        }
+
+        public IStyleActivator Get() => _single ?? _multiple!;
+    }
+}

src/Avalonia.Styling/Styling/Activators/PropertyEqualsActivator.cs

@@ -0,0 +1,38 @@
+using System;
+
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// An <see cref="IStyleActivator"/> which listens to a property value on a control.
+    /// </summary>
+    internal class PropertyEqualsActivator : StyleActivatorBase, IObserver<object>
+    {
+        private readonly IStyleable _control;
+        private readonly AvaloniaProperty _property;
+        private readonly object? _value;
+        private IDisposable? _subscription;
+
+        public PropertyEqualsActivator(
+            IStyleable control,
+            AvaloniaProperty property,
+            object? value)
+        {
+            _control = control ?? throw new ArgumentNullException(nameof(control));
+            _property = property ?? throw new ArgumentNullException(nameof(property));
+            _value = value;
+        }
+
+        protected override void Initialize()
+        {
+            _subscription = _control.GetObservable(_property).Subscribe(this);
+        }
+
+        protected override void Deinitialize() => _subscription?.Dispose();
+
+        void IObserver<object>.OnCompleted() { }
+        void IObserver<object>.OnError(Exception error) { }
+        void IObserver<object>.OnNext(object value) => PublishNext(Equals(value, _value));
+    }
+}

src/Avalonia.Styling/Styling/Activators/StyleActivatorBase.cs

@@ -0,0 +1,58 @@
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// Base class implementation of <see cref="IStyleActivator"/>.
+    /// </summary>
+    internal abstract class StyleActivatorBase : IStyleActivator
+    {
+        private IStyleActivatorSink? _sink;
+        private int _tag;
+        private bool? _value;
+
+        public void Subscribe(IStyleActivatorSink sink, int tag = 0)
+        {
+            if (_sink is null)
+            {
+                _sink = sink;
+                _tag = tag;
+                _value = null;
+                Initialize();
+            }
+            else
+            {
+                throw new AvaloniaInternalException("Cannot subscribe to a StyleActivator more than once.");
+            }
+        }
+
+        public void Unsubscribe(IStyleActivatorSink sink)
+        {
+            if (_sink != sink)
+            {
+                throw new AvaloniaInternalException("StyleActivatorSink is not subscribed.");
+            }
+
+            _sink = null;
+            Deinitialize();
+        }
+
+        public void PublishNext(bool value)
+        {
+            if (_value != value)
+            {
+                _value = value;
+                _sink?.OnNext(value, _tag);
+            }
+        }
+
+        public void Dispose()
+        {
+            _sink = null;
+            Deinitialize();
+        }
+
+        protected abstract void Initialize();
+        protected abstract void Deinitialize();
+    }
+}

src/Avalonia.Styling/Styling/Activators/StyleClassActivator.cs

@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using Avalonia.Collections;
+
+#nullable enable
+
+namespace Avalonia.Styling.Activators
+{
+    /// <summary>
+    /// An <see cref="IStyleActivator"/> which is active when a set of classes match those on a
+    /// control.
+    /// </summary>
+    internal sealed class StyleClassActivator : StyleActivatorBase
+    {
+        private readonly IList<string> _match;
+        private readonly IAvaloniaReadOnlyList<string> _classes;
+
+        public StyleClassActivator(IAvaloniaReadOnlyList<string> classes, IList<string> match)
+        {
+            _classes = classes;
+            _match = match;
+        }
+
+        public static bool AreClassesMatching(IReadOnlyList<string> classes, IList<string> toMatch)
+        {
+            int remainingMatches = toMatch.Count;
+            int classesCount = classes.Count;
+
+            // Early bail out - we can't match if control does not have enough classes.
+            if (classesCount < remainingMatches)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < classesCount; i++)
+            {
+                var c = classes[i];
+
+                if (toMatch.Contains(c))
+                {
+                    --remainingMatches;
+
+                    // Already matched so we can skip checking other classes.
+                    if (remainingMatches == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return remainingMatches == 0;
+        }
+
+
+        protected override void Initialize()
+        {
+            PublishNext(IsMatching());
+            _classes.CollectionChanged += ClassesChanged;
+        }
+
+        protected override void Deinitialize()
+        {
+            _classes.CollectionChanged -= ClassesChanged;
+        }
+
+        private void ClassesChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (e.Action != NotifyCollectionChangedAction.Move)
+            {
+                PublishNext(IsMatching());
+            }
+        }
+
+        private bool IsMatching() => AreClassesMatching(_classes, _match);
+    }
+}

src/Avalonia.Styling/Styling/DescendentSelector.cs

@@ -2,24 +2,21 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
 using Avalonia.LogicalTree;
+using Avalonia.Styling.Activators;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
     internal class DescendantSelector : Selector
     {
         private readonly Selector _parent;
-        private string _selectorString;
+        private string? _selectorString;
 
-        public DescendantSelector(Selector parent)
+        public DescendantSelector(Selector? parent)
         {
-            if (parent == null)
+            _parent = parent ?? throw new InvalidOperationException("Descendant selector must be preceeded by a selector.");
-            {
-                throw new InvalidOperationException("Descendant selector must be preceeded by a selector.");
-            }
-
-            _parent = parent;
         }
 
         /// <inheritdoc/>
@@ -29,7 +26,7 @@ namespace Avalonia.Styling
         public override bool InTemplate => _parent.InTemplate;
 
         /// <inheritdoc/>
-        public override Type TargetType => null;
+        public override Type? TargetType => null;
 
         public override string ToString()
         {
@@ -43,8 +40,8 @@ namespace Avalonia.Styling
 
         protected override SelectorMatch Evaluate(IStyleable control, bool subscribe)
         {
-            ILogical c = (ILogical)control;
+            var c = (ILogical)control;
-            List<IObservable<bool>> descendantMatches = new List<IObservable<bool>>();
+            var descendantMatches = new OrActivatorBuilder();
 
             while (c != null)
             {
@@ -67,7 +64,7 @@ namespace Avalonia.Styling
 
             if (descendantMatches.Count > 0)
             {
-                return new SelectorMatch(StyleActivator.Or(descendantMatches));
+                return new SelectorMatch(descendantMatches.Get());
             }
             else
             {
@@ -75,6 +72,6 @@ namespace Avalonia.Styling
             }
         }
 
-        protected override Selector MovePrevious() => null;
+        protected override Selector? MovePrevious() => null;
     }
 }

src/Avalonia.Styling/Styling/ISetter.cs

@@ -3,6 +3,8 @@
 
 using System;
 
+#nullable enable
+
 namespace Avalonia.Styling
 {
     /// <summary>
@@ -11,11 +13,15 @@ namespace Avalonia.Styling
     public interface ISetter
     {
         /// <summary>
-        /// Applies the setter to a control.
+        /// Instances a setter on a control.
         /// </summary>
-        /// <param name="style">The style that is being applied.</param>
+        /// <param name="target">The control.</param>
-        /// <param name="control">The control.</param>
+        /// <returns>An <see cref="ISetterInstance"/>.</returns>
-        /// <param name="activator">An optional activator.</param>
+        /// <remarks>
-        IDisposable Apply(IStyle style, IStyleable control, IObservable<bool> activator);
+        /// This method should return an <see cref="ISetterInstance"/> which can be used to apply
+        /// the setter to the specified control. Note that it should not apply the setter value 
+        /// until <see cref="ISetterInstance.Start(bool)"/> is called.
+        /// </remarks>
+        ISetterInstance Instance(IStyleable target);
     }
-}
+}

src/Avalonia.Styling/Styling/ISetterInstance.cs

@@ -0,0 +1,40 @@
+#nullable enable
+
+using System;
+
+namespace Avalonia.Styling
+{
+    /// <summary>
+    /// Represents a setter that has been instanced on a control.
+    /// </summary>
+    public interface ISetterInstance : IDisposable
+    {
+        /// <summary>
+        /// Starts the setter instance.
+        /// </summary>
+        /// <param name="hasActivator">Whether the parent style has an activator.</param>
+        /// <remarks>
+        /// If <paramref name="hasActivator"/> is false then the setter should be immediately
+        /// applied and <see cref="Activate"/> and <see cref="Deactivate"/> should not be called.
+        /// If true, then bindings etc should be initiated but not produce a value until
+        /// <see cref="Activate"/> called.
+        /// </remarks>
+        public void Start(bool hasActivator);
+
+        /// <summary>
+        /// Activates the setter.
+        /// </summary>
+        /// <remarks>
+        /// Should only be called if hasActivator was true when <see cref="Start(bool)"/> was called.
+        /// </remarks>
+        public void Activate();
+
+        /// <summary>
+        /// Deactivates the setter.
+        /// </summary>
+        /// <remarks>
+        /// Should only be called if hasActivator was true when <see cref="Start(bool)"/> was called.
+        /// </remarks>
+        public void Deactivate();
+    }
+}

src/Avalonia.Styling/Styling/IStyle.cs

@@ -3,6 +3,8 @@
 
 using Avalonia.Controls;
 
+#nullable enable
+
 namespace Avalonia.Styling
 {
     /// <summary>
@@ -13,17 +15,11 @@ namespace Avalonia.Styling
         /// <summary>
         /// Attaches the style to a control if the style's selector matches.
         /// </summary>
-        /// <param name="control">The control to attach to.</param>
+        /// <param name="target">The control to attach to.</param>
-        /// <param name="container">
+        /// <param name="host">The element that hosts the style.</param>
-        /// The control that contains this style. May be null.
-        /// </param>
         /// <returns>
-        /// True if the style can match a control of type <paramref name="control"/>
+        /// A <see cref="SelectorMatchResult"/> describing how the style matches the control.
-        /// (even if it does not match this control specifically); false if the style
-        /// can never match.
         /// </returns>
-        bool Attach(IStyleable control, IStyleHost container);
+        SelectorMatchResult TryAttach(IStyleable target, IStyleHost? host);
-
-        void Detach();
     }
 }

src/Avalonia.Styling/Styling/IStyleInstance.cs

@@ -0,0 +1,22 @@
+using System;
+
+#nullable enable
+
+namespace Avalonia.Styling
+{
+    /// <summary>
+    /// Represents a style that has been instanced on a control.
+    /// </summary>
+    public interface IStyleInstance : IDisposable
+    {
+        /// <summary>
+        /// Gets the source style.
+        /// </summary>
+        IStyle Source { get; }
+
+        /// <summary>
+        /// Instructs the style to start acting upon the control.
+        /// </summary>
+        void Start();
+    }
+}

src/Avalonia.Styling/Styling/IStyleable.cs

@@ -4,6 +4,8 @@
 using System;
 using Avalonia.Collections;
 
+#nullable enable
+
 namespace Avalonia.Styling
 {
     /// <summary>
@@ -11,11 +13,6 @@ namespace Avalonia.Styling
     /// </summary>
     public interface IStyleable : IAvaloniaObject, INamed
     {
-        /// <summary>
-        /// Signaled when the control's style should be removed.
-        /// </summary>
-        IObservable<IStyleable> StyleDetach { get; }
-
         /// <summary>
         /// Gets the list of classes for the control.
         /// </summary>
@@ -29,6 +26,17 @@ namespace Avalonia.Styling
         /// <summary>
         /// Gets the template parent of this element if the control comes from a template.
         /// </summary>
-        ITemplatedControl TemplatedParent { get; }
+        ITemplatedControl? TemplatedParent { get; }
+
+        /// <summary>
+        /// Notifies the element that a style has been applied.
+        /// </summary>
+        /// <param name="instance">The style instance.</param>
+        void StyleApplied(IStyleInstance instance);
+
+        /// <summary>
+        /// Detaches all styles applied to the element.
+        /// </summary>
+        void DetachStyles();
     }
 }

src/Avalonia.Styling/Styling/NotSelector.cs

@@ -2,7 +2,9 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Reactive.Linq;
+using Avalonia.Styling.Activators;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -11,16 +13,16 @@ namespace Avalonia.Styling
     /// </summary>
     internal class NotSelector : Selector
     {
-        private readonly Selector _previous;
+        private readonly Selector? _previous;
         private readonly Selector _argument;
-        private string _selectorString;
+        private string? _selectorString;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="NotSelector"/> class.
         /// </summary>
         /// <param name="previous">The previous selector.</param>
         /// <param name="argument">The selector to be not-ed.</param>
-        public NotSelector(Selector previous, Selector argument)
+        public NotSelector(Selector? previous, Selector argument)
         {
             _previous = previous;
             _argument = argument ?? throw new InvalidOperationException("Not selector must have a selector argument.");
@@ -33,14 +35,14 @@ namespace Avalonia.Styling
         public override bool IsCombinator => false;
 
         /// <inheritdoc/>
-        public override Type TargetType => _previous?.TargetType;
+        public override Type? TargetType => _previous?.TargetType;
 
         /// <inheritdoc/>
         public override string ToString()
         {
             if (_selectorString == null)
             {
-                _selectorString = ":not(" + _argument.ToString() + ")";
+                _selectorString = $"{_previous?.ToString()}:not({_argument})";
             }
 
             return _selectorString;
@@ -61,12 +63,12 @@ namespace Avalonia.Styling
                 case SelectorMatchResult.NeverThisType:
                     return SelectorMatch.AlwaysThisType;
                 case SelectorMatchResult.Sometimes:
-                    return new SelectorMatch(innerResult.Activator.Select(x => !x));
+                    return new SelectorMatch(new NotActivator(innerResult.Activator!));
                 default:
                     throw new InvalidOperationException("Invalid SelectorMatchResult.");
             }
         }
 
-        protected override Selector MovePrevious() => _previous;
+        protected override Selector? MovePrevious() => _previous;
     }
 }

src/Avalonia.Styling/Styling/OrSelector.cs

@@ -3,6 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using Avalonia.Styling.Activators;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -12,8 +15,8 @@ namespace Avalonia.Styling
     internal class OrSelector : Selector
     {
         private readonly IReadOnlyList<Selector> _selectors;
-        private string _selectorString;
+        private string? _selectorString;
-        private Type _targetType;
+        private Type? _targetType;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OrSelector"/> class.
@@ -21,8 +24,15 @@ namespace Avalonia.Styling
         /// <param name="selectors">The selectors to OR.</param>
         public OrSelector(IReadOnlyList<Selector> selectors)
         {
-            Contract.Requires<ArgumentNullException>(selectors != null);
+            if (selectors is null)
-            Contract.Requires<ArgumentException>(selectors.Count > 1);
+            {
+                throw new ArgumentNullException(nameof(selectors));
+            }
+
+            if (selectors.Count <= 1)
+            {
+                throw new ArgumentException("Need more than one selector to OR.");
+            }
 
             _selectors = selectors;
         }
@@ -34,7 +44,7 @@ namespace Avalonia.Styling
         public override bool IsCombinator => false;
 
         /// <inheritdoc/>
-        public override Type TargetType
+        public override Type? TargetType
         {
             get
             {
@@ -60,7 +70,7 @@ namespace Avalonia.Styling
 
         protected override SelectorMatch Evaluate(IStyleable control, bool subscribe)
         {
-            var activators = new List<IObservable<bool>>();
+            var activators = new OrActivatorBuilder();
             var neverThisInstance = false;
 
             foreach (var selector in _selectors)
@@ -76,18 +86,14 @@ namespace Avalonia.Styling
                         neverThisInstance = true;
                         break;
                     case SelectorMatchResult.Sometimes:
-                        activators.Add(match.Activator);
+                        activators.Add(match.Activator!);
                         break;
                 }
             }
 
-            if (activators.Count > 1)
+            if (activators.Count > 0)
-            {
-                return new SelectorMatch(StyleActivator.Or(activators));
-            }
-            else if (activators.Count == 1)
             {
-                return new SelectorMatch(activators[0]);
+                return new SelectorMatch(activators.Get());
             }
             else if (neverThisInstance)
             {
@@ -99,11 +105,11 @@ namespace Avalonia.Styling
             }
         }
 
-        protected override Selector MovePrevious() => null;
+        protected override Selector? MovePrevious() => null;
 
-        private Type EvaluateTargetType()
+        private Type? EvaluateTargetType()
         {
-            var result = default(Type);
+            Type? result = null;
 
             foreach (var selector in _selectors)
             {

src/Avalonia.Styling/Styling/PropertyEqualsSelector.cs

@@ -2,8 +2,10 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Reactive.Linq;
 using System.Text;
+using Avalonia.Styling.Activators;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -13,14 +15,14 @@ namespace Avalonia.Styling
     /// </summary>
     internal class PropertyEqualsSelector : Selector
     {
-        private readonly Selector _previous;
+        private readonly Selector? _previous;
         private readonly AvaloniaProperty _property;
-        private readonly object _value;
+        private readonly object? _value;
-        private string _selectorString;
+        private string? _selectorString;
 
-        public PropertyEqualsSelector(Selector previous, AvaloniaProperty property, object value)
+        public PropertyEqualsSelector(Selector? previous, AvaloniaProperty property, object? value)
         {
-            Contract.Requires<ArgumentNullException>(property != null);
+            property = property ?? throw new ArgumentNullException(nameof(property));
 
             _previous = previous;
             _property = property;
@@ -33,13 +35,8 @@ namespace Avalonia.Styling
         /// <inheritdoc/>
         public override bool IsCombinator => false;
 
-        /// <summary>
-        /// Gets the name of the control to match.
-        /// </summary>
-        public string Name { get; private set; }
-
         /// <inheritdoc/>
-        public override Type TargetType => _previous?.TargetType;
+        public override Type? TargetType => _previous?.TargetType;
 
         /// <inheritdoc/>
         public override string ToString()
@@ -77,7 +74,7 @@ namespace Avalonia.Styling
         {
             if (subscribe)
             {
-                return new SelectorMatch(control.GetObservable(_property).Select(v => Equals(v ?? string.Empty, _value)));
+                return new SelectorMatch(new PropertyEqualsActivator(control, _property, _value));
             }
             else
             {
@@ -86,6 +83,6 @@ namespace Avalonia.Styling
             }
         }
 
-        protected override Selector MovePrevious() => _previous;
+        protected override Selector? MovePrevious() => _previous;
     }
 }

src/Avalonia.Styling/Styling/PropertySetterBindingInstance.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Reactive.Subjects;
+using Avalonia.Data;
+using Avalonia.Reactive;
+
+#nullable enable
+
+namespace Avalonia.Styling
+{
+    /// <summary>
+    /// A <see cref="Setter"/> which has been instanced on a control and has an
+    /// <see cref="IBinding"/> as its value.
+    /// </summary>
+    /// <typeparam name="T">The target property type.</typeparam>
+    internal class PropertySetterBindingInstance<T> : SingleSubscriberObservableBase<BindingValue<T>>,
+        ISubject<BindingValue<T>>,
+        ISetterInstance
+    {
+        private readonly IStyleable _target;
+        private readonly StyledPropertyBase<T>? _styledProperty;
+        private readonly DirectPropertyBase<T>? _directProperty;
+        private readonly InstancedBinding _binding;
+        private readonly Inner _inner;
+        private BindingValue<T> _value;
+        private IDisposable? _subscription;
+        private IDisposable? _subscriptionTwoWay;
+        private bool _isActive;
+
+        public PropertySetterBindingInstance(
+            IStyleable target,
+            StyledPropertyBase<T> property,
+            IBinding binding)
+        {
+            _target = target;
+            _styledProperty = property;
+            _binding = binding.Initiate(_target, property);
+
+            if (_binding.Mode == BindingMode.OneTime)
+            {
+                // For the moment, we don't support OneTime bindings in setters, because I'm not
+                // sure what the semantics should be in the case of activation/deactivation.
+                throw new NotSupportedException("OneTime bindings are not supported in setters.");
+            }
+
+            _inner = new Inner(this);
+        }
+
+        public PropertySetterBindingInstance(
+            IStyleable target,
+            DirectPropertyBase<T> property,
+            IBinding binding)
+        {
+            _target = target;
+            _directProperty = property;
+            _binding = binding.Initiate(_target, property);
+            _inner = new Inner(this);
+        }
+
+        public void Start(bool hasActivator)
+        {
+            _isActive = !hasActivator;
+
+            if (_styledProperty is object)
+            {
+                if (_binding.Mode != BindingMode.OneWayToSource)
+                {
+                    var priority = hasActivator ? BindingPriority.StyleTrigger : BindingPriority.Style;
+                    _subscription = _target.Bind(_styledProperty, this, priority);
+                }
+
+                if (_binding.Mode == BindingMode.TwoWay)
+                {
+                    _subscriptionTwoWay = _target.GetBindingObservable(_styledProperty).Subscribe(this);
+                }
+            }
+            else
+            {
+                if (_binding.Mode != BindingMode.OneWayToSource)
+                {
+                    _subscription = _target.Bind(_directProperty!, this);
+                }
+
+                if (_binding.Mode == BindingMode.TwoWay)
+                {
+                    _subscriptionTwoWay = _target.GetBindingObservable(_directProperty!).Subscribe(this);
+                }
+            }
+        }
+
+        public void Activate()
+        {
+            if (!_isActive)
+            {
+                _isActive = true;
+                PublishNext();
+            }
+        }
+
+        public void Deactivate()
+        {
+            if (_isActive)
+            {
+                _isActive = false;
+                PublishNext();
+            }
+        }
+
+        public override void Dispose()
+        {
+            if (_subscription is object)
+            {
+                var sub = _subscription;
+                _subscription = null;
+                sub.Dispose();
+            }
+
+            if (_subscriptionTwoWay is object)
+            {
+                var sub = _subscriptionTwoWay;
+                _subscriptionTwoWay = null;
+                sub.Dispose();
+            }
+
+            base.Dispose();
+        }
+
+        void IObserver<BindingValue<T>>.OnCompleted()
+        {
+            // This is the observable coming from the target control. It should not complete.
+        }
+
+        void IObserver<BindingValue<T>>.OnError(Exception error)
+        {
+            // This is the observable coming from the target control. It should not error.
+        }
+
+        void IObserver<BindingValue<T>>.OnNext(BindingValue<T> value)
+        {
+            if (value.HasValue && _isActive)
+            {
+                _binding.Subject.OnNext(value.Value);
+            }
+        }
+
+        protected override void Subscribed()
+        {
+            _subscription = _binding.Observable.Subscribe(_inner);
+        }
+
+        protected override void Unsubscribed()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+        }
+
+        private void PublishNext()
+        {
+            PublishNext(_isActive ? _value : default);
+        }
+
+        private void ConvertAndPublishNext(object? value)
+        {
+            _value = value is T v ? v : BindingValue<object>.FromUntyped(value).Convert<T>();
+
+            if (_isActive)
+            {
+                PublishNext();
+            }
+        }
+
+        private class Inner : IObserver<object?>
+        {
+            private readonly PropertySetterBindingInstance<T> _owner;
+            public Inner(PropertySetterBindingInstance<T> owner) => _owner = owner;
+            public void OnCompleted() => _owner.PublishCompleted();
+            public void OnError(Exception error) => _owner.PublishError(error);
+            public void OnNext(object? value) => _owner.ConvertAndPublishNext(value);
+        }
+    }
+}

src/Avalonia.Styling/Styling/PropertySetterInstance.cs

@@ -0,0 +1,118 @@
+using System;
+using Avalonia.Data;
+using Avalonia.Reactive;
+
+#nullable enable
+
+namespace Avalonia.Styling
+{
+    /// <summary>
+    /// A <see cref="Setter"/> which has been instance on a control.
+    /// </summary>
+    /// <typeparam name="T">The target property type.</typeparam>
+    internal class PropertySetterInstance<T> : SingleSubscriberObservableBase<BindingValue<T>>,
+        ISetterInstance
+    {
+        private readonly IStyleable _target;
+        private readonly StyledPropertyBase<T>? _styledProperty;
+        private readonly DirectPropertyBase<T>? _directProperty;
+        private readonly T _value;
+        private IDisposable? _subscription;
+        private bool _isActive;
+
+        public PropertySetterInstance(
+            IStyleable target,
+            StyledPropertyBase<T> property,
+            T value)
+        {
+            _target = target;
+            _styledProperty = property;
+            _value = value;
+        }
+
+        public PropertySetterInstance(
+            IStyleable target,
+            DirectPropertyBase<T> property,
+            T value)
+        {
+            _target = target;
+            _directProperty = property;
+            _value = value;
+        }
+
+        public void Start(bool hasActivator)
+        {
+            if (hasActivator)
+            {
+                if (_styledProperty is object)
+                {
+                    _subscription = _target.Bind(_styledProperty, this, BindingPriority.StyleTrigger);
+                }
+                else
+                {
+                    _subscription = _target.Bind(_directProperty, this);
+                }
+            }
+            else
+            {
+                if (_styledProperty is object)
+                {
+                    _subscription = _target.SetValue(_styledProperty, _value, BindingPriority.Style);
+                }
+                else
+                {
+                    _target.SetValue(_directProperty!, _value);
+                }
+            }
+        }
+
+        public void Activate()
+        {
+            if (!_isActive)
+            {
+                _isActive = true;
+                PublishNext();
+            }
+        }
+
+        public void Deactivate()
+        {
+            if (_isActive)
+            {
+                _isActive = false;
+                PublishNext();
+            }
+        }
+
+        public override void Dispose()
+        {
+            if (_subscription is object)
+            {
+                var sub = _subscription;
+                _subscription = null;
+                sub.Dispose();
+            }
+            else if (_isActive)
+            {
+                if (_styledProperty is object)
+                {
+                    _target.ClearValue(_styledProperty);
+                }
+                else
+                {
+                    _target.ClearValue(_directProperty);
+                }
+            }
+
+            base.Dispose();
+        }
+
+        protected override void Subscribed() => PublishNext();
+        protected override void Unsubscribed() { }
+
+        private void PublishNext()
+        {
+            PublishNext(_isActive ? new BindingValue<T>(_value) : default);
+        }
+    }
+}

src/Avalonia.Styling/Styling/Selector.cs

@@ -2,9 +2,9 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
+using Avalonia.Styling.Activators;
-using System.Diagnostics;
+
-using Avalonia.Utilities;
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -30,7 +30,7 @@ namespace Avalonia.Styling
         /// <summary>
         /// Gets the target type of the selector, if available.
         /// </summary>
-        public abstract Type TargetType { get; }
+        public abstract Type? TargetType { get; }
 
         /// <summary>
         /// Tries to match the selector with a control.
@@ -43,54 +43,28 @@ namespace Avalonia.Styling
         /// <returns>A <see cref="SelectorMatch"/>.</returns>
         public SelectorMatch Match(IStyleable control, bool subscribe = true)
         {
-            ValueSingleOrList<IObservable<bool>> inputs = default;
+            // First match the selector until a combinator is found. Selectors are stored from 
-
+            // right-to-left, so MatchUntilCombinator reverses this order because the type selector
-            var selector = this;
+            // will be on the left.
-            var alwaysThisType = true;
+            var match = MatchUntilCombinator(control, this, subscribe, out var combinator);
-            var hitCombinator = false;
+            
-
+            // If the pre-combinator selector matches, we can now match the combinator, if any.
-            while (selector != null)
+            if (match.IsMatch && combinator is object)
             {
-                hitCombinator |= selector.IsCombinator;
+                match = match.And(combinator.Match(control, subscribe));
 
-                var match = selector.Evaluate(control, subscribe);
+                // If we have a combinator then we can never say that we always match a control of
-
+                // this type, because by definition the combinator matches on things outside of the
-                if (!match.IsMatch)
+                // control.
-                {
+                match = match.Result switch
-                    return hitCombinator ? SelectorMatch.NeverThisInstance : match;
-                }
-                else if (selector.InTemplate && control.TemplatedParent == null)
                 {
-                    return SelectorMatch.NeverThisInstance;
+                    SelectorMatchResult.AlwaysThisType => SelectorMatch.AlwaysThisInstance,
-                }
+                    SelectorMatchResult.NeverThisType => SelectorMatch.NeverThisInstance,
-                else if (match.Result == SelectorMatchResult.AlwaysThisInstance)
+                    _ => match
-                {
+                };
-                    alwaysThisType = false;
-                }
-                else if (match.Result == SelectorMatchResult.Sometimes)
-                {
-                    Debug.Assert(match.Activator != null);
-
-                    inputs.Add(match.Activator);
-                }
-
-                selector = selector.MovePrevious();
             }
 
-            if (inputs.HasList)
+            return match;
-            {
-                return new SelectorMatch(StyleActivator.And(inputs.List));
-            }
-            else if (inputs.IsSingle)
-            {
-                return new SelectorMatch(inputs.Single);
-            }
-            else
-            {
-                return alwaysThisType && !hitCombinator ?
-                    SelectorMatch.AlwaysThisType :
-                    SelectorMatch.AlwaysThisInstance;
-            }
         }
 
         /// <summary>
@@ -107,6 +81,65 @@ namespace Avalonia.Styling
         /// <summary>
         /// Moves to the previous selector.
         /// </summary>
-        protected abstract Selector MovePrevious();
+        protected abstract Selector? MovePrevious();
+
+        private static SelectorMatch MatchUntilCombinator(
+            IStyleable control,
+            Selector start,
+            bool subscribe,
+            out Selector? combinator)
+        {
+            combinator = null;
+
+            var activators = new AndActivatorBuilder();
+            var result = Match(control, start, subscribe, ref activators, ref combinator);
+
+            return result == SelectorMatchResult.Sometimes ?
+                new SelectorMatch(activators.Get()) :
+                new SelectorMatch(result);
+        }
+
+        private static SelectorMatchResult Match(
+            IStyleable control,
+            Selector selector,
+            bool subscribe,
+            ref AndActivatorBuilder activators,
+            ref Selector? combinator)
+        {
+            var previous = selector.MovePrevious();
+
+            // Selectors are stored from right-to-left, so we recurse into the selector in order to
+            // reverse this order, because the type selector will be on the left and is our best
+            // opportunity to exit early.
+            if (previous != null && !previous.IsCombinator)
+            {
+                var previousMatch = Match(control, previous, subscribe, ref activators, ref combinator);
+
+                if (previousMatch < SelectorMatchResult.Sometimes)
+                {
+                    return previousMatch;
+                }
+            }
+
+            // Match this selector.
+            var match = selector.Evaluate(control, subscribe);
+
+            if (!match.IsMatch)
+            {
+                combinator = null;
+                return match.Result;
+            }
+            else if (match.Activator is object)
+            {
+                activators.Add(match.Activator!);
+            }
+
+            if (previous?.IsCombinator == true)
+            {
+                combinator = previous;
+            }
+
+            return match.Result;
+        }
     }
 }

src/Avalonia.Styling/Styling/SelectorMatch.cs

@@ -2,6 +2,9 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
+using Avalonia.Styling.Activators;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -21,9 +24,9 @@ namespace Avalonia.Styling
         NeverThisInstance,
 
         /// <summary>
-        /// The selector always matches this type.
+        /// The selector matches this instance based on the <see cref="SelectorMatch.Activator"/>.
         /// </summary>
-        AlwaysThisType,
+        Sometimes,
 
         /// <summary>
         /// The selector always matches this instance, but doesn't always match this type.
@@ -31,9 +34,9 @@ namespace Avalonia.Styling
         AlwaysThisInstance,
 
         /// <summary>
-        /// The selector matches this instance based on the <see cref="SelectorMatch.Activator"/>.
+        /// The selector always matches this type.
         /// </summary>
-        Sometimes,
+        AlwaysThisType,
     }
 
     /// <summary>
@@ -43,7 +46,7 @@ namespace Avalonia.Styling
     /// A selector match describes whether and how a <see cref="Selector"/> matches a control, and
     /// in addition whether the selector can ever match a control of the same type.
     /// </remarks>
-    public class SelectorMatch
+    public readonly struct SelectorMatch
     {
         /// <summary>
         /// A selector match with the result of <see cref="SelectorMatchResult.NeverThisType"/>.
@@ -70,20 +73,28 @@ namespace Avalonia.Styling
         /// <see cref="SelectorMatchResult.Sometimes"/> result.
         /// </summary>
         /// <param name="match">The match activator.</param>
-        public SelectorMatch(IObservable<bool> match)
+        public SelectorMatch(IStyleActivator match)
         {
-            Contract.Requires<ArgumentNullException>(match != null);
+            match = match ?? throw new ArgumentNullException(nameof(match));
 
             Result = SelectorMatchResult.Sometimes;
             Activator = match;
         }
 
-        private SelectorMatch(SelectorMatchResult result) => Result = result;
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SelectorMatch"/> class with the specified result.
+        /// </summary>
+        /// <param name="result">The match result.</param>
+        public SelectorMatch(SelectorMatchResult result)
+        {
+            Result = result;
+            Activator = null;
+        }
 
         /// <summary>
         /// Gets a value indicating whether the match was positive.
         /// </summary>
-        public bool IsMatch => Result >= SelectorMatchResult.AlwaysThisType;
+        public bool IsMatch => Result >= SelectorMatchResult.Sometimes;
 
         /// <summary>
         /// Gets the result of the match.
@@ -91,9 +102,34 @@ namespace Avalonia.Styling
         public SelectorMatchResult Result { get; }
 
         /// <summary>
-        /// Gets an observable which tracks the selector match, in the case of selectors that can
+        /// Gets an activator which tracks the selector match, in the case of selectors that can
         /// change over time.
         /// </summary>
-        public IObservable<bool> Activator { get; }
+        public IStyleActivator? Activator { get; }
+
+        /// <summary>
+        /// Logical ANDs this <see cref="SelectorMatch"/> with another.
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        public SelectorMatch And(in SelectorMatch other)
+        {
+            var result = (SelectorMatchResult)Math.Min((int)Result, (int)other.Result);
+
+            if (result == SelectorMatchResult.Sometimes)
+            {
+                var activators = new AndActivatorBuilder();
+                activators.Add(Activator);
+                activators.Add(other.Activator);
+                return new SelectorMatch(activators.Get());
+            }
+            else
+            {
+                return new SelectorMatch(result);
+            }
+        }
+
+        /// <inheritdoc/>
+        public override string ToString() => Result.ToString();
     }
 }

src/Avalonia.Styling/Styling/Setter.cs

@@ -2,11 +2,12 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Reactive.Disposables;
 using Avalonia.Animation;
 using Avalonia.Data;
 using Avalonia.Metadata;
-using Avalonia.Reactive;
+using Avalonia.Utilities;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -17,9 +18,9 @@ namespace Avalonia.Styling
     /// A <see cref="Setter"/> is used to set a <see cref="AvaloniaProperty"/> value on a
     /// <see cref="AvaloniaObject"/> depending on a condition.
     /// </remarks>
-    public class Setter : ISetter, IAnimationSetter
+    public class Setter : ISetter, IAnimationSetter, IAvaloniaPropertyVisitor<Setter.SetterVisitorData>
     {
-        private object _value;
+        private object? _value;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Setter"/> class.
@@ -42,11 +43,7 @@ namespace Avalonia.Styling
         /// <summary>
         /// Gets or sets the property to set.
         /// </summary>
-        public AvaloniaProperty Property
+        public AvaloniaProperty? Property { get; set; }
-        {
-            get;
-            set;
-        }
 
         /// <summary>
         /// Gets or sets the property value.
@@ -54,13 +51,9 @@ namespace Avalonia.Styling
         [Content]
         [AssignBinding]
         [DependsOn(nameof(Property))]
-        public object Value
+        public object? Value
         {
-            get
+            get => _value;
-            {
-                return _value;
-            }
-
             set
             {
                 (value as ISetterValue)?.Initialize(this);
@@ -68,99 +61,78 @@ namespace Avalonia.Styling
             }
         }
 
-        /// <summary>
+        public ISetterInstance Instance(IStyleable target)
-        /// Applies the setter to a control.
-        /// </summary>
-        /// <param name="style">The style that is being applied.</param>
-        /// <param name="control">The control.</param>
-        /// <param name="activator">An optional activator.</param>
-        public IDisposable Apply(IStyle style, IStyleable control, IObservable<bool> activator)
         {
-            Contract.Requires<ArgumentNullException>(control != null);
+            target = target ?? throw new ArgumentNullException(nameof(target));
 
-            if (Property == null)
+            if (Property is null)
             {
                 throw new InvalidOperationException("Setter.Property must be set.");
             }
 
             var value = Value;
-            var binding = value as IBinding;
 
-            if (binding == null)
+            if (value is ITemplate template &&
+                !typeof(ITemplate).IsAssignableFrom(Property.PropertyType))
             {
-                if (value is ITemplate template)
+                value = template.Build();
-                {
-                    bool isPropertyOfTypeITemplate = typeof(ITemplate).IsAssignableFrom(Property.PropertyType);
-
-                    if (!isPropertyOfTypeITemplate)
-                    {
-                        var materialized = template.Build();
-                        value = materialized;
-                    }
-                }
-
-                if (activator == null)
-                {
-                    return control.Bind(Property, ObservableEx.SingleValue(value), BindingPriority.Style);
-                }
-                else
-                {
-                    var description = style?.ToString();
-
-                    var activated = new ActivatedValue(activator, value, description);
-                    return control.Bind(Property, activated, BindingPriority.StyleTrigger);
-                }
             }
-            else
-            {
-                var source = binding.Initiate(control, Property);
 
-                if (source != null)
+            var data = new SetterVisitorData
-                {
+            {
-                    var cloned = Clone(source, source.Mode == BindingMode.Default ? Property.GetMetadata(control.GetType()).DefaultBindingMode : source.Mode, style, activator);
+                target = target,
-                    return BindingOperations.Apply(control, Property, cloned, null);
+                value = value,
-                }
+            };
-            }
 
-            return Disposable.Empty;
+            Property.Accept(this, ref data);
+            return data.result!;
         }
 
-        private InstancedBinding Clone(InstancedBinding sourceInstance, BindingMode mode, IStyle style, IObservable<bool> activator)
+        void IAvaloniaPropertyVisitor<SetterVisitorData>.Visit<T>(
+            StyledPropertyBase<T> property,
+            ref SetterVisitorData data)
         {
-            if (activator != null)
+            if (data.value is IBinding binding)
+            {
+                data.result = new PropertySetterBindingInstance<T>(
+                    data.target,
+                    property,
+                    binding);
+            }
+            else
             {
-                var description = style?.ToString();
+                data.result = new PropertySetterInstance<T>(
-
+                    data.target,
-                switch (mode)
+                    property,
-                {
+                    (T)data.value);
-                    case BindingMode.OneTime:
+            }
-                        if (sourceInstance.Observable != null)
+        }
-                        {
-                            var activated = new ActivatedObservable(activator, sourceInstance.Observable, description);
-                            return InstancedBinding.OneTime(activated, BindingPriority.StyleTrigger);
-                        }
-                        else
-                        {
-                            var activated = new ActivatedValue(activator, sourceInstance.Value, description);
-                            return InstancedBinding.OneTime(activated, BindingPriority.StyleTrigger);
-                        }
-                    case BindingMode.OneWay:
-                        {
-                            var activated = new ActivatedObservable(activator, sourceInstance.Observable, description);
-                            return InstancedBinding.OneWay(activated, BindingPriority.StyleTrigger);
-                        }
-                    default:
-                        {
-                            var activated = new ActivatedSubject(activator, sourceInstance.Subject, description);
-                            return new InstancedBinding(activated, sourceInstance.Mode, BindingPriority.StyleTrigger);
-                        }
-                }
 
+        void IAvaloniaPropertyVisitor<SetterVisitorData>.Visit<T>(
+            DirectPropertyBase<T> property,
+            ref SetterVisitorData data)
+        {
+            if (data.value is IBinding binding)
+            {
+                data.result = new PropertySetterBindingInstance<T>(
+                    data.target,
+                    property,
+                    binding);
             }
             else
             {
-                return sourceInstance.WithPriority(BindingPriority.Style);
+                data.result = new PropertySetterInstance<T>(
+                    data.target,
+                    property,
+                    (T)data.value);
             }
         }
+
+        private struct SetterVisitorData
+        {
+            public IStyleable target;
+            public object? value;
+            public ISetterInstance? result;
+        }
     }
 }

src/Avalonia.Styling/Styling/Style.cs

@@ -3,12 +3,12 @@
 
 using System;
 using System.Collections.Generic;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
 using Avalonia.Animation;
 using Avalonia.Controls;
 using Avalonia.Metadata;
 
+#nullable enable
+
 namespace Avalonia.Styling
 {
     /// <summary>
@@ -16,15 +16,10 @@ namespace Avalonia.Styling
     /// </summary>
     public class Style : AvaloniaObject, IStyle, ISetResourceParent
     {
-        private static Dictionary<IStyleable, CompositeDisposable> _applied =
+        private IResourceNode? _parent;
-            new Dictionary<IStyleable, CompositeDisposable>();
+        private IResourceDictionary? _resources;
-        private IResourceNode _parent;
+        private List<ISetter>? _setters;
-
+        private List<IAnimation>? _animations;
-        private CompositeDisposable _subscriptions;
-
-        private IResourceDictionary _resources;
-
-        private IList<IAnimation> _animations;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Style"/> class.
@@ -37,13 +32,13 @@ namespace Avalonia.Styling
         /// Initializes a new instance of the <see cref="Style"/> class.
         /// </summary>
         /// <param name="selector">The style selector.</param>
-        public Style(Func<Selector, Selector> selector)
+        public Style(Func<Selector?, Selector> selector)
         {
             Selector = selector(null);
         }
 
         /// <inheritdoc/>
-        public event EventHandler<ResourcesChangedEventArgs> ResourcesChanged;
+        public event EventHandler<ResourcesChangedEventArgs>? ResourcesChanged;
 
         /// <summary>
         /// Gets or sets a dictionary of style resources.
@@ -53,7 +48,7 @@ namespace Avalonia.Styling
             get => _resources ?? (Resources = new ResourceDictionary());
             set
             {
-                Contract.Requires<ArgumentNullException>(value != null);
+                value = value ?? throw new ArgumentNullException(nameof(value));
 
                 var hadResources = false;
 
@@ -76,117 +71,45 @@ namespace Avalonia.Styling
         /// <summary>
         /// Gets or sets the style's selector.
         /// </summary>
-        public Selector Selector { get; set; }
+        public Selector? Selector { get; set; }
 
         /// <summary>
-        /// Gets or sets the style's setters.
+        /// Gets the style's setters.
         /// </summary>
         [Content]
-        public IList<ISetter> Setters { get; set; } = new List<ISetter>();
+        public IList<ISetter> Setters => _setters ??= new List<ISetter>();
-
-        public IList<IAnimation> Animations
-        {
-            get
-            {
-                return _animations ?? (_animations = new List<IAnimation>());
-            }
-        }
 
-        private CompositeDisposable Subscriptions
+        /// <summary>
-        {
+        /// Gets the style's animations.
-            get
+        /// </summary>
-            {
+        public IList<IAnimation> Animations => _animations ??= new List<IAnimation>();
-                return _subscriptions ?? (_subscriptions = new CompositeDisposable(2));
-            }
-        }
 
         /// <inheritdoc/>
-        IResourceNode IResourceNode.ResourceParent => _parent;
+        IResourceNode? IResourceNode.ResourceParent => _parent;
 
         /// <inheritdoc/>
         bool IResourceProvider.HasResources => _resources?.Count > 0;
 
         /// <inheritdoc/>
-        public bool Attach(IStyleable control, IStyleHost container)
+        public SelectorMatchResult TryAttach(IStyleable target, IStyleHost? host)
         {
-            if (Selector != null)
+            target = target ?? throw new ArgumentNullException(nameof(target));
-            {
-                var match = Selector.Match(control);
-
-                if (match.IsMatch)
-                {
-                    var controlSubscriptions = GetSubscriptions(control);
-
-                    var animatable = control as Animatable;
-
-                    var setters = Setters;
-                    var settersCount = setters.Count;
-                    var animations = Animations;
-                    var animationsCount = animations.Count;
 
-                    var subs = new CompositeDisposable(settersCount + (animatable != null ? animationsCount : 0) + 1);
+            var match = Selector is object ? Selector.Match(target) :
-
+                target == host ? SelectorMatch.AlwaysThisInstance : SelectorMatch.NeverThisInstance;
-                    if (animatable != null)
-                    {
-                        for (var i = 0; i < animationsCount; i++)
-                        {
-                            var animation = animations[i];
-                            var obsMatch = match.Activator;
-
-                            if (match.Result == SelectorMatchResult.AlwaysThisType ||
-                                match.Result == SelectorMatchResult.AlwaysThisInstance)
-                            {
-                                obsMatch = Observable.Return(true);
-                            }
-
-                            var sub = animation.Apply(animatable, null, obsMatch);
-                            subs.Add(sub);
-                        }
-                    }
-
-                    for (var i = 0; i < settersCount; i++)
-                    {
-                        var setter = setters[i];
-                        var sub = setter.Apply(this, control, match.Activator);
-                        subs.Add(sub);
-                    }
-
-                    subs.Add(Disposable.Create((subs, Subscriptions) , state =>  state.Subscriptions.Remove(state.subs)));
-
-                    controlSubscriptions.Add(subs);
-                    Subscriptions.Add(subs);
-                }
 
-                return match.Result != SelectorMatchResult.NeverThisType;
+            if (match.IsMatch && (_setters is object || _animations is object))
-            }
-            else if (control == container)
             {
-                var setters = Setters;
+                var instance = new StyleInstance(this, target, _setters, _animations, match.Activator);
-                var settersCount = setters.Count;
+                target.StyleApplied(instance);
-
+                instance.Start();
-                var controlSubscriptions = GetSubscriptions(control);
-
-                var subs = new CompositeDisposable(settersCount + 1);
-
-                for (var i = 0; i < settersCount; i++)
-                {
-                    var setter = setters[i];
-                    var sub = setter.Apply(this, control, null);
-                    subs.Add(sub);
-                }
-
-                subs.Add(Disposable.Create((subs, Subscriptions), state => state.Subscriptions.Remove(state.subs)));
-
-                controlSubscriptions.Add(subs);
-                Subscriptions.Add(subs);
-                return true;
             }
 
-            return false;
+            return match.Result;
         }
 
         /// <inheritdoc/>
-        public bool TryGetResource(object key, out object result)
+        public bool TryGetResource(object key, out object? result)
         {
             result = null;
             return _resources?.TryGetResource(key, out result) ?? false;
@@ -222,46 +145,9 @@ namespace Avalonia.Styling
                 throw new InvalidOperationException("The Style already has a parent.");
             }
 
-            if (parent == null)
-            {
-                Detach();
-            }
-
             _parent = parent;
         }
 
-        public void Detach()
-        {
-            _subscriptions?.Dispose();
-            _subscriptions = null;
-        }
-
-        private static CompositeDisposable GetSubscriptions(IStyleable control)
-        {
-            if (!_applied.TryGetValue(control, out var subscriptions))
-            {
-                subscriptions = new CompositeDisposable(3);
-                subscriptions.Add(control.StyleDetach.Subscribe(ControlDetach));
-                _applied.Add(control, subscriptions);
-            }
-
-            return subscriptions;
-        }
-
-        /// <summary>
-        /// Called when a control's <see cref="IStyleable.StyleDetach"/> is signaled to remove
-        /// all applied styles.
-        /// </summary>
-        /// <param name="control">The control.</param>
-        private static void ControlDetach(IStyleable control)
-        {
-            var subscriptions = _applied[control];
-
-            subscriptions.Dispose();
-
-            _applied.Remove(control);
-        }
-
         private void ResourceDictionaryChanged(object sender, ResourcesChangedEventArgs e)
         {
             ResourcesChanged?.Invoke(this, e);

src/Avalonia.Styling/Styling/StyleActivator.cs

@@ -1,56 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive;
-using System.Reactive.Linq;
-
-namespace Avalonia.Styling
-{
-    public enum ActivatorMode
-    {
-        And,
-        Or,
-    }
-
-    public static class StyleActivator
-    {
-        public static IObservable<bool> And(IList<IObservable<bool>> inputs)
-        {
-            if (inputs.Count == 0)
-            {
-                throw new ArgumentException("StyleActivator.And inputs may not be empty.");
-            }
-            else if (inputs.Count == 1)
-            {
-                return inputs[0];
-            }
-            else
-            {
-                return inputs.CombineLatest()
-                    .Select(values => values.All(x => x))
-                    .DistinctUntilChanged();
-            }
-        }
-
-        public static IObservable<bool> Or(IList<IObservable<bool>> inputs)
-        {
-            if (inputs.Count == 0)
-            {
-                throw new ArgumentException("StyleActivator.Or inputs may not be empty.");
-            }
-            else if (inputs.Count == 1)
-            {
-                return inputs[0];
-            }
-            else
-            {
-                return inputs.CombineLatest()
-                    .Select(values => values.Any(x => x))
-                    .DistinctUntilChanged();
-            }
-        }
-    }
-}

src/Avalonia.Styling/Styling/StyleInstance.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Reactive.Subjects;
+using Avalonia.Animation;
+using Avalonia.Styling.Activators;
+
+#nullable enable
+
+namespace Avalonia.Styling
+{
+    /// <summary>
+    /// A <see cref="Style"/> which has been instanced on a control.
+    /// </summary>
+    internal class StyleInstance : IStyleInstance, IStyleActivatorSink
+    {
+        private readonly List<ISetterInstance>? _setters;
+        private readonly List<IDisposable>? _animations;
+        private readonly IStyleActivator? _activator;
+        private readonly Subject<bool>? _animationTrigger;
+        private bool _active;
+
+        public StyleInstance(
+            IStyle source,
+            IStyleable target,
+            IReadOnlyList<ISetter>? setters,
+            IReadOnlyList<IAnimation>? animations,
+            IStyleActivator? activator = null)
+        {
+            Source = source ?? throw new ArgumentNullException(nameof(source));
+            Target = target ?? throw new ArgumentNullException(nameof(target));
+            _activator = activator;
+
+            if (setters is object)
+            {
+                var setterCount = setters.Count;
+
+                _setters = new List<ISetterInstance>(setterCount);
+
+                for (var i = 0; i < setterCount; ++i)
+                {
+                    _setters.Add(setters[i].Instance(Target));
+                }
+            }
+
+            if (animations is object && target is Animatable animatable)
+            {
+                var animationsCount = animations.Count;
+
+                _animations = new List<IDisposable>(animationsCount);
+                _animationTrigger = new Subject<bool>();
+
+                for (var i = 0; i < animationsCount; ++i)
+                {
+                    _animations.Add(animations[i].Apply(animatable, null, _animationTrigger));
+                }
+            }
+        }
+
+        public IStyle Source { get; }
+        public IStyleable Target { get; }
+
+        public void Start()
+        {
+            var hasActivator = _activator is object;
+
+            if (_setters is object)
+            {
+                foreach (var setter in _setters)
+                {
+                    setter.Start(hasActivator);
+                }
+            }
+
+            if (hasActivator)
+            {
+                _activator!.Subscribe(this, 0);
+            }
+            else if (_animationTrigger != null)
+            {
+                _animationTrigger.OnNext(true);
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_setters is object)
+            {
+                foreach (var setter in _setters)
+                {
+                    setter.Dispose();
+                }
+            }
+
+            if (_animations is object)
+            {
+                foreach (var subscripion in _animations)
+                {
+                    subscripion.Dispose();
+                }
+            }
+
+            _activator?.Dispose();
+        }
+
+        private void ActivatorChanged(bool value)
+        {
+            if (_active != value)
+            {
+                _active = value;
+
+                _animationTrigger?.OnNext(value);
+
+                if (_setters is object)
+                {
+                    if (_active)
+                    {
+                        foreach (var setter in _setters)
+                        {
+                            setter.Activate();
+                        }
+                    }
+                    else
+                    {
+                        foreach (var setter in _setters)
+                        {
+                            setter.Deactivate();
+                        }
+                    }
+                }
+            }
+        }
+
+        void IStyleActivatorSink.OnNext(bool value, int tag) => ActivatorChanged(value);
+    }
+}

src/Avalonia.Styling/Styling/Styler.cs

@@ -3,35 +3,34 @@
 
 using System;
 
+#nullable enable
+
 namespace Avalonia.Styling
 {
     public class Styler : IStyler
     {
-        public void ApplyStyles(IStyleable control)
+        public void ApplyStyles(IStyleable target)
         {
-            var styleHost = control as IStyleHost;
+            target = target ?? throw new ArgumentNullException(nameof(target));
 
-            if (styleHost != null)
+            if (target is IStyleHost styleHost)
             {
-                ApplyStyles(control, styleHost);
+                ApplyStyles(target, styleHost);
             }
         }
 
-        private void ApplyStyles(IStyleable control, IStyleHost styleHost)
+        private void ApplyStyles(IStyleable target, IStyleHost host)
         {
-            Contract.Requires<ArgumentNullException>(control != null);
+            var parent = host.StylingParent;
-            Contract.Requires<ArgumentNullException>(styleHost != null);
-
-            var parentContainer = styleHost.StylingParent;
 
-            if (parentContainer != null)
+            if (parent != null)
             {
-                ApplyStyles(control, parentContainer);
+                ApplyStyles(target, parent);
             }
 
-            if (styleHost.IsStylesInitialized)
+            if (host.IsStylesInitialized)
             {
-                styleHost.Styles.Attach(control, styleHost);
+                host.Styles.TryAttach(target, host);
             }
         }
     }

src/Avalonia.Styling/Styling/Styles.cs

@@ -9,6 +9,8 @@ using System.Linq;
 using Avalonia.Collections;
 using Avalonia.Controls;
 
+#nullable enable
+
 namespace Avalonia.Styling
 {
     /// <summary>
@@ -16,10 +18,10 @@ namespace Avalonia.Styling
     /// </summary>
     public class Styles : AvaloniaObject, IAvaloniaList<IStyle>, IStyle, ISetResourceParent
     {
-        private IResourceNode _parent;
+        private readonly AvaloniaList<IStyle> _styles = new AvaloniaList<IStyle>();
-        private IResourceDictionary _resources;
+        private IResourceNode? _parent;
-        private AvaloniaList<IStyle> _styles = new AvaloniaList<IStyle>();
+        private IResourceDictionary? _resources;
-        private Dictionary<Type, List<IStyle>> _cache;
+        private Dictionary<Type, List<IStyle>?>? _cache;
         private bool _notifyingResourcesChanged;
 
         public Styles()
@@ -74,7 +76,7 @@ namespace Avalonia.Styling
         }
 
         /// <inheritdoc/>
-        public event EventHandler<ResourcesChangedEventArgs> ResourcesChanged;
+        public event EventHandler<ResourcesChangedEventArgs>? ResourcesChanged;
 
         /// <inheritdoc/>
         public int Count => _styles.Count;
@@ -90,7 +92,7 @@ namespace Avalonia.Styling
             get => _resources ?? (Resources = new ResourceDictionary());
             set
             {
-                Contract.Requires<ArgumentNullException>(value != null);
+                value = value ?? throw new ArgumentNullException(nameof(Resources));
 
                 var hadResources = false;
 
@@ -111,7 +113,7 @@ namespace Avalonia.Styling
         }
 
         /// <inheritdoc/>
-        IResourceNode IResourceNode.ResourceParent => _parent;
+        IResourceNode? IResourceNode.ResourceParent => _parent;
 
         /// <inheritdoc/>
         bool ICollection<IStyle>.IsReadOnly => false;
@@ -126,66 +128,50 @@ namespace Avalonia.Styling
             set => _styles[index] = value;
         }
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Attaches the style to a control if the style's selector matches.
+        public SelectorMatchResult TryAttach(IStyleable target, IStyleHost? host)
-        /// </summary>
-        /// <param name="control">The control to attach to.</param>
-        /// <param name="container">
-        /// The control that contains this style. May be null.
-        /// </param>
-        public bool Attach(IStyleable control, IStyleHost container)
         {
-            if (_cache == null)
+            _cache ??= new Dictionary<Type, List<IStyle>?>();
-            {
-                _cache = new Dictionary<Type, List<IStyle>>();
-            }
 
-            if (_cache.TryGetValue(control.StyleKey, out var cached))
+            if (_cache.TryGetValue(target.StyleKey, out var cached))
             {
-                if (cached != null)
+                if (cached is object)
                 {
                     foreach (var style in cached)
                     {
-                        style.Attach(control, container);
+                        style.TryAttach(target, host);
                     }
 
-                    return true;
+                    return SelectorMatchResult.AlwaysThisType;
+                }
+                else
+                {
+                    return SelectorMatchResult.NeverThisType;
                 }
-
-                return false;
             }
             else
             {
-                List<IStyle> result = null;
+                List<IStyle>? matches = null;
 
-                foreach (var style in this)
+                foreach (var child in this)
                 {
-                    if (style.Attach(control, container))
+                    if (child.TryAttach(target, host) != SelectorMatchResult.NeverThisType)
                     {
-                        if (result == null)
+                        matches ??= new List<IStyle>();
-                        {
+                        matches.Add(child);
-                            result = new List<IStyle>();
-                        }
-
-                        result.Add(style);
                     }
                 }
 
-                _cache.Add(control.StyleKey, result);
+                _cache.Add(target.StyleKey, matches);
-                return result != null;
+                
-            }
+                return matches is null ?
-        }
+                    SelectorMatchResult.NeverThisType :
-
+                    SelectorMatchResult.AlwaysThisType;
-        public void Detach()
-        {
-            foreach (IStyle style in this)
-            {
-                style.Detach();
             }
         }
 
         /// <inheritdoc/>
-        public bool TryGetResource(object key, out object value)
+        public bool TryGetResource(object key, out object? value)
         {
             if (_resources != null && _resources.TryGetResource(key, out value))
             {

src/Avalonia.Styling/Styling/TemplateSelector.cs

@@ -41,12 +41,11 @@ namespace Avalonia.Styling
 
         protected override SelectorMatch Evaluate(IStyleable control, bool subscribe)
         {
-            IStyleable templatedParent = control.TemplatedParent as IStyleable;
+            var templatedParent = control.TemplatedParent as IStyleable;
 
             if (templatedParent == null)
             {
-                throw new InvalidOperationException(
+                return SelectorMatch.NeverThisInstance;
-                    "Cannot call Template selector on control with null TemplatedParent.");
             }
 
             return _parent.Match(templatedParent, subscribe);

src/Avalonia.Styling/Styling/TypeNameAndClassSelector.cs

@@ -3,11 +3,10 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Reflection;
 using System.Text;
-using Avalonia.Collections;
+using Avalonia.Styling.Activators;
-using Avalonia.Reactive;
+
+#nullable enable
 
 namespace Avalonia.Styling
 {
@@ -17,13 +16,12 @@ namespace Avalonia.Styling
     /// </summary>
     internal class TypeNameAndClassSelector : Selector
     {
-        private readonly Selector _previous;
+        private readonly Selector? _previous;
         private readonly Lazy<List<string>> _classes = new Lazy<List<string>>(() => new List<string>());
-        private Type _targetType;
+        private Type? _targetType;
-        
+        private string? _selectorString;
-        private string _selectorString;
 
-        public static TypeNameAndClassSelector OfType(Selector previous, Type targetType)
+        public static TypeNameAndClassSelector OfType(Selector? previous, Type targetType)
         {
             var result = new TypeNameAndClassSelector(previous);
             result._targetType = targetType;
@@ -32,7 +30,7 @@ namespace Avalonia.Styling
             return result;
         }
 
-        public static TypeNameAndClassSelector Is(Selector previous, Type targetType)
+        public static TypeNameAndClassSelector Is(Selector? previous, Type targetType)
         {
             var result = new TypeNameAndClassSelector(previous);
             result._targetType = targetType;
@@ -41,7 +39,7 @@ namespace Avalonia.Styling
             return result;
         }
 
-        public static TypeNameAndClassSelector ForName(Selector previous, string name)
+        public static TypeNameAndClassSelector ForName(Selector? previous, string name)
         {
             var result = new TypeNameAndClassSelector(previous);
             result.Name = name;
@@ -49,7 +47,7 @@ namespace Avalonia.Styling
             return result;
         }
 
-        public static TypeNameAndClassSelector ForClass(Selector previous, string className)
+        public static TypeNameAndClassSelector ForClass(Selector? previous, string className)
         {
             var result = new TypeNameAndClassSelector(previous);
             result.Classes.Add(className);
@@ -57,7 +55,7 @@ namespace Avalonia.Styling
             return result;
         }
 
-        protected TypeNameAndClassSelector(Selector previous)
+        protected TypeNameAndClassSelector(Selector? previous)
         {
             _previous = previous;
         }
@@ -68,10 +66,10 @@ namespace Avalonia.Styling
         /// <summary>
         /// Gets the name of the control to match.
         /// </summary>
-        public string Name { get; set; }
+        public string? Name { get; set; }
 
         /// <inheritdoc/>
-        public override Type TargetType => _targetType ?? _previous?.TargetType;
+        public override Type? TargetType => _targetType ?? _previous?.TargetType;
 
         /// <inheritdoc/>
         public override bool IsCombinator => false;
@@ -130,12 +128,12 @@ namespace Avalonia.Styling
             {
                 if (subscribe)
                 {
-                    var observable = new ClassObserver(control.Classes, _classes.Value);
+                    var observable = new StyleClassActivator(control.Classes, _classes.Value);
 
                     return new SelectorMatch(observable);
                 }
 
-                if (!AreClassesMatching(control.Classes, Classes))
+                if (!StyleClassActivator.AreClassesMatching(control.Classes, Classes))
                 {
                     return SelectorMatch.NeverThisInstance;
                 }
@@ -144,7 +142,7 @@ namespace Avalonia.Styling
             return Name == null ? SelectorMatch.AlwaysThisType : SelectorMatch.AlwaysThisInstance;
         }
 
-        protected override Selector MovePrevious() => _previous;
+        protected override Selector? MovePrevious() => _previous;
 
         private string BuildSelectorString()
         {
@@ -190,80 +188,5 @@ namespace Avalonia.Styling
 
             return builder.ToString();
         }
-
-        private static bool AreClassesMatching(IReadOnlyList<string> classes, IList<string> toMatch)
-        {
-            int remainingMatches = toMatch.Count;
-            int classesCount = classes.Count;
-
-            // Early bail out - we can't match if control does not have enough classes.
-            if (classesCount < remainingMatches)
-            {
-                return false;
-            }
-
-            for (var i = 0; i < classesCount; i++)
-            {
-                var c = classes[i];
-
-                if (toMatch.Contains(c))
-                {
-                    --remainingMatches;
-
-                    // Already matched so we can skip checking other classes.
-                    if (remainingMatches == 0)
-                    {
-                        break;
-                    }
-                }
-            }
-
-            return remainingMatches == 0;
-        }
-
-        private sealed class ClassObserver : LightweightObservableBase<bool>
-        {
-            private readonly IList<string> _match;
-            private readonly IAvaloniaReadOnlyList<string> _classes;
-            private bool _hasMatch;
-
-            public ClassObserver(IAvaloniaReadOnlyList<string> classes, IList<string> match)
-            {
-                _classes = classes;
-                _match = match;
-            }
-
-            protected override void Deinitialize() => _classes.CollectionChanged -= ClassesChanged;
-
-            protected override void Initialize()
-            {
-                _hasMatch = IsMatching();
-                _classes.CollectionChanged += ClassesChanged;
-            }
-
-            protected override void Subscribed(IObserver<bool> observer, bool first)
-            {
-                observer.OnNext(_hasMatch);
-            }
-
-            private void ClassesChanged(object sender, NotifyCollectionChangedEventArgs e)
-            {
-                if (e.Action != NotifyCollectionChangedAction.Move)
-                {
-                    var hasMatch = IsMatching();
-
-                    if (hasMatch != _hasMatch)
-                    {
-                        PublishNext(hasMatch);
-                        _hasMatch = hasMatch;
-                    }
-                }
-            }
-
-            private bool IsMatching()
-            {
-                return AreClassesMatching(_classes, _match);
-            }
-        }
     }
 }

src/Avalonia.Visuals/AvaloniaPropertyExtensions.cs

@@ -0,0 +1,27 @@
+using Avalonia.Media;
+
+#nullable enable
+
+namespace Avalonia
+{
+    /// <summary>
+    /// Extensions for <see cref="AvaloniaProperty"/>.
+    /// </summary>
+    public static class AvaloniaPropertyExtensions
+    {
+        /// <summary>
+        /// Checks if values of given property can affect rendering (via <see cref="IAffectsRender"/>).
+        /// </summary>
+        /// <param name="property">Property to check.</param>
+        public static bool CanValueAffectRender(this AvaloniaProperty property)
+        {
+            var propertyType = property.PropertyType;
+
+            // Only case that we are sure that property value CAN'T affect render are sealed types that don't implement
+            // the interface.
+            var cannotAffectRender = propertyType.IsSealed && !typeof(IAffectsRender).IsAssignableFrom(propertyType);
+
+            return !cannotAffectRender;
+        }
+    }
+}

src/Avalonia.Visuals/Media/Brush.cs

@@ -69,14 +69,14 @@ namespace Avalonia.Media
         protected static void AffectsRender<T>(params AvaloniaProperty[] properties)
             where T : Brush
         {
-            void Invalidate(AvaloniaPropertyChangedEventArgs e)
+            static void Invalidate(AvaloniaPropertyChangedEventArgs e)
             {
                 (e.Sender as T)?.RaiseInvalidated(EventArgs.Empty);
             }
 
             foreach (var property in properties)
             {
-                property.Changed.Subscribe(Invalidate);
+                property.Changed.Subscribe(e => Invalidate(e));
             }
         }
 

src/Avalonia.Visuals/Media/Pen.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
 using Avalonia.Media.Immutable;
 using Avalonia.Utilities;
 
@@ -197,7 +196,15 @@ namespace Avalonia.Media
         protected static void AffectsRender<T>(params AvaloniaProperty[] properties)
             where T : Pen
         {
-            void Invalidate(AvaloniaPropertyChangedEventArgs e)
+            static void Invalidate(AvaloniaPropertyChangedEventArgs e)
+            {
+                if (e.Sender is T sender)
+                {
+                    sender.RaiseInvalidated(EventArgs.Empty);
+                }
+            }
+
+            static void InvalidateAndSubscribe(AvaloniaPropertyChangedEventArgs e)
             {
                 if (e.Sender is T sender)
                 {
@@ -223,7 +230,14 @@ namespace Avalonia.Media
 
             foreach (var property in properties)
             {
-                property.Changed.Subscribe(Invalidate);
+                if (property.CanValueAffectRender())
+                {
+                    property.Changed.Subscribe(e => InvalidateAndSubscribe(e));
+                }
+                else
+                {
+                    property.Changed.Subscribe(e => Invalidate(e));
+                }
             }
         }
 

src/Avalonia.Visuals/Visual.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Specialized;
-using System.Linq;
 using Avalonia.Collections;
 using Avalonia.Data;
 using Avalonia.Logging;
@@ -336,7 +335,15 @@ namespace Avalonia
         protected static void AffectsRender<T>(params AvaloniaProperty[] properties)
             where T : Visual
         {
-            void Invalidate(AvaloniaPropertyChangedEventArgs e)
+            static void Invalidate(AvaloniaPropertyChangedEventArgs e)
+            {
+                if (e.Sender is T sender)
+                {
+                    sender.InvalidateVisual();
+                }
+            }
+
+            static void InvalidateAndSubscribe(AvaloniaPropertyChangedEventArgs e)
             {
                 if (e.Sender is T sender)
                 {
@@ -347,7 +354,7 @@ namespace Avalonia
 
                     if (e.NewValue is IAffectsRender newValue)
                     {
-                        WeakEventHandlerManager.Subscribe<IAffectsRender, EventArgs, T>(newValue, nameof(newValue.Invalidated), sender.AffectsRenderInvalidated);                        
+                        WeakEventHandlerManager.Subscribe<IAffectsRender, EventArgs, T>(newValue, nameof(newValue.Invalidated), sender.AffectsRenderInvalidated);
                     }
 
                     sender.InvalidateVisual();
@@ -356,7 +363,14 @@ namespace Avalonia
 
             foreach (var property in properties)
             {
-                property.Changed.Subscribe(Invalidate);
+                if (property.CanValueAffectRender())
+                {
+                    property.Changed.Subscribe(e => InvalidateAndSubscribe(e));
+                }
+                else
+                {
+                    property.Changed.Subscribe(e => Invalidate(e));
+                }
             }
         }
 

src/Markup/Avalonia.Markup.Xaml/Styling/StyleInclude.cs

@@ -4,6 +4,7 @@
 using Avalonia.Styling;
 using System;
 using Avalonia.Controls;
+using System.Collections.Generic;
 
 namespace Avalonia.Markup.Xaml.Styling
 {
@@ -67,23 +68,7 @@ namespace Avalonia.Markup.Xaml.Styling
         IResourceNode IResourceNode.ResourceParent => _parent;
 
         /// <inheritdoc/>
-        public bool Attach(IStyleable control, IStyleHost container)
+        public SelectorMatchResult TryAttach(IStyleable target, IStyleHost host) => Loaded.TryAttach(target, host);
-        {
-            if (Source != null)
-            {
-                return Loaded.Attach(control, container);
-            }
-
-            return false;
-        }
-
-        public void Detach()
-        {
-            if (Source != null)
-            {
-                Loaded.Detach();
-            }
-        }
 
         /// <inheritdoc/>
         public bool TryGetResource(object key, out object value) => Loaded.TryGetResource(key, out value);

tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_SetValue.cs

@@ -284,6 +284,41 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("newvalue", target.GetValue(Class1.FrankProperty));
         }
 
+        [Fact]
+        public void Disposing_Style_SetValue_Reverts_To_DefaultValue()
+        {
+            Class1 target = new Class1();
+
+            var d = target.SetValue(Class1.FooProperty, "foo", BindingPriority.Style);
+            d.Dispose();
+
+            Assert.Equal("foodefault", target.GetValue(Class1.FooProperty));
+        }
+
+        [Fact]
+        public void Disposing_Style_SetValue_Reverts_To_Previous_Style_Value()
+        {
+            Class1 target = new Class1();
+
+            target.SetValue(Class1.FooProperty, "foo", BindingPriority.Style);
+            var d = target.SetValue(Class1.FooProperty, "bar", BindingPriority.Style);
+            d.Dispose();
+
+            Assert.Equal("foo", target.GetValue(Class1.FooProperty));
+        }
+
+        [Fact]
+        public void Disposing_Animation_SetValue_Reverts_To_Previous_Local_Value()
+        {
+            Class1 target = new Class1();
+
+            target.SetValue(Class1.FooProperty, "foo", BindingPriority.LocalValue);
+            var d = target.SetValue(Class1.FooProperty, "bar", BindingPriority.Animation);
+            d.Dispose();
+
+            Assert.Equal("foo", target.GetValue(Class1.FooProperty));
+        }
+
         private class Class1 : AvaloniaObject
         {
             public static readonly StyledProperty<string> FooProperty =

tests/Avalonia.Base.UnitTests/AvaloniaPropertyTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using Avalonia.Data;
+using Avalonia.Utilities;
 using Xunit;
 
 namespace Avalonia.Base.UnitTests
@@ -123,6 +124,11 @@ namespace Avalonia.Base.UnitTests
                 OverrideMetadata(typeof(T), metadata);
             }
 
+            public override void Accept<TData>(IAvaloniaPropertyVisitor<TData> vistor, ref TData data)
+            {
+                throw new NotImplementedException();
+            }
+
             internal override IDisposable RouteBind(
                 IAvaloniaObject o,
                 IObservable<BindingValue<object>> source,
@@ -146,7 +152,7 @@ namespace Avalonia.Base.UnitTests
                 throw new NotImplementedException();
             }
 
-            internal override void RouteSetValue(
+            internal override IDisposable RouteSetValue(
                 IAvaloniaObject o,
                 object value,
                 BindingPriority priority)

tests/Avalonia.Base.UnitTests/PriorityValueTests.cs

@@ -24,7 +24,11 @@ namespace Avalonia.Base.UnitTests
                 Owner,
                 TestProperty,
                 NullSink,
-                new ConstantValueEntry<string>(TestProperty, "1", BindingPriority.StyleTrigger));
+                new ConstantValueEntry<string>(
+                    TestProperty,
+                    "1",
+                    BindingPriority.StyleTrigger,
+                    NullSink));
 
             Assert.Equal("1", target.Value.Value);
             Assert.Equal(BindingPriority.StyleTrigger, target.ValuePriority);

tests/Avalonia.Benchmarks/Styling/ApplyStyling.cs

@@ -45,7 +45,7 @@ namespace Avalonia.Benchmarks.Styling
             {
                 _window.Styles.Add(new Style(x => x.OfType<TextBox>().Class("foo").Class("bar").Class("baz"))
                 {
-                    Setters = new[]
+                    Setters =
                     {
                         new Setter(TextBox.TextProperty, "foo"),
                     }

tests/Avalonia.Benchmarks/Styling/StyleAttachBenchmark.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 using Avalonia.Controls;
+using Avalonia.Styling;
 using Avalonia.UnitTests;
 using BenchmarkDotNet.Attributes;
 
@@ -34,9 +35,8 @@ namespace Avalonia.Benchmarks.Styling
         {
             var styles = UnitTestApplication.Current.Styles;
 
-            styles.Attach(_control, UnitTestApplication.Current);
+            styles.TryAttach(_control, UnitTestApplication.Current);
-
+            ((IStyleable)_control).DetachStyles();
-            styles.Detach();
         }
 
         public void Dispose()

tests/Avalonia.Controls.UnitTests/Primitives/TemplatedControlTests.cs

@@ -363,7 +363,7 @@ namespace Avalonia.Controls.UnitTests.Primitives
                     {
                         new Style(x => x.OfType<TestTemplatedControl>())
                         {
-                            Setters = new[]
+                            Setters =
                             {
                                 new Setter(
                                     TemplatedControl.TemplateProperty,
@@ -399,7 +399,7 @@ namespace Avalonia.Controls.UnitTests.Primitives
                     {
                         new Style(x => x.OfType<TestTemplatedControl>())
                         {
-                            Setters = new[]
+                            Setters =
                             {
                                 new Setter(
                                     TemplatedControl.TemplateProperty,
@@ -438,7 +438,7 @@ namespace Avalonia.Controls.UnitTests.Primitives
                     {
                         new Style(x => x.OfType<TestTemplatedControl>())
                         {
-                            Setters = new[]
+                            Setters =
                             {
                                 new Setter(
                                     TemplatedControl.TemplateProperty,
@@ -458,7 +458,7 @@ namespace Avalonia.Controls.UnitTests.Primitives
                     {
                         new Style(x => x.OfType<TestTemplatedControl>())
                         {
-                            Setters = new[]
+                            Setters =
                             {
                                 new Setter(
                                     TemplatedControl.TemplateProperty,

tests/Avalonia.Controls.UnitTests/TabControlTests.cs

@@ -163,7 +163,7 @@ namespace Avalonia.Controls.UnitTests
                     {
                         new Style(x => x.OfType<TabItem>())
                         {
-                            Setters = new[]
+                            Setters =
                             {
                                 new Setter(TemplatedControl.TemplateProperty, template)
                             }

tests/Avalonia.Controls.UnitTests/UserControlTests.cs

@@ -25,7 +25,7 @@ namespace Avalonia.Controls.UnitTests
                     {
                         new Style(x => x.OfType<UserControl>())
                         {
-                            Setters = new[]
+                            Setters =
                             {
                                 new Setter(TemplatedControl.TemplateProperty, GetTemplate())
                             }

tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs

@@ -139,7 +139,15 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
                 get { throw new NotImplementedException(); }
             }
 
-            IObservable<IStyleable> IStyleable.StyleDetach { get; }
+            public void DetachStyles()
+            {
+                throw new NotImplementedException();
+            }
+
+            public void StyleApplied(IStyleInstance instance)
+            {
+                throw new NotImplementedException();
+            }
         }
 
         private class AttachedOwner

tests/Avalonia.Markup.Xaml.UnitTests/StyleTests.cs

@@ -53,42 +53,7 @@ namespace Avalonia.Markup.Xaml.UnitTests
                     }
                 };
 
-                setter.Apply(null, control, null);
+                setter.Instance(control).Start(false);
-                Assert.Equal("foo", control.Text);
-
-                control.Text = "bar";
-                Assert.Equal("bar", data.Foo);
-            }
-        }
-
-        [Fact]
-        public void Setter_With_TwoWay_Binding_And_Activator_Should_Update_Source()
-        {
-            using (UnitTestApplication.Start(TestServices.MockThreadingInterface))
-            {
-                var data = new Data
-                {
-                    Foo = "foo",
-                };
-
-                var control = new TextBox
-                {
-                    DataContext = data,
-                };
-
-                var setter = new Setter
-                {
-                    Property = TextBox.TextProperty,
-                    Value = new Binding
-                    {
-                        Path = "Foo",
-                        Mode = BindingMode.TwoWay
-                    }
-                };
-
-                var activator = Observable.Never<bool>().StartWith(true);
-
-                setter.Apply(null, control, activator);
                 Assert.Equal("foo", control.Text);
 
                 control.Text = "bar";

tests/Avalonia.Styling.UnitTests/ActivatedObservableTests.cs

@@ -1,71 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-using Xunit;
-
-namespace Avalonia.Styling.UnitTests
-{
-    public class ActivatedObservableTests
-    {
-        [Fact]
-        public void Should_Produce_Correct_Values()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var source = new BehaviorSubject<object>(1);
-            var target = new ActivatedObservable(activator, source, string.Empty);
-            var result = new List<object>();
-
-            target.Subscribe(x => result.Add(x));
-
-            activator.OnNext(true);
-            source.OnNext(2);
-            activator.OnNext(false);
-            source.OnNext(3);
-            activator.OnNext(true);
-
-            Assert.Equal(
-                new[] 
-                {
-                    AvaloniaProperty.UnsetValue,
-                    1,
-                    2,
-                    AvaloniaProperty.UnsetValue,
-                    3,
-                }, 
-                result);
-        }
-
-        [Fact]
-        public void Should_Complete_When_Source_Completes()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var source = new BehaviorSubject<object>(1);
-            var target = new ActivatedObservable(activator, source, string.Empty);
-            var completed = false;
-
-            target.Subscribe(_ => { }, () => completed = true);
-            source.OnCompleted();
-
-            Assert.True(completed);
-        }
-
-        [Fact]
-        public void Should_Error_When_Source_Errors()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var source = new BehaviorSubject<object>(1);
-            var target = new ActivatedObservable(activator, source, string.Empty);
-            var error = new Exception();
-            var completed = false;
-
-            target.Subscribe(_ => { }, x => completed = true);
-            source.OnError(error);
-
-            Assert.True(completed);
-        }
-    }
-}

tests/Avalonia.Styling.UnitTests/ActivatedSubjectTests.cs

@@ -1,92 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Reactive.Disposables;
-using System.Reactive.Subjects;
-using Xunit;
-
-namespace Avalonia.Styling.UnitTests
-{
-    public class ActivatedSubjectTests
-    {
-        [Fact]
-        public void Should_Set_Values()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var source = new TestSubject();
-            var target = new ActivatedSubject(activator, source, string.Empty);
-
-            target.Subscribe();
-            target.OnNext("bar");
-            Assert.Equal(AvaloniaProperty.UnsetValue, source.Value);
-            activator.OnNext(true);
-            target.OnNext("baz");
-            Assert.Equal("baz", source.Value);
-            activator.OnNext(false);
-            Assert.Equal(AvaloniaProperty.UnsetValue, source.Value);
-            target.OnNext("bax");
-            activator.OnNext(true);
-            Assert.Equal("bax", source.Value);
-        }
-
-        [Fact]
-        public void Should_Invoke_OnCompleted_On_Activator_Completed()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var source = new TestSubject();
-            var target = new ActivatedSubject(activator, source, string.Empty);
-
-            target.Subscribe();
-            activator.OnCompleted();
-
-            Assert.True(source.Completed);
-        }
-
-        [Fact]
-        public void Should_Invoke_OnError_On_Activator_Error()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var source = new TestSubject();
-            var target = new ActivatedSubject(activator, source, string.Empty);
-            var targetError = default(Exception);
-            var error = new Exception();
-
-            target.Subscribe(_ => { }, e => targetError = e);
-            activator.OnError(error);
-
-            Assert.Same(error, source.Error);
-            Assert.Same(error, targetError);
-        }
-
-        private class TestSubject : ISubject<object>
-        {
-            private IObserver<object> _observer;
-
-            public bool Completed { get; set; }
-            public Exception Error { get; set; }
-            public object Value { get; set; } = AvaloniaProperty.UnsetValue;
-
-            public void OnCompleted()
-            {
-                Completed = true;
-            }
-
-            public void OnError(Exception error)
-            {
-                Error = error;
-            }
-
-            public void OnNext(object value)
-            {
-                Value = value;
-            }
-
-            public IDisposable Subscribe(IObserver<object> observer)
-            {
-                _observer = observer;
-                return Disposable.Empty;
-            }
-        }
-    }
-}

tests/Avalonia.Styling.UnitTests/ActivatedValueTests.cs

@@ -1,75 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-using Microsoft.Reactive.Testing;
-using Xunit;
-
-namespace Avalonia.Styling.UnitTests
-{
-    public class ActivatedValueTests
-    {
-        [Fact]
-        public void Should_Produce_Correct_Values()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var target = new ActivatedValue(activator, 1, string.Empty);
-            var result = new List<object>();
-
-            target.Subscribe(x => result.Add(x));
-
-            activator.OnNext(true);
-            activator.OnNext(false);
-
-            Assert.Equal(new[] { AvaloniaProperty.UnsetValue, 1, AvaloniaProperty.UnsetValue }, result);
-        }
-
-        [Fact]
-        public void Should_Complete_When_Activator_Completes()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var target = new ActivatedValue(activator, 1, string.Empty);
-            var completed = false;
-
-            target.Subscribe(_ => { }, () => completed = true);
-            activator.OnCompleted();
-
-            Assert.True(completed);
-        }
-
-        [Fact]
-        public void Should_Error_When_Activator_Errors()
-        {
-            var activator = new BehaviorSubject<bool>(false);
-            var target = new ActivatedValue(activator, 1, string.Empty);
-            var error = new Exception();
-            var completed = false;
-
-            target.Subscribe(_ => { }, x => completed = true);
-            activator.OnError(error);
-
-            Assert.True(completed);
-        }
-
-        [Fact]
-        public void Should_Unsubscribe_From_Activator_When_All_Subscriptions_Disposed()
-        {
-            var scheduler = new TestScheduler();
-            var activator1 = scheduler.CreateColdObservable<bool>();
-            var activator2 = scheduler.CreateColdObservable<bool>();
-            var activator = StyleActivator.And(new[] { activator1, activator2 });
-            var target = new ActivatedValue(activator, 1, string.Empty);
-
-            var subscription = target.Subscribe(_ => { });
-            Assert.Equal(1, activator1.Subscriptions.Count);
-            Assert.Equal(Subscription.Infinite, activator1.Subscriptions[0].Unsubscribe);
-
-            subscription.Dispose();
-            Assert.Equal(1, activator1.Subscriptions.Count);
-            Assert.Equal(0, activator1.Subscriptions[0].Unsubscribe);
-        }
-    }
-}

tests/Avalonia.Styling.UnitTests/SelectorTests_Class.cs

@@ -36,7 +36,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "foo" },
+                Classes = { "foo" },
             };
 
             var target = default(Selector).Class("foo");
@@ -51,7 +51,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "bar" },
+                Classes = { "bar" },
             };
 
             var target = default(Selector).Class("foo");
@@ -66,7 +66,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "foo" },
+                Classes = { "foo" },
                 TemplatedParent = new Mock<ITemplatedControl>().Object,
             };
 
@@ -83,7 +83,7 @@ namespace Avalonia.Styling.UnitTests
             var control = new Control1();
 
             var target = default(Selector).Class("foo");
-            var activator = target.Match(control).Activator;
+            var activator = target.Match(control).Activator.ToObservable();
 
             Assert.False(await activator.Take(1));
             control.Classes.Add("foo");
@@ -95,11 +95,11 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "foo" },
+                Classes = { "foo" },
             };
 
             var target = default(Selector).Class("foo");
-            var activator = target.Match(control).Activator;
+            var activator = target.Match(control).Activator.ToObservable();
 
             Assert.True(await activator.Take(1));
             control.Classes.Remove("foo");
@@ -111,7 +111,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1();
             var target = default(Selector).Class("foo").Class("bar");
-            var activator = target.Match(control).Activator;
+            var activator = target.Match(control).Activator.ToObservable();
 
             Assert.False(await activator.Take(1));
             control.Classes.Add("foo");
@@ -128,7 +128,7 @@ namespace Avalonia.Styling.UnitTests
             // Test for #1698
             var control = new Control1
             {
-                Classes = new Classes { "foo" },
+                Classes = { "foo" },
             };
 
             var target = default(Selector).Class("foo");

tests/Avalonia.Styling.UnitTests/SelectorTests_Descendent.cs

@@ -90,7 +90,7 @@ namespace Avalonia.Styling.UnitTests
             child.LogicalParent = parent;
 
             var selector = default(Selector).OfType<TestLogical1>().Class("foo").Descendant().OfType<TestLogical3>();
-            var activator = selector.Match(child).Activator;
+            var activator = selector.Match(child).Activator.ToObservable();
 
             Assert.False(await activator.Take(1));
             parent.Classes.Add("foo");

tests/Avalonia.Styling.UnitTests/SelectorTests_Multiple.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.VisualTree;
@@ -85,6 +86,35 @@ namespace Avalonia.Styling.UnitTests
             Assert.Equal(SelectorMatchResult.NeverThisType, match.Result);
         }
 
+        [Fact]
+        public void Control_With_Class_Descendent_Of_Control_With_Two_Classes()
+        {
+            var textBlock = new TextBlock();
+            var control = new Button { Content = textBlock };
+
+            control.ApplyTemplate();
+
+            var selector = default(Selector)
+                .OfType<Button>()
+                .Class("foo")
+                .Class("bar")
+                .Descendant()
+                .OfType<TextBlock>()
+                .Class("baz");
+
+            var values = new List<bool>();
+            var match = selector.Match(textBlock);
+
+            Assert.Equal(SelectorMatchResult.Sometimes, match.Result);
+            match.Activator.Subscribe(x => values.Add(x));
+
+            Assert.Equal(new[] { false }, values);
+            control.Classes.AddRange(new[] { "foo", "bar" });
+            Assert.Equal(new[] { false }, values);
+            textBlock.Classes.Add("baz");
+            Assert.Equal(new[] { false, true }, values);
+        }
+
         [Fact]
         public void Named_Class_Template_Child_Of_Control()
         {
@@ -123,6 +153,31 @@ namespace Avalonia.Styling.UnitTests
             Assert.Equal(new[] { false, true, false }, values);
         }
 
+        [Fact]
+        public async Task Nested_PropertyEquals()
+        {
+            var control = new Canvas();
+            var parent = new Border { Child = control };
+
+            var target = default(Selector)
+                .OfType<Border>()
+                .PropertyEquals(Border.TagProperty, "foo")
+                .Child()
+                .OfType<Canvas>()
+                .PropertyEquals(Canvas.TagProperty, "bar");
+
+            var match = target.Match(control);
+            Assert.Equal(SelectorMatchResult.Sometimes, match.Result);
+
+            var activator = match.Activator;
+
+            Assert.False(await activator.Take(1));
+            control.Tag = "bar";
+            Assert.False(await activator.Take(1));
+            parent.Tag = "foo";
+            Assert.True(await activator.Take(1));
+        }
+
         [Fact]
         public void TargetType_OfType()
         {

tests/Avalonia.Styling.UnitTests/SelectorTests_Not.cs

@@ -41,7 +41,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "foo" },
+                Classes = { "foo" },
             };
 
             var target = default(Selector).Not(x => x.Class("foo"));
@@ -56,7 +56,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "bar" },
+                Classes = { "bar" },
             };
 
             var target = default(Selector).Not(x => x.Class("foo"));
@@ -71,7 +71,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control1
             {
-                Classes = new Classes { "bar" },
+                Classes = { "bar" },
             };
 
             var target = default(Selector).OfType<Control1>().Not(x => x.Class("foo"));
@@ -86,7 +86,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Control2
             {
-                Classes = new Classes { "foo" },
+                Classes = { "foo" },
             };
 
             var target = default(Selector).OfType<Control1>().Not(x => x.Class("foo"));

tests/Avalonia.Styling.UnitTests/SelectorTests_PropertyEquals.cs

@@ -16,7 +16,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new TextBlock();
             var target = default(Selector).PropertyEquals(TextBlock.TextProperty, "foo");
-            var activator = target.Match(control).Activator;
+            var activator = target.Match(control).Activator.ToObservable();
 
             Assert.False(await activator.Take(1));
             control.Text = "foo";

tests/Avalonia.Styling.UnitTests/SetterTests.cs

@@ -33,7 +33,7 @@ namespace Avalonia.Styling.UnitTests
             var style = Mock.Of<IStyle>();
             var setter = new Setter(TextBlock.TextProperty, binding);
 
-            setter.Apply(style, control, null);
+            setter.Instance(control).Start(false);
 
             Assert.Equal("foo", control.Text);
         }
@@ -46,7 +46,7 @@ namespace Avalonia.Styling.UnitTests
             var style = Mock.Of<IStyle>();
             var setter = new Setter(Decorator.ChildProperty, template);
 
-            setter.Apply(style, control, null);
+            setter.Instance(control).Start(false);
 
             Assert.IsType<Canvas>(control.Child);
         }
@@ -62,13 +62,15 @@ namespace Avalonia.Styling.UnitTests
                 RelativeSource = new RelativeSource(RelativeSourceMode.Self),
             };
             var setter = new Setter(Decorator.TagProperty, binding);
-            var activator = new BehaviorSubject<bool>(true);
 
-            setter.Apply(style, control, activator);
+            var instance = setter.Instance(control);
+            instance.Start(true);
+            instance.Activate();
+
             Assert.Equal("foobar", control.Tag);
 
             // Issue #1218 caused TestConverter.ConvertBack to throw here.
-            activator.OnNext(false);
+            instance.Deactivate();
             Assert.Null(control.Tag);
         }
 
@@ -77,28 +79,32 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Mock<IStyleable>();
             var style = Mock.Of<Style>();
-            var setter = new Setter(TextBlock.TextProperty, "foo");
+            var setter = new Setter(TextBlock.TagProperty, "foo");
 
-            setter.Apply(style, control.Object, null);
+            setter.Instance(control.Object).Start(false);
 
-            control.Verify(x => x.Bind(
+            control.Verify(x => x.SetValue(
-                TextBlock.TextProperty,
+                TextBlock.TagProperty,
-                It.IsAny<IObservable<BindingValue<string>>>()));
+                "foo",
+                BindingPriority.Style));
         }
 
         [Fact]
-        public void Setter_Should_Apply_Value_With_Activator_With_StyleTrigger_Priority()
+        public void Setter_Should_Apply_Value_With_Activator_As_Binding_With_StyleTrigger_Priority()
         {
             var control = new Mock<IStyleable>();
             var style = Mock.Of<Style>();
-            var setter = new Setter(TextBlock.TextProperty, "foo");
+            var setter = new Setter(TextBlock.TagProperty, "foo");
             var activator = new Subject<bool>();
 
-            setter.Apply(style, control.Object, activator);
+            var instance = setter.Instance(control.Object);
+            instance.Start(true);
+            instance.Activate();
 
             control.Verify(x => x.Bind(
-                TextBlock.TextProperty,
+                TextBlock.TagProperty,
-                It.IsAny<IObservable<BindingValue<string>>>()));
+                It.IsAny<IObservable<BindingValue<object>>>(),
+                BindingPriority.StyleTrigger));
         }
 
         [Fact]
@@ -106,13 +112,14 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Mock<IStyleable>();
             var style = Mock.Of<Style>();
-            var setter = new Setter(TextBlock.TextProperty, CreateMockBinding(TextBlock.TextProperty));
+            var setter = new Setter(TextBlock.TagProperty, CreateMockBinding(TextBlock.TagProperty));
 
-            setter.Apply(style, control.Object, null);
+            setter.Instance(control.Object).Start(false);
 
             control.Verify(x => x.Bind(
-                TextBlock.TextProperty,
+                TextBlock.TagProperty,
-                It.IsAny<IObservable<BindingValue<string>>>()));
+                It.IsAny<PropertySetterBindingInstance<object>>(),
+                BindingPriority.Style));
         }
 
         [Fact]
@@ -120,14 +127,16 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new Mock<IStyleable>();
             var style = Mock.Of<Style>();
-            var setter = new Setter(TextBlock.TextProperty, CreateMockBinding(TextBlock.TextProperty));
+            var setter = new Setter(TextBlock.TagProperty, CreateMockBinding(TextBlock.TagProperty));
-            var activator = new Subject<bool>();
 
-            setter.Apply(style, control.Object, activator);
+            var instance = setter.Instance(control.Object);
+            instance.Start(true);
+            instance.Activate();
 
             control.Verify(x => x.Bind(
-                TextBlock.TextProperty,
+                TextBlock.TagProperty,
-                It.IsAny<IObservable<BindingValue<string>>>()));
+                It.IsAny<IObservable<BindingValue<object>>>(),
+                BindingPriority.StyleTrigger));
         }
 
         private IBinding CreateMockBinding(AvaloniaProperty property)

tests/Avalonia.Styling.UnitTests/StyleActivatorExtensions.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Avalonia.Reactive;
+using Avalonia.Styling.Activators;
+
+namespace Avalonia.Styling.UnitTests
+{
+    internal static class StyleActivatorExtensions
+    {
+        public static IDisposable Subscribe(this IStyleActivator activator, Action<bool> action)
+        {
+            return activator.ToObservable().Subscribe(action);
+        }
+
+        public static async Task<bool> Take(this IStyleActivator activator, int value)
+        {
+            return await activator.ToObservable().Take(value);
+        }
+
+        public static IObservable<bool> ToObservable(this IStyleActivator activator)
+        {
+            return new ObservableAdapter(activator);
+        }
+
+        private class ObservableAdapter : LightweightObservableBase<bool>, IStyleActivatorSink
+        {
+            private readonly IStyleActivator _source;
+            private bool _value;
+            
+            public ObservableAdapter(IStyleActivator source) => _source = source;
+            protected override void Initialize() => _source.Subscribe(this);
+            protected override void Deinitialize() => _source.Unsubscribe(this);
+
+            void IStyleActivatorSink.OnNext(bool value, int tag)
+            {
+                _value = value;
+                PublishNext(value);
+            }
+        }
+    }
+}

tests/Avalonia.Styling.UnitTests/StyleActivatorTests.cs

@@ -1,169 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Reactive;
-using System.Reactive.Linq;
-using Microsoft.Reactive.Testing;
-using Xunit;
-
-namespace Avalonia.Styling.UnitTests
-{
-    public class StyleActivatorTests : ReactiveTest
-    {
-        [Fact]
-        public void Activator_Should_Subscribe_To_Inputs_On_First_Subscription()
-        {
-            var scheduler = new TestScheduler();
-            var source = scheduler.CreateColdObservable<bool>();
-            var target = StyleActivator.And(new[] { source });
-
-            Assert.Equal(0, source.Subscriptions.Count);
-            target.Subscribe(_ => { });
-            Assert.Equal(1, source.Subscriptions.Count);
-        }
-
-        [Fact]
-        public void Activator_Should_Unsubscribe_From_Inputs_After_Last_Subscriber_Completes()
-        {
-            var scheduler = new TestScheduler();
-            var source = scheduler.CreateColdObservable<bool>();
-            var target = StyleActivator.And(new[] { source });
-
-            var dispose = target.Subscribe(_ => { });
-            Assert.Equal(1, source.Subscriptions.Count);
-            Assert.Equal(Subscription.Infinite, source.Subscriptions[0].Unsubscribe);
-
-            dispose.Dispose();
-            Assert.Equal(1, source.Subscriptions.Count);
-            Assert.Equal(0, source.Subscriptions[0].Unsubscribe);
-        }
-
-        [Fact]
-        public void Activator_And_Should_Follow_Single_Input()
-        {
-            var inputs = new[] { new TestSubject<bool>(false) };
-            var target = StyleActivator.And(inputs);
-            var result = new TestObserver<bool>();
-
-            target.Subscribe(result);
-            Assert.False(result.GetValue());
-            inputs[0].OnNext(true);
-            Assert.True(result.GetValue());
-            inputs[0].OnNext(false);
-            Assert.False(result.GetValue());
-            inputs[0].OnNext(true);
-            Assert.True(result.GetValue());
-
-            Assert.Equal(1, inputs[0].SubscriberCount);
-        }
-
-        [Fact]
-        public void Activator_And_Should_AND_Multiple_Inputs()
-        {
-            var inputs = new[]
-            {
-                new TestSubject<bool>(false),
-                new TestSubject<bool>(false),
-                new TestSubject<bool>(true),
-            };
-            var target = StyleActivator.And(inputs);
-            var result = new TestObserver<bool>();
-
-            target.Subscribe(result);
-            Assert.False(result.GetValue());
-            inputs[0].OnNext(true);
-            inputs[1].OnNext(true);
-            Assert.True(result.GetValue());
-            inputs[0].OnNext(false);
-            Assert.False(result.GetValue());
-
-            Assert.Equal(1, inputs[0].SubscriberCount);
-            Assert.Equal(1, inputs[1].SubscriberCount);
-            Assert.Equal(1, inputs[2].SubscriberCount);
-        }
-
-        [Fact]
-        public void Activator_Or_Should_Follow_Single_Input()
-        {
-            var inputs = new[] { new TestSubject<bool>(false) };
-            var target = StyleActivator.Or(inputs);
-            var result = new TestObserver<bool>();
-
-            target.Subscribe(result);
-            Assert.False(result.GetValue());
-            inputs[0].OnNext(true);
-            Assert.True(result.GetValue());
-            inputs[0].OnNext(false);
-            Assert.False(result.GetValue());
-            inputs[0].OnNext(true);
-            Assert.True(result.GetValue());
-
-            Assert.Equal(1, inputs[0].SubscriberCount);
-        }
-
-        [Fact]
-        public void Activator_Or_Should_OR_Multiple_Inputs()
-        {
-            var inputs = new[]
-            {
-                new TestSubject<bool>(false),
-                new TestSubject<bool>(false),
-                new TestSubject<bool>(true),
-            };
-            var target = StyleActivator.Or(inputs);
-            var result = new TestObserver<bool>();
-
-            target.Subscribe(result);
-            Assert.True(result.GetValue());
-            inputs[2].OnNext(false);
-            Assert.False(result.GetValue());
-            inputs[0].OnNext(true);
-            Assert.True(result.GetValue());
-
-            Assert.Equal(1, inputs[0].SubscriberCount);
-            Assert.Equal(1, inputs[1].SubscriberCount);
-            Assert.Equal(1, inputs[2].SubscriberCount);
-        }
-
-        [Fact]
-        public void Activator_Or_Should_Not_Unsubscribe_All_When_Input_Completes_On_False()
-        {
-            var inputs = new[]
-            {
-                new TestSubject<bool>(false),
-                new TestSubject<bool>(false),
-                new TestSubject<bool>(true),
-            };
-            var target = StyleActivator.Or(inputs);
-            var result = new TestObserver<bool>();
-
-            target.Subscribe(result);
-            Assert.True(result.GetValue());
-            inputs[2].OnNext(false);
-            Assert.False(result.GetValue());
-            inputs[2].OnCompleted();
-
-            Assert.Equal(1, inputs[0].SubscriberCount);
-            Assert.Equal(1, inputs[1].SubscriberCount);
-            Assert.Equal(0, inputs[2].SubscriberCount);
-        }
-
-        [Fact]
-        public void Completed_Activator_Should_Signal_OnCompleted()
-        {
-            var inputs = new[]
-            {
-                Observable.Return(false),
-            };
-
-            var target = StyleActivator.Or(inputs);
-            var completed = false;
-
-            target.Subscribe(_ => { }, () => completed = true);
-
-            Assert.True(completed);
-        }
-    }
-}

tests/Avalonia.Styling.UnitTests/StyleTests.cs

@@ -3,8 +3,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Reactive.Subjects;
 using Avalonia.Controls;
+using Avalonia.Data;
 using Avalonia.UnitTests;
 using Xunit;
 
@@ -17,7 +17,7 @@ namespace Avalonia.Styling.UnitTests
         {
             Style style = new Style(x => x.OfType<Class1>())
             {
-                Setters = new[]
+                Setters =
                 {
                     new Setter(Class1.FooProperty, "Foo"),
                 },
@@ -25,7 +25,7 @@ namespace Avalonia.Styling.UnitTests
 
             var target = new Class1();
 
-            style.Attach(target, null);
+            style.TryAttach(target, null);
 
             Assert.Equal("Foo", target.Foo);
         }
@@ -35,7 +35,7 @@ namespace Avalonia.Styling.UnitTests
         {
             Style style = new Style(x => x.OfType<Class1>().Class("foo"))
             {
-                Setters = new[]
+                Setters =
                 {
                     new Setter(Class1.FooProperty, "Foo"),
                 },
@@ -43,7 +43,7 @@ namespace Avalonia.Styling.UnitTests
 
             var target = new Class1();
 
-            style.Attach(target, null);
+            style.TryAttach(target, null);
             Assert.Equal("foodefault", target.Foo);
             target.Classes.Add("foo");
             Assert.Equal("Foo", target.Foo);
@@ -56,7 +56,7 @@ namespace Avalonia.Styling.UnitTests
         {
             Style style = new Style
             {
-                Setters = new[]
+                Setters =
                 {
                     new Setter(Class1.FooProperty, "Foo"),
                 },
@@ -64,7 +64,7 @@ namespace Avalonia.Styling.UnitTests
 
             var target = new Class1();
 
-            style.Attach(target, target);
+            style.TryAttach(target, target);
 
             Assert.Equal("Foo", target.Foo);
         }
@@ -74,7 +74,7 @@ namespace Avalonia.Styling.UnitTests
         {
             Style style = new Style
             {
-                Setters = new[]
+                Setters =
                 {
                     new Setter(Class1.FooProperty, "Foo"),
                 },
@@ -83,7 +83,7 @@ namespace Avalonia.Styling.UnitTests
             var target = new Class1();
             var other = new Class1();
 
-            style.Attach(target, other);
+            style.TryAttach(target, other);
 
             Assert.Equal("foodefault", target.Foo);
         }
@@ -93,7 +93,7 @@ namespace Avalonia.Styling.UnitTests
         {
             Style style = new Style(x => x.OfType<Class1>())
             {
-                Setters = new[]
+                Setters =
                 {
                     new Setter(Class1.FooProperty, "Foo"),
                 },
@@ -104,7 +104,7 @@ namespace Avalonia.Styling.UnitTests
                 Foo = "Original",
             };
 
-            style.Attach(target, null);
+            style.TryAttach(target, null);
             Assert.Equal("Original", target.Foo);
         }
 
@@ -115,7 +115,7 @@ namespace Avalonia.Styling.UnitTests
             {
                 new Style(x => x.OfType<Class1>().Class("foo"))
                 {
-                    Setters = new[]
+                    Setters =
                     {
                         new Setter(Class1.FooProperty, "Foo"),
                     },
@@ -123,7 +123,7 @@ namespace Avalonia.Styling.UnitTests
 
                 new Style(x => x.OfType<Class1>().Class("foo"))
                 {
-                    Setters = new[]
+                    Setters =
                     {
                         new Setter(Class1.FooProperty, "Bar"),
                     },
@@ -135,7 +135,7 @@ namespace Avalonia.Styling.UnitTests
             List<string> values = new List<string>();
             target.GetObservable(Class1.FooProperty).Subscribe(x => values.Add(x));
 
-            styles.Attach(target, null);
+            styles.TryAttach(target, null);
             target.Classes.Add("foo");
             target.Classes.Remove("foo");
 
@@ -143,38 +143,90 @@ namespace Avalonia.Styling.UnitTests
         }
 
         [Fact]
-        public void Style_Should_Detach_When_Removed_From_Logical_Tree()
+        public void Later_Styles_Should_Override_Earlier_2()
         {
-            Border border;
+            Styles styles = new Styles
+            {
+                new Style(x => x.OfType<Class1>().Class("foo"))
+                {
+                    Setters =
+                    {
+                        new Setter(Class1.FooProperty, "Foo"),
+                    },
+                },
 
-            var style = new Style(x => x.OfType<Border>())
+                new Style(x => x.OfType<Class1>().Class("bar"))
+                {
+                    Setters =
+                    {
+                        new Setter(Class1.FooProperty, "Bar"),
+                    },
+                }
+            };
+
+            var target = new Class1();
+
+            List<string> values = new List<string>();
+            target.GetObservable(Class1.FooProperty).Subscribe(x => values.Add(x));
+
+            styles.TryAttach(target, null);
+            target.Classes.Add("bar");
+            target.Classes.Add("foo");
+            target.Classes.Remove("foo");
+
+            Assert.Equal(new[] { "foodefault", "Bar" }, values);
+        }
+
+        [Fact]
+        public void Later_Styles_Should_Override_Earlier_3()
+        {
+            Styles styles = new Styles
             {
-                Setters = new[]
+                new Style(x => x.OfType<Class1>().Class("foo"))
                 {
-                    new Setter(Border.BorderThicknessProperty, new Thickness(4)),
+                    Setters =
+                    {
+                        new Setter(Class1.FooProperty, new Binding("Foo")),
+                    },
+                },
+
+                new Style(x => x.OfType<Class1>().Class("bar"))
+                {
+                    Setters =
+                    {
+                        new Setter(Class1.FooProperty, new Binding("Bar")),
+                    },
                 }
             };
 
-            var root = new TestRoot
+            var target = new Class1
             {
-                Child = border = new Border(),
+                DataContext = new
+                {
+                    Foo = "Foo",
+                    Bar = "Bar",
+                }
             };
 
-            style.Attach(border, null);
+            List<string> values = new List<string>();
+            target.GetObservable(Class1.FooProperty).Subscribe(x => values.Add(x));
 
-            Assert.Equal(new Thickness(4), border.BorderThickness);
+            styles.TryAttach(target, null);
-            root.Child = null;
+            target.Classes.Add("bar");
-            Assert.Equal(new Thickness(0), border.BorderThickness);
+            target.Classes.Add("foo");
+            target.Classes.Remove("foo");
+
+            Assert.Equal(new[] { "foodefault", "Bar" }, values);
         }
 
         [Fact]
-        public void Style_Should_Detach_Setters_When_Detach_Is_Called()
+        public void Style_Should_Detach_When_Control_Removed_From_Logical_Tree()
         {
             Border border;
 
             var style = new Style(x => x.OfType<Border>())
             {
-                Setters = new[]
+                Setters =
                 {
                     new Setter(Border.BorderThicknessProperty, new Thickness(4)),
                 }
@@ -185,10 +237,10 @@ namespace Avalonia.Styling.UnitTests
                 Child = border = new Border(),
             };
 
-            style.Attach(border, null);
+            style.TryAttach(border, null);
 
             Assert.Equal(new Thickness(4), border.BorderThickness);
-            style.Detach();
+            root.Child = null;
             Assert.Equal(new Thickness(0), border.BorderThickness);
         }
 

tests/Avalonia.Styling.UnitTests/StyledElementTests.cs

@@ -352,7 +352,7 @@ namespace Avalonia.Styling.UnitTests
         }
 
         [Fact]
-        public void StyleDetach_Is_Triggered_When_Control_Removed_From_Logical_Tree()
+        public void StyleInstance_Is_Disposed_When_Control_Removed_From_Logical_Tree()
         {
             using (AvaloniaLocator.EnterScope())
             {
@@ -361,11 +361,12 @@ namespace Avalonia.Styling.UnitTests
 
                 root.Child = child;
 
-                bool styleDetachTriggered = false;
+                var styleInstance = new Mock<IStyleInstance>();
-                ((IStyleable)child).StyleDetach.Subscribe(_ => styleDetachTriggered = true);
+                ((IStyleable)child).StyleApplied(styleInstance.Object);
+
                 root.Child = null;
 
-                Assert.True(styleDetachTriggered);
+                styleInstance.Verify(x => x.Dispose(), Times.Once);
             }
         }