BindableObject Classe

Definizione

Specifica un meccanismo con il quale gli sviluppatori di applicazioni possono propagare le modifiche apportate ai dati di un oggetto in un altro oggetto, abilitando la convalida, la coercizione del tipo e un sistema di eventi.Provides a mechanism by which application developers can propagate changes that are made to data in one object to another, by enabling validation, type coercion, and an event system. BindablePropertyBindableProperty.

public abstract class BindableObject : System.ComponentModel.INotifyPropertyChanged, Xamarin.Forms.Internals.IDynamicResourceHandler
type BindableObject = class
    interface INotifyPropertyChanged
    interface IDynamicResourceHandler
Ereditarietà
BindableObject
Derivato
Implementazioni

Commenti

La classe BindableObject fornisce un meccanismo di archiviazione dei dati che consente allo sviluppatore di applicazioni di sincronizzare i dati tra gli oggetti in risposta alle modifiche, ad esempio, tra la vista e il modello di visualizzazione nello schema progettuale MVVM.The BindableObject class provides a data storage mechanism that enables the application developer to synchronize data between objects in response to changes, for example, between the View and View Model in the MVVM design pattern. Tutti gli elementi visivi nello spazio dei nomi Xamarin.Forms ereditano dalla classe BindableObject, in modo che possano essere utilizzati tutti per associare i dati dietro gli elementi dell'interfaccia utente per visualizzare i modelli forniti dallo sviluppatore dell'applicazione.All of the visual elements in the Xamarin.Forms namespace inherit from BindableObject class, so they can all be used to bind the data behind their user interface elements to View Models that are supplied by the application developer.

Per associare i dati sottostanti a una proprietà in un BindableObject, in genere una vista, a una proprietà nel modello di visualizzazione, gli sviluppatori di applicazioni devono eseguire le operazioni seguenti.To bind the data behind a property in a BindableObject, typically a view, to a property in the View Model, application developers should do the following.

Per prima cosa, lo sviluppatore crea una coppia di proprietà nella vista, una delle quali è una BindablePropertye l'altra è una proprietà del tipo richiesto.First, the developer creates a pair of properties on the view, one of which is a BindableProperty, and the other of which is a property of whatever type is required. Nel codice riportato di seguito, MockBindableObject è in genere un oggetto dell'interfaccia utente nel codice di produzione.In the code below, MockBindableObject stands in for what would typically be a user interface object in production code. Gli sviluppatori di applicazioni devono notare l'uso di SetValue(BindableProperty, Object) e GetValue(BindableProperty) per ottenere e impostare il valore nella proprietà associata; La proprietà del tipo desiderato fornisce l'interfaccia che viene implementata dalla destinazione della proprietà associata.Application developers should note the use of SetValue(BindableProperty, Object) and GetValue(BindableProperty) to get and set the value on the bound property; The property of the desired type provides the interface that the target of the bound property will implement.


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); }
    }
}

In secondo luogo, lo sviluppatore crea l'implementazione per la proprietà associata in una classe che implementa l'interfaccia INotifyPropertyChanged.Second, the developer creates the implementation for the bound property in a class that implements the INotifyPropertyChanged interface. Nel modello di progettazione MVVM questa operazione viene in genere eseguita dal modello di visualizzazione.In the MVVM design pattern, this is typically done by the View Model. Gli sviluppatori di applicazioni devono implementare l'interfaccia INotifyPropertyChanged sulle classi che desiderano utilizzare come modelli di visualizzazione.Application developers should implement the INotifyPropertyChanged interface on classes that they want to use as View Models. Nell'esempio riportato di seguito, gli sviluppatori di app devono prendere nota del modo in cui la proprietà Name viene implementata, prima di tutto, assicurarsi che la proprietà sia effettivamente cambiata e restituisca in caso contrario, quindi assegnare il valore e chiamare il metodo OnPropertyChanged(String).In the example below, app developers should take note of the idiomatic way that the Name property is implemented to, first, ensure that the property actually changed and return if it did not, and only then assign the value and call the OnPropertyChanged(String) method. Inoltre, la proprietà Name nell'esempio seguente esegue semplicemente il wrapping del campo Name .Additionally, the Name property in the example below merely wraps the name field. In pratica, lo sviluppatore di applicazioni può scegliere un modello diverso in cui archiviare i dati dell'applicazione.In practice, the application developer may choose a different model in which to store application data.


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));
    }
}

Terzo, infine, lo sviluppatore dell'applicazione associa un'istanza di un BindableObject a un'istanza che implementa INotifyPropertyChanged.Third, and finally, the application developer binds an instance of a BindableObject to an instance that implements INotifyPropertyChanged. Nel vocabolario del modello di progettazione MVVM, questo è "associazione di un'istanza della vista a un'istanza di un modello di visualizzazione".In the vocabulary of the MVVM design pattern, this is "binding an instance of the View to an instance of a View Model." Una volta completato questo passaggio, le modifiche apportate ai dati vengono propagate tra la vista e il modello di visualizzazione in un modo determinato dal valore dell'enumerazione BindingMode, se presente, che è stata passata durante il passaggio di associazione.Once this step is complete, changes in the data are propagated between the View and View Model in a way that is determined by the value of the BindingMode enumeration, if any, that was passed during the binding step.

Il codice riportato di seguito, se incluso in un progetto che fa riferimento alle classi precedenti, crea un'istanza di MockBindable e MockViewModel, esegue alcuni intitialization, imposta l'associazione e quindi illustra un'associazione unidirezionale.The code below, when included in a project that reference the classes above, creates an instance of both MockBindable and MockViewModel, performs some intitialization, sets the binding, and then demonstrates a one-way binding. Il codice seguente viene eseguito senza generare un'eccezione.The code below runs without throwing an exception.


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 ();
}

Costruttori

BindableObject()

Inizializza una nuova istanza della classe BindableObject.Initializes a new instance of the BindableObject class.

Campi

BindingContextProperty

Implementa la proprietà associata, la cui interfaccia viene specificata dalla proprietà BindingContext.Implements the bound property whose interface is provided by the BindingContext property.

Proprietà

BindingContext

Ottiene o imposta l'oggetto contenente le proprietà che saranno interessate dalle proprietà associate appartenenti a questo elemento BindableObject.Gets or sets object that contains the properties that will be targeted by the bound properties that belong to this BindableObject.

Metodi

ApplyBindings()

Applica le associazioni a BindingContext.Apply the bindings to BindingContext.

ClearValue(BindableProperty)

Cancella qualsiasi valore impostato da SetValue per property.Clears any value set by SetValue for property.

ClearValue(BindablePropertyKey)

Cancella qualsiasi valore impostato dalla proprietà SetValue identificato da propertyKey.Clears any value set by SetValue for the property that is identified by propertyKey.

GetValue(BindableProperty)

Restituisce il valore contenuto in BindableProperty.Returns the value that is contained in the BindableProperty.

GetValues(BindableProperty, BindableProperty)

Per uso interno della piattaforma Xamarin.Forms.For internal use by the Xamarin.Forms platform.

GetValues(BindableProperty, BindableProperty, BindableProperty)

Per uso interno della piattaforma Xamarin.Forms.For internal use by the Xamarin.Forms platform.

IsSet(BindableProperty)

Restituisce true se la proprietà di destinazione esiste ed è stata impostata.Returns true if the target property exists and has been set.

OnBindingContextChanged()

Eseguire l'override di questo metodo per eseguire un'azione quando BindingContext viene modificato.Override this method to execute an action when the BindingContext changes.

OnPropertyChanged(String)

Chiamare questo metodo da una classe figlio per segnalare una modifica che si è verificata su una proprietà.Call this method from a child class to notify that a change happened on a property.

OnPropertyChanging(String)

Chiamare questo metodo da una classe figlio per segnalare che una proprietà sta per essere modificata.Call this method from a child class to notify that a change is going to happen on a property.

RemoveBinding(BindableProperty)

Rimuove un'associazione impostata in precedenza.Removes a previously set binding.

SetBinding(BindableProperty, BindingBase)

Assegna un'associazione a una proprietà.Assigns a binding to a property.

SetInheritedBindingContext(BindableObject, Object)

Imposta il contesto ereditato su un elemento annidato.Sets the inherited context to a nested element.

SetValue(BindableProperty, Object)

Imposta il valore della proprietà specificata.Sets the value of the specified property.

SetValue(BindablePropertyKey, Object)

Imposta il valore di propertyKey.Sets the value of the propertyKey.

SetValueCore(BindableProperty, Object, SetValueFlags)

Per uso interno della piattaforma Xamarin.Forms.For internal use by the Xamarin.Forms platform.

UnapplyBindings()

Annulla tutte le associazioni impostate in precedenza.Unapplies all previously set bindings.

Eventi

BindingContextChanged

Si verifica ogni volta che la proprietà BindingContext cambia.Raised whenever the BindingContext property changes.

PropertyChanged

Viene chiamato quando una proprietà è stata modificata.Raised when a property has changed.

PropertyChanging

Viene chiamato quando una proprietà sta per essere modificata.Raised when a property is about to change.

Implementazioni dell'interfaccia esplicita

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)

Per uso interno della piattaforma Xamarin.Forms.For internal use by the Xamarin.Forms platform.

Metodi di estensione

SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)

Crea un'associazione e la applica a una proprietà.Creates and applies a binding to a property.

SetBinding<TSource>(BindableObject, BindableProperty, Expression<Func<TSource,Object>>, BindingMode, IValueConverter, String)

Crea e applica un'associazione da un'espressione.Creates and applies a binding from an expression.

Si applica a