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. BindableProperty

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

Commenti

La BindableObject classe 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. Tutti gli elementi visivi nello Xamarin.Forms spazio dei nomi ereditano dalla BindableObject classe, quindi possono essere usati tutti per associare i dati dietro gli elementi dell'interfaccia utente per visualizzare i modelli forniti dallo sviluppatore dell'applicazione.

Per associare i dati dietro una proprietà in un oggetto BindableObject , in genere una vista, a una proprietà nel modello di visualizzazione, gli sviluppatori di applicazioni devono eseguire le operazioni seguenti.

Per prima cosa, lo sviluppatore crea una coppia di proprietà nella vista, una delle quali è un oggetto BindableProperty e l'altra è una proprietà del tipo richiesto. Nel codice riportato di seguito, MockBindableObject è in genere un oggetto dell'interfaccia utente nel codice di produzione. Gli sviluppatori di applicazioni devono tenere presente l'utilizzo 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.

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' INotifyPropertyChanged interfaccia. Nel modello di progettazione MVVM questa operazione viene in genere eseguita dal modello di visualizzazione. Gli sviluppatori di applicazioni devono implementare l' INotifyPropertyChanged interfaccia sulle classi che desiderano utilizzare come modelli di visualizzazione. 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 OnPropertyChanged(String) metodo. Inoltre, la proprietà Name nell'esempio seguente esegue semplicemente il wrapping del campo Name . In pratica, lo sviluppatore di applicazioni può scegliere un modello diverso in cui archiviare i dati dell'applicazione.

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. Nel vocabolario del modello di progettazione MVVM, questo è "associazione di un'istanza della vista a un'istanza di un modello di visualizzazione". 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' BindingMode enumerazione, se presente, che è stato passato durante il passaggio di associazione.

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. Il codice seguente viene eseguito senza generare un'eccezione.

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.

Campi

BindingContextProperty

Implementa la proprietà associata, la cui interfaccia viene specificata dalla proprietà BindingContext.

Proprietà

BindingContext

Ottiene o imposta l'oggetto contenente le proprietà che saranno interessate dalle proprietà associate appartenenti a questo elemento BindableObject.

Dispatcher

Metodi

ApplyBindings()

Applica le associazioni a BindingContext.

ClearValue(BindableProperty)

Cancella qualsiasi valore impostato da SetValue per property.

ClearValue(BindablePropertyKey)

Cancella qualsiasi valore impostato dalla proprietà SetValue identificato da propertyKey.

CoerceValue(BindableProperty)
CoerceValue(BindablePropertyKey)
GetValue(BindableProperty)

Restituisce il valore contenuto in BindableProperty.

GetValues(BindableProperty, BindableProperty)
Obsoleta.

Per uso interno della piattaforma Xamarin.Forms.

GetValues(BindableProperty, BindableProperty, BindableProperty)
Obsoleta.

Per uso interno della piattaforma Xamarin.Forms.

IsSet(BindableProperty)

Restituisce true se la proprietà di destinazione esiste ed è stata impostata.

OnBindingContextChanged()

Eseguire l'override di questo metodo per eseguire un'azione quando BindingContext viene modificato.

OnPropertyChanged(String)

Chiamare questo metodo da una classe figlio per segnalare una modifica che si è verificata su una proprietà.

OnPropertyChanging(String)

Chiamare questo metodo da una classe figlio per segnalare che una proprietà sta per essere modificata.

RemoveBinding(BindableProperty)

Rimuove un'associazione impostata in precedenza.

SetBinding(BindableProperty, BindingBase)

Assegna un'associazione a una proprietà.

SetInheritedBindingContext(BindableObject, Object)

Imposta il contesto ereditato su un elemento annidato.

SetValue(BindableProperty, Object)

Imposta il valore della proprietà specificata.

SetValue(BindablePropertyKey, Object)

Imposta il valore di propertyKey.

SetValueCore(BindableProperty, Object, SetValueFlags)

Per uso interno della piattaforma Xamarin.Forms.

UnapplyBindings()

Annulla tutte le associazioni impostate in precedenza.

Eventi

BindingContextChanged

Si verifica ogni volta che la proprietà BindingContext cambia.

PropertyChanged

Viene chiamato quando una proprietà è stata modificata.

PropertyChanging

Viene chiamato quando una proprietà sta per essere modificata.

Implementazioni dell'interfaccia esplicita

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)

Per uso interno della piattaforma Xamarin.Forms.

Metodi di estensione

GetPropertyIfSet<T>(BindableObject, BindableProperty, T)
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)
SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)

Crea un'associazione e la applica a una proprietà.

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

Crea e applica un'associazione da un'espressione.

SetOnAppTheme<T>(BindableObject, BindableProperty, T, T)

Si applica a