public string MyProperty { get; set; }

And then in XAML, you could set the value of the property like this:

<MyControl MyProperty="someValue" />

This works fine for setting specific values in templates that are unlikely to change or if they do change then the change is always manually made to the XAML file.  But what happens if you want to have the value of the property bound to some other value that is retrieved from a database, web service, etc?  You might try Binding to the property like so:

<MyControl MyProperty="{Binding DynamicPropertyValue}" />

Where DynamicPropertyValue was a property on the parent element that you wanted to to have your property get data from.  But when you run it, you get and error similar to the following:

Silverlight error
ErrorCode: 2260
ErrorType: ParserError
Message: AG_E_PARSER_BAD_PROPERTY_VALUE
XAMLFile:
Line: 1
Position: 6030

Enter the DependencyProperty.  The DependencyProperty is a property that can be bound dynamically.  The downside is that there is a bit more overhead.  Here is the same property from above expressed as a DependencyProperty:

/// <summary>
/// Gets or sets the MyProperty value.
/// </summary>
public string MyProperty
{
    get { return (string)GetValue(MyProperty); }
    set { SetValue(MyProperty, value); }
}

/// <summary>
/// Dependency field of MyProperty property.
/// </summary>
public static readonly DependencyProperty MyPropertyProperty =
        DependencyProperty.Register("MyProperty", 
                                    typeof(string), 
                                    typeof(MyControl),
                                    null);

Now if you want to add some logic that happens when the property value is changed you can set up your DependencyProperty like this:

/// <summary>
/// Dependency field of MyProperty property.
/// </summary>
public static readonly DependencyProperty MyPropertyProperty =
        DependencyProperty.Register("MyProperty", 
                 typeof(string), 
                 typeof(MyControl),
                 new PropertyMetadata(

new PropertyChangedCallback(OnMyPropertyPropertyChanged)));

private static void OnMyPropertyPropertyChanged(DependencyObject sender, 
            DependencyPropertyChangedEventArgs args)
{
    MyControl myControl = (MyControl)sender;
    myControl.OnMyPropertyChanged((string)args.NewValue);
}

/// <summary>
/// Event handler for the MyProperty property changed event.
/// </summary>
/// <param name="newMyPropertyValue">The new MyProperty value to set.</param>
protected virtual void OnCurrentRatingValueChanged(string newMyPropertyValue)
{
    if (newMyPropertyValue.Length == 0)
    {
        throw new ArgumentException("MyProperty cannot be null.");
    }
}

Anyway, there you have it, you can now bind data to properties in XAML.  As usual, should you find this information to have been helpful, or less than helpful, please feel free to leave comments.

myElement.SizeChanged += new SizeChangedEventHandler(OnSizeChanged);

Now, in the event handler you can use the NewSize property to get the newly measured ActualHeight and ActualWidth.

private void OnSizeChanged(object sender, 
                           SizeChangedEventArgs e)
{
    actualHeight = e.NewSize.Height;
    actualWidth = e.NewSize.Width;
}

Thanks everybody!  I’ll be here all week!  Be sure to tip your waitresses…

Error    6    The property '_UnknownContent' does not exist on the type 'ResourceDictionary' in the XML namespace 'https://schemas.microsoft.com/winfx/2006/xaml/presentation'.    C:\Source\Controls\MyControl.xaml

Error    7    The type 'List`1' is inside a ResourceDictionary and does not have a key.    C:\Source\Controls\MyControl.xaml

Unfortunately this in not a very helpful error message.  I’m embarrassed to say how long it took me to figure out the problem, so I’m not going to tell you.  But I will tell you how to solve this if you run into it.  Its surprisingly simple:

1. Right-click the file in “Solution Explorer”.

2. Change the “Build Action” to “Resource”.

3. Save the project and rebuild.

So there you have it, an easy solution to an obnoxious, uninformative error.

One > Two > Three > Four > Five

where “Five” is a child of the “Four” category, which, in turn, is a child of the “Three” category, and so on.  The way I initially though about it was that I would use a TextBlock for each of the categories and the “>” separators.  This actually worked fine.  Here’s a simple version of the XAML that I used:

    <StackPanel x:Name="LayoutRoot" Background="Black" 
                Orientation="Horizontal" Width="185" Height="15">
        <StackPanel.Resources>
            <Style x:Name="CategoryStyle" TargetType="TextBlock">
                <Setter Property="Foreground" Value="White" />
                <Setter Property="FontSize" Value="11" />
                <Setter Property="FontFamily" Value="Verdana" />
            </Style>
            <Style x:Name="SeparatorStyle" TargetType="TextBlock">
                <Setter Property="Foreground" Value="White" />
                <Setter Property="FontSize" Value="11" />
                <Setter Property="FontFamily" Value="Verdana" />
                <Setter Property="Margin" Value="3 0 3 0" />
            </Style>
        </StackPanel.Resources>
    </StackPanel>

And here’s the code:

    public void AddCategory(string categoryName)
    {
        TextBlock tb = new TextBlock();
        tb.Text = categoryName;
        tb.Style = this.CategoryStyle;
        tb.MouseEnter += new MouseEventHandler(OnMouseEnter);
        tb.MouseLeave += new MouseEventHandler(OnMouseLeave);
        this.LayoutRoot.Children.Add(tb);
    }

    private void OnMouseEnter(object sender, MouseEventArgs e)
    {
        TextBlock tb = (TextBlock)sender;
        tb.TextDecorations = TextDecorations.Underline;
    }

    private void OnMouseLeave(object sender, MouseEventArgs e)
    {
        TextBlock tb = (TextBlock)sender;
        tb.TextDecorations = null;
    }

    public void AddSeparator()
    {
        TextBlock separator = new TextBlock();
        separator.Text = ">";
        separator.Style = this.SeparatorStyle;
        this.LayoutRoot.Children.Add(separator);
    }

When I ran this it looked liked the following:

And when you mouse over one of the categories, it underlines.  So I sent out my project for code review and one of the first comments to come back was: “Why didn’t you use a HyperlinkButton?”

Having never heard of the HyperlinkButton, I said, “There’s a HyperlinkButton?”  But I looked it up and indeed, not only was there a HyperlinkButton, but it had automatic underlining, so I no longer had to handle that myself.

So I changed the code to add HyperlinkButtons instead of TextBlocks.  This had the extra benefit of removing 12 lines of unnecessary code.  My new method looked like the following:

    public void AddCategory(string categoryName)
    {
        HyperlinkButton hb = new HyperlinkButton();
        hb.Content = categoryName;
        hb.Style = this.CategoryStyle;
        this.LayoutRoot.Children.Add(hb);
    }

and I was able to completely remove the OnMouseEnter() and OnMouseLeave() methods.  I left the seperators in as TextBlocks because they have no actions associated with them. 

Among other things, since HyperlinkButtons are Buttons, they expose the Click event so there is no need to handle the related Mouse and Keyboard events.

I’ve been working on a project where I have a Button with a default Style that I wanted to change when the Button was clicked.  So let’s say you have a Button and a couple of Styles as shown below:

<UserControl x:Class="SilverlightApplication1.Page"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" 
    Width="400" Height="300">
    <UserControl.Resources>
        <Style x:Key="RedStyle" TargetType="Button">
            <Setter Property="FontFamily" Value="Verdana"/>
            <Setter Property="Foreground" Value="Red"/>
            <Setter Property="FontSize" Value="11"/>
        </Style>
        <Style x:Name="BlueStyle" TargetType="Button">
            <Setter Property="FontFamily" Value="Courier New"/>
            <Setter Property="Foreground" Value="Blue"/>
            <Setter Property="FontSize" Value="11"/>
        </Style>
    </UserControl.Resources>
    <Grid x:Name="LayoutRoot" Background="White">
        <Button x:Name="MyButton" Content="Style Me" Style="{StaticResource RedStyle}"/>
    </Grid>
</UserControl>

I want the default style for this Button to be RedStyle so I have the Style set to:

Style="{StaticResource RedStyle}"

Now, in the code, I want to change the Style when the UserControl is clicked:

void MyButton_Click(object sender, RoutedEventArgs e)
{
    Style blueStyle = this.Resources["BlueStyle"] as Style;
    if (blueStyle != null)
    {
        this.MyButton.Style = blueStyle;
    }
}

But the problem comes along when you actually click the the control and the following exception is thrown:

Catastrophic failure (Exception from HRESULT: 0x8000FFFF (E_UNEXPECTED))

Wait, why can’t I change my style?  You might think that the reason is because assigning the Style as a StaticResource makes it permanent.  That’s true.  However, the whole truth is that once a Style is assigned to an object, it can never have another Style assigned to it.  Let’s test this out by not assigning the Style as a StaticResource in the XAML.  Instead, let’s assign it in the constructor:

public Page()
{
    InitializeComponent();
    this.MyTextBlock.Style = this.Resources["RedStyle"] as Style;
    this.MouseLeftButtonUp += new MouseButtonEventHandler(Page_MouseLeftButtonUp);
}

Now when we click the control what happens?

Catastrophic failure (Exception from HRESULT: 0x8000FFFF (E_UNEXPECTED))

But I really want to change the Style of the Button when I click it.  Enter the ControlTemplate.  First, let’s change the default style to include a ControlTemplate:

<Style x:Key="BaseStyle" TargetType="Button">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="Button">
                <Grid x:Name="Content" Background="Black" Width="200" Height="100">
                    <Grid.Resources>
                        <Style x:Key="RedStyle" TargetType="TextBlock">
                            <Setter Property="FontFamily" Value="Verdana"/>
                            <Setter Property="Foreground" Value="Red"/>
                            <Setter Property="FontSize" Value="11"/>
                        </Style>
                    </Grid.Resources>
                    <TextBlock Text="{TemplateBinding Content}" Style="{StaticResource RedStyle}"/>
                </Grid>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Here I’m saying that I want my Button to be a Grid that contains a TextBlock.  It looks like this:

Now I’m going to add another ControlTemplate that will turn my text blue and change the font:

<ControlTemplate x:Key="BlueTemplate" TargetType="Button">
    <Grid x:Name="Content" Background="Yellow" Width="100" Height="50">
        <Grid.Resources>
            <Style x:Key="BlueStyle" TargetType="TextBlock">
                <Setter Property="FontFamily" Value="Courier New"/>
                <Setter Property="Foreground" Value="Blue"/>
                <Setter Property="FontSize" Value="13"/>
            </Style>
        </Grid.Resources>
        <TextBlock Text="{TemplateBinding Content}" Style="{StaticResource BlueStyle}"/>
    </Grid>
</ControlTemplate>

My MyButton_Click() method now changes to:

void MyButton_Click(object sender, RoutedEventArgs e)
{
    ControlTemplate blueTemplate = this.Resources["BlueTemplate"] as ControlTemplate;
    if (blueTemplate != null)
    {
        this.MyButton.Template = blueTemplate;
    }
}

Now, when I click the Style Me button, it looks like this:

The reason this now works is that while Style is write-once, the Template property isn’t.  It can be set any number of times.