Dependency Properties & Attached Properties

using System.Globalization;
using System.Windows;
using System.Windows.Media;

namespace Bookshelf.Desktop.Controls;

/// <summary>Shows a book rating as filled and empty stars.</summary>
public class StarRating : FrameworkElement
{
    private const double StarSize = 16;

    // 1. A read-only property: RegisterReadOnly returns a *key*, kept private.
    private static readonly DependencyPropertyKey IsRatedPropertyKey =
        DependencyProperty.RegisterReadOnly(
            name: nameof(IsRated),
            propertyType: typeof(bool),
            ownerType: typeof(StarRating),
            typeMetadata: new FrameworkPropertyMetadata(defaultValue: false));

    // The public identifier is derived from the key: it can read, not write.
    public static readonly DependencyProperty IsRatedProperty = IsRatedPropertyKey.DependencyProperty;

    // 2. Maximum: layout changes when it changes; its callback re-coerces Rating.
    public static readonly DependencyProperty MaximumProperty =
        DependencyProperty.Register(
            name: nameof(Maximum),
            propertyType: typeof(int),
            ownerType: typeof(StarRating),
            typeMetadata: new FrameworkPropertyMetadata(
                defaultValue: 5,
                flags: FrameworkPropertyMetadataOptions.AffectsMeasure,
                propertyChangedCallback: OnMaximumChanged),
            validateValueCallback: IsValidMaximum);

    // 3. Rating: redraws, binds two-way by default, is coerced into 0..Maximum.
    public static readonly DependencyProperty RatingProperty =
        DependencyProperty.Register(
            name: nameof(Rating),
            propertyType: typeof(double),
            ownerType: typeof(StarRating),
            typeMetadata: new FrameworkPropertyMetadata(
                defaultValue: 0.0,
                flags: FrameworkPropertyMetadataOptions.AffectsRender
                     | FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,
                propertyChangedCallback: OnRatingChanged,
                coerceValueCallback: CoerceRating),
            validateValueCallback: IsValidRating);

    // CLR wrappers: GetValue / SetValue and nothing else.
    public int Maximum
    {
        get => (int)GetValue(MaximumProperty);
        set => SetValue(MaximumProperty, value);
    }

    public double Rating
    {
        get => (double)GetValue(RatingProperty);
        set => SetValue(RatingProperty, value);
    }

    public bool IsRated
    {
        get => (bool)GetValue(IsRatedProperty);
        private set => SetValue(IsRatedPropertyKey, value); // key, not identifier
    }

    // Validation: static, no instance, runs for every value including defaults.
    private static bool IsValidMaximum(object value) => value is int max && max is >= 1 and <= 20;

    private static bool IsValidRating(object value) =>
        value is double rating && !double.IsNaN(rating) && !double.IsInfinity(rating);

    // Coercion: has the instance, may depend on other properties.
    private static object CoerceRating(DependencyObject d, object baseValue)
    {
        var control = (StarRating)d;
        return Math.Clamp((double)baseValue, 0, control.Maximum);
    }

    private static void OnMaximumChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) =>
        d.CoerceValue(RatingProperty); // a smaller Maximum must clip Rating; a larger one restores it

    private static void OnRatingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) =>
        ((StarRating)d).IsRated = (double)e.NewValue > 0;

    protected override Size MeasureOverride(Size availableSize) => new(Maximum * StarSize + 32, StarSize);

    protected override void OnRender(DrawingContext drawingContext)
    {
        var empty = Brushes.LightGray;
        var filled = Brushes.Goldenrod;
        for (var i = 0; i < Maximum; i++)
        {
            var fill = Math.Clamp(Rating - i, 0, 1);
            var cell = new Rect(i * StarSize, 0, StarSize - 2, StarSize - 2);
            drawingContext.DrawRectangle(empty, null, cell);
            if (fill > 0)
            {
                drawingContext.DrawRectangle(filled, null, new Rect(cell.X, cell.Y, cell.Width * fill, cell.Height));
            }
        }

        var label = new FormattedText(
            Rating.ToString("0.#", CultureInfo.CurrentCulture),
            CultureInfo.CurrentCulture,
            FlowDirection,
            new Typeface("Segoe UI"),
            11,
            Brushes.Black,
            VisualTreeHelper.GetDpi(this).PixelsPerDip);
        drawingContext.DrawText(label, new Point(Maximum * StarSize + 4, 0));
    }
}

<Window x:Class="Bookshelf.Desktop.Views.BookDetailsWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:controls="clr-namespace:Bookshelf.Desktop.Controls"
        Title="Book details" Width="420" Height="240">
    <Window.Resources>
        <!-- Every StarRating in this window shows 10 stars unless it overrides Maximum locally. -->
        <Style TargetType="controls:StarRating">
            <Setter Property="Maximum" Value="10"/>
        </Style>
    </Window.Resources>

    <StackPanel Margin="16">
        <TextBlock Text="{Binding Title}" FontWeight="SemiBold"/>

        <!-- BindsTwoWayByDefault: no Mode=TwoWay needed. -->
        <controls:StarRating Rating="{Binding Rating}" Margin="0,8,0,0"/>

        <!-- IsRated is read-only: it can be bound from, never to. -->
        <TextBlock Text="Rated" Margin="0,8,0,0"
                   Visibility="{Binding IsRated, ElementName=ratingControl,
                                Converter={StaticResource BooleanToVisibilityConverter}}"/>
        <controls:StarRating x:Name="ratingControl" Rating="{Binding Rating}" Maximum="5"/>
    </StackPanel>
</Window>

<Style TargetType="controls:StarRating">
    <Style.Triggers>
        <!-- IsRated is read-only; the trigger only reads it. -->
        <Trigger Property="IsRated" Value="False">
            <Setter Property="Opacity" Value="0.5"/>
        </Trigger>
    </Style.Triggers>
</Style>

using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Controls;
using Bookshelf.Core;

namespace Bookshelf.Desktop.Controls;

public class ShelfView : Control
{
    private static readonly DependencyPropertyKey BooksPropertyKey =
        DependencyProperty.RegisterReadOnly(
            name: nameof(Books),
            propertyType: typeof(ObservableCollection<Book>),
            ownerType: typeof(ShelfView),
            typeMetadata: new FrameworkPropertyMetadata(defaultValue: null)); // not new ObservableCollection<Book>()

    public static readonly DependencyProperty BooksProperty = BooksPropertyKey.DependencyProperty;

    public ShelfView()
    {
        // One collection per instance.
        SetValue(BooksPropertyKey, new ObservableCollection<Book>());
    }

    public ObservableCollection<Book> Books => (ObservableCollection<Book>)GetValue(BooksProperty);
}

using System.Windows;

namespace Bookshelf.Desktop.Theming;

public enum UiDensity
{
    Comfortable,
    Compact,
}

public static class DensityOptions
{
    public static readonly DependencyProperty DensityProperty =
        DependencyProperty.RegisterAttached(
            name: "Density",
            propertyType: typeof(UiDensity),
            ownerType: typeof(DensityOptions),
            defaultMetadata: new FrameworkPropertyMetadata(
                defaultValue: UiDensity.Comfortable,
                flags: FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure));

    public static UiDensity GetDensity(DependencyObject element)
    {
        ArgumentNullException.ThrowIfNull(element);
        return (UiDensity)element.GetValue(DensityProperty);
    }

    public static void SetDensity(DependencyObject element, UiDensity value)
    {
        ArgumentNullException.ThrowIfNull(element);
        element.SetValue(DensityProperty, value);
    }
}

<Window x:Class="Bookshelf.Desktop.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:theming="clr-namespace:Bookshelf.Desktop.Theming"
        theming:DensityOptions.Density="Compact"
        Title="Bookshelf Desktop" Width="900" Height="600">
    <Window.Resources>
        <!-- Style trigger on an inherited attached property: Compact shrinks every Button below. -->
        <Style TargetType="Button">
            <Style.Triggers>
                <Trigger Property="theming:DensityOptions.Density" Value="Compact">
                    <Setter Property="Padding" Value="4,1"/>
                    <Setter Property="MinHeight" Value="22"/>
                </Trigger>
            </Style.Triggers>
        </Style>
    </Window.Resources>

    <StackPanel>
        <!-- Both buttons inherit Compact from the Window: no per-button setting. -->
        <Button Content="Add book" Command="{Binding AddBookCommand}"/>
        <Button Content="Delete" Command="{Binding DeleteBookCommand}"/>
        <!-- A local value stops the inheritance for this subtree only. -->
        <Button Content="Large action" theming:DensityOptions.Density="Comfortable"/>
    </StackPanel>
</Window>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Bookshelf.Desktop.Behaviors;

public static class TextBoxBehavior
{
    public static readonly DependencyProperty SelectAllOnFocusProperty =
        DependencyProperty.RegisterAttached(
            name: "SelectAllOnFocus",
            propertyType: typeof(bool),
            ownerType: typeof(TextBoxBehavior),
            defaultMetadata: new PropertyMetadata(false, OnSelectAllOnFocusChanged));

    public static bool GetSelectAllOnFocus(DependencyObject element) =>
        (bool)element.GetValue(SelectAllOnFocusProperty);

    public static void SetSelectAllOnFocus(DependencyObject element, bool value) =>
        element.SetValue(SelectAllOnFocusProperty, value);

    private static void OnSelectAllOnFocusChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not TextBox textBox)
        {
            return;
        }

        // Always unhook first: callbacks run for every change, and the same box can be set twice.
        textBox.GotKeyboardFocus -= OnGotKeyboardFocus;
        if ((bool)e.NewValue)
        {
            textBox.GotKeyboardFocus += OnGotKeyboardFocus;
        }
    }

    private static void OnGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e) =>
        ((TextBox)sender).SelectAll();
}

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Bookshelf.Desktop.Behaviors;

public static class ListBoxBehavior
{
    public static readonly DependencyProperty DoubleClickCommandProperty =
        DependencyProperty.RegisterAttached(
            name: "DoubleClickCommand",
            propertyType: typeof(ICommand),
            ownerType: typeof(ListBoxBehavior),
            defaultMetadata: new PropertyMetadata(null, OnDoubleClickCommandChanged));

    public static ICommand? GetDoubleClickCommand(DependencyObject element) =>
        (ICommand?)element.GetValue(DoubleClickCommandProperty);

    public static void SetDoubleClickCommand(DependencyObject element, ICommand? value) =>
        element.SetValue(DoubleClickCommandProperty, value);

    private static void OnDoubleClickCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not Control control)
        {
            return;
        }

        // OldValue / NewValue tell us whether to hook or unhook; avoids leaks and double subscription.
        control.MouseDoubleClick -= OnMouseDoubleClick;
        if (e.NewValue is ICommand)
        {
            control.MouseDoubleClick += OnMouseDoubleClick;
        }
    }

    private static void OnMouseDoubleClick(object sender, MouseButtonEventArgs e)
    {
        if (sender is not ListBox listBox || GetDoubleClickCommand(listBox) is not { } command)
        {
            return;
        }

        var parameter = listBox.SelectedItem;
        if (parameter is not null && command.CanExecute(parameter))
        {
            command.Execute(parameter);
        }
    }
}

using System.Collections.ObjectModel;
using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop.ViewModels;

public partial class BooksViewModel : ObservableObject
{
    private readonly IBookRepository _repository;
    private readonly INavigationService _navigation;

    public BooksViewModel(IBookRepository repository, INavigationService navigation)
    {
        _repository = repository;
        _navigation = navigation;
    }

    public ObservableCollection<BookViewModel> Books { get; } = [];

    [ObservableProperty]
    public partial string SearchText { get; set; } = string.Empty;

    // The behaviour passes the selected BookViewModel as the command parameter.
    [RelayCommand]
    private void OpenBook(BookViewModel book) => _navigation.NavigateTo<BookDetailsViewModel>(book.Id);

    [RelayCommand]
    private async Task LoadAsync(CancellationToken cancellationToken)
    {
        Books.Clear();
        foreach (var book in await _repository.GetAllAsync(cancellationToken))
        {
            Books.Add(new BookViewModel(book));
        }
    }
}

<UserControl x:Class="Bookshelf.Desktop.Views.BooksView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:b="clr-namespace:Bookshelf.Desktop.Behaviors">
    <DockPanel>
        <!-- Attached behaviour: select all text when the box gets focus. -->
        <TextBox DockPanel.Dock="Top"
                 Text="{Binding SearchText, UpdateSourceTrigger=PropertyChanged}"
                 b:TextBoxBehavior.SelectAllOnFocus="True"/>

        <!-- Attached behaviour: double-click opens the selected book. -->
        <ListBox ItemsSource="{Binding Books}" DisplayMemberPath="Title"
                 b:ListBoxBehavior.DoubleClickCommand="{Binding OpenBookCommand}"/>
    </DockPanel>
</UserControl>

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

namespace Bookshelf.WinUI.Controls;

public sealed class StarRating : Control
{
    public static readonly DependencyProperty RatingProperty =
        DependencyProperty.Register(
            nameof(Rating),
            typeof(double),
            typeof(StarRating),
            PropertyMetadata.Create(0.0, OnRatingChanged));

    public double Rating
    {
        get => (double)GetValue(RatingProperty);
        set => SetValue(RatingProperty, value);
    }

    private static void OnRatingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (StarRating)d;
        var clamped = Math.Clamp((double)e.NewValue, 0, 5);
        if (clamped != (double)e.NewValue)
        {
            control.Rating = clamped; // re-enters the callback once with the clamped value
        }
    }
}