ObservableObject

A ObservableObject é uma classe base para objetos que são observáveis ao implementar as interfaces INotifyPropertyChanged e INotifyPropertyChanging. Pode ser usado como ponto de partida para todo o tipo de objetos que precisam de suportar notificações de alteração de propriedade.

APIs da plataforma:ObservableObject, TaskNotifier, TaskNotifier<T>

Como funciona

ObservableObject possui as seguintes características principais:

• Fornece uma implementação base para INotifyPropertyChanged e INotifyPropertyChanging, expondo os PropertyChanged eventos e PropertyChanging .
• Fornece uma série de SetProperty métodos que podem ser usados para definir facilmente valores de propriedades a partir de tipos que herdam de ObservableObject, e para gerar automaticamente os eventos apropriados.
• Fornece o método SetPropertyAndNotifyOnCompletion, que é análogo a SetProperty, mas com a capacidade de definir propriedades Task e gerar automaticamente os eventos de notificação quando as tarefas atribuídas são concluídas.
• Expõe os métodos OnPropertyChanged e OnPropertyChanging, que podem ser substituídos em tipos derivados para personalizar como os eventos de notificação são disparados.

Propriedade simples

Aqui está um exemplo de como implementar suporte de notificações para uma propriedade personalizada:

public class User : ObservableObject
{
    private string name;

    public string Name
    {
        get => name;
        set => SetProperty(ref name, value);
    }
}

O método fornecido SetProperty<T>(ref T, T, string) verifica o valor atual da propriedade, atualiza-o se for diferente, e depois também aumenta automaticamente os eventos relevantes. O nome da propriedade é automaticamente capturado através do uso do [CallerMemberName] atributo, por isso não é necessário especificar manualmente qual a propriedade que está a ser atualizada.

Encapsular um modelo não observável

Um cenário comum, por exemplo, ao trabalhar com itens de uma base de dados, consiste em criar um modelo "associável" de encapsulamento que retransmita as propriedades do modelo da base de dados e dispare as notificações de alteração de propriedade quando necessário. Isto também é necessário quando se quer injetar suporte de notificações em modelos que não implementam a INotifyPropertyChanged interface. ObservableObject fornece um método dedicado para tornar este processo mais simples. Para o exemplo seguinte, User é um modelo que mapeia diretamente uma tabela de base de dados, sem herdar de ObservableObject:

public class ObservableUser : ObservableObject
{
    private readonly User user;

    public ObservableUser(User user) => this.user = user;

    public string Name
    {
        get => user.Name;
        set => SetProperty(user.Name, value, user, (u, n) => u.Name = n);
    }
}

Neste caso, estamos a usar a versão sobrecarregada SetProperty<TModel, T>(T, T, TModel, Action<TModel, T>, string). A assinatura é ligeiramente mais complexa do que a anterior – isto é necessário para que o código continue extremamente eficiente, mesmo que não tenhamos acesso a um campo de apoio como no cenário anterior. Podemos analisar cada parte desta assinatura de método em detalhe para compreender o papel dos diferentes componentes:

• TModel é um argumento de tipo, indicando o tipo do modelo que estamos a envolver. Neste caso, será a nossa User classe. Note que não precisamos de especificar isto explicitamente – o compilador C# irá inferir isto automaticamente pela forma como estamos a invocar o SetProperty método.
• T é o tipo de propriedade que queremos definir. De forma semelhante a TModel, isto é inferido automaticamente.
• T oldValue é o primeiro parâmetro e, neste caso, estamos a usar user.Name para passar o valor atual dessa propriedade que estamos a envolver.
• T newValue é o novo valor a definir para a propriedade, e aqui estamos a passar value, que é o valor de entrada dentro do definidor de propriedades.
• TModel model é o modelo alvo que estamos a envolver, neste caso estamos a passar a instância armazenada no user campo.
• Action<TModel, T> callback é uma função que será invocada se o novo valor da propriedade for diferente do atual, e a propriedade tiver de ser definida. Isto será feito através desta função de callback, que recebe como parâmetros o modelo de destino e o novo valor a atribuir à propriedade. Neste caso, estamos apenas a atribuir o valor de entrada (que chamámos n) à Name propriedade (fazendo u.Name = n). É importante, neste caso, evitar capturar valores do contexto atual e interagir apenas com os que são fornecidos como entrada à callback, pois isso permite ao compilador de C# colocar a função de callback em cache e efetuar várias otimizações de desempenho. É por isso que não estamos apenas a aceder diretamente ao user campo aqui ou ao value parâmetro no setter, mas sim apenas a usar os parâmetros de entrada para a expressão lambda.

O SetProperty<TModel, T>(T, T, TModel, Action<TModel, T>, string) método torna a criação destas propriedades de wrapping extremamente simples, pois trata tanto da recuperação como da definição das propriedades alvo, ao mesmo tempo que fornece uma API extremamente compacta.

Propriedades de manuseamento Task<T>

Se uma propriedade for um Task, também é necessário disparar o evento de notificação quando a tarefa estiver concluída, para que os bindings sejam atualizados no momento certo, por exemplo, para apresentar um indicador de carregamento ou outras informações de estado relativas à operação representada pela tarefa. ObservableObject tem uma API para este cenário:

public class MyModel : ObservableObject
{
    private TaskNotifier<int>? requestTask;

    public Task<int>? RequestTask
    {
        get => requestTask;
        set => SetPropertyAndNotifyOnCompletion(ref requestTask, value);
    }

    public void RequestValue()
    {
        RequestTask = WebService.LoadMyValueAsync();
    }
}

Aqui, o SetPropertyAndNotifyOnCompletion<T>(ref TaskNotifier<T>, Task<T>, string) método trata de atualizar o campo de destino, monitorizar a nova tarefa, se existir, e levantar o evento de notificação quando essa tarefa for concluída. Desta forma, é possível simplesmente vincular-se a uma propriedade de uma tarefa e ser notificado quando o respetivo estado se alterar. O TaskNotifier<T> é um tipo especial exposto por ObservableObject que envolve uma instância de destino Task<T> e permite a lógica de notificação necessária para este método. O tipo TaskNotifier também está disponível para ser utilizado diretamente se tiver apenas um Task genérico.

Exemplos

• Dá uma vista de olhos à aplicação de exemplo (para múltiplos frameworks de interface) para veres o MVVM Toolkit em ação.
• Também podes encontrar mais exemplos nos testes unitários.