Binding to FrameworkElement's properties inside an attached property

Question

I already now how to solve my problem but I need an explanation why it works this way. I've created a test attached property which sets Text property of a TextBlock control. Because of my need of having more parameters in my attached property, I made the property to accept a general property (IGeneralAttProp), so I can use it like this:

    <TextBlock>
        <local:AttProp.Setter>
            <local:AttPropertyImpl TTD="{Binding TextToDisplay}" />
        </local:AttProp.Setter>
    </TextBlock>

Here are the implementations of Setter attached property and IGeneralAttProp interface:

public class AttProp {
    #region Setter dependancy property
    // Using a DependencyProperty as the backing store for Setter.
    public static readonly DependencyProperty SetterProperty =
        DependencyProperty.RegisterAttached("Setter", 
            typeof(IGeneralAttProp), 
            typeof(AttProp),
            new PropertyMetadata((s, e) => {
                IGeneralAttProp gap = e.NewValue as IGeneralAttProp;
                if (gap != null) {
                    gap.Initialize(s);
                }
            }));

    public static IGeneralAttProp GetSetter(DependencyObject element) {
        return (IGeneralAttProp)element.GetValue(SetterProperty);
    }

    public static void SetSetter(DependencyObject element, IGeneralAttProp value) {
        element.SetValue(SetterProperty, value);
    }
    #endregion
}

public interface IGeneralAttProp {
    void Initialize(DependencyObject host);
}

and the implementation of AttPropertyImpl class:

class AttPropertyImpl: Freezable, IGeneralAttProp {
    #region IGeneralAttProp Members
    TextBlock _host;
    public void Initialize(DependencyObject host) {
        _host = host as TextBlock;
        if (_host != null) {
            _host.SetBinding(TextBlock.TextProperty, new Binding("TTD") { Source = this, UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged });
        }
    }
    #endregion

    protected override Freezable CreateInstanceCore() {
        return new AttPropertyImpl();
    }


    #region TTD dependancy property
    // Using a DependencyProperty as the backing store for TTD.
    public static readonly DependencyProperty TTDProperty =
        DependencyProperty.Register("TTD", typeof(string), typeof(AttPropertyImpl));

    public string TTD {
        get { return (string)GetValue(TTDProperty); }
        set { SetValue(TTDProperty, value); }
    }
    #endregion
}

Everything works fine if the AttPropertyImpl inherits from Freezable. If it's only a DependencyObject than it fails to bind with message:

Cannot find governing FrameworkElement or FrameworkContentElement for target element. BindingExpression:Path=TextToDisplay; DataItem=null; target element is 'AttPropertyImpl' (HashCode=15874253); target property is 'TTD' (type 'String')

When it's a FrameworkElement there's no error in binding, nevertheless the value is not bound.

The Question is: why AttPropertyImpl has to inherit from Freezable to work properly.

Answer 1

The problem is that AttPropertyImpl is not in the element tree, take a look at this post, it explains what the Freezable object's role is in this scenario.