BindableObject Classe

Définition

Espace de noms:

Xamarin.Forms

Assembly:

Xamarin.Forms.Core.dll

Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.

public abstract class BindableObject : System.ComponentModel.INotifyPropertyChanged, Xamarin.Forms.Internals.IDynamicResourceHandler

type BindableObject = class
    interface INotifyPropertyChanged
    interface IDynamicResourceHandler

Héritage

Object

BindableObject

Dérivé

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

Implémente

INotifyPropertyChanged IDynamicResourceHandler

Remarques

La BindableObject classe fournit un mécanisme de stockage de données qui permet au développeur d’applications de synchroniser des données entre des objets en réponse à des modifications, par exemple, entre l’affichage et le modèle d’affichage dans le modèle de conception MVVM. Tous les éléments visuels de l’espace de noms héritent de BindableObject la Xamarin.Forms classe , de sorte qu’ils peuvent tous être utilisés pour lier les données derrière leurs éléments d’interface utilisateur aux modèles d’affichage fournis par le développeur d’application.

Pour lier les données derrière une propriété dans un BindableObject, généralement une vue, à une propriété dans le modèle d’affichage, les développeurs d’applications doivent effectuer les opérations suivantes.

Tout d’abord, le développeur crée une paire de propriétés sur la vue, dont l’une est un BindablePropertyet l’autre une propriété de tout type requis. Dans le code ci-dessous, MockBindableObject correspond à ce qui serait généralement un objet d’interface utilisateur dans le code de production. Les développeurs d’applications doivent noter l’utilisation de SetValue(BindableProperty, Object) et GetValue(BindableProperty) pour obtenir et définir la valeur sur la propriété liée ; La propriété du type souhaité fournit l’interface que la cible de la propriété liée implémentera.

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

Deuxièmement, le développeur crée l’implémentation de la propriété liée dans une classe qui implémente l’interface INotifyPropertyChanged . Dans le modèle de conception MVVM, cette opération est généralement effectuée par le modèle d’affichage. Les développeurs d’applications doivent implémenter l’interface INotifyPropertyChanged sur les classes qu’ils souhaitent utiliser comme modèles d’affichage. Dans l’exemple ci-dessous, les développeurs d’applications doivent prendre note de la façon idiomatique pour laquelle la Name propriété est implémentée, tout d’abord, s’assurer que la propriété a réellement changé et retourner si ce n’est pas le cas, puis seulement affecter la valeur et appeler la OnPropertyChanged(String) méthode . En outre, la Name propriété dans l’exemple ci-dessous encapsule simplement le name champ. Dans la pratique, le développeur d’applications peut choisir un autre modèle dans lequel stocker les données d’application.

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

Troisièmement, et enfin, le développeur d’applications lie un instance d’un BindableObject à un instance qui implémente INotifyPropertyChanged. Dans le vocabulaire du modèle de conception MVVM, il s’agit de « lier un instance de la vue à un instance d’un modèle d’affichage ». Une fois cette étape terminée, les modifications apportées aux données sont propagées entre l’affichage et le modèle d’affichage d’une manière déterminée par la valeur de l’énumération, le BindingMode cas échéant, qui a été passée pendant l’étape de liaison.

Le code ci-dessous, lorsqu’il est inclus dans un projet qui référence les classes ci-dessus, crée une instance de MockBindable et MockViewModel, effectue une intitialisation, définit la liaison, puis illustre une liaison unidirectionnelle. Le code ci-dessous s’exécute sans lever d’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 ();
}

Constructeurs

BindableObject()

Initialise une nouvelle instance de la classe BindableObject.

Champs

BindingContextProperty

Implémente la propriété liée dont l’interface est fournie par la propriété BindingContext.

Propriétés

BindingContext	Obtient ou définit l’objet qui contient les propriétés qui seront ciblées par les propriétés liées appartenant à ce BindableObject.
Dispatcher	Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.

Méthodes

ApplyBindings()	Applique les liaisons à BindingContext.
ClearValue(BindableProperty)	Efface toute valeur définie par SetValue pour property.
ClearValue(BindablePropertyKey)	Efface toute valeur définie par SetValue pour la propriété qui est identifiée par propertyKey.
CoerceValue(BindableProperty)	Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.
CoerceValue(BindablePropertyKey)	Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.
GetValue(BindableProperty)	Retourne la valeur qui est contenue dans BindableProperty.
GetValues(BindableProperty, BindableProperty)	Obsolète. Pour un usage interne par la plateforme Xamarin.Forms.
GetValues(BindableProperty, BindableProperty, BindableProperty)	Obsolète. Pour un usage interne par la plateforme Xamarin.Forms.
IsSet(BindableProperty)	Retourne true si la propriété cible existe et qu’elle a été configurée.
OnBindingContextChanged()	Substituez cette méthode pour exécuter une action lorsque le BindingContext change.
OnPropertyChanged(String)	Appelez cette méthode à partir d’une classe enfant pour avertir qu’un changement s’est produit au niveau d’une propriété.
OnPropertyChanging(String)	Appelez cette méthode à partir d’une classe enfant pour avertir qu’un changement va se produire au niveau d’une propriété.
RemoveBinding(BindableProperty)	Supprime une liaison précédemment définie.
SetBinding(BindableProperty, BindingBase)	Affecte une liaison à une propriété.
SetInheritedBindingContext(BindableObject, Object)	Définit le contexte hérité sur un élément imbriqué.
SetValue(BindableProperty, Object)	Définit la valeur de la propriété spécifiée.
SetValue(BindablePropertyKey, Object)	Définit la valeur de propertyKey.
SetValueCore(BindableProperty, Object, SetValueFlags)	Pour un usage interne par la plateforme Xamarin.Forms.
UnapplyBindings()	Supprime toutes les liaisons précédemment définies.

Événements

BindingContextChanged	Déclenché chaque fois que la propriété BindingContext est modifiée.
PropertyChanged	Déclenché lorsqu’une propriété a été modifiée.
PropertyChanging	Déclenché lorsqu’une propriété est sur le point d’être modifiée.

Implémentations d’interfaces explicites

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)

Pour un usage interne par la plateforme Xamarin.Forms.

Méthodes d’extension

GetPropertyIfSet<T>(BindableObject, BindableProperty, T)	Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)	Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.
SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)	Crée et applique une liaison à une propriété.
SetBinding<TSource>(BindableObject, BindableProperty, Expression<Func<TSource,Object>>, BindingMode, IValueConverter, String)	Obsolète. Crée et applique une liaison à partir d’une expression.
SetOnAppTheme<T>(BindableObject, BindableProperty, T, T)	Fournit un mécanisme par lequel les développeurs d’applications peuvent propager les modifications qui sont apportées aux données d’un objet vers un autre objet, en activant la validation, le forçage de type et un système d’événements. BindableProperty.