Markup extensions with state in WPF

Question

I've just discovered that WPF Markup extension instances are reused in control templates. So each copy of the control template gets the same set of markup extensions.

This doesn't work if you want the extension to maintain some state per control it is attached to. Any idea how to solve this.

Answer 1

Don't store state in the Markup extension. Store it another way. For example.

public abstract class DynamicMarkupExtension : MarkupExtension
{
    public class State
    {

        public object TargetObject { get; set; }

        public object TargetProperty { get; set; }

        public void UpdateValue(object value)
        {
            if (TargetObject != null)
            {
                if (TargetProperty is DependencyProperty)
                {
                    DependencyObject obj = TargetObject as DependencyObject;
                    DependencyProperty prop = TargetProperty as DependencyProperty;

                    Action updateAction = () => obj.SetValue(prop, value);

                    // Check whether the target object can be accessed from the
                    // current thread, and use Dispatcher.Invoke if it can't

                    if (obj.CheckAccess())
                        updateAction();
                    else
                        obj.Dispatcher.Invoke(updateAction);
                }
                else // TargetProperty is PropertyInfo
                {
                    PropertyInfo prop = TargetProperty as PropertyInfo;
                    prop.SetValue(TargetObject, value, null);
                }
            }
        }
    }

    public sealed override object ProvideValue(IServiceProvider serviceProvider)
    {
        IProvideValueTarget target = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
        State state = new State();
        if (target != null)
        {
            state.TargetObject = target.TargetObject;
            state.TargetProperty = target.TargetProperty;
            return ProvideValueInternal(serviceProvider, state);
        }
        else
        {
            return null;
        }

    }


    protected abstract object ProvideValueInternal(IServiceProvider serviceProvider, State state);
}

is a base class for handling the type of problem where you need to update the property the markup extension is attached to at run time. For example a markup extension for binding to ISubject as

<TextBox Text="{Markup:Subscription Path=Excenter, ErrorsPath=Errors}"/> 

using the SubscriptionExtension as below. I had had trouble with the code when I used it within templates but I fixed it so the MarkupExtension did not store state in itself

using ReactiveUI.Ext;
using ReactiveUI.Subjects;
using ReactiveUI.Utils;
using System;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Disposables;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;

namespace ReactiveUI.Markup
{
    [MarkupExtensionReturnType(typeof(BindingExpression))]
    public class SubscriptionExtension : DynamicMarkupExtension
    {
        [ConstructorArgument("path")]
        public PropertyPath Path { get; set; }

        [ConstructorArgument("errorsPath")]
        public PropertyPath ErrorsPath { get; set; }

        public SubscriptionExtension() { }

        Maybe<Exception> currentErrorState = Maybe.None<Exception>();

        public SubscriptionExtension(PropertyPath path, PropertyPath errorsPath)
        {
            Path = path;
            ErrorsPath = errorsPath;
        }

        class Proxy : ReactiveObject, IDataErrorInfo, IDisposable
        {
            string _Value;
            public string Value
            {
                get { return _Value; }
                set { this.RaiseAndSetIfChanged(value); }
            }

            public string Error
            {
                get { return currentError.Select(e => e.Message).Else(""); }
            }

            public string this[string columnName]
            {
                get { return currentError.Select(e => e.Message).Else(""); }
            }

            public IObservable<Maybe<Exception>> Errors { get; set; }

            public Maybe<Exception> currentError = Maybe.None<Exception>();

            private CompositeDisposable Subscriptions = new CompositeDisposable();
            public Proxy(IObservable<Maybe<Exception>> errors)
            {
                Errors = errors;
                var subscription = errors.Subscribe(e => currentError = e);
                Subscriptions.Add(subscription);
            }

            public void Dispose()
            {
                Subscriptions.Dispose();
            }
        }

        protected override object ProvideValueInternal(IServiceProvider serviceProvider, DynamicMarkupExtension.State state )
        {
            var pvt = serviceProvider as IProvideValueTarget;
            if (pvt == null)
            {
                return null;
            }

            var frameworkElement = pvt.TargetObject as FrameworkElement;
            if (frameworkElement == null)
            {
                return this;
            }

            DependencyPropertyChangedEventHandler myd = delegate(object sender, DependencyPropertyChangedEventArgs e){
                state.UpdateValue(MakeBinding(serviceProvider, frameworkElement));
            };

            frameworkElement.DataContextChanged += myd;

            return MakeBinding(serviceProvider, frameworkElement);
        }


        private object MakeBinding(IServiceProvider serviceProvider, FrameworkElement frameworkElement)
        {
            var dataContext = frameworkElement.DataContext;

            if (dataContext is String)
            {
                return dataContext;
            }

            ISubject<string> subject = Lens.Empty<string>().Subject;
            IObservable<Maybe<Exception>> errors = Observable.Empty<Maybe<Exception>>();
            Binding binding;
            Proxy proxy = new Proxy(errors);

            bool madeit = false;
            if (dataContext != null)
            {

                subject = GetProperty<ISubject<string>>(dataContext, Path);

                if (subject != null)
                {

                    errors = GetProperty<IObservable<Maybe<Exception>>>
                        (dataContext
                        , ErrorsPath) ?? Observable.Empty<Maybe<Exception>>();

                    proxy = new Proxy(errors);
                }
                madeit = true;
            }
            if(!madeit)
            {
                subject = new BehaviorSubject<string>("Binding Error");
            }

            // Bind the subject to the property via a helper ( in private library )
            var subscription = subject.TwoWayBindTo(proxy, x => x.Value);

            // Make sure we don't leak subscriptions
            frameworkElement.Unloaded += (e, v) => subscription.Dispose();

            binding = new Binding()
            {
                Source = proxy,
                Path = new System.Windows.PropertyPath("Value"),
                ValidatesOnDataErrors = true
            };

            return binding.ProvideValue(serviceProvider);
        }


        private static T GetProperty<T>(object context, PropertyPath propPath)
        where T : class
        {
            if (propPath==null)
            {
                return null;
            }
            try
            {
                object propValue = propPath.Path
                    .Split('.')
                    .Aggregate(context, (value, name)
                        => value.GetType()
                            .GetProperty(name)
                            .GetValue(value, null));
                return propValue as T;
            }
            catch (NullReferenceException e)
            {
                throw new MemberAccessException(propPath.Path + " is not available on " + context.GetType(),e);
            }

        }

    }
}