WpfAnalyzers

The WPF0015 analyzer rule detects when a DependencyProperty is registered with an owner type that does not inherit from DependencyObject. This typically occurs when attempting to register an attached property using DependencyProperty.Register instead of DependencyProperty.RegisterAttached (or RegisterAttachedReadOnly).

To fix this violation, you have two primary options:

1. Use Attached Property Registration: If the owner type is a static class (which cannot inherit from DependencyObject), change the registration method to DependencyProperty.RegisterAttached or DependencyProperty.RegisterAttachedReadOnly.
2. Inherit from DependencyObject: If the owner type is intended to be a standard property owner, ensure the class inherits from System.Windows.DependencyObject.

using System.Windows;

public static class Foo
{
    // FIX: Use RegisterAttached instead of Register for static classes
    public static readonly DependencyProperty BarProperty = DependencyProperty.RegisterAttached(
        "Bar",
        typeof(int), 
        typeof(Foo), 
        new FrameworkPropertyMetadata(
            default(int), 
            FrameworkPropertyMetadataOptions.Inherits));

    public static void SetBar(DependencyObject element, int value)
    {
        element.SetValue(BarProperty, value);
    }

    public static int GetBar(DependencyObject element)
    {
        return (int) element.GetValue(BarProperty);
    }
}

You can suppress WPF0010 violations using several methods:

1. #pragma directive: Disable the warning for a specific block of code or for the entire file.
2. [SuppressMessage] attribute: Use the System.Diagnostics.CodeAnalysis.SuppressMessage attribute to suppress the warning with a specific justification.
3. Ruleset file: Configure the severity via a standard .NET ruleset file.

// Using #pragma to disable/restore for a specific block
#pragma warning disable WPF0010 // Default value type must match registered type
Code violating the rule here
#pragma warning restore WPF0010 // Default value type must match registered type

// Or disable for the whole file
#pragma warning disable WPF0010

// Using [SuppressMessage] attribute
[System.Diagnostics.CodeAnalysis.SuppressMessage("WpfAnalyzers.DependencyProperty", 
    "WPF0010:Default value type must match registered type", 
    Justification = "Reason...")]

The WPF0007 rule ensures that the ValidateValueCallback method name matches the name of the Dependency Property it is validating. This is a stylistic rule to improve code readability and maintainability.

Violation Example: If you register a property named Bar but provide a callback named WrongName, a violation is triggered.

How to fix: Rename the callback method so that it includes the property name (e.g., if the property is Bar, name the callback BarValidateValue).

public class FooControl : Control
{
    public static readonly DependencyProperty BarProperty = DependencyProperty.Register(
        nameof(Bar),
        typeof(int),
        typeof(FooControl),
        new PropertyMetadata(default(int)),
        BarValidateValue); // Callback name matches property name

    public int Bar
    {
        get { return (int)this.GetValue(BarProperty); }
        set { this.SetValue(BarProperty, value); }
    }

    private static bool BarValidateValue(object value)
    {
        return (int)value >= 0;
    }
}

The WPF0006 rule ensures that the name of a CoerceValueCallback method matches the name of the DependencyProperty it is registered with. This is a stylistic rule to improve code readability and maintainability in WPF development.

Violation Example: If you register a property named BarProperty but provide a callback named WrongName, a violation is triggered.

How to fix: Rename the callback method to follow the pattern Coerce[PropertyName] (e.g., CoerceBar).

// Correct implementation
public class FooControl : Control
{
    public static readonly DependencyProperty BarProperty = DependencyProperty.Register(
        nameof(Bar),
        typeof(int),
        typeof(FooControl),
        new PropertyMetadata(
            default(int),
            null,
            CoerceBar)); // Name matches the property 'Bar'

    public int Bar
    {
        get { return (int)this.GetValue(BarProperty); }
        set { this.SetValue(BarProperty, value); }
    }

    private static object CoerceBar(DependencyObject d, object baseValue)
    {
        return baseValue;
    }
}

The WPF0003 analyzer ensures that the name of a CLR property accessor matches the name used when registering its corresponding DependencyProperty. While technically legal to use different names, mismatching them creates a confusing API that violates standard WPF conventions.

Violation Example: In the example below, the DependencyProperty is registered as Title, but the CLR property is named HighlightBrush.

using System.Windows;
public class MyControl : FrameworkElement
{
    public static readonly DependencyProperty TitleProperty = DependencyProperty.Register(
        nameof(Title),
        typeof(string),
        typeof(MyControl),
        new PropertyMetadata(default(string)));

    public string HighlightBrush
    {
        get { return (string)this.GetValue(TitleProperty); }
        set { this.SetValue(TitleProperty, value); }
    }
}

Correct Implementation: Rename the CLR property to match the registered name (Title).

using System.Windows;
public class MyControl : FrameworkElement
{
    public static readonly DependencyProperty TitleProperty = DependencyProperty.Register(
        nameof(Title),
        typeof(string),
        typeof(MyControl),
        new PropertyMetadata(default(string)));

    public string Title
    {
        get { return (string)this.GetValue(TitleProperty); }
        set { this.SetValue(TitleProperty, value); }
    }
}