Verhaltensweisen

Artikel
12/18/2024

Beispiel durchsuchen. Beispiel durchsuchen

Mit .NET Multi-Platform App UI (.NET MAUI)-Verhaltensweisen können Sie Benutzeroberflächensteuerelementen, wie z. B. Button oder Entry, zusätzliche Funktionen hinzufügen, ohne die Steuerelemente unterklassen zu müssen. Stattdessen wird die zusätzliche Funktionalität in einer Behavior-Klasse implementiert und dem Steuerelement zugeordnet.

Verhalten können verwendet werden, um UI-Steuerelementen unterschiedliche Funktionen hinzuzufügen, z. B.:

Eingabeüberprüfungen. Verhaltensweisen können mit Eingabesteuerelementen verwendet werden, um sicherzustellen, dass die Daten gültig sind. Zum Beispiel könnten Sie ein Skript für ein Entry schreiben, um sicherzustellen, dass sich eine Telefonnummer oder eine E-Mail-Adresse im richtigen Format befindet.
Verbessern der Benutzeroberfläche. Verhaltensweisen können verwendet werden, um Benutzeroberflächen-Steuerelemente in Ihrer App zu optimieren. Sie können z. B. ein Verhalten für eine Button schreiben, damit es beim Klicken wackelt oder seine Farbe ändert.
Laufzeitantworten. Verhaltensweisen können verwendet werden, um Steuerelemente auf verschiedene Situationen reagieren zu lassen. Beispielsweise können Sie Benutzereingaben automatisch in einer Entry speichern, wenn ein Benutzer die Eingabe beendet hat.

.NET MAUI unterstützt drei verschiedene Arten von Verhaltensweisen:

Angefügte Verhaltensweisen sind static Klassen mit einer oder mehreren angefügten Eigenschaften. Weitere Informationen zu angefügten Verhaltensweisen finden Sie unter angefügten Verhaltensweisen.
.NET MAUI-Verhalten sind Klassen, die von den Klassen Behavior oder Behavior<T> abgeleitet sind, wobei T der Typ des Steuerelements ist, auf das das Verhalten angewendet werden soll. Weitere Informationen finden Sie unter .NET MAUI Behaviors.
Plattformverhalten ist eine Klasse, die von der PlatformBehavior<TView>- oder PlatformBehavior<TView,TPlatformView>-Klasse abgeleitet ist. Diese Verhaltensweisen können auf beliebige Bedingungen und Ereignisse in einem systemeigenen Steuerelement reagieren. Weitere Informationen finden Sie unter Plattformverhaltensweisen.

Angefügte Verhaltensweisen

Angefügte Verhaltensweisen sind statische Klassen mit mindestens einer angefügten Eigenschaft. Eine angefügte Eigenschaft ist ein spezieller Typ von bindungsfähigen Eigenschaften. Sie werden in einer Klasse definiert, aber anderen Objekten zugewiesen, und sie sind in XAML als Attribute erkennbar, die eine Klasse und einen durch einen Punkt getrennten Eigenschaftsnamen enthalten. Weitere Informationen zu angehängten Eigenschaften finden Sie unter .

Eine angefügte Eigenschaft kann einen propertyChanged-Delegaten definieren, der ausgeführt wird, wenn sich der Wert der Eigenschaft ändert, z. B. wenn die Eigenschaft für ein Steuerelement gesetzt wird. Wenn der propertyChanged-Delegat ausgeführt wird, wird ein Verweis auf das Steuerelement übergeben, an das er angefügt ist, sowie Parameter, die die alten und neuen Werte der Eigenschaft enthalten. Dieser Delegat kann verwendet werden, um dem Steuerelement, dem die Eigenschaft zugeordnet ist, neue Funktionen hinzuzufügen, indem der übergebene Verweis folgendermaßen bearbeitet wird:

Der propertyChanged Delegat wandelt den Steuerelementverweis um, der als BindableObjectempfangen wird, in den Steuerelementtyp, den das Verhalten verbessern soll.
Der propertyChanged Delegat ändert die Eigenschaften des Steuerelements, ruft dessen Methoden auf oder registriert Ereignishandler für Ereignisse, die vom Steuerelement verfügbar gemacht werden, um die grundlegenden Verhaltensfunktionen zu implementieren.

Warnung

Beigefügte Verhaltensweisen werden in einer static-Klasse mit static-Eigenschaften und -Methoden definiert. Dadurch wird es schwierig, angefügte Verhaltensweisen mit Zustand zu erstellen.

Erstellen eines angefügten Verhaltens

Ein angebundenes Verhalten kann implementiert werden, indem eine statische Klasse erstellt wird, die eine angeschlossene Eigenschaft enthält, die einen propertyChanged-Delegaten angibt.

Das folgende Beispiel zeigt die AttachedNumericValidationBehavior-Klasse, die den vom Benutzer eingegebenen Wert in einem Entry-Steuerelement rot hervorhebt, wenn er keine doubleist.

public static class AttachedNumericValidationBehavior
{
    public static readonly BindableProperty AttachBehaviorProperty =
        BindableProperty.CreateAttached("AttachBehavior", typeof(bool), typeof(AttachedNumericValidationBehavior), false, propertyChanged: OnAttachBehaviorChanged);

    public static bool GetAttachBehavior(BindableObject view)
    {
        return (bool)view.GetValue(AttachBehaviorProperty);
    }

    public static void SetAttachBehavior(BindableObject view, bool value)
    {
        view.SetValue(AttachBehaviorProperty, value);
    }

    static void OnAttachBehaviorChanged(BindableObject view, object oldValue, object newValue)
    {
        Entry entry = view as Entry;
        if (entry == null)
        {
            return;
        }

        bool attachBehavior = (bool)newValue;
        if (attachBehavior)
        {
            entry.TextChanged += OnEntryTextChanged;
        }
        else
        {
            entry.TextChanged -= OnEntryTextChanged;
        }
    }

    static void OnEntryTextChanged(object sender, TextChangedEventArgs args)
    {
        double result;
        bool isValid = double.TryParse(args.NewTextValue, out result);
        ((Entry)sender).TextColor = isValid ? Colors.Black : Colors.Red;
    }
}

In diesem Beispiel enthält die AttachedNumericValidationBehavior-Klasse eine angefügte Eigenschaft namens AttachBehavior mit einem static Getter und Setter, die das Hinzufügen oder Entfernen des Verhaltens an das Steuerelement steuert, an das es angefügt wird. Diese angefügte Eigenschaft registriert die Methode OnAttachBehaviorChanged, die bei einer Änderung des Eigenschaftswerts ausgeführt wird. Diese Methode registriert oder deregistriert einen Ereignishandler für das TextChanged-Ereignis basierend auf dem Wert der angefügten Eigenschaft AttachBehavior. Die Kernfunktionalität des Verhaltens wird von der OnEntryTextChanged-Methode bereitgestellt, die den in der Entry eingegebenen Wert analysiert und die TextColor Eigenschaft auf Rot festlegt, wenn der Wert kein doubleist.

Nutzung eines angefügten Verhaltens

Ein angefügtes Verhalten kann genutzt werden, indem die angefügte Eigenschaft für das Zielsteuerelement festgelegt wird.

Das folgende Beispiel zeigt, wie die AttachedNumericValidationBehavior-Klasse auf einem Entry konsumiert wird, indem die angefügte Eigenschaft AttachBehavior zu Entryhinzugefügt wird.


<ContentPage ...
             xmlns:local="clr-namespace:BehaviorsDemos">
    <Entry Placeholder="Enter a System.Double" local:AttachedNumericValidationBehavior.AttachBehavior="true" />
</ContentPage>

Das entsprechende Entry in C# wird im folgenden Codebeispiel gezeigt:

Entry entry = new Entry { Placeholder = "Enter a System.Double" };
AttachedNumericValidationBehavior.SetAttachBehavior(entry, true);

Der folgende Screenshot zeigt das angefügte Verhalten, das auf ungültige Eingaben reagiert:

Screenshot des angefügten Verhaltens, das auf ungültige Eingaben reagiert

Anmerkung

Angefügte Verhaltensweisen werden für einen bestimmten Steuerelementtyp geschrieben (oder eine Superklasse, die auf viele Steuerelemente angewendet werden kann), und sie sollten nur einem kompatiblen Steuerelement hinzugefügt werden.

Ein angefügtes Verhalten entfernen

Die AttachedNumericValidationBehavior-Klasse kann aus einem Steuerelement entfernt werden, indem die angefügte Eigenschaft AttachBehavior auf falsefestgelegt wird.

<Entry Placeholder="Enter a System.Double" local:AttachedNumericValidationBehavior.AttachBehavior="false" />

Zur Laufzeit wird die OnAttachBehaviorChanged-Methode ausgeführt, wenn der Wert der angefügten eigenschaft AttachBehavior auf falsefestgelegt ist. Die OnAttachBehaviorChanged-Methode deregistriert dann den Ereignishandler für das TextChanged-Ereignis und stellt sicher, dass das Verhalten nicht ausgeführt wird, während Sie mit dem Steuerelement interagieren.

.NET MAUI-Verhalten

.NET MAUI-Verhalten werden durch Ableiten von der Behavior oder Behavior<T> Klasse erstellt.

Der Prozess zum Erstellen eines .NET MAUI-Verhaltens lautet wie folgt:

Erstellen Sie eine Klasse, die von der Behavior oder Behavior<T> Klasse erbt, wobei T der Typ des Steuerelements ist, auf das das Verhalten angewendet werden soll.
Überschreiben Sie die OnAttachedTo-Methode, um alle erforderlichen Setups auszuführen.
Überschreiben Sie die OnDetachingFrom-Methode, um alle erforderlichen Bereinigungen durchzuführen.
Implementieren Sie die Kernfunktionen des Verhaltens.

Dies führt zu der Struktur, die im folgenden Beispiel gezeigt wird:

public class MyBehavior : Behavior<View>
{
    protected override void OnAttachedTo(View bindable)
    {
        base.OnAttachedTo(bindable);
        // Perform setup
    }

    protected override void OnDetachingFrom(View bindable)
    {
        base.OnDetachingFrom(bindable);
        // Perform clean up
    }

    // Behavior implementation
}

Die OnAttachedTo-Methode wird unmittelbar nach dem Anfügen des Verhaltens an ein Steuerelement aufgerufen. Diese Methode empfängt einen Verweis auf das Steuerelement, an das es angefügt ist, und kann zum Registrieren von Ereignishandlern oder zum Ausführen anderer Setups verwendet werden, die zur Unterstützung der Verhaltensfunktionalität erforderlich sind. Sie können z. B. ein Ereignis für ein Steuerelement abonnieren. Die Verhaltenfunktionalität würde dann im Ereignishandler für das Ereignis implementiert werden.

Die OnDetachingFrom-Methode wird aufgerufen, wenn das Verhalten aus dem Steuerelement entfernt wird. Diese Methode empfängt einen Verweis auf das Steuerelement, an das es gebunden ist, und wird verwendet, um alle erforderlichen Bereinigungen durchzuführen. Sie können z. B. ein Abonnement eines Ereignisses auf einem Steuerelement kündigen, um Speicherverluste zu verhindern.

Das Verhalten kann dann genutzt werden, indem es an die Behaviors Sammlung des Steuerelements angefügt wird.

Ein .NET MAUI-Verhalten erstellen

Ein .NET MAUI-Verhalten kann implementiert werden, indem eine Klasse erstellt wird, die von der Behavior oder Behavior<T> Klasse abgeleitet wird, und die methoden OnAttachedTo und OnDetachingFrom außer Kraft gesetzt werden.

Das folgende Beispiel zeigt die NumericValidationBehavior Klasse, die den vom Benutzer eingegebenen Wert in ein Entry-Steuerelement rot hervorhebt, wenn es sich nicht um eine doublehandelt:

public class NumericValidationBehavior : Behavior<Entry>
{
    protected override void OnAttachedTo(Entry entry)
    {
        entry.TextChanged += OnEntryTextChanged;
        base.OnAttachedTo(entry);
    }

    protected override void OnDetachingFrom(Entry entry)
    {
        entry.TextChanged -= OnEntryTextChanged;
        base.OnDetachingFrom(entry);
    }

    void OnEntryTextChanged(object sender, TextChangedEventArgs args)
    {
        double result;
        bool isValid = double.TryParse(args.NewTextValue, out result);
        ((Entry)sender).TextColor = isValid ? Colors.Black : Colors.Red;
    }
}

In diesem Beispiel wird die NumericValidationBehavior Klasse von der Behavior<T> Klasse abgeleitet, wobei T eine Entryist. Die OnAttachedTo-Methode registriert einen Ereignishandler für das TextChanged-Ereignis, wobei die OnDetachingFrom Methode das TextChanged-Ereignis deregistriert, um Speicherverluste zu verhindern. Die Kernfunktionalität des Verhaltens wird von der OnEntryTextChanged-Methode bereitgestellt, die den in der Entry eingegebenen Wert analysiert und die TextColor-Eigenschaft auf Rot setzt, wenn der Wert kein doubleist.

Wichtig

.NET MAUI legt das BindingContext eines Verhaltens nicht fest, da Verhalten durch Stile gemeinsam genutzt und auf mehrere Steuerelemente angewendet werden können.

Verwenden eines .NET MAUI-Verhaltens

Jedes .NET MAUI-Steuerelement verfügt über eine Behaviors Auflistung, zu der ein oder mehrere Verhaltensweisen hinzugefügt werden können:

<Entry Placeholder="Enter a System.Double">
    <Entry.Behaviors>
        <local:NumericValidationBehavior />
    </Entry.Behaviors>
</Entry>

Das entsprechende Entry in C# wird im folgenden Codebeispiel gezeigt:

Entry entry = new Entry { Placeholder = "Enter a System.Double" };
entry.Behaviors.Add(new NumericValidationBehavior());

Der folgende Screenshot zeigt das .NET MAUI-Verhalten, das auf ungültige Eingaben reagiert:

Screenshot des .NET MAUI-Verhaltens, das auf ungültige Eingaben reagiert

Warnung

.NET MAUI-Verhalten werden für einen bestimmten Steuerelementtyp geschrieben (oder eine Superklasse, die auf viele Steuerelemente angewendet werden kann), und sie sollten nur einem kompatiblen Steuerelement hinzugefügt werden. Wenn Sie versuchen, ein .NET MAUI-Verhalten an ein inkompatibles Steuerelement anzufügen, wird eine Ausnahme ausgelöst.

Verwenden eines .NET MAUI-Verhaltens mit einem Stil

.NET MAUI-Verhalten können mittels eines expliziten oder impliziten Stils genutzt werden. Das Erstellen eines Stils, der die Eigenschaft Behaviors eines Steuerelements festlegt, ist jedoch nicht möglich, da die Eigenschaft schreibgeschützt ist. Die Lösung besteht darin, der Verhaltensklasse eine angefügte Eigenschaft hinzuzufügen, die das Hinzufügen und Entfernen des Verhaltens steuert. Der Prozess lautet wie folgt:

Fügen Sie der Verhaltensklasse eine angefügte Eigenschaft hinzu, die zum Steuern des Hinzufügens oder Entfernens des Verhaltens an das Steuerelement verwendet wird, an das das Verhalten angefügt wird. Stellen Sie sicher, dass die angefügte Eigenschaft einen propertyChanged Delegaten registriert, der ausgeführt wird, wenn sich der Wert der Eigenschaft ändert.
Erstellen Sie einen static Getter und Setter für die angefügte Eigenschaft.
Implementieren Sie Logik im propertyChanged Delegaten, um das Verhalten hinzuzufügen und zu entfernen.

Das folgende Beispiel zeigt die NumericValidationStyleBehavior Klasse, die über eine angefügte Eigenschaft verfügt, die das Hinzufügen und Entfernen des Verhaltens steuert:

public class NumericValidationStyleBehavior : Behavior<Entry>
{
    public static readonly BindableProperty AttachBehaviorProperty =
        BindableProperty.CreateAttached("AttachBehavior", typeof(bool), typeof(NumericValidationStyleBehavior), false, propertyChanged: OnAttachBehaviorChanged);

    public static bool GetAttachBehavior(BindableObject view)
    {
        return (bool)view.GetValue(AttachBehaviorProperty);
    }

    public static void SetAttachBehavior(BindableObject view, bool value)
    {
        view.SetValue(AttachBehaviorProperty, value);
    }

    static void OnAttachBehaviorChanged(BindableObject view, object oldValue, object newValue)
    {
        Entry entry = view as Entry;
        if (entry == null)
        {
            return;
        }

        bool attachBehavior = (bool)newValue;
        if (attachBehavior)
        {
            entry.Behaviors.Add(new NumericValidationStyleBehavior());
        }
        else
        {
            Behavior toRemove = entry.Behaviors.FirstOrDefault(b => b is NumericValidationStyleBehavior);
            if (toRemove != null)
            {
                entry.Behaviors.Remove(toRemove);
            }
        }
    }

    protected override void OnAttachedTo(Entry entry)
    {
        entry.TextChanged += OnEntryTextChanged;
        base.OnAttachedTo(entry);
    }

    protected override void OnDetachingFrom(Entry entry)
    {
        entry.TextChanged -= OnEntryTextChanged;
        base.OnDetachingFrom(entry);
    }

    void OnEntryTextChanged(object sender, TextChangedEventArgs args)
    {
        double result;
        bool isValid = double.TryParse(args.NewTextValue, out result);
        ((Entry)sender).TextColor = isValid ? Colors.Black : Colors.Red;
    }
}

In diesem Beispiel enthält die NumericValidationStyleBehavior-Klasse eine angefügte Eigenschaft namens AttachBehavior mit einem static Getter und Setter, der das Hinzufügen oder Entfernen des Verhaltens zum Steuerelement steuert, an das es angefügt wird. Diese angehängte Eigenschaft registriert die OnAttachBehaviorChanged-Methode, die ausgeführt wird, wenn sich der Wert der Eigenschaft ändert. Mit dieser Methode wird das Verhalten dem Steuerelement hinzugefügt oder entfernt, je nach Wert der angefügten Eigenschaft AttachBehavior.

Das folgende Codebeispiel zeigt einen expliziten Stil für die NumericValidationStyleBehavior, die die angefügte Eigenschaft AttachBehavior verwendet, und der auf Entry Steuerelemente angewendet werden kann.

<Style x:Key="NumericValidationStyle" TargetType="Entry">
    <Style.Setters>
        <Setter Property="local:NumericValidationStyleBehavior.AttachBehavior" Value="true" />
    </Style.Setters>
</Style>

Die Style kann auf eine Entry angewendet werden, indem ihre Style-Eigenschaft auf den Stil festgelegt wird, mithilfe der StaticResource Markuperweiterung.

<Entry Placeholder="Enter a System.Double" Style="{StaticResource NumericValidationStyle}">

Weitere Informationen zu Stilen finden Sie unter Styles.

Anmerkung

Sie können zwar bindungsfähige Eigenschaften zu einem Verhalten hinzufügen, das in XAML festgelegt oder abgefragt wird, wenn Sie jedoch Verhaltensweisen erstellen, die den Zustand aufweisen, dass sie nicht zwischen Steuerelementen in einer Style in einem ResourceDictionaryfreigegeben werden sollen.

Entfernen eines .NET MAUI-Verhaltens

Die OnDetachingFrom-Methode wird aufgerufen, wenn ein Verhalten von einem Steuerelement entfernt wird, und dient dazu, alle erforderlichen Bereinigungen vorzunehmen, wie z. B. das Abmelden von einem Ereignis, um einen Speicherverlust zu verhindern. Verhaltensweisen werden jedoch nicht implizit aus Steuerelementen entfernt, es sei denn, die Behaviors-Auflistung des Steuerelements wird von der Remove oder Clear Methode geändert:

Behavior toRemove = entry.Behaviors.FirstOrDefault(b => b is NumericValidationStyleBehavior);
if (toRemove != null)
{
    entry.Behaviors.Remove(toRemove);
}

Alternativ kann die Sammlung des Steuerelements Behaviors gelöscht werden:

entry.Behaviors.Clear();

Anmerkung

.NET MAUI-Verhalten werden nicht implizit aus Steuerelementen entfernt, wenn Seiten aus dem Navigationsstapel entfernt werden. Stattdessen müssen sie explizit entfernt werden, bevor die Seiten aus dem Geltungsbereich herausfallen.

Plattformverhalten

Plattformverhalten werden durch das Ableiten von der Klasse PlatformBehavior<TView> oder PlatformBehavior<TView,TPlatformView> erstellt. Sie reagieren auf beliebige Bedingungen und Ereignisse in einem systemeigenen Steuerelement.

Ein Plattformverhalten kann durch bedingte Kompilierung oder partielle Klassen implementiert werden. Der hier angenommene Ansatz besteht darin, partielle Klassen zu verwenden, bei denen ein Plattformverhalten in der Regel aus einer plattformübergreifenden Partielle Klasse besteht, die die Verhaltens-API definiert, und eine systemeigene Partielle Klasse, die das Verhalten auf jeder Plattform implementiert. Zur Erstellungszeit kombiniert Multi-Targeting die partiellen Klassen, um das Plattformverhalten auf jeder Plattform zu erstellen.

Der Prozess zum Erstellen eines Plattformverhaltens lautet wie folgt:

Erstellen Sie eine plattformübergreifende Partielle Klasse, die die API für das Plattformverhalten definiert.
Erstellen Sie eine systemeigene Partielle Klasse auf jeder Plattform, für die Ihre App erstellt wird, die denselben Namen wie die plattformübergreifende Partielle Klasse aufweist. Diese partielle systemeigene Klasse sollte von der PlatformBehavior<TView>- oder PlatformBehavior<TView,TPlatformView>-Klasse erben, wobei TView das plattformübergreifende Steuerelement ist, auf das das Verhalten angewendet werden soll, und TPlatformView die native Ansicht ist, die das plattformübergreifende Steuerelement auf einer bestimmten Plattform implementiert.

Anmerkung

Obwohl es erforderlich ist, eine plattformspezifische partielle Klasse für jede Plattform zu erstellen, für die Ihre App entwickelt wird, ist es nicht notwendig, die plattformbezogene Funktionalität auf jeder Plattform zu implementieren. Sie können z. B. ein Verhalten auf der Plattform erstellen, das die Rahmenstärke eines nativen Steuerelements auf einigen, aber nicht allen Plattformen ändert.
In jeder nativen Partialklasse, die Sie benötigen, um das Plattformverhalten zu implementieren, sollten Sie:
1. Überschreiben Sie die OnAttachedTo-Methode, um alle Setups auszuführen.
2. Überschreiben Sie die OnDetachedFrom-Methode, um die notwendigen Aufräumarbeiten durchzuführen.
3. Implementieren Sie die Kernfunktionalität des Verhaltens der Plattform.

Das Verhalten kann dann genutzt werden, indem es an die Behaviors Auflistung des Steuerelements angefügt wird.

Plattformverhalten erstellen

Zum Erstellen eines Plattformverhaltens müssen Sie zunächst eine plattformübergreifende Partielle Klasse erstellen, die die API für das Plattformverhalten definiert:

namespace BehaviorsDemos
{
    public partial class TintColorBehavior
    {
        public static readonly BindableProperty TintColorProperty =
            BindableProperty.Create(nameof(TintColor), typeof(Color), typeof(TintColorBehavior));

        public Color TintColor
        {
            get => (Color)GetValue(TintColorProperty);
            set => SetValue(TintColorProperty, value);
        }
    }
}

Das Plattformverhalten ist eine partielle Klasse, deren Implementierung auf jeder erforderlichen Plattform mit einer zusätzlichen Teilklasse abgeschlossen wird, die denselben Namen verwendet. In diesem Beispiel definiert die TintColorBehavior-Klasse eine einzige bindbare Eigenschaft, TintColor, die ein Bild mit der angegebenen Farbe tönen wird.

Nach dem Erstellen der plattformübergreifenden partiellen Klasse sollten Sie eine plattform-spezifische partielle Klasse auf jeder Plattform entwickeln, für die Sie die App erstellen. Dies kann erreicht werden, indem partielle Klassen zu den erforderlichen untergeordneten Ordnern des Ordners Plattformen hinzugefügt werden.

Screenshot der nativen Teilklassen für ein Plattformverhalten.

Alternativ können Sie Ihr Projekt so konfigurieren, dass dateinamenbasiertes Multi-Targeting oder ordnerbasiertes Multi-Targeting oder beides unterstützt werden. Weitere Informationen zu Multi-Targeting finden Sie unter Konfigurieren von Multi-Targeting.

Die nativen Teilklassen sollten von der PlatformBehavior<TView>-Klasse oder der PlatformBehavior<TView,TPlatformView>-Klasse erben, wobei TView das plattformübergreifende Steuerelement ist, auf das das Verhalten angewendet werden soll, und TPlatformView die plattformspezifische Ansicht ist, die das plattformübergreifende Steuerelement auf einer bestimmten Plattform implementiert. In jeder systemeigenen Partialklasse, die Sie zum Implementieren des Plattformverhaltens benötigen, sollten Sie die OnAttachedTo-Methode und die OnDetachedFrom-Methode außer Kraft setzen und die Kernfunktionen des Plattformverhaltens implementieren.

Die OnAttachedTo-Methode wird unmittelbar aufgerufen, nachdem das Plattformverhalten an ein plattformübergreifendes Steuerelement angefügt wurde. Die Methode empfängt einen Verweis auf das plattformübergreifende Steuerelement, an das es angefügt ist, und optional einen Verweis auf das systemeigene Steuerelement, das das plattformübergreifende Steuerelement implementiert. Die Methode kann zum Registrieren von Ereignishandlern oder zum Ausführen anderer Setups verwendet werden, die zur Unterstützung der Plattformverhaltensfunktionalität erforderlich sind. Sie können z. B. ein Ereignis für ein Steuerelement abonnieren. Die Verhaltenfunktionalität würde dann im Ereignishandler für das Ereignis implementiert werden.

Die OnDetachedFrom-Methode wird aufgerufen, wenn das Verhalten aus dem plattformübergreifenden Steuerelement entfernt wird. Die Methode empfängt einen Verweis auf das Steuerelement, an das sie angefügt ist, und optional einen Verweis auf das native Steuerelement, das das plattformübergreifende Steuerelement implementiert. Die Methode sollte verwendet werden, um alle erforderlichen Bereinigungen vorzunehmen. Sie können z. B. ein Abonnement eines Ereignisses in einem Steuerelement kündigen, um Speicherverluste zu verhindern.

Wichtig

Die Teilklassen müssen sich im selben Namespace befinden und identische Namen verwenden.

Das folgende Beispiel zeigt die TintColorBehavior partielle Klasse für Android, die ein Bild mit einer angegebenen Farbe einfärbt.

using Android.Graphics;
using Android.Widget;
using Microsoft.Maui.Platform;
using Color = Microsoft.Maui.Graphics.Color;

namespace BehaviorsDemos
{
    public partial class TintColorBehavior : PlatformBehavior<Image, ImageView>
    {
        protected override void OnAttachedTo(Image bindable, ImageView platformView)
        {
            base.OnAttachedTo(bindable, platformView);

            if (bindable is null)
                return;
            if (TintColor is null)
                ClearColor(platformView);
            else
                ApplyColor(platformView, TintColor);
        }

        protected override void OnDetachedFrom(Image bindable, ImageView platformView)
        {
            base.OnDetachedFrom(bindable, platformView);

            if (bindable is null)
                return;
            ClearColor(platformView);
        }

        void ApplyColor(ImageView imageView, Color color)
        {
            imageView.SetColorFilter(new PorterDuffColorFilter(color.ToPlatform(), PorterDuff.Mode.SrcIn ?? throw new NullReferenceException()));
        }

        void ClearColor(ImageView imageView)
        {
            imageView.ClearColorFilter();
        }
    }
}

In diesem Beispiel wird die TintColorBehavior Klasse von der klasse PlatformBehavior<TView,TPlatformView> abgeleitet, wobei TView ein Image ist und TPlatformView ein ImageViewist. Die OnAttachedTo wendet den Farbton auf das Bild an, vorausgesetzt, die Eigenschaft TintColor weist einen Wert auf. Die OnDetachedFrom-Methode entfernt den Farbton aus dem Bild.

Auf jeder Plattform, für die Sie Ihre App erstellen, muss eine systemeigene Partielle Klasse hinzugefügt werden. Sie können jedoch die systemeigene Partielle Klasse NO-OP erstellen, wenn das Plattformverhalten auf einer bestimmten Plattform nicht erforderlich ist. Dies kann erreicht werden, indem eine leere Klasse bereitgestellt wird:

using Microsoft.UI.Xaml;

namespace BehaviorsDemos
{
    public partial class TintColorBehavior : PlatformBehavior<Image, FrameworkElement>
    {
        // NO-OP on Windows
    }
}

Wichtig

.NET MAUI legt den BindingContext eines Plattformverhaltens nicht fest.

Nutzen eines Plattformverhaltens

Jedes .NET MAUI-Steuerelement verfügt über eine Behaviors-Sammlung, zu der ein oder mehrere Plattformverhaltensweisen hinzugefügt werden können.

<Image Source="dotnet_bot.png"
       HeightRequest="200"
       HorizontalOptions="Center">
    <Image.Behaviors>
        <local:TintColorBehavior TintColor="Red" />
    </Image.Behaviors>
</Image>

Das entsprechende Image in C# wird im folgenden Beispiel gezeigt:

Image image = new Image { Source = "dotnet_bot.png", HeightRequest = 200, HorizontalOptions = LayoutOptions.Center };
image.Behaviors.Add(new TintColorBehavior());

Der folgende Screenshot zeigt das Plattformverhalten beim Einfärben eines Bilds:

Screenshot des Verhaltens der .NET MAUI-Plattform beim Einfärben eines Bildes.

Warnung

Plattformverhalten wird für einen bestimmten Steuerelementtyp geschrieben (oder eine Superklasse, die auf viele Steuerelemente angewendet werden kann), und sie sollten nur einem kompatiblen Steuerelement hinzugefügt werden. Wenn Sie versuchen, ein Plattformverhalten an ein inkompatibles Steuerelement anzuhängen, wird eine Ausnahme ausgelöst.

Freigeben über

Verhaltensweisen

Angefügte Verhaltensweisen

Erstellen eines angefügten Verhaltens

Nutzung eines angefügten Verhaltens

Ein angefügtes Verhalten entfernen

.NET MAUI-Verhalten

Ein .NET MAUI-Verhalten erstellen

Verwenden eines .NET MAUI-Verhaltens

Verwenden eines .NET MAUI-Verhaltens mit einem Stil

Entfernen eines .NET MAUI-Verhaltens

Plattformverhalten

Plattformverhalten erstellen

Nutzen eines Plattformverhaltens

Zusätzliche Ressourcen