Erstellen von benutzerdefinierten Auslösern und Aktionen
Triggers und Actions modellieren Ursache-und-Wirkung-Beziehungen. Ein Trigger reagiert auf die Ursache und ruft eine oder mehrere Actions auf.
Erstellen von Auslösern
Ein Trigger ist ein Objekt, das auf eine bestimmte Bedingung reagiert, wie z. B. auf einen bestimmten Wert festgelegte Ereignisauslöser oder Eigenschaften, und das als Reaktion eine oder mehrere zugeordnete Actions aufruft. Triggers können EventTrigger sein, die eine Action auslösen, wenn ein Maus- oder Tastaturereignis ausgelöst wird, oder CollisionTrigger , die eine Action auslösen, wenn zwei Objekte miteinander kollidieren. Triggers sind beliebig erweiterbar. Sie können bei Bedarf also auch benutzerdefinierte Auslöser erstellen. Ein Trigger muss eine grundlegende Syntax enthalten, um von den Behaviors zur Laufzeit erkannt zu werden.
Das folgende Codebeispiel zeigt einen Basis- Trigger :
public class Trigger1 : TriggerBase<DependencyObject>
{
protected override void OnAttached()
{
base.OnAttached();
// Insert code that you want to run when the Trigger is attached to an object.
}
protected override void OnDetaching()
{
base.OnDetaching();
// Insert code that you want to run when the Trigger is removed from an object.
}
//
// To invoke any associated Actions when this Trigger gets called, use
// this.InvokeActions(o), where o is an object that you can pass in as a parameter.
//
}
Im oben stehenden Codebeispiel wird die Klasse ab TriggerBase erweitert. Dieser Typ wird in der Datei "System.Windows.Interactivity.dll" bereitgestellt. Nachdem die Klasse ab der TriggerBase -Klasse erweitert wurde, können Sie die Methoden OnAttached und OnDetaching wie im Codebeispiel gezeigt außer Kraft setzen.
OnDetaching wird unmittelbar vor der Trennung des Trigger von seiner AssociatedObject -Eigenschaft aufgerufen. Das Objekt ist somit nach wie vor über den Bereich des Trigger verfügbar, sodass Ihr Code weiterhin darauf angewendet werden kann, bis OnDetaching beendet wird (beispielsweise, um die Einbindung von Ereignishandlern aufzuheben).
Wichtig ist jedoch, dass der Trigger auch wirklich auslöst. Damit der Trigger auslöst, müssen Sie die InvokeActions -Methode aufrufen. Wenn InvokeActions aufgerufen wird, werden alle mit diesem Trigger verknüpften Actions benachrichtigt, zu reagieren.
Erstellen von Aktionen
Ein Trigger ist ein Objekt, das nur Ereignisse überwachen kann. Eine Action ist ein Objekt, das nur etwas ausführen kann.
Das folgende Codebeispiel zeigt eine Basis- Action :
public class MyAction : TriggerAction<DependencyObject>
{
public MyAction()
{
// Insert code required for object creation below this point.
}
protected override void Invoke(object o)
{
// Insert code that defines what the Action will do when it is triggered or invoked.
}
}
Da der Trigger die Invoke -Methode aufruft, müssen Sie sicherstellen, dass die Invoke -Methode auf jeden Code, den die Action ausführen soll, in irgendeiner Form zugegriffen werden kann. Das folgende Codebeispiel zeigt eine Action , die bei Ihrer Auslösung ein MessageBox -Element anzeigt:
public class ShowMessageBoxAction : TriggerAction<DependencyObject>
{
public string Message
{
get { return (string)GetValue(MessageProperty); }
set { SetValue(MessageProperty, value); }
}
public static readonly DependencyProperty MessageProperty = DependencyProperty.Register("Message", typeof(string), typeof(ShowMessageBoxAction), new PropertyMetadata(""));
public ShowMessageBoxAction()
{
// Insert code required for object creation below this point.
}
protected override void Invoke(object o)
{
MessageBox.Show(Message);
}
}
Die Action im oben stehenden Codebeispiel ist komplexer als die zuvor gezeigte einfache Action , doch die allgemeinen Merkmale, die eine Action auszeichnen, sind nach wie vor vorhanden. ShowMessageBoxAction geht von TriggerAction aus und überschreibt die Invoke -Methode.
Ausrichten auf Elemente
Die Action hat standardmäßig nur Zugriff auf die AssociatedObject -Eigenschaft, also auf das Element, an das sie angefügt ist, auch wenn Sie das Wirkungsziel der Action ändern können. Wenn Sie die Action auf ein anderes Element ausrichten möchten, erweitern Sie die Klasse, die die Action darstellt, ab TargetedTriggerAction statt ab TriggerAction :
public class MyAction : TargetedTriggerAction<DependencyObject>
{
// See TriggerAction in the preceding code sample...
}
Nachdem Sie die Klasse ab TargetedTriggerAction erweitert haben, können Sie mithilfe der Eigenschaften TargetName und Target auf die Zielelemente zugreifen. Da die AssociatedObject -Eigenschaft stets auf das Element verweist, mit dem die Action derzeit verknüpft ist, vermeiden Sie es, die Eigenschaften AssociatedObject und TargetName bzw. Target bei ihrer Verwendung untereinander auszutauschen.