Vzory bezpečného konstruktoru pro DependencyObjects (WPF .NET)

Ve spravovaném programování kódu existuje obecný princip, který často vynucuje nástroje pro analýzu kódu, že konstruktory tříd by neměly volat přepisovatelné metody. Pokud je přepisovatelná metoda volána konstruktorem základní třídy a odvozená třída přepíše tuto metodu, pak přepsaná metoda v odvozené třídě může být spuštěna před tím, než se zavolá konstruktor odvozené třídy. Pokud konstruktor odvozené třídy provádí inicializaci třídy, pak odvozená třída metoda může přistupovat k neinicializovaným členům třídy. Třídy vlastností závislostí by se měly vyhnout nastavení hodnot vlastností závislostí v konstruktoru třídy, aby nedocházelo k problémům s inicializací modulu runtime. Tento článek popisuje, jak implementovat DependencyObject konstruktory způsobem, který se těmto problémům vyhne.

Virtuální metody a zpětná volání systému vlastností

Virtuální metody a zpětná volání vlastností závislostí jsou součástí systému vlastností Windows Presentation Foundation (WPF) a rozšiřují všestrannost vlastností závislostí.

Základní operace, jako je nastavení hodnoty vlastnosti závislosti pomocí SetValue, vyvolá událost OnPropertyChanged a potenciálně několik zpětných volání systému vlastností WPF.

OnPropertyChanged je příkladem virtuální metody systému vlastností WPF, kterou lze přepsat třídami, které mají DependencyObject v hierarchii dědičnosti. Pokud v konstruktoru, který se volá během vytváření instance vaší vlastní třídy závislostní vlastnosti, nastavíte hodnotu této vlastnosti a odvozená třída z ní přepíše virtuální metodu OnPropertyChanged, pak se metoda OnPropertyChanged této odvozené třídy spustí před jakýmkoli konstruktorem této odvozené třídy.

PropertyChangedCallback a CoerceValueCallback jsou příklady zpětných volání systému vlastností WPF, které lze zaregistrovat třídami vlastností závislostí a přepsat třídami, které z nich jsou odvozeny. Pokud nastavíte hodnotu závislostní vlastnosti v konstruktoru vlastní třídy závislostní vlastnosti a třída, která je odvozena z ní, přepíše jedno z těchto zpětných volání v metadatech vlastností, pak se zpětné volání v odvozené třídě spustí před jakýmkoli konstruktorem odvozené třídy. Tento problém není relevantní pro ValidateValueCallback, protože není součástí metadat vlastností a je možné ho zadat pouze registrací třídy.

Další informace o zpětném volání vlastností závislostí najdete v tématu Zpětné volání vlastností závislostí a ověřování.

Analyzátory .NET

Analyzátory platformy kompilátoru .NET kontrolují problémy s kvalitou a stylem kódu jazyka C# nebo Visual Basic. Pokud voláte přepisovatelné metody, když je v konstruktoru aktivní pravidlo analyzátoru CA2214, zobrazí se upozornění CA2214: Don't call overridable methods in constructors. Pravidlo ale nebude označovat virtuální metody a zpětná volání, která jsou vyvolána základním systémem vlastností WPF, když je hodnota vlastnosti závislosti nastavena v konstruktoru.

Problémy způsobené odvozenými třídami

Pokud zapečetíte svou vlastní třídu vlastnosti závislosti nebo jinak víte, že z vaší třídy nebude odvozováno, pak se na tuto třídu nevztahují problémy při inicializaci odvozených tříd za běhu. Pokud ale vytvoříte třídu vlastností závislostí, která je zděděná, například pokud vytváříte šablony nebo sadu rozšiřitelné knihovny ovládacích prvků, vyhněte se volání přepisovatelných metod nebo nastavení hodnot vlastností závislostí z konstruktoru.

Následující testovací kód ukazuje nebezpečný vzor konstruktoru, kde konstruktor základní třídy nastaví hodnotu vlastnosti závislosti, čímž aktivuje volání virtuálních metod a zpětné volání.

    private static void TestUnsafeConstructorPattern()
    {
        //Aquarium aquarium = new();
        //Debug.WriteLine($"Aquarium temperature (C): {aquarium.TempCelcius}");

        // Instantiate and set tropical aquarium temperature.
        TropicalAquarium tropicalAquarium = new(tempCelcius: 25);
        Debug.WriteLine($"Tropical aquarium temperature (C): " +
            $"{tropicalAquarium.TempCelcius}");

        /* Test output:
        Derived class static constructor running.
        Base class ValidateValueCallback running.
        Base class ValidateValueCallback running.
        Base class ValidateValueCallback running.
        Base class parameterless constructor running.
        Base class ValidateValueCallback running.
        Derived class CoerceValueCallback running.
        Derived class CoerceValueCallback: null reference exception.
        Derived class OnPropertyChanged event running.
        Derived class OnPropertyChanged event: null reference exception.
        Derived class PropertyChangedCallback running.
        Derived class PropertyChangedCallback: null reference exception.
        Aquarium temperature (C): 20
        Derived class parameterless constructor running.
        Derived class parameter constructor running.
        Base class ValidateValueCallback running.
        Derived class CoerceValueCallback running.
        Derived class OnPropertyChanged event running.
        Derived class PropertyChangedCallback running.
        Tropical aquarium temperature (C): 25
        */
    }
}

public class Aquarium : DependencyObject
{
    // Register a dependency property with the specified property name,
    // property type, owner type, property metadata with default value,
    // and validate-value callback.
    public static readonly DependencyProperty TempCelciusProperty =
        DependencyProperty.Register(
            name: "TempCelcius",
            propertyType: typeof(int),
            ownerType: typeof(Aquarium),
            typeMetadata: new PropertyMetadata(defaultValue: 0),
            validateValueCallback: 
                new ValidateValueCallback(ValidateValueCallback));

    // Parameterless constructor.
    public Aquarium()
    {
        Debug.WriteLine("Base class parameterless constructor running.");

        // Set typical aquarium temperature.
        TempCelcius = 20;

        Debug.WriteLine($"Aquarium temperature (C): {TempCelcius}");
    }

    // Declare public read-write accessors.
    public int TempCelcius
    {
        get => (int)GetValue(TempCelciusProperty);
        set => SetValue(TempCelciusProperty, value);
    }

    // Validate-value callback.
    public static bool ValidateValueCallback(object value)
    {
        Debug.WriteLine("Base class ValidateValueCallback running.");
        double val = (int)value;
        return val >= 0;
    }
}

public class TropicalAquarium : Aquarium
{
    // Class field.
    private static List<int> s_temperatureLog;

    // Static constructor.
    static TropicalAquarium()
    {
        Debug.WriteLine("Derived class static constructor running.");

        // Create a new metadata instance with callbacks specified.
        PropertyMetadata newPropertyMetadata = new(
            defaultValue: 0,
            propertyChangedCallback: new PropertyChangedCallback(PropertyChangedCallback),
            coerceValueCallback: new CoerceValueCallback(CoerceValueCallback));

        // Call OverrideMetadata on the dependency property identifier.
        TempCelciusProperty.OverrideMetadata(
            forType: typeof(TropicalAquarium),
            typeMetadata: newPropertyMetadata);
    }

    // Parameterless constructor.
    public TropicalAquarium()
    {
        Debug.WriteLine("Derived class parameterless constructor running.");
        s_temperatureLog = new List<int>();
    }

    // Parameter constructor.
    public TropicalAquarium(int tempCelcius) : this()
    {
        Debug.WriteLine("Derived class parameter constructor running.");
        TempCelcius = tempCelcius;
        s_temperatureLog.Add(tempCelcius);
    }

    // Property-changed callback.
    private static void PropertyChangedCallback(DependencyObject depObj, 
        DependencyPropertyChangedEventArgs e)
    {
        Debug.WriteLine("Derived class PropertyChangedCallback running.");
        try
        {
            s_temperatureLog.Add((int)e.NewValue);
        }
        catch (NullReferenceException)
        {
            Debug.WriteLine("Derived class PropertyChangedCallback: null reference exception.");
        }
    }

    // Coerce-value callback.
    private static object CoerceValueCallback(DependencyObject depObj, object value)
    {
        Debug.WriteLine("Derived class CoerceValueCallback running.");
        try
        {
            s_temperatureLog.Add((int)value);
        }
        catch (NullReferenceException)
        {
            Debug.WriteLine("Derived class CoerceValueCallback: null reference exception.");
        }
        return value;
    }

    // OnPropertyChanged event.
    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
    {
        Debug.WriteLine("Derived class OnPropertyChanged event running.");
        try
        {
            s_temperatureLog.Add((int)e.NewValue);
        }
        catch (NullReferenceException)
        {
            Debug.WriteLine("Derived class OnPropertyChanged event: null reference exception.");
        }

        // Mandatory call to base implementation.
        base.OnPropertyChanged(e);
    }
}

    Private Shared Sub TestUnsafeConstructorPattern()
        'Aquarium aquarium = new Aquarium();
        'Debug.WriteLine($"Aquarium temperature (C): {aquarium.TempCelcius}");

        ' Instantiate And set tropical aquarium temperature.
        Dim tropicalAquarium As New TropicalAquarium(tempCelc:=25)
        Debug.WriteLine($"Tropical aquarium temperature (C): 
            {tropicalAquarium.TempCelcius}")

        ' Test output:
        ' Derived class static constructor running.
        ' Base class ValidateValueCallback running.
        ' Base class ValidateValueCallback running.
        ' Base class ValidateValueCallback running.
        ' Base class parameterless constructor running.
        ' Base class ValidateValueCallback running.
        ' Derived class CoerceValueCallback running.
        ' Derived class CoerceValueCallback: null reference exception.
        ' Derived class OnPropertyChanged event running.
        ' Derived class OnPropertyChanged event: null reference exception.
        ' Derived class PropertyChangedCallback running.
        ' Derived class PropertyChangedCallback: null reference exception.
        ' Aquarium temperature(C):  20
        ' Derived class parameterless constructor running.
        ' Derived class parameter constructor running.
        ' Base class ValidateValueCallback running.
        ' Derived class CoerceValueCallback running.
        ' Derived class OnPropertyChanged event running.
        ' Derived class PropertyChangedCallback running.
        ' Tropical Aquarium temperature (C): 25

    End Sub
End Class

Public Class Aquarium
    Inherits DependencyObject

    'Register a dependency property with the specified property name,
    ' property type, owner type, property metadata with default value,
    ' and validate-value callback.
    Public Shared ReadOnly TempCelciusProperty As DependencyProperty =
        DependencyProperty.Register(
        name:="TempCelcius",
        propertyType:=GetType(Integer),
        ownerType:=GetType(Aquarium),
        typeMetadata:=New PropertyMetadata(defaultValue:=0),
        validateValueCallback:=
            New ValidateValueCallback(AddressOf ValidateValueCallback))

    ' Parameterless constructor.
    Public Sub New()
        Debug.WriteLine("Base class parameterless constructor running.")

        ' Set typical aquarium temperature.
        TempCelcius = 20

        Debug.WriteLine($"Aquarium temperature (C): {TempCelcius}")
    End Sub

    ' Declare public read-write accessors.
    Public Property TempCelcius As Integer
        Get
            Return GetValue(TempCelciusProperty)
        End Get
        Set(value As Integer)
            SetValue(TempCelciusProperty, value)
        End Set
    End Property

    ' Validate-value callback.
    Public Shared Function ValidateValueCallback(value As Object) As Boolean
        Debug.WriteLine("Base class ValidateValueCallback running.")
        Dim val As Double = CInt(value)
        Return val >= 0
    End Function

End Class

Public Class TropicalAquarium
    Inherits Aquarium

    ' Class field.
    Private Shared s_temperatureLog As List(Of Integer)

    ' Static constructor.
    Shared Sub New()
        Debug.WriteLine("Derived class static constructor running.")

        ' Create a new metadata instance with callbacks specified.
        Dim newPropertyMetadata As New PropertyMetadata(
                defaultValue:=0,
                propertyChangedCallback:=
                    New PropertyChangedCallback(AddressOf PropertyChangedCallback),
                coerceValueCallback:=
                    New CoerceValueCallback(AddressOf CoerceValueCallback))

        ' Call OverrideMetadata on the dependency property identifier.
        TempCelciusProperty.OverrideMetadata(
                forType:=GetType(TropicalAquarium),
                typeMetadata:=newPropertyMetadata)
    End Sub

    ' Parameterless constructor.
    Public Sub New()
        Debug.WriteLine("Derived class parameterless constructor running.")
        s_temperatureLog = New List(Of Integer)()
    End Sub

    ' Parameter constructor.
    Public Sub New(tempCelc As Integer)
        Me.New()
        Debug.WriteLine("Derived class parameter constructor running.")
        TempCelcius = tempCelc
        s_temperatureLog.Add(TempCelcius)
    End Sub

    ' Property-changed callback.
    Private Shared Sub PropertyChangedCallback(depObj As DependencyObject,
        e As DependencyPropertyChangedEventArgs)
        Debug.WriteLine("Derived class PropertyChangedCallback running.")

        Try
            s_temperatureLog.Add(e.NewValue)
        Catch ex As NullReferenceException
            Debug.WriteLine("Derived class PropertyChangedCallback: null reference exception.")
        End Try
    End Sub

    ' Coerce-value callback.
    Private Shared Function CoerceValueCallback(depObj As DependencyObject, value As Object) As Object
        Debug.WriteLine("Derived class CoerceValueCallback running.")

        Try
            s_temperatureLog.Add(value)
        Catch ex As NullReferenceException
            Debug.WriteLine("Derived class CoerceValueCallback: null reference exception.")
        End Try

        Return value
    End Function

    ' OnPropertyChanged event.
    Protected Overrides Sub OnPropertyChanged(e As DependencyPropertyChangedEventArgs)
        Debug.WriteLine("Derived class OnPropertyChanged event running.")

        Try
            s_temperatureLog.Add(e.NewValue)
        Catch ex As NullReferenceException
            Debug.WriteLine("Derived class OnPropertyChanged event: null reference exception.")
        End Try

        ' Mandatory call to base implementation.
        MyBase.OnPropertyChanged(e)
    End Sub

End Class

Pořadí, ve kterém se volají metody v testu nebezpečného konstruktorového vzoru, je:

1. Statický konstruktor odvozené třídy, který přepisuje metadata závislé vlastnosti Aquarium za účelem registrace PropertyChangedCallback a CoerceValueCallback.

2. Konstruktor základní třídy, který nastaví novou hodnotu vlastnosti závislosti, což vede k volání metody SetValue. Volání SetValue aktivuje zpětná volání a události v následujícím pořadí:

   1. ValidateValueCallback, který je implementován v základní třídě. Toto zpětné volání není součástí metadat vlastností závislostí a nelze je implementovat do odvozené třídy přepsáním metadat.

   2. PropertyChangedCallback, který je implementován v odvozené třídě přepsáním metadat vlastnosti závislosti. Toto zpětné volání způsobí výjimku nulového odkazu, když volá metodu na poli třídy, která není inicializována s_temperatureLog.

   3. CoerceValueCallback, který je implementován v odvozené třídě přepsáním metadat vlastností závislostí. Toto zpětné volání způsobí výjimku nulového odkazu, když volá metodu v poli neinicializované třídy s_temperatureLog.

   4. Událost OnPropertyChanged, která je implementována v odvozené třídě přepsáním virtuální metody. Tato událost způsobí výjimku nulového odkazu, když se pokusí zavolat metodu na nezainicializovaném třídním poli s_temperatureLog.

3. Konstruktor bez parametrů odvozené třídy, který inicializuje s_temperatureLog.

4. Konstruktor parametrů odvozené třídy, který nastaví novou hodnotu vlastnosti závislosti, což vede k dalšímu volání SetValue metody. Vzhledem k tomu, že s_temperatureLog je nyní inicializován, zpětná volání a události budou probíhat, aniž by způsobily výjimky z důvodu nulového odkazu.

Tyto problémy s inicializací se dají vyhnout použitím vzorů bezpečného konstruktoru.

Vzory bezpečného konstruktoru

Problémy inicializace odvozené třídy demonstrované v testovacím kódu je možné vyřešit různými způsoby, mezi které patří:

• Vyhněte se nastavení hodnoty vlastnosti závislosti v konstruktoru vlastní třídy vlastností závislostí, pokud vaše třída může být použita jako základní třída. Pokud potřebujete inicializovat hodnotu vlastnosti závislosti, zvažte nastavení požadované hodnoty jako výchozí hodnoty v metadatech vlastností během registrace vlastnosti závislosti nebo při přepsání metadat.

• Inicializujte odvozená pole třídy před jejich použitím. Například použití některého z těchto přístupů:

  • Vytvořte instanci a instanční pole přiřaďte v jednom příkazu. V předchozím příkladu by příkaz List<int> s_temperatureLog = new(); zabránil pozdnímu přiřazení.

  • Proveďte přiřazení v statickém konstruktoru odvozené třídy, který běží před libovolným konstruktorem základní třídy. V předchozím příkladu by vložení příkazu přiřazení s_temperatureLog = new List<int>(); do statického konstruktoru odvozené třídy zabránilo pozdnímu přiřazení.

  • Použijte opožděnou inicializaci a instanciaci, což znamená, že objekty se inicializují, když jsou potřeba. V předchozím příkladu by vytvoření instance a přiřazení s_temperatureLog pomocí opožděné inicializace zabránilo pozdnímu přiřazení. Další informace naleznete v tématu Opožděná inicializace.

• Nepoužívejte neinicializované proměnné třídy v zpětných voláních a událostech systému vlastností WPF.

Viz také

• OnPropertyChanged
• PropertyChangedCallback
• CoerceValueCallback
• ValidateValueCallback
• zpětné volání a ověřování vlastností závislostí
• Uživatelské vlastnosti závislostí
• Přehled vlastností závislosti
• zabezpečení vlastnosti závislosti