BindableObject Classe

Definição

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
BindableObject
Derivado
Implementações

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 possam ser usados para associar os dados por trás de seus elementos da interface do usuário para exibir modelos 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 BindableProperty , e a outra é uma propriedade de qualquer tipo que seja 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 bound; A propriedade do tipo desejado fornece a interface que o destino da propriedade associada irá 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 bound em uma classe que implementa a INotifyPropertyChanged interface. No padrão de design MVVM, isso normalmente é feito pelo modelo de exibição. Os desenvolvedores de aplicativos devem implementar a INotifyPropertyChanged interface em classes que desejam usar como modelos de exibição. No exemplo a seguir, os desenvolvedores de aplicativos devem anotar a idiomática maneira como a propriedade Name é implementada, primeiro, verificar se a propriedade realmente foi alterada e retornar se ela não e, em seguida, atribuir o valor e chamar o OnPropertyChanged(String) método. Além disso, a propriedade Name no exemplo abaixo simplesmente encapsula o campo Name . Na prática, o desenvolvedor do aplicativo pode escolher um modelo diferente no qual armazenar os 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 finalmente, o desenvolvedor do aplicativo associa uma instância de um Vinculobject a uma instância que implementa INotifyPropertyChanged. No vocabulário do padrão de design MVVM, isso é "associando uma instância da 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 a exibição e o modelo de exibição de uma maneira que seja determinada pelo valor da BindingMode enumeração, se houver, que foi passado durante a etapa de associação.

O código a seguir, quando incluído em um projeto que referencia as classes acima, cria uma instância de MockBindable e MockViewModel, executa algumas intitialization, define a associação e, em seguida, 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

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)
CoerceValue(BindablePropertyKey)
GetValue(BindableProperty)

Retorna o valor contido na BindableProperty.

GetValues(BindableProperty, BindableProperty)
Obsoleto.

Para uso interno pela plataforma do Xamarin.Forms.

GetValues(BindableProperty, 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)
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)
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)

Aplica-se a