BindableObject Classe

Definição

Namespace:

Xamarin.Forms

Assembly:

Xamarin.Forms.Core.dll

Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.

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

type BindableObject = class
    interface INotifyPropertyChanged
    interface IDynamicResourceHandler

Herança

System.Object

BindableObject

Derivado

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

Implementações

System.ComponentModel.INotifyPropertyChanged IDynamicResourceHandler

Comentários

A BindableObject classe fornece um mecanismo de armazenamento de dados que permite que o desenvolvedor do aplicativo sincronize dados entre objetos em resposta a alterações, por exemplo, entre o modelo de exibição e exibição no padrão de design MVVM. Todos os elementos visuais no Xamarin.Forms namespace herdam da BindableObject classe , para que todos eles possam ser usados para associar os dados por trás de seus elementos de interface do usuário a Modelos de Exibição fornecidos pelo desenvolvedor do aplicativo.

Para associar os dados por trás de uma propriedade em um BindableObject, normalmente uma exibição, a uma propriedade no Modelo de Exibição, os desenvolvedores de aplicativos devem fazer o seguinte.

Primeiro, o desenvolvedor cria um par de propriedades na exibição, uma das quais é uma BindablePropertye a outra é uma propriedade de qualquer tipo necessário. No código abaixo, MockBindableObject significa o que normalmente seria um objeto de interface do usuário no código de produção. Os desenvolvedores de aplicativos devem observar o uso de SetValue(BindableProperty, Object) e GetValue(BindableProperty) para obter e definir o valor na propriedade associada; A propriedade do tipo desejado fornece a interface que o destino da propriedade associada implementará.

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

Em segundo lugar, o desenvolvedor cria a implementação para a propriedade associada em uma classe que implementa a System.ComponentModel.INotifyPropertyChanged interface . No padrão de design MVVM, isso normalmente é feito pelo Modelo de Exibição. Os desenvolvedores de aplicativos devem implementar a System.ComponentModel.INotifyPropertyChanged interface em classes que desejam usar como Modelos de Exibição. No exemplo a seguir, os desenvolvedores de aplicativos devem tomar nota da maneira idiomática para a qual a Name propriedade é implementada, primeiro, garantir que a propriedade realmente foi alterada e retornar se não o fez e, em seguida, atribuir o valor e chamar o OnPropertyChanged(String) método. Além disso, a Name propriedade no exemplo abaixo simplesmente encapsula o name campo. Na prática, o desenvolvedor de aplicativos pode escolher um modelo diferente no qual armazenar dados do aplicativo.

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

Terceiro e, por fim, o desenvolvedor de aplicativos associa uma instância de um BindableObject a uma instância que implementa INotifyPropertyChanged. No vocabulário do padrão de design MVVM, isso é "associar uma instância do Modo de Exibição a uma instância de um Modelo de Exibição". Depois que essa etapa for concluída, as alterações nos dados serão propagadas entre o Modo de Exibição e o Modelo de Exibição de uma maneira determinada pelo valor da BindingMode enumeração, se houver, que foi passado durante a etapa de associação.

O código abaixo, quando incluído em um projeto que faz referência às classes acima, cria uma instância de MockBindable e MockViewModel, executa alguma intialização, define a associação e demonstra uma associação unidirecional. O código a seguir é executado sem gerar uma exceção.

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

Construtores

BindableObject()

Inicializa uma nova instância da classe BindableObject.

Campos

BindingContextProperty

Implementa a propriedade associada cuja interface é fornecida pela propriedade BindingContext.

Propriedades

BindingContext	Obtém ou define o objeto que contém as propriedades que serão o destino das propriedades associadas que pertencem a este BindableObject.
Dispatcher	Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.

Métodos

ApplyBindings()	Aplicar as associações a BindingContext.
ClearValue(BindableProperty)	Limpa qualquer valor definido por SetValue para property.
ClearValue(BindablePropertyKey)	Limpa qualquer valor definido por SetValue para a propriedade identificada por propertyKey.
CoerceValue(BindableProperty)	Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.
CoerceValue(BindablePropertyKey)	Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.
GetValue(BindableProperty)	Retorna o valor contido na BindableProperty.
GetValues(BindableProperty, BindableProperty, BindableProperty)	Obsoleto. Para uso interno pela plataforma do Xamarin.Forms.
GetValues(BindableProperty, BindableProperty)	Obsoleto. Para uso interno pela plataforma do Xamarin.Forms.
IsSet(BindableProperty)	Retornará true se a propriedade de destino existir e tiver sido definida.
OnBindingContextChanged()	Substitua este método para executar uma ação quando BindingContext mudar.
OnPropertyChanged(String)	Chame esse método de uma classe filho para notificar que ocorreu uma alteração em uma propriedade.
OnPropertyChanging(String)	Chame esse método de uma classe filho para notificar que uma alteração vai acontecer em uma propriedade.
RemoveBinding(BindableProperty)	Remove uma associação definida anteriormente.
SetBinding(BindableProperty, BindingBase)	Atribui uma associação a uma propriedade.
SetInheritedBindingContext(BindableObject, Object)	Define o contexto herdado para um elemento aninhado.
SetValue(BindableProperty, Object)	Define o valor da propriedade especificada.
SetValue(BindablePropertyKey, Object)	Define o valor da propertyKey.
SetValueCore(BindableProperty, Object, SetValueFlags)	Para uso interno pela plataforma do Xamarin.Forms.
UnapplyBindings()	Cancela a aplicação de todas as associações definidas anteriormente.

Eventos

BindingContextChanged	Gerado sempre que a propriedade BindingContext muda.
PropertyChanged	Gerado quando uma propriedade foi alterada.
PropertyChanging	Gerado quando uma propriedade está prestes a mudar.

Implantações explícitas de interface

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)

Para uso interno pela plataforma do Xamarin.Forms.

Métodos de Extensão

GetPropertyIfSet<T>(BindableObject, BindableProperty, T)	Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)	Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.
SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)	Cria e aplica uma associação a uma propriedade.
SetBinding<TSource>(BindableObject, BindableProperty, Expression<Func<TSource,Object>>, BindingMode, IValueConverter, String)	Obsoleto. Cria e aplica uma associação de uma expressão.
SetOnAppTheme<T>(BindableObject, BindableProperty, T, T)	Fornece um mecanismo pelo qual desenvolvedores de aplicativo podem propagar as alterações feitas aos dados em um objeto para outro, habilitando validação, coerção de tipo e um sistema de evento. BindableProperty.