Der Standardwert des Attributs kann die Gültigkeit des Attributs sicherstellen.
Die Gültigkeit der Attributüberprüfung kann verwendet werden, um die Eingabeattribute und obligatorischen Attributrückrufe zu überprüfen, d. h. Benachrichtigungen müssen unabhängig davon erfolgen, ob sich die Attribute geändert haben oder nicht.
Benachrichtigung über Attributänderungen: Wenn sich ein Attribut ändert, kann das Programm benachrichtigt werden, um eine Reihe von Prozessen auszuführen.
An WPF ist hier nichts auszusetzen. Sehen wir uns an, wie Abhängigkeitseigenschaften die oben genannten Probleme lösen.
Die Inhaltszusammenfassung definiert die ersten und einfachsten Abhängigkeitsattribute, Abhängigkeitsattributwerte, Basisoperationsattribut-Wrapper-Attributmetadaten (PropertyMetadata).
Grundlegendes Verhalten von Attributmetadaten
Obwohl die ursprünglichen Worte von MSDN unverblümt sind, besteht kein Zweifel an ihrer Richtigkeit. Sobald Sie es verstanden haben, werden Sie beim Betrachten eine andere Erfahrung machen.
1. Definieren Sie das erste und einfachste Abhängigkeitsattribut
MSDN-Originalwörter: Windows Presentation Foundation (WPF) stellt eine Reihe von Diensten bereit, mit denen die Funktionalität von CLR-Eigenschaften (Common Language Runtime) erweitert werden kann. Diese Dienste werden häufig zusammenfassend als WPF-Eigenschaftssystem bezeichnet. Vom WPF-Eigenschaftensystem unterstützte Eigenschaften werden als Abhängigkeitseigenschaften bezeichnet.
Definieren wir ein Altersabhängigkeitsattribut wie folgt:
öffentliche Klasse DPCustomPeople
{
public static readonly DependencyProperty AgeProperty =
DependencyProperty.Register("Age", typeof(int), typeof(DPCustomPeople));
public void DisplayAgeProperty()
{
Console.WriteLine("DPName:" + DPCustomPeople.AgeProperty.Name);
Console.WriteLine("DPPropertyType:" + DPCustomPeople.AgeProperty.PropertyType);
Console.WriteLine("DPOWnerType:" + DPCustomPeople.AgeProperty.OwnerType);
}
}
Rufen Sie dann das Ausgabeergebnis auf
Klassenprogramm
{
static void Main(string[] args)
{
DPCustomPeople people = new DPCustomPeople();
people.DisplayAgeProperty();
}
}
Möglicherweise sind Sie mit der DependencyProperty-Klasse nicht vertraut. Die DependencyProperty-Klasse stellt einige grundlegende Merkmale von Abhängigkeitseigenschaften bereit.
Die Möglichkeit, eine Abhängigkeitseigenschaft zu registrieren, besteht darin, die statische Register-Methode von DependencyProperty aufzurufen, die mehrere überladene Methoden bereitstellt. Die folgenden drei Schritte sind jedoch erforderlich. Sobald die Registrierung abgeschlossen ist, handelt es sich um eine statische Eigenschaft
Geben Sie den registrierten Namen (Name) „Alter“ an.
Registrieren Sie den Eigenschaftstyp (PropertyType) typeof (int)
Registrieren Sie den Besitzertyp des Abhängigkeitsattributs (OwnerType) typeof (DPCustomPeople)
Hinweis: Der Attributname, der Attributtyp und der Attributbesitzertyp können nach der Registrierung nicht mehr geändert werden.
Das Folgende ist das Ausgabeergebnis
2. Grundoperationen abhängiger Attributwerte (Werterfassung und -zuweisung)
Nach der Definition der Age-Abhängigkeitseigenschaft sollten wir in der Lage sein, Werterfassungs- und Zuweisungsvorgänge für die Eigenschaft durchzuführen. DependencyProperty selbst stellt diese Vorgänge nicht bereit, sondern wird von DependencyObject verarbeitet.
DependencyObject stellt ein Objekt dar, das am Abhängigkeitseigenschaftensystem teilnimmt.
Daher ist es erforderlich, dass die definierte Klasse von DependencyObject erbt und dann DPCustomPeople neu schreibt
öffentliche Klasse DPCustomPeople:System.Windows.DependencyObject
{
}
Grundlegende Wertzuweisungsoperationen: GetValue- und SetValue-Methoden
public void DPPropertyBasicOperator()
{
Console.WriteLine("Alter:" + this.GetValue(DPCustomPeople.AgeProperty));
this.SetValue(DPCustomPeople.AgeProperty, 24);
Console.WriteLine("ChangedAge:" + this.GetValue(DPCustomPeople.AgeProperty));
}
Ergebnisse ausgeben
3. Der Attribut-Wrapper verwendet die Methoden GetValue und SetValue, um Werte zu bearbeiten, damit wir ihn umschließen und das Age-Attribut definieren können.
öffentliches Int. Alter
{
get { return (int)GetValue(AgeProperty);
set { SetValue(AgeProperty, value);
}
Hinweis: Die Namenskonvention für die Verpackung abhängiger Eigenschaften besteht darin, die folgende Eigenschaft zu entfernen
public void DPPropertyBasicOperatorUsingProperty()
{
Console.WriteLine("Alter:" + this.Age);
this.Age=24;
Console.WriteLine("ChangedAge:" + this.Age);
}
Sieht der obige Code prägnanter aus?
4. Eigenschaftsmetadaten (PropertyMetadata)
MSDN-Original: Das Eigenschaftensystem der Windows Presentation Foundation (WPF) umfasst ein Metadaten-Berichtssystem, das nicht auf das beschränkt ist, was über eine Eigenschaft durch Reflektion oder reguläre CLR-Funktionen (Common Language Runtime) gemeldet werden kann.
Wenn man von Attributmetadaten spricht, fällt mir als Erstes das Attribut von .net ein
Person der öffentlichen Klasse
{
[DefaultValue(200),Category("Layout")]
public int Breite { get;
}
Attribute müssen die Leistungsfähigkeit von Visual Studio nutzen, um die IDE-freundliche Unterstützung für Attribute bereitzustellen, oder sich auf Reflektion verlassen, um Werte zuzuweisen.
Ohne diese Technologien wird jedoch über normale Kanäle eine neue Instanz erstellt, und das Hinzufügen von Attributen hat keine Auswirkung. Wir können uns nicht auf diese Attribute verlassen, um einige grundlegende Eigenschaften der Attribute sicherzustellen (z. B. auf die Attributmetadaten). Attribute. Anders als die oben beschriebenen Metadaten.
Metadaten für Abhängigkeitseigenschaften
Kann durch die Klasse, in der die Abhängigkeitseigenschaft definiert ist, eindeutig angegeben werden. Kann geändert werden, wenn die Abhängigkeitseigenschaft einer anderen Klasse hinzugefügt wird. Kann von allen abgeleiteten Klassen, die die Abhängigkeitseigenschaft von der definierenden Basisklasse erben, explizit überschrieben werden. Die obige Sprache ist unverblümt: Aber es erklärt die Absicht. Aber wir können die Gedanken des Designers nicht immer zuerst verstehen.
5. Grundlegendes Verhalten von Attributmetadaten Das grundlegende Verhalten von Attributmetadaten bietet drei Funktionen für abhängige Attribute. Dies ist auch das Problem, das gerade in diesem Artikel angesprochen wurde.
Standard-Property-Metadata-Eigenschaft Obligatorischer Rückruf Werfen wir zunächst einen Blick auf den Konstruktor eines vollständigen PropertyMetadata. Wenn die Standard-PropertyMetadata nicht für die abhängige Eigenschaft festgelegt ist, wird intern automatisch ein PropertyMetadata-Objekt für die abhängige Eigenschaft erstellt.
öffentliche PropertyMetadata(Objekt defaultValue, PropertyChangedCallback propertyChangedCallback, CoerceValueCallback coerceValueCallback)
Abhängige Attribute übernehmen das Konzept der Attributmetadaten, um Attributstandardwerte, Attributbenachrichtigungen, erzwungene Rückrufe und andere Verhaltensweisen zu vervollständigen
1.Standardwert des Attributs
public static readonly DependencyProperty NameProperty =
DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople),
new PropertyMetadata(string.Empty));
Die meisten Leute werden eine Frage haben, wenn sie dies sehen: Warum PropertyMetadata verwenden, um einen Standardwert festzulegen?
public static readonly DependencyProperty NameProperty =
DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople),
string.Empty);
Natürlich beschäftigt mich diese Frage schon seit langem und es gibt nichts, was ich tun kann, wenn ich sie nicht lösen kann, also lasse ich sie erst einmal in Ruhe.
Hinweis: Beim Zuweisen eines Standardwerts zu einer Eigenschaft in PropertyMetadata kann die Typkorrektheit nicht erkannt werden.
Eine solche Definition ist erwähnenswert, da der Standardwert des DP-Codesegments in vs 0 ist
public static readonly DependencyProperty NameProperty =
DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople),
new UIPropertyMetadata(0));
2. Attribut-Standardwert-Wiederherstellungsvorgang
Nachdem der Eigenschaft ein Wert zugewiesen wurde, können Sie den Standardwert über die ClearValue-Methode von DependencyObject wiederherstellen, wie im folgenden Code gezeigt
öffentlicher String-Name
{
get { return (string)GetValue(NameProperty);
set { SetValue(NameProperty, value);
}
public static readonly DependencyProperty NameProperty =
DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople),
new UIPropertyMetadata(string.Empty));
public void DPPropertyClearOperator()
{
Console.WriteLine("Name:" + this.Name);
this.Name="Terry";
Console.WriteLine("ChangedName:" + this.Name);
this.ClearValue(NameProperty);
Console.WriteLine("Name:" + this.Name);
}
Ergebnisse ausgeben
Hinweis: Unterscheiden Sie zwischen Standardzuweisung und Standardwert
Die Standardzuweisung erfolgt normalerweise im Konstruktor, dies ist jedoch nicht der Standardwert (dies galt vor dem Aufkommen von Abhängigkeitseigenschaften), insbesondere wenn abgeleitete Klassen Eigenschaften überschreiben.
öffentliche Klasse Student: DPCustomPeople
{
publicStudent()
{
this.Name = "Sky";
}
public void TestSubDefaultDpValue()
{
Console.WriteLine("Löschen vor:"+this.Name);
this.ClearValue(Student.NameProperty);
Console.WriteLine("Löschen nach:" + this.Name);
}
}
Ergebnisse ausgeben
3. Benachrichtigung über Eigentumsänderungen
Diese Funktion wird am häufigsten verwendet, wenn sich der Eigenschaftswert ändert.
öffentlicher Bool IsBoy
{
get { return (bool)GetValue(IsBoyProperty);
set { SetValue(IsBoyProperty, value);
}
öffentliche statische schreibgeschützte DependencyProperty IsBoyProperty =
DependencyProperty.Register("IsBoy", typeof(bool), typeof(Student),
new UIPropertyMetadata(false,new PropertyChangedCallback(IsBoyPropertyChangedCallback)));
public static void IsBoyPropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Student st = d als Student;
if (st.IsBoy)
{
Console.WriteLine("Hallo, Junge");
}
anders
{
Console.WriteLine("Hallo,Mädchen");
}
}
public void TestPropertyChangedCallback()
{
this.IsBoy = false;
this.IsBoy = true; this.IsBoy = true;
}
Sie können die Ausgabeergebnisse des alten Werts und des neuen Werts über DependencyPropertyChangedEventArgs anzeigen
Notiz:
(1). Haben Sie anhand der obigen Ausgabeergebnisse gesehen, dass der Standardwert abhängiger Eigenschaften keine Benachrichtigungen über Eigenschaftsänderungen auslöst?
(2). Attributänderungsbenachrichtigungen manuell auslösen
Wenn Sie möchten, dass der Standardwert eine Eigenschaftsänderung auslöst (manchmal ist dies tatsächlich notwendig), müssen Sie nicht warten und die Änderung manuell auslösen.
private void RaiseIsBoyPropertyChangedCallback()
{
IsBoyPropertyChangedCallback(this,new DependencyPropertyChangedEventArgs
(Student.IsBoyProperty, Student.IsBoyProperty.DefaultMetadata.DefaultValue, null));
}
(3) Stellen Sie bei einer Attributänderungsbenachrichtigung sicher, dass der Standardwerttyp des Attributs korrekt ist.
Wir wissen, dass Werttypen Standardwerte haben, Referenztypen jedoch nicht (das heißt, sie können mit dem Standardschlüsselwort überprüft werden, ob sie einen Standardtyp haben).
Wir schreiben den Standardwert der oben definierten Abhängigkeitseigenschaft auf Null um. Es kann gut ausgeführt werden, wenn kein PropertyChangedCallback vorhanden ist. Wenn jedoch eine Eigenschaftsänderungsbenachrichtigung vorliegt, tritt eine Katastrophe auf und das Programm löst eine Ausnahme aus, die besagt, dass dies bei dem Typ nicht der Fall ist übereinstimmen.
öffentliche statische schreibgeschützte DependencyProperty IsBoyProperty =
DependencyProperty.Register("IsBoy", typeof(bool), typeof(Student),
new UIPropertyMetadata(null,new PropertyChangedCallback(IsBoyPropertyChangedCallback)));
Schauen wir uns den Referenztyp noch einmal an. Wenn der Standardwert null ist, ist alles in Ordnung.
öffentliche IList LovedGirl
{
get { return (IList)GetValue(LovedGirlProperty);
set { SetValue(LovedGirlProperty, value);
}
öffentlich statisch schreibgeschützt DependencyProperty LovedGirlProperty =
DependencyProperty.Register("LovedGirl", typeof(IList), typeof(Student),
new UIPropertyMetadata(null, new PropertyChangedCallback(LovedGirlChangedCallback)));
public static void LovedGirlChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Student st = d als Student;
foreach (var-Element in e.NewValue als IList)
{
Console.WriteLine(item);
}
}
public void TestReferenceDpType()
{
List<string> list = new List<string>();
list.Add("Mädchen 1");
list.Add("Mädchen 2");
this.LovedGirl = Liste;
}
4. Erzwungener Attributrückruf
Erstens löst der Standardwert die Rückrufmethode immer noch nicht aus.
Die erzwungene Rückrufmethode bedeutet, dass unabhängig davon, ob sich der Attributwert ändert oder nicht, die Rückrufmethode eingegeben wird.
public int Ergebnis
{
get { return (int)GetValue(ScoreProperty);
set { SetValue(ScoreProperty, value);
}
öffentliche statische schreibgeschützte DependencyProperty ScoreProperty =
DependencyProperty.Register("Score", typeof(int), typeof(Student),
new UIPropertyMetadata(0,null,new CoerceValueCallback(ScoreCoerceValueCallback)));
öffentliches statisches Objekt ScoreCoerceValueCallback(DependencyObject d, Objekt baseValue)
{
Console.WriteLine(baseValue);
return baseValue;
}
public void TestCoerceValueCallback()
{
this.Score = 0;
this.Score = 0;
this.Score = 0;
}