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

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

INotifyPropertyChanged IDynamicResourceHandler

Hinweise

Die BindableObject -Klasse stellt einen Datenspeichermechanismus bereit, mit dem der Anwendungsentwickler Daten zwischen Objekten als Reaktion auf Änderungen synchronisieren kann, 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 View Models zu binden, die vom Anwendungsentwickler bereitgestellt werden.

Um die Daten hinter einer Eigenschaft in einer BindableObject- in der Regel einer Sicht - 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 ist BindablePropertyund die andere eine Eigenschaft des erforderlichen Typs ist. Im folgenden Code steht für das, MockBindableObject was in der Regel ein Benutzeroberflächenobjekt im Produktionscode ist. 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 das Ziel der gebundenen Eigenschaft implementiert.

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 INotifyPropertyChanged Schnittstelle implementiert. Im MVVM-Entwurfsmuster erfolgt dies in der Regel durch das Ansichtsmodell. Anwendungsentwickler sollten die INotifyPropertyChanged Schnittstelle für Klassen implementieren, die sie als Ansichtsmodelle verwenden möchten. Im folgenden Beispiel sollten Sich App-Entwickler die idiomatische Art und Weise notieren, 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 Vorgang war, 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 eines instance der Ansicht an eine instance eines Ansichtsmodells". Sobald dieser Schritt abgeschlossen ist, werden Änderungen in den Daten zwischen dem 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.

Wenn der folgende Code in einem Projekt enthalten ist, das auf die oben genannten Klassen verweist, erstellt eine instance von und MockBindableMockViewModel, führt eine gewisse Intitialisierung 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)	Veraltet. Für die interne Verwendung durch die Xamarin.Forms-Plattform.
GetValues(BindableProperty, 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.