How do I set the binding of a child proxy relative to the DataContext?

Question

I looked at a lot of topics, but they all in one way or another are related to the definition of the DataContext of UI elements.

I have a task that requires a completely different approach. And no matter how much I puzzled over the decision, I could not think of anything.

Description of the problem.
Initially, there is a simple proxy:

using System;
using System.Windows;


namespace Proxy
{
    /// <summary> Provides a <see cref="DependencyObject"/> proxy with
    /// one property and an event notifying about its change. </summary>
    public class Proxy : Freezable
    {
        /// <summary> Property for setting external bindings. </summary>
        public object Value
        {
            get { return (object)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Value.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ValueProperty =
            DependencyProperty.Register(nameof(Value), typeof(object), typeof(Proxy), new PropertyMetadata(null));

        protected override Freezable CreateInstanceCore()
        {
            throw new NotImplementedException();
        }
    }
}

If you set it in the Resources of any element, then it can get the DataContext with a simple Binding:

<FrameworkElement.Resources>
    <proxy:ProxyValue x:Key="proxy"
                      Value="{Binding}"/>
</FrameworkElement.Resources>

Likewise, any Bindig without an explicitly specified source will use the DataContext of the element in whose resources the proxy instance is declared as the source.

Child proxy injection.
Now, for a certain task (its conditions are not relevant to the question, so I will not describe it) I needed a nested (child) proxy which can also be assigned a binding relative to the data context.
And I need to set this binding in code.

A highly simplified example for demonstration:

using System.Windows.Data;

namespace Proxy
{
    public class PregnantProxy : Proxy
    {
        public Proxy Child { get; } = new Proxy();

        public PregnantProxy()
        {
            Binding binding = new Binding();
            BindingOperations.SetBinding(this, ValueProperty, binding);
            BindingOperations.SetBinding(Child, ValueProperty, binding);
        }
    }
}

<StackPanel DataContext="Some data">
    <FrameworkElement.Resources>
        <proxy:PregnantProxy x:Key="proxy"/>
    </FrameworkElement.Resources>
    <TextBlock Text="{Binding}" Margin="10"/>
    <TextBlock Text="{Binding Value, Source={StaticResource proxy}}" Margin="10"/>
    <TextBlock Text="{Binding Child.Value, Source={StaticResource proxy}}" Margin="10"/>
</StackPanel>

Parent proxy binding works as expected.
But linking a child will not return anything.

How can you set the correct binding for a child?

Answer 1

"If you set it in the Resources of any element, then it can get the DataContext with a simple Binding" - this is the crucial mistake. Resource dictionary has not the DataContext inheritance. You can easy see it, if you add to the resource dictionary e.g. a Label and try to use binding for it(see example below).

That it works for Text="{Binding Value, Source={StaticResource proxy}}" lays on inheritance from Freezable class, which finds out data context and use for it if I'm not mistaken Freezable.ContextList, which is private see implementation of Freezable. This implementation doesn't work for Child, since it's not in a resource dictionary.

So if you do inherit not from Freezable, but from let us say it's parent class DependencyObject, also Text="{Binding Value, Source={StaticResource proxy}}" will not work.

I don't know for what you need this construction, it looks for me a kind of weird, but if you inherit from FrameworkElement and provide a DataContext for the proxy and it's child element (in XAML you can hard code it, or use StaticResource or custom MarkupExtension for it) it can work. See modified code.

    public class Proxy : FrameworkElement
    {
        /// <summary> Property for setting external bindings. </summary>
        public object Value
        {
            get { return (object)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }
    
        // Using a DependencyProperty as the backing store for Value.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ValueProperty =
            DependencyProperty.Register(nameof(Value), typeof(object), typeof(Proxy), new PropertyMetadata(null)); 

        //protected override Freezable CreateInstanceCore()
        //{
        //    throw new NotImplementedException();
        //}
    
    }
    public class PregnantProxy : Proxy
    {
        public Proxy Child { get; } = new Proxy();
    
        public PregnantProxy()
        {
            var binding = new Binding() {};
            BindingOperations.SetBinding(this, ValueProperty, binding);
    
            //Child
            this.AddLogicalChild(Child);
            BindingOperations.SetBinding(Child, DataContextProperty, binding);
    
            BindingOperations.SetBinding(Child, ValueProperty, binding);
        }
    }

and in XAML accordingly:

<StackPanel DataContext="Some data">
    <StackPanel.Resources>
        <local:PregnantProxy x:Key="proxyResBinding"  DataContext="{Binding}"/>
        <local:PregnantProxy x:Key="proxyHardCodedDC"  DataContext="Proxy hardcoded DC"/>

        <Label x:Key="lblResBinding" DataContext="{Binding}"/>
        <Label x:Key="lblHardcoded" DataContext="hard coded DC"/>
    </StackPanel.Resources>

    <Label Content="{Binding}" Background="Yellow" />

    <Label Content="{Binding Child.Value, Source={StaticResource proxyResBinding}}" Background="Red"/>
    <Label Content="{Binding Value, Source={StaticResource proxyResBinding}}" Background="Red"/>
            
    <Label Content="{Binding Child.Value, Source={StaticResource proxyHardCodedDC}}" Background="Green"/>
    <Label Content="{Binding Value, Source={StaticResource proxyHardCodedDC}}" Background="Green"/>

    <Label Content="{Binding DataContext, Source={StaticResource lblResBinding}}" Background="Red"/>
    <Label Content="{Binding DataContext, Source={StaticResource lblHardcoded}}" Background="Green"/>
            
</StackPanel>

Answer 2

For now, I've implemented a working solution with finding the parent FrameworkElement and adding a child proxy to the resources of the parent FrameworkElement.

The test use case shown in the question works correctly.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;

namespace Proxy
{
    public class PregnantProxy : Proxy
    {
        public Proxy Child { get; } = new Proxy();

        public PregnantProxy()
        {
            BindingOperations.SetBinding(this, ParentProperty, FindAncestorFrameworkElement);
            Binding binding = new Binding() { RelativeSource = new RelativeSource(RelativeSourceMode.FindAncestor, typeof(StackPanel), 1) };
            BindingOperations.SetBinding(this, ValueProperty, binding);
            BindingOperations.SetBinding(Child, ValueProperty, binding);

        }


        /// <summary>
        /// Родительский FrameworkElement
        /// </summary>
        public FrameworkElement Parent
        {
            get { return (FrameworkElement)GetValue(ParentProperty); }
            set { SetValue(ParentProperty, value); }
        }

        /// <summary><see cref="DependencyProperty"/> для свойства <see cref="Parent"/>.</summary>
        public static readonly DependencyProperty ParentProperty =
            DependencyProperty.Register(nameof(Parent), typeof(FrameworkElement), typeof(PregnantProxy), new PropertyMetadata(null, ParentChanged));

        private static void ParentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            PregnantProxy proxy = (PregnantProxy)d;
            if (e.OldValue is FrameworkElement oldElement)
            {
                oldElement.Resources.Remove(proxy.key);
            }
            if (e.NewValue is FrameworkElement newElement)
            {
                double key;
                do
                {
                    key = random.NextDouble();
                } while (newElement.Resources.Contains(key));
                newElement.Resources.Add(proxy.key = key, proxy.Child);
            }

            if (!Equals(BindingOperations.GetBinding(proxy, ParentProperty), FindAncestorFrameworkElement))
                BindingOperations.SetBinding(proxy, ParentProperty, FindAncestorFrameworkElement);

        }
        private double key;
        private static readonly Random random = new Random();
        private static readonly Binding FindAncestorFrameworkElement = new Binding() { RelativeSource = new RelativeSource(RelativeSourceMode.FindAncestor, typeof(FrameworkElement), 1) };
    }
}

But such a solution may throw an exception if the resources are locked or read-only.

The final solution.

The answer from @Rekshino pushed me to look for a solution in a different direction.
I created an extension method to set a DependencyObject's context relative to another DependencyObject.

The method can be applied to any DependecyObject.
But context-relative bindings are only interpreted by Freezable. So it makes little sense for the rest of the DependecyObject.
But maybe I missed something, and I can somehow use it or modify it.

using System;
using System.Linq;
using System.Reflection;
using System.Windows;

namespace Proxy
{
    public static class ProxyExtensionMethods
    {
        private static readonly Func<DependencyObject, DependencyObject, DependencyProperty, bool> ProvideSelfAsInheritanceContextHandler;

        static ProxyExtensionMethods()
        {
            var methods = typeof(DependencyObject)
                 .GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);

            MethodInfo method = null;

            foreach (var meth in methods
                .Where(m => m.Name == "ProvideSelfAsInheritanceContext" &&
                        m.ReturnType == typeof(bool)))
            {
                var parameters = meth.GetParameters();

                if (parameters?.Length == 2 &&
                    typeof(DependencyObject) == parameters[0].ParameterType &&
                    typeof(DependencyProperty) == parameters[1].ParameterType)
                {
                    method = meth;
                    break;
                }
            }

            ProvideSelfAsInheritanceContextHandler = (Func<DependencyObject, DependencyObject, DependencyProperty, bool>)
                 method
                 .CreateDelegate
                 (
                     typeof(Func<DependencyObject, DependencyObject, DependencyProperty, bool>)
                 );

        }

        /// <summary>Sets the DependecyObject context</summary>
        /// <param name="obj">The object for which the Context is to be set.</param>
        /// <param name="context">The object to be used as the Context.</param>
        public static void SetContext(this DependencyObject obj, DependencyObject context)
        {
                ProvideSelfAsInheritanceContextHandler(context, obj, PrivateKey.DependencyProperty);
        }

        private static readonly DependencyPropertyKey PrivateKey=
            DependencyProperty.RegisterAttachedReadOnly("Private", typeof(object), typeof(ProxyExtensionMethods), new PropertyMetadata(null));
    }
}

Usage example.

using System.Windows.Data;

namespace Proxy
{
    public class PregnantProxy : Proxy
    {
        public Proxy Child { get; } = new Proxy();

        public PregnantProxy()
        {
            Child.SetContext(this);

            Binding binding = new Binding() { };
            BindingOperations.SetBinding(this, ValueProperty, binding);
            BindingOperations.SetBinding(Child, ValueProperty, binding);
        }
    }
}

The XAML shown in the question works correctly with such an implementation.

If someone has comments on the code and possible problems with such an implementation, I am ready to listen carefully.