BindableObject Classe

Definizione

Spazio dei nomi:

Xamarin.Forms

Assembly:

Xamarin.Forms.Core.dll

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à

Object

BindableObject

Derivato

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

Implementazioni

INotifyPropertyChanged IDynamicResourceHandler

Commenti

La BindableObject classe fornisce un meccanismo di archiviazione dei dati che consente allo sviluppatore dell'applicazione di sincronizzare i dati tra gli oggetti in risposta alle modifiche, ad esempio tra view e view model nel modello di progettazione MVVM. Tutti gli elementi visivi nello Xamarin.Forms spazio dei nomi ereditano dalla BindableObject classe, quindi possono essere tutti usati per associare i dati dietro gli elementi dell'interfaccia utente a View Models forniti dallo sviluppatore dell'applicazione.

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

In primo luogo, lo sviluppatore crea una coppia di proprietà nella visualizzazione, una delle quali è un BindablePropertye l'altra di cui è una proprietà di qualsiasi tipo è necessario. Nel codice seguente, MockBindableObject indica ciò che in genere sarebbe un oggetto dell'interfaccia utente nel codice di produzione. Gli sviluppatori di applicazioni devono prendere nota dell'uso di SetValue(BindableProperty, Object) e GetValue(BindableProperty) per ottenere e impostare il valore sulla proprietà associata; La proprietà del tipo desiderato fornisce l'interfaccia che verrà 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'interfaccia INotifyPropertyChanged . Nel modello di progettazione MVVM, questa operazione viene in genere eseguita dal modello di visualizzazione. Gli sviluppatori di applicazioni devono implementare l'interfaccia INotifyPropertyChanged nelle classi che vogliono usare come modelli di visualizzazione. Nell'esempio seguente, gli sviluppatori di app devono prendere nota del modo idiomatico in cui viene implementata la Name proprietà, prima di tutto, assicurarsi che la proprietà sia stata effettivamente modificata e restituita se non lo fosse e quindi assegnare solo il valore e chiamare il OnPropertyChanged(String) metodo. Inoltre, la Name proprietà nell'esempio seguente esegue semplicemente il wrapping del name campo. 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));
    }
}

Infine, lo sviluppatore dell'applicazione associa un'istanza di BindableObject a un'istanza che implementa INotifyPropertyChanged. Nel vocabolario del modello di progettazione MVVM, si tratta di "associazione di un'istanza della visualizzazione a un'istanza di un modello di visualizzazione". Al termine di questo passaggio, le modifiche apportate ai dati vengono propagate tra view e View Model in modo che sia determinato dal valore dell'enumerazione BindingMode , se presente, passato durante il passaggio di associazione.

Il codice seguente, se incluso in un progetto che fa riferimento alle classi precedenti, crea un'istanza di e MockBindableMockViewModel, esegue un'intitializzazione, 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	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.

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)	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.
CoerceValue(BindablePropertyKey)	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.
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)	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.
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)	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.
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)	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.