Question

My control has 5 dependency properties. I set them in XAML like this:

<MyControl Prop1="1" Prop2="2" Prop3="3" Prop4="4" />

As you can see, I am only setting 4 of the 5 properties in XAML.

What I need to find is some mechanism to indicate that all the properties set in XAML have been processed. With this event, I can run my SetItAllUp() method.

Option 1. Use the DP setter

FAIL: Not an option because I cannot call SetItAllUp() but one time. This also has the side effect of activating based on the ordinal declaration of each DP in the XAML. If there is some type of chaining or dependency between my properties, this undermines it.

Option 2. Use the DP setter, and test all values are set

FAIL: Not an option because sometimes certain DP values are optional – let’s just pretend that the logic necessary to determine if optional values are properly set or not is too complex to implement this solution for now, please.

Option 3. Use MyControl.Loaded

FAIL: Not an option because this fires too early. In fact, every event I can see fires too early. It is almost as if the object is created and then something under the hood starts to set the DP values based on the declarations.

---

Update! Loaded is the solution. My question was flawed.

There’s some event or something, right?
// Thanks

Answer 1

Loaded works fine. Sorry for the confusion.

I tested this class:

public class MyPath : Path
{
    public MyPath()
    {
        Loaded += MyPath_Loaded;
    }

    void MyPath_Loaded(object sender, RoutedEventArgs e)
    {
        System.Diagnostics.Debug.WriteLine("Loaded");
    }
    public int Test1
    {
        get { return (int)GetValue(Test1Property); }
        set
        {
            SetValue(Test1Property, value);
            System.Diagnostics.Debug.WriteLine("Test1");
        }
    }
    public static readonly DependencyProperty Test1Property =
        DependencyProperty.Register("Test1", typeof(int), typeof(MyPath),
        new PropertyMetadata(DependencyProperty.UnsetValue, null));

    public int Test2
    {
        get { return (int)GetValue(Test2Property); }
        set
        {
            SetValue(Test2Property, value);
            System.Diagnostics.Debug.WriteLine("Test2");
        }
    }
    public static readonly DependencyProperty Test2Property =
        DependencyProperty.Register("Test2", typeof(int), typeof(MyPath),
        new PropertyMetadata(DependencyProperty.UnsetValue, null));

    public int Test3
    {
        get { return (int)GetValue(Test3Property); }
        set
        {
            SetValue(Test3Property, value);
            System.Diagnostics.Debug.WriteLine("Test3");
        }
    }
    public static readonly DependencyProperty Test3Property =
        DependencyProperty.Register("Test3", typeof(int), typeof(MyPath),
        new PropertyMetadata(DependencyProperty.UnsetValue, null));

    public int Test4
    {
        get { return (int)GetValue(Test4Property); }
        set
        {
            SetValue(Test4Property, value);
            System.Diagnostics.Debug.WriteLine("Test4");
        }
    }
    public static readonly DependencyProperty Test4Property =
        DependencyProperty.Register("Test4", typeof(int), typeof(MyPath),
        new PropertyMetadata(DependencyProperty.UnsetValue, null));

    public int Test5
    {
        get { return (int)GetValue(Test5Property); }
        set
        {
            SetValue(Test5Property, value);
            System.Diagnostics.Debug.WriteLine("Test5");
        }
    }
    public static readonly DependencyProperty Test5Property =
        DependencyProperty.Register("Test5", typeof(int), typeof(MyPath),
        new PropertyMetadata(DependencyProperty.UnsetValue, null));
}

With this XAML:

<Grid Background="{StaticResource ApplicationPageBackgroundBrush}">
    <local:MyPath Test1="1" Test2="2" Test3="3" Test4="4" />
</Grid>

And got this Trace:

Test1
Test2
Test3
Test4
Loaded

And it turns out Loaded works just fine.
My previous testing must have had some other factor.
My simplified test shows Loaded seems perfect.