BindableObject Klasse

Definition

Namespace:

Xamarin.Forms

Assembly:

Xamarin.Forms.Core.dll

Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.

public abstract class BindableObject : System.ComponentModel.INotifyPropertyChanged, Xamarin.Forms.Internals.IDynamicResourceHandler

type BindableObject = class
    interface INotifyPropertyChanged
    interface IDynamicResourceHandler

Vererbung

System.Object

BindableObject

Abgeleitet

Xamarin.Forms.BackButtonBehavior

Xamarin.Forms.Behavior

Xamarin.Forms.Brush

Xamarin.Forms.ColumnDefinition

Xamarin.Forms.Element

Xamarin.Forms.GradientStop

Xamarin.Forms.Internals.TemplatedItemsList<TView,TItem>

Xamarin.Forms.ItemsLayout

Xamarin.Forms.RowDefinition

Xamarin.Forms.SearchHandler

Xamarin.Forms.Shapes.Geometry

Xamarin.Forms.Shapes.PathFigure

Xamarin.Forms.Shapes.PathSegment

Xamarin.Forms.Shapes.Transform

Xamarin.Forms.StateTriggerBase

Xamarin.Forms.TableSectionBase

Xamarin.Forms.TriggerBase

Xamarin.Forms.WebViewSource

Implementiert

System.ComponentModel.INotifyPropertyChanged IDynamicResourceHandler

Hinweise

Die BindableObject -Klasse stellt einen Datenspeichermechanismus bereit, der es dem Anwendungsentwickler ermöglicht, Daten zwischen Objekten als Reaktion auf Änderungen zu synchronisieren, z. B. zwischen ansichts- und ansichtsmodell im MVVM-Entwurfsmuster. Alle visuellen Elemente im Namespace erben von BindableObject der Xamarin.Forms -Klasse, sodass sie alle verwendet werden können, um die Daten hinter ihren Benutzeroberflächenelementen an Ansichtsmodelle zu binden, die vom Anwendungsentwickler bereitgestellt werden.

Um die Daten hinter einer Eigenschaft in einer BindableObject- in der Regel einer Ansicht - an eine Eigenschaft im Ansichtsmodell zu binden, sollten Anwendungsentwickler die folgenden Schritte ausführen.

Zunächst erstellt der Entwickler ein Eigenschaftenpaar für die Ansicht, von denen eine eine BindablePropertyist, und das andere eine Eigenschaft des erforderlichen Typs ist. Im folgenden MockBindableObject Code steht für das, was in der Regel ein Benutzeroberflächenobjekt im Produktionscode wäre. Anwendungsentwickler sollten die Verwendung von SetValue(BindableProperty, Object) und GetValue(BindableProperty) beachten, um den Wert für die gebundene Eigenschaft abzurufen und festzulegen. Die -Eigenschaft des gewünschten Typs stellt die Schnittstelle bereit, die vom Ziel der gebundenen Eigenschaft implementiert wird.

class MockBindableObject : BindableObject
{
    // App developers should use the method below in production code for 
    // better performance
    public static readonly BindableProperty BoundNameProperty =
         BindableProperty.Create ("Foo", typeof (string),
                                  typeof (MockBindableObject),
                                  default(string));

    // App developers should use the method below during development for
    // design-time error checking as the codebase evolves.
    // public static readonly BindableProperty FooProperty 
    //     = BindableProperty.Create<MockBindableObject, string> (
    //         o => o.Foo, default (string)
    //     );

    public string BoundName
    {
        get { return (string) GetValue (BoundNameProperty); }
        set { SetValue (BoundNameProperty, value); }
    }
}

Zweitens erstellt der Entwickler die Implementierung für die gebundene Eigenschaft in einer Klasse, die die System.ComponentModel.INotifyPropertyChanged -Schnittstelle implementiert. Im MVVM-Entwurfsmuster erfolgt dies in der Regel durch das Ansichtsmodell. Anwendungsentwickler sollten die System.ComponentModel.INotifyPropertyChanged Schnittstelle für Klassen implementieren, die sie als Ansichtsmodelle verwenden möchten. Im folgenden Beispiel sollten App-Entwickler die idiomatische Art und Weise beachten, in der die Name Eigenschaft implementiert wird. Stellen Sie zunächst sicher, dass sich die Eigenschaft tatsächlich geändert hat, und zurückgeben, wenn dies nicht der Fehler ist, und weisen Sie erst dann den Wert zu, und rufen Sie die OnPropertyChanged(String) Methode auf. Darüber hinaus umschließt die Name -Eigenschaft im folgenden Beispiel lediglich das name Feld. In der Praxis kann der Anwendungsentwickler ein anderes Modell auswählen, in dem Anwendungsdaten gespeichert werden sollen.

class MockViewModel : INotifyPropertyChanged
{
    string name;

    public string Name
    {
        get { return name; }
        set
        {
            // OnPropertyChanged should not be called if the property value
            // does not change.
            if (name == value)
                return;
            name = value;
            OnPropertyChanged ();
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    void OnPropertyChanged (string propertyName = null)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null)
            handler (this, new PropertyChangedEventArgs (propertyName));
    }
}

Drittens und schließlich bindet der Anwendungsentwickler eine instance eines BindableObject an eine instance, die INotifyPropertyChanged implementiert. Im Vokabular des MVVM-Entwurfsmusters ist dies "Bindung einer instance der Ansicht an eine instance eines Ansichtsmodells". Sobald dieser Schritt abgeschlossen ist, werden Änderungen in den Daten zwischen ansichts- und Ansichtsmodell auf eine Weise weitergegeben, die durch den Wert der BindingMode Enumeration bestimmt wird, falls vorhanden, der während des Bindungsschritts übergeben wurde.

Der folgende Code erstellt, wenn er in einem Projekt enthalten ist, das auf die oben genannten Klassen verweist, eine instance von und MockBindableMockViewModel, führt eine gewisse Initialisierung durch, legt die Bindung fest und veranschaulicht dann eine unidirektionale Bindung. Der folgende Code wird ohne Ausnahme ausgeführt.

public static void OneWayDemo ()
{
    var view = new MockBindableObject ();
    var viewModel = new MockViewModel ();

    // Pre-load the ViewModel, for demonstration purposes
    viewModel.Name = "Testing";

    // Create a one-way (default) binding
    view.SetBinding (MockBindableObject.BoundNameProperty, new Binding ("Name"));

    // App developers should only set the binding context after all
    // calls to SetBinding() have been made, for performance reasons.
    view.BindingContext = viewModel;

    // In a one way binding, the ViewModel value will be used to update
    // the values in the View during initialization
    if (view.BoundName != "Testing")
        throw new Exception ();

    view.BoundName = "gnitseT";

    // in a one way binding, changes to the View will NOT update the ViewModel
    if (viewModel.Name == "gnitseT")
        throw new Exception ();
}

Konstruktoren

BindableObject()

Initialisiert eine neue Instanz der BindableObject-Klasse.

Felder

BindingContextProperty

Implementiert die gebundene Eigenschaft, deren Schnittstelle von der BindingContext-Eigenschaft bereitgestellt wird.

Eigenschaften

BindingContext	Ruft das Objekt ab, das die Eigenschaften enthält, die von den gebundenen Eigenschaften dieses BindableObject-Objekts angezielt werden, oder legt es fest.
Dispatcher	Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.

Methoden

ApplyBindings()	Wendet die Bindungen auf BindingContext an.
ClearValue(BindableProperty)	Löscht alle Werte, die von SetValue für property festgelegt wurden.
ClearValue(BindablePropertyKey)	Löscht alle Werte, die von SetValue für die Eigenschaft festgelegt wurden, die durch propertyKey ermittelt wird.
CoerceValue(BindableProperty)	Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.
CoerceValue(BindablePropertyKey)	Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.
GetValue(BindableProperty)	Gibt den Wert zurück, der in der BindableProperty-Klasse enthalten ist.
GetValues(BindableProperty, BindableProperty, BindableProperty)	Veraltet. Für die interne Verwendung durch die Xamarin.Forms-Plattform.
GetValues(BindableProperty, BindableProperty)	Veraltet. Für die interne Verwendung durch die Xamarin.Forms-Plattform.
IsSet(BindableProperty)	Gibt true zurück, wenn die Zieleigenschaft vorhanden ist und festgelegt wurde.
OnBindingContextChanged()	Überschreibt diese Methode, um eine Aktion auszuführen, wenn die BindingContext-Klasse geändert wird.
OnPropertyChanged(String)	Ruft diese Methode aus einer untergeordneten Klasse auf, um eine Benachrichtigung anzuzeigen, dass eine Eigenschaft geändert wurde.
OnPropertyChanging(String)	Ruft diese Methode aus einer untergeordneten Klasse auf, um eine Benachrichtigung anzuzeigen, dass eine Eigenschaft geändert wird.
RemoveBinding(BindableProperty)	Entfernt eine zuvor festgelegte Bindung.
SetBinding(BindableProperty, BindingBase)	Weist eine Bindung einer Eigenschaft zu.
SetInheritedBindingContext(BindableObject, Object)	Legt den geerbten Kontext auf ein geschachteltes Element fest.
SetValue(BindableProperty, Object)	Legt den Wert der angegebenen Eigenschaft fest.
SetValue(BindablePropertyKey, Object)	Legt den Wert von „propertyKey“ fest.
SetValueCore(BindableProperty, Object, SetValueFlags)	Für die interne Verwendung durch die Xamarin.Forms-Plattform.
UnapplyBindings()	Hebt alle zuvor festgelegten Bindungen auf.

Ereignisse

BindingContextChanged	Wird ausgelöst, wenn sich die BindingContext-Eigenschaft ändert.
PropertyChanged	Wird ausgelöst, wenn eine Eigenschaft geändert wurde.
PropertyChanging	Wird ausgelöst, wenn eine Eigenschaft geändert wird.

Explizite Schnittstellenimplementierungen

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)

Für die interne Verwendung durch die Xamarin.Forms-Plattform.

Erweiterungsmethoden

GetPropertyIfSet<T>(BindableObject, BindableProperty, T)	Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)	Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.
SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)	Erstellt eine Bindung mit einer Eigenschaft und wendet diese an.
SetBinding<TSource>(BindableObject, BindableProperty, Expression<Func<TSource,Object>>, BindingMode, IValueConverter, String)	Veraltet. Erstellt eine Bindung aus einem Ausdruck und wendet diese an.
SetOnAppTheme<T>(BindableObject, BindableProperty, T, T)	Stellt einen Mechanismus bereit, durch den die Entwickler von Anwendungen die Änderungen an Daten in einem Objekt an ein anderes weitergeben können. Dies wird durch das Aktivieren der Überprüfung, Typkoersion und ein Ereignissystem ermöglicht. BindableProperty.