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, der es dem Anwendungsentwickler ermöglicht, Daten zwischen Objekten als Reaktion auf Änderungen zu synchronisieren, z. B. zwischen dem 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 folgendes ausführen.

Zunächst erstellt der Entwickler ein Paar von Eigenschaften in der Ansicht, eines davon ist eins BindableProperty, und der andere ist eine Eigenschaft des gewünschten Typs. Im folgenden MockBindableObject Code steht für das, was normalerweise ein Benutzeroberflächenobjekt im Produktionscode sein würde. Anwendungsentwickler sollten die Verwendung SetValue(BindableProperty, Object) von und zum Abrufen und GetValue(BindableProperty) Festlegen des Werts für die gebundene Eigenschaft beachten; 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 App-Entwickler die idiomatische Art und Weise beachten, in der die Name Eigenschaft implementiert wird, zuerst sicherstellen, dass die Eigenschaft tatsächlich geändert und zurückgegeben wird, wenn sie nicht erfolgt ist, und weisen Sie dann den Wert zu und rufen Sie die OnPropertyChanged(String) Methode auf. Darüber hinaus wird die Name Eigenschaft im folgenden Beispiel lediglich das name Feld umgebrochen. 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 Instanz eines BindableObject an eine Instanz, die INotifyPropertyChanged implementiert. Im Vokabular des MVVM-Entwurfsmusters ist dies "Bindung einer Instanz der Ansicht an eine Instanz eines Ansichtsmodells". Sobald dieser Schritt abgeschlossen ist, werden Änderungen in den Daten zwischen dem Ansichts- und Ansichtsmodell auf eine Weise verteilt, die durch den Wert der BindingMode Enumeration bestimmt wird, falls vorhanden, die während des Bindungsschritts übergeben wurde.

Der folgende Code, der in einem Projekt enthalten ist, das auf die oben genannten Klassen verweist, erstellt eine Instanz von beiden MockBindable und MockViewModelführt einige Intitialisierungen aus, legt die Bindung fest und veranschaulicht dann eine unidirektionale Bindung. Der folgende Code wird ausgeführt, ohne eine Ausnahme zu auslösen.

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.