public class CustomControl : UIElement
{
    // 后續(xù)的依賴屬性將在這里添加
}

public static readonly DependencyProperty MyPropertyProperty =
    DependencyProperty.Register(
        "MyProperty",                     // 屬性名稱
        typeof(PropertyType),             // 屬性類型
        typeof(OwnerClass),               // 擁有者類型
        new PropertyMetadata(defaultValue)// 元數(shù)據(jù)
    );

public PropertyType MyProperty
{
    get { return (PropertyType)GetValue(MyPropertyProperty); }
    set { SetValue(MyPropertyProperty, value); }
}

public class CustomControl : UIElement
{
    // 注冊(cè)依賴屬性
    public static readonly DependencyProperty TextProperty =
        DependencyProperty.Register(
            "Text",
            typeof(string),
            typeof(CustomControl),
            new PropertyMetadata("Default Text")
        );
    
    // CLR屬性包裝器
    public string Text
    {
        get { return (string)GetValue(TextProperty); }
        set { SetValue(TextProperty, value); }
    }
}

public static readonly DependencyProperty ValueProperty =
    DependencyProperty.Register(
        "Value",
        typeof(double),
        typeof(CustomControl),
        new PropertyMetadata(0.0, OnValueChanged)
    );

private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    var control = d as CustomControl;
    double oldValue = (double)e.OldValue;
    double newValue = (double)e.NewValue;
    
    // 在這里處理值變更邏輯
    control.OnValueChanged(oldValue, newValue);
}

protected virtual void OnValueChanged(double oldValue, double newValue)
{
    // 可以觸發(fā)事件或執(zhí)行其他操作
}

public static readonly DependencyProperty AgeProperty =
    DependencyProperty.Register(
        "Age",
        typeof(int),
        typeof(CustomControl),
        new PropertyMetadata(0),
        ValidateAgeValue
    );

private static bool ValidateAgeValue(object value)
{
    int age = (int)value;
    return age >= 0 && age <= 120;  // 年齡必須在0-120之間
}

public static readonly DependencyProperty ProgressProperty =
    DependencyProperty.Register(
        "Progress",
        typeof(double),
        typeof(CustomControl),
        new PropertyMetadata(0.0, null, CoerceProgress)
    );

private static object CoerceProgress(DependencyObject d, object baseValue)
{
    double progress = (double)baseValue;
    // 確保進(jìn)度值在0-100之間
    if (progress < 0) return 0;
    if (progress > 100) return 100;
    return progress;
}

public class CustomControl : UIElement
{
    // 注冊(cè)依賴屬性，包含所有三種回調(diào)
    public static readonly DependencyProperty ValueProperty =
        DependencyProperty.Register(
            "Value",
            typeof(double),
            typeof(CustomControl),
            new FrameworkPropertyMetadata(
                0.0,
                FrameworkPropertyMetadataOptions.None,
                OnValueChanged,
                CoerceValue
            ),
            ValidateValue
        );
    
    // 驗(yàn)證回調(diào)
    private static bool ValidateValue(object value)
    {
        double val = (double)value;
        return !double.IsNaN(val);  // 不允許NaN值
    }
    
    // 變更回調(diào)
    private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        CustomControl control = d as CustomControl;
        control.RaiseValueChangedEvent((double)e.OldValue, (double)e.NewValue);
    }
    
    // 強(qiáng)制回調(diào)
    private static object CoerceValue(DependencyObject d, object baseValue)
    {
        double value = (double)baseValue;
        if (value < 0) return 0;
        if (value > 100) return 100;
        return value;
    }
    
    // CLR包裝器
    public double Value
    {
        get { return (double)GetValue(ValueProperty); }
        set { SetValue(ValueProperty, value); }
    }
    
    // 自定義事件
    public event EventHandler<ValueChangedEventArgs> ValueChanged;
    
    protected virtual void RaiseValueChangedEvent(double oldValue, double newValue)
    {
        ValueChanged?.Invoke(this, new ValueChangedEventArgs(oldValue, newValue));
    }
}

// 自定義事件參數(shù)
public class ValueChangedEventArgs : EventArgs
{
    public double OldValue { get; }
    public double NewValue { get; }
    
    public ValueChangedEventArgs(double oldValue, double newValue)
    {
        OldValue = oldValue;
        NewValue = newValue;
    }
}

public class GridHelper
{
    public static readonly DependencyProperty RowCountProperty =
        DependencyProperty.RegisterAttached(
            "RowCount",
            typeof(int),
            typeof(GridHelper),
            new PropertyMetadata(1, OnRowCountChanged)
        );
    
    public static int GetRowCount(DependencyObject obj)
    {
        return (int)obj.GetValue(RowCountProperty);
    }
    
    public static void SetRowCount(DependencyObject obj, int value)
    {
        obj.SetValue(RowCountProperty, value);
    }
    
    private static void OnRowCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is Grid grid)
        {
            grid.RowDefinitions.Clear();
            
            for (int i = 0; i < (int)e.NewValue; i++)
            {
                grid.RowDefinitions.Add(new RowDefinition());
            }
        }
    }
}

<Grid local:GridHelper.RowCount="3">
    <!-- 內(nèi)容 -->
</Grid>

public class CustomControl : UIElement
{
    private static readonly DependencyPropertyKey IsActivePropertyKey =
        DependencyProperty.RegisterReadOnly(
            "IsActive",
            typeof(bool),
            typeof(CustomControl),
            new PropertyMetadata(false)
        );
    
    public static readonly DependencyProperty IsActiveProperty = 
        IsActivePropertyKey.DependencyProperty;
    
    public bool IsActive
    {
        get { return (bool)GetValue(IsActiveProperty); }
        private set { SetValue(IsActivePropertyKey, value); }
    }
    
    // 內(nèi)部方法修改只讀屬性
    private void UpdateActiveState(bool active)
    {
        IsActive = active;
    }
}

new FrameworkPropertyMetadata(
    defaultValue,
    FrameworkPropertyMetadataOptions.AffectsMeasure |
    FrameworkPropertyMetadataOptions.AffectsRender,
    OnPropertyChanged,
    CoerceValue
)

// 靜態(tài)構(gòu)造函數(shù)中注冊(cè)
static CustomControl()
{
    MyPropertyProperty = DependencyProperty.Register(
        "MyProperty",
        typeof(string),
        typeof(CustomControl),
        new PropertyMetadata("Default")
    );
}

new FrameworkPropertyMetadata(
    "Default",
    FrameworkPropertyMetadataOptions.AffectsRender,
    OnTextChanged
)

private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    // 錯(cuò)誤：直接執(zhí)行耗時(shí)操作
    // Thread.Sleep(100);
    
    // 正確：使用Dispatcher異步處理
    Dispatcher.CurrentDispatcher.BeginInvoke(
        DispatcherPriority.Background,
        new Action(() => {
            // 耗時(shí)操作
        })
    );
}

public class CommandBehavior
{
    public static readonly DependencyProperty CommandProperty =
        DependencyProperty.RegisterAttached(
            "Command",
            typeof(ICommand),
            typeof(CommandBehavior),
            new PropertyMetadata(null, OnCommandChanged)
        );
    
    public static ICommand GetCommand(DependencyObject obj)
    {
        return (ICommand)obj.GetValue(CommandProperty);
    }
    
    public static void SetCommand(DependencyObject obj, ICommand value)
    {
        obj.SetValue(CommandProperty, value);
    }
    
    private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is Button button)
        {
            button.Click -= OnButtonClick;
            if (e.NewValue != null)
            {
                button.Click += OnButtonClick;
            }
        }
    }
    
    private static void OnButtonClick(object sender, RoutedEventArgs e)
    {
        if (sender is DependencyObject d)
        {
            ICommand command = GetCommand(d);
            if (command?.CanExecute(null) == true)
            {
                command.Execute(null);
            }
        }
    }
}

public class AnimatedControl : UIElement
{
    public static readonly DependencyProperty AngleProperty =
        DependencyProperty.Register(
            "Angle",
            typeof(double),
            typeof(AnimatedControl),
            new FrameworkPropertyMetadata(
                0.0,
                FrameworkPropertyMetadataOptions.AffectsRender,
                OnAngleChanged
            )
        );
    
    public double Angle
    {
        get { return (double)GetValue(AngleProperty); }
        set { SetValue(AngleProperty, value); }
    }
    
    private static void OnAngleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = d as AnimatedControl;
        double newAngle = (double)e.NewValue;
        
        // 創(chuàng)建動(dòng)畫
        DoubleAnimation animation = new DoubleAnimation(
            control.currentAngle, 
            newAngle,
            new Duration(TimeSpan.FromSeconds(0.5))
        );
        
        control.BeginAnimation(AngleProperty, animation);
    }
    
    private double currentAngle;
    
    protected override void OnRender(DrawingContext drawingContext)
    {
        base.OnRender(drawingContext);
        
        // 保存當(dāng)前角度
        currentAngle = Angle;
        
        // 使用角度進(jìn)行繪制
        // ...
    }
}

var source = DependencyPropertyHelper.GetValueSource(element, SomeDependencyProperty);
Debug.WriteLine($"Value comes from: {source.BaseValueSource}");