Compartilhar via

Migração do MvvmLight

  • Artigo

Este artigo descreve algumas das principais diferenças entre o Kit de Ferramentas MvvmLight e o Kit de Ferramentas MVVM para facilitar sua migração.

Embora este artigo se concentre especificamente nas migrações do MvvmLight para o Kit de Ferramentas MVVM, observe que há melhorias adicionais que foram feitas no Kit de Ferramentas MVVM, portanto, é altamente recomendável dar uma olhada na documentação das novas APIs individuais.

APIs da plataforma:ObservableObject, ObservableRecipient, RelayCommand, RelayCommand<T>, AsyncRelayCommand, AsyncRelayCommand<T>, IMessenger, WeakReferenceMessenger, StrongReferenceMessenger, IRecipient<TMessage>, MessageHandler<TRecipient, TMessage>, IMessengerExtensions

Instalar o Kit de Ferramentas MVVM

Para aproveitar o Kit de Ferramentas MVVM, primeiro você precisará instalar o pacote NuGet mais recente em seu aplicativo .NET existente.

Instalar por meio da CLI do .NET

dotnet add package CommunityToolkit.Mvvm --version 8.1.0

Instalar por meio do PackageReference

<PackageReference Include="CommunityToolkit.Mvvm" Version="8.1.0" />

Migração do ObservableObject

As etapas a seguir se concentram na migração de seus componentes existentes que aproveitam o ObservableObject do Kit de Ferramentas MvvmLight. O Kit de Ferramentas MVVM fornece um tipo de ObservableObject semelhante.

A primeira alteração aqui será a troca usando diretivas em seus componentes.

// MvvmLight
using GalaSoft.MvvmLight;

// MVVM Toolkit
using CommunityToolkit.Mvvm.ComponentModel;

Veja abaixo uma lista de migrações que precisarão ser executadas se forem usadas em sua solução atual.

Métodos ObservableObject

Set<T>(Expression, ref T, T)

Set(Expression, ref T, T) não possui uma substituição de assinatura do método semelhante.

No entanto, SetProperty(ref T, T, string) fornece a mesma funcionalidade com benefícios adicionais de desempenho.

// MvvmLight
Set(() => MyProperty, ref this.myProperty, value);

// MVVM Toolkit
SetProperty(ref this.myProperty, value);

Observe que o parâmetro string não será necessário se o método estiver sendo chamado do setter da propriedade, pois é inferido do nome do membro do chamador, como pode ser visto aqui. Se você quiser invocar SetProperty de uma propriedade diferente daquela em que o método está sendo invocado, poderá fazer isso usando o operador nameof que pode ser útil para tornar o código menos sujeito a erros por não ter nomes codificados. Por exemplo:

SetProperty(ref this.someProperty, value, nameof(SomeProperty));

Set<T>(string, ref T, T)

Set<T>(string, ref T, T) não possui uma substituição de assinatura do método semelhante.

No entanto, SetProperty<T>(ref T, T, string) fornece a mesma funcionalidade com parâmetros reordenados.

// MvvmLight
Set(nameof(MyProperty), ref this.myProperty, value);

// MVVM Toolkit
SetProperty(ref this.myProperty, value);

Set<T>(ref T, T, string)

Set<T>(ref T, T, string) possui uma substituição direta renomeada, SetProperty<T>(ref T, T, string).

// MvvmLight
Set(ref this.myProperty, value, nameof(MyProperty));

// MVVM Toolkit
SetProperty(ref this.myProperty, value);

RaisePropertyChanged(string)

RaisePropertyChanged(string) possui uma substituição direta renomeada, OnPropertyChanged(string).

// MvvmLight
RaisePropertyChanged(nameof(MyProperty));

// MVVM Toolkit
OnPropertyChanged();

Assim como acontece com SetProperty, o nome da propriedade atual é inferido automaticamente pelo método OnPropertyChanged. Se você quiser usar esse método para gerar manualmente o evento PropertyChanged para outra propriedade, também poderá especificar manualmente o nome dessa propriedade usando o operador nameof novamente. Por exemplo:

OnPropertyChanged(nameof(SomeProperty));

RaisePropertyChanged<T>(Expression)

RaisePropertyChanged<T>(Expression) não possui um substituição direta.

É recomendável melhorar o desempenho que você substitui RaisePropertyChanged<T>(Expression) pelo OnPropertyChanged(string) do Kit de Ferramentas usando a palavra-chave nameof em vez disso (ou sem parâmetros, se a propriedade de destino for a mesma chama o método, para que o nome possa ser inferido automaticamente conforme mencionado acima).

// MvvmLight
RaisePropertyChanged(() => MyProperty);

// MVVM Toolkit
OnPropertyChanged(nameof(MyProperty));

VerifyPropertyName(string)

Não há substituição direta para o método VerifyPropertyName(string) e os códigos que o utilizam devem ser alterados ou removidos.

O motivo da omissão do Kit de Ferramentas MVVM é que o uso da palavra-chave nameof de uma propriedade verifica se ele existe. Quando o MvvmLight foi criado, a palavra-chave nameof não estava disponível e esse método foi utilizado para garantir que a propriedade existia no objeto.

// MvvmLight
VerifyPropertyName(nameof(MyProperty));

// MVVM Toolkit
// No direct replacement, remove

Propriedades ObservableObject

PropertyChangedHandler

PropertyChangedHandler não possui um substituição direta.

Para gerar um evento de propriedade alterada por meio do manipulador de eventos PropertyChanged, você precisará chamar o método OnPropertyChanged.

// MvvmLight
PropertyChangedEventHandler handler = PropertyChangedHandler;

// MVVM Toolkit
OnPropertyChanged();

Migração do ViewModelBase

As etapas a seguir se concentram na migração de seus componentes existentes que aproveitam o ViewModelBase do Kit de Ferramentas MvvmLight.

O Kit de Ferramentas MVVM fornece um tipo de ObservableRecipient que oferece funcionalidades semelhantes.

Veja abaixo uma lista de migrações que precisarão ser executadas se forem usadas em sua solução atual.

Métodos ViewModelBase

Set<T>(string, ref T, T, bool)

Set<T>(string, ref T, T, bool) não possui uma substituição de assinatura do método semelhante.

No entanto, SetProperty<T>(ref T, T, bool, string) fornece a mesma funcionalidade com parâmetros reordenados.

// MvvmLight
Set(nameof(MyProperty), ref this.myProperty, value, true);

// MVVM Toolkit
SetProperty(ref this.myProperty, value, true);

Observe que os parâmetros boolianos de valor e difusão não são opcionais na implementação do Kit de Ferramentas MVVM e devem ser fornecidos para usar esse método. O motivo dessa alteração é que, ao omitir o parâmetro de difusão ao chamar esse método, ele chamará por padrão o método SetProperty do ObservableObject.

Além disso, o parâmetro string não será necessário se o método estiver sendo chamado do setter da propriedade, pois é inferido do nome do membro do chamador, assim como com os métodos na classe ObservableObject base.

Set<T>(ref T, T, bool, string)

Set<T>(ref T, T, bool, string) possui uma substituição direta renomeada, SetProperty<T>(ref T, T, bool, string).

// MvvmLight
Set(ref this.myProperty, value, true, nameof(MyProperty));

// MVVM Toolkit
SetProperty(ref this.myProperty, value, true);

Set<T>(Expression, ref T, T, bool)

Set<T>(Expression, ref T, T, bool) não possui um substituição direta.

É recomendável que você substitua isso pelo SetProperty<T>(ref T, T, bool, string) do Kit de Ferramentas MVVM usando a palavra-chave nameof.

// MvvmLight
Set<MyObject>(() => MyProperty, ref this.myProperty, value, true);

// MVVM Toolkit
SetProperty(ref this.myProperty, value, true);

Broadcast<T>(T, T, string)

Broadcast<T>(T, T, string) possui uma substituição direta que não requer uma renomeação.

// MvvmLight
Broadcast<MyObject>(oldValue, newValue, nameof(MyProperty));

// MVVM Toolkit
Broadcast(oldValue, newValue, nameof(MyProperty));

Observe que a mensagem enviada por meio da propriedade Messenger ao chamar o método Broadcast tem uma substituição direta para PropertyChangedMessage dentro da biblioteca do Kit de Ferramentas MVVM.

RaisePropertyChanged<T>(string, T, T, bool)

Não há substituição direta para o método RaisePropertyChanged<T>(string, T, T, bool).

A alternativa mais simples é chamar OnPropertyChanged e, posteriormente, chamar Broadcast para obter essa funcionalidade.

// MvvmLight
RaisePropertyChanged<MyObject>(nameof(MyProperty), oldValue, newValue, true);

// MVVM Toolkit
OnPropertyChanged();
Broadcast(oldValue, newValue, nameof(MyProperty));

RaisePropertyChanged<T>(Expression, T, T, bool)

Não há substituição direta para o método RaisePropertyChanged<T>(Expression, T, T, bool).

A alternativa mais simples é chamar OnPropertyChanged e, posteriormente, chamar Broadcast para obter essa funcionalidade.

// MvvmLight
RaisePropertyChanged<MyObject>(() => MyProperty, oldValue, newValue, true);

// MVVM Toolkit
OnPropertyChanged(nameof(MyProperty));
Broadcast(oldValue, newValue, nameof(MyProperty));

ICleanup.Cleanup()

Não há substituição direta para a interface ICleanup.

No entanto, o ObservableRecipient fornece um método OnDeactivated que deve ser usado para fornecer a mesma funcionalidade que Cleanup.

OnDeactivated no Kit de Ferramentas MVVM também cancelará o registro de todos os eventos do mensageiro registrados quando chamado.

// MvvmLight
Cleanup();

// MVVM Toolkit
OnDeactivated();

Observe que os métodos OnActivated e OnDeactivated podem ser chamados de sua solução existente como com Cleanup.

No entanto, o ObservableRecipient expõe uma propriedade IsActive que também controla a chamada a esses métodos quando definida.

Propriedades ViewModelBase

MessengerInstance

MessengerInstance possui uma substituição direta renomeada, Messenger.

// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;

Observação

O valor padrão da propriedade Messenger será a instância de WeakReferenceMessenger.Default, que é a implementação do mensageiro de referência fraca padrão no Kit de Ferramentas MVVM. Isso pode ser personalizado apenas injetando uma instância de IMessenger diferente no construtor ObservableRecipient.

IsInDesignMode

Não há substituição direta para a propriedade IsInDesignMode e os códigos que o utilizam devem ser alterados ou removidos.

O motivo da omissão do Kit de Ferramentas MVVM é que a propriedade IsInDesignMode expôs implementações específicas da plataforma. O Kit de Ferramentas MVVM foi projetado para ser independente da plataforma.

// MvvmLight
var isInDesignMode = IsInDesignMode;

// MVVM Toolkit
// No direct replacement, remove

Propriedades estáticas ViewModelBase

IsInDesignModeStatic

Não há substituição direta para a propriedade IsInDesignModeStatic e os códigos que o utilizam devem ser alterados ou removidos.

O motivo da omissão do Kit de Ferramentas MVVM é que a propriedade IsInDesignMode expôs implementações específicas da plataforma. O Kit de Ferramentas MVVM foi projetado para ser independente da plataforma.

// MvvmLight
var isInDesignMode = ViewModelBase.IsInDesignModeStatic;

// MVVM Toolkit
// No direct replacement, remove

Migração do RelayCommand

As etapas a seguir se concentram na migração de seus componentes existentes que aproveitam o RelayCommand do Kit de Ferramentas MvvmLight.

O Kit de Ferramentas MVVM fornece um tipo de RelayCommand que oferece funcionalidade semelhante aproveitando a interface do sistema ICommand.

Veja abaixo uma lista de migrações que precisarão ser executadas se forem usadas em sua solução atual. Quando um método ou propriedade não está listado, há uma substituição direta com o mesmo nome no Kit de Ferramentas MVVM e não há nenhuma alteração necessária.

A primeira alteração aqui será a troca usando diretivas em seus componentes.

// MvvmLight
using GalaSoft.MvvmLight.Command;
using Galasoft.MvvmLight.CommandWpf;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Observação

O MvvmLight usa referências fracas para estabelecer o vínculo entre o comando e a ação chamada da classe associada. Isso não é exigido pela implementação do Kit de Ferramentas MVVM e, se esse parâmetro opcional tiver sido definido como true em qualquer um dos construtores, isso será removido.

Usar o RelayCommand com ações assíncronas

Se você estiver usando a implementação do MvvmLight RelayCommand com ações assíncronas, o Kit de Ferramentas MVVM exporá uma implementação aprimorada para esses cenários.

Você pode simplesmente substituir o RelayCommand existente pelo AsyncRelayCommand que foi criado para fins assíncronos.

// MvvmLight
var command = new RelayCommand(() => OnCommandAsync());
var command = new RelayCommand(async () => await OnCommandAsync());

// MVVM Toolkit
var asyncCommand = new AsyncRelayCommand(OnCommandAsync);

Métodos do RelayCommand

RaiseCanExecuteChanged()

A funcionalidade do RaiseCanExecuteChanged() pode ser obtida com o método NotifyCanExecuteChanged() do Kit de Ferramentas MVVM.

// MvvmLight
var command = new RelayCommand(OnCommand);
command.RaiseCanExecuteChanged();

// MVVM Toolkit
var command = new RelayCommand(OnCommand);
command.NotifyCanExecuteChanged();

Migração do RelayCommand<T>

As etapas a seguir se concentram na migração de seus componentes existentes que aproveitam o RelayCommand<T> do Kit de Ferramentas MvvmLight.

O Kit de Ferramentas MVVM fornece um tipo de RelayCommand<T> que oferece funcionalidade semelhante aproveitando a interface do sistema ICommand.

Veja abaixo uma lista de migrações que precisarão ser executadas se forem usadas em sua solução atual. Quando um método ou propriedade não está listado, há uma substituição direta com o mesmo nome no Kit de Ferramentas MVVM e não há nenhuma alteração necessária.

A primeira alteração aqui será a troca usando diretivas em seus componentes.

// MvvmLight
using GalaSoft.MvvmLight.Command;
using Galasoft.MvvmLight.CommandWpf;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Usar o RelayCommand com ações assíncronas

Se você estiver usando a implementação do MvvmLight RelayCommand<T> com ações assíncronas, o Kit de Ferramentas MVVM exporá uma implementação aprimorada para esses cenários.

Você pode simplesmente substituir o RelayCommand<T> existente pelo AsyncRelayCommand<T> que foi criado para fins assíncronos.

// MvvmLight
var command = new RelayCommand<string>(async () => await OnCommandAsync());

// MVVM Toolkit
var asyncCommand = new AsyncRelayCommand<string>(OnCommandAsync);

RelayCommand<T> Métodos

RaiseCanExecuteChanged()

A funcionalidade do RaiseCanExecuteChanged() pode ser obtida com o método NotifyCanExecuteChanged() do Kit de Ferramentas MVVM.

// MvvmLight
var command = new RelayCommand<string>(OnCommand);
command.RaiseCanExecuteChanged();

// MVVM Toolkit
var command = new RelayCommand<string>(OnCommand);
command.NotifyCanExecuteChanged();

Migração do SimpleIoc

A implementação do IoC no Kit de Ferramentas MVVM não inclui nenhuma lógica interna para lidar com a injeção de dependência por conta própria, portanto, você pode usar qualquer biblioteca de terceiros para recuperar uma instância de IServiceProvider que você pode passar para o método Ioc.ConfigureServices. Nos exemplos abaixo, o tipo de ServiceCollection da biblioteca de Microsoft.Extensions.DependencyInjection será usado.

Essa é a maior mudança entre o MvvmLight e o Kit de Ferramentas MVVM.

Essa implementação parecerá familiar se você tiver implementado a injeção de dependência com aplicativos ASP.NET Core.

Registrar suas dependências

Com o MvvmLight, você pode ter registrado suas dependências semelhantes a esses cenários usando SimpleIoc.

public void RegisterServices()
{
  SimpleIoc.Default.Register<INavigationService, NavigationService>();

  SimpleIoc.Default.Register<IDialogService>(() => new DialogService());
}

Com o Kit de Ferramentas MVVM, você conseguiria o mesmo resultado.

public void RegisterServices()
{
  Ioc.Default.ConfigureServices(
    new ServiceCollection()
    .AddSingleton<INavigationService, NavigationService>()
    .AddSingleton<IDialogService>(new DialogService())
    .BuildServiceProvider());
}

Resolver dependências

Depois de inicializados, os serviços podem ser recuperados da classe Ioc exatamente como com SimpleIoc:

IDialogService dialogService = SimpleIoc.Default.GetInstance<IDialogService>();

Ao migrar para o Kit de Ferramentas MVVM, você conseguiria o mesmo resultado com:

IDialogService dialogService = Ioc.Default.GetService<IDialogService>();

Removendo dependências

Com SimpleIoc, você cancelaria o registro de suas dependências com a chamada de método a seguir.

SimpleIoc.Default.Unregister<INavigationService>();

Não há substituição direta para remover dependências com a implementação do Kit de Ferramentas MVVM Ioc.

Construtor preferencial

Ao registrar suas dependências no SimpleIoc do MvvmLight, você terá a opção em suas classes de fornecer um atributo PreferredConstructor para aqueles com vários construtores.

Esse atributo precisará ser retirado quando usado e você precisará usar todos os atributos da biblioteca de injeção de dependência de terceiros em uso, se houver suporte.

Migração do Messenger

As etapas a seguir se concentram na migração de seus componentes existentes que aproveitam o Messenger do Kit de Ferramentas MvvmLight.

O Kit de Ferramentas MVVM fornece duas implementações do mensageiro (WeakReferenceMessenger e StrongReferenceMessenger, confira os documentos aqui) que fornece funcionalidade semelhante, com algumas diferenças importantes detalhadas abaixo.

Veja abaixo uma lista de migrações que precisarão ser executadas se forem usadas em sua solução atual.

A primeira alteração aqui será a troca usando diretivas em seus componentes.

// MvvmLight
using GalaSoft.MvvmLight.Messaging;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Messaging;

Métodos do mensageiro

Register<TMessage>(object, Action<TMessage>)

A funcionalidade do Register<TMessage>(object, Action<TMessage>) pode ser obtida com o método de extensão IMessenger do Kit de Ferramentas MVVM Register<TRecipient, TMessage>(object, MessageHandler<TRecipient, TMessage>).

// MvvmLight
Messenger.Default.Register<MyMessage>(this, this.OnMyMessageReceived);

// MVVM Toolkit
Messenger.Register<MyViewModel, MyMessage>(this, static (r, m) => r.OnMyMessageReceived(m));

O motivo dessa assinatura é que ela permite que o mensageiro use referências fracas para rastrear corretamente os destinatários e evitar a criação de fechamentos para capturar o próprio destinatário. Ou seja, o destinatário de entrada é passado como uma entrada para a expressão lambda, portanto, ele não precisa ser capturado pela própria expressão lambda. Isso também resulta em um código mais eficiente, pois o mesmo manipulador pode ser reutilizado várias vezes sem alocações. Observe que essa é apenas uma das maneiras compatíveis de registrar manipuladores e também é possível usar a interface IRecipient<TMessage> (detalhada nos documentos do mensageiro), o que torna o registro automático e menos detalhado.

Observação

O modificador static da expressões lambda requer C# 9 e é opcional. É útil usá-lo aqui para garantir que você não capture acidentalmente o destinatário ou algum outro membro, causando assim a alocação de um fechamento, mas não é obrigatório. Se você não puder usar o C# 9, basta remover static aqui e ter cuidado para garantir que o código não esteja capturando nada.

Além disso, este exemplo e os outros abaixo usarão apenas a propriedade Messenger de ObservableRecipient. Se você quiser acessar estaticamente uma instância do mensageiro de qualquer outro lugar do seu código, os mesmos exemplos também se aplicam, com a única diferença sendo que Messenger precisa ser substituído por exemplo. WeakReferenceMessenger.Default em vez disso.

Register<TMessage>(object, bool, Action<TMessage>)

Não há substituto direto para esse mecanismo de registro que também permite suportar o recebimento de mensagens para tipos de mensagens derivadas. Esta mudança é intencional, pois a implementação do Messenger visa não utilizar a reflexão para obter benefícios de desempenho.

Como alternativa, há algumas opções do que pode ser feito para obter essa funcionalidade.

  • Crie uma implementação de IMessenger personalizada.
  • Registre os tipos de mensagem adicionais usando um manipulador compartilhado que verifica o tipo e invoca o método correto.
// MvvmLight
Messenger.Default.Register<MyMessage>(this, true, this.OnMyMessageReceived);

// MVVM Toolkit
Messenger.Register<MyViewModel, MyMessage>(this, static (r, m) => r.OnMyMessageReceived(m));
Messenger.Register<MyViewModel, MyOtherMessage>(this, static (r, m) => r.OnMyMessageReceived(m));

Register<TMessage>(object, object, Action<TMessage>)

A funcionalidade do Register<TMessage>(object, object, Action<TMessage>) pode ser obtida com o método Register<TRecipient, TMessage, TToken>(object, TToken, MessageHandler<TRecipient, TMessage>) do Kit de Ferramentas MVVM.

// MvvmLight
Messenger.Default.Register<MyMessage>(this, nameof(MyViewModel), this.OnMyMessageReceived);

// MVVM Toolkit
Messenger.Register<MyViewModel, MyMessage, string>(this, nameof(MyViewModel), static (r, m) => r.OnMyMessageReceived(m));

Register<TMessage>(object, object, bool, Action<TMessage>)

Não há substituto direto para esse mecanismo de registro que também permite suportar o recebimento de mensagens para tipos de mensagens derivadas. Esta mudança é intencional, pois a implementação do Messenger visa não utilizar a reflexão para obter benefícios de desempenho.

Como alternativa, há algumas opções do que pode ser feito para obter essa funcionalidade.

  • Crie uma implementação de IMessenger personalizada.
  • Registre os tipos de mensagem adicionais usando um manipulador compartilhado que verifica o tipo e invoca o método correto.
// MvvmLight
Messenger.Default.Register<MyMessage>(this, nameof(MyViewModel), true, this.OnMyMessageReceived);

// MVVM Toolkit
Messenger.Register<MyViewModel, MyMessage, string>(this, nameof(MyViewModel), static (r, m) => r.OnMyMessageReceived(m));
Messenger.Register<MyViewModel, MyOtherMessage, string>(this, nameof(MyViewModel), static (r, m) => r.OnMyMessageReceived(m));

Send<TMessage>(TMessage)

A funcionalidade do Send<TMessage>(TMessage) pode ser obtida com o método de extensão IMessenger do Kit de Ferramentas MVVM Send<TMessage>(TMessage).

// MvvmLight
Messenger.Default.Send<MyMessage>(new MyMessage());
Messenger.Default.Send(new MyMessage());

// MVVM Toolkit
Messenger.Send(new MyMessage());

No cenário acima, onde a mensagem enviada possui um construtor sem parâmetros, o Kit de Ferramentas MVVM possui uma extensão simplificada para enviar uma mensagem neste formato.

// MVVM Toolkit
Messenger.Send<MyMessage>();

Send<TMessage>(TMessage, object)

A funcionalidade do Send<TMessage>(TMessage, object) pode ser obtida com o método Send<TMessage, TToken>(TMessage, TToken) do Kit de Ferramentas MVVM.

// MvvmLight
Messenger.Default.Send<MyMessage>(new MyMessage(), nameof(MyViewModel));
Messenger.Default.Send(new MyMessage(), nameof(MyViewModel));

// MVVM Toolkit
Messenger.Send(new MyMessage(), nameof(MyViewModel));

Unregister(object)

A funcionalidade do Unregister(object) pode ser obtida com o método UnregisterAll(object) do Kit de Ferramentas MVVM.

// MvvmLight
Messenger.Default.Unregister(this);

// MVVM Toolkit
Messenger.UnregisterAll(this);

Unregister<TMessage>(object)

A funcionalidade do Unregister<TMessage>(object) pode ser obtida com o método de extensão IMessenger do Kit de Ferramentas MVVM Unregister<TMessage>(object).

// MvvmLight
Messenger.Default.Unregister<MyMessage>(this);

// MVVM Toolkit
Messenger.Unregister<MyMessage>(this);

Unregister<TMessage>(object, Action<TMessage>)

Não há substituição direta para o método Unregister<TMessage>(object, Action<TMessage>) no Kit de Ferramentas MVVM.

O motivo da omissão é que um destinatário da mensagem só pode ter um único manipulador registrado para qualquer tipo de mensagem fornecido.

É recomendável obter essa funcionalidade com o método de extensão IMessenger do Kit de Ferramentas MVVM Unregister<TMessage>(object).

// MvvmLight
Messenger.Default.Unregister<MyMessage>(this, OnMyMessageReceived);

// MVVM Toolkit
Messenger.Unregister<MyMessage>(this);

Unregister<TMessage>(object, object)

A funcionalidade do Unregister<TMessage>(object, object) pode ser obtida com o método Unregister<TMessage, TToken>(object, TToken) do Kit de Ferramentas MVVM.

// MvvmLight
Messenger.Default.Unregister<MyMessage>(this, nameof(MyViewModel));

// MVVM Toolkit
Messenger.Unregister<MyMessage, string>(this, nameof(MyViewModel));

Unregister<TMessage>(object, object, Action<TMessage>)

Não há substituição direta para o método Unregister<TMessage>(object, object, Action<TMessage>) no Kit de Ferramentas MVVM.

O motivo da omissão é que um destinatário da mensagem só pode ter um único manipulador registrado para qualquer tipo de mensagem fornecido.

É recomendável obter essa funcionalidade com o método Unregister<TMessage, TToken>(object, TToken) do Kit de Ferramentas MVVM.

// MvvmLight
Messenger.Default.Unregister<MyMessage>(this, nameof(MyViewModel), OnMyMessageReceived);

// MVVM Toolkit
Messenger.Unregister<MyMessage, string>(this, nameof(MyViewModel));

Cleanup()

O método Cleanup possui uma substituição direta com o mesmo nome no Kit de Ferramentas MVVM. Observe que esse método só é útil quando um mensageiro que usa referências fracas está sendo usado, enquanto o tipo de StrongReferenceMessenger simplesmente não fará nada quando esse método é chamado, pois o estado interno já é cortado automaticamente conforme o mensageiro é usado.

// MvvmLight
Messenger.Default.Cleanup();

// MVVM Toolkit
Messenger.Cleanup();

RequestCleanup()

Não há substituição direta para o método RequestCleanup no Kit de Ferramentas MVVM. No contexto do MvvmLight, RequestCleanup é usado para iniciar uma solicitação para remover registros que não estão mais ativos, pois a implementação aproveita as referências fracas.

Todas as chamadas para o método RequestCleanup podem ser removidas ou substituídas por Cleanup.

// MvvmLight
Messenger.Default.RequestCleanup();

// MVVM Toolkit
// No direct replacement, remove

ResetAll()

A funcionalidade do ResetAll() pode ser obtida com o método Reset() do Kit de Ferramentas MVVM.

Ao contrário da implementação do MvvmLight que anula a instância, o Kit de Ferramentas MVVM limpa os mapas registrados.

// MvvmLight
Messenger.Default.ResetAll();

// MVVM Toolkit
Messenger.Reset();

Métodos estáticos do mensageiro

OverrideDefault(IMessenger)

Não há substituição direta para o método OverrideDefault(IMessenger) no Kit de Ferramentas MVVM.

Para usar uma implementação personalizada do IMessenger, registre a implementação personalizada nos registros de serviço para injeção de dependência ou construa manualmente uma instância estática e passe isso quando necessário.

// MvvmLight
Messenger.OverrideDefault(new Messenger());

// MVVM Toolkit
// No direct replacement

Reset()

Não há substituição direta para o método Reset estático no Kit de Ferramentas MVVM.

A mesma funcionalidade pode ser obtida chamando o método Reset da instância de Default estática de um dos tipos do mensageiro.

// MvvmLight
Messenger.Reset();

// MVVM Toolkit
WeakReferenceMessenger.Default.Reset();

Propriedades estáticas do mensageiro

Default

Default tem uma substituição direta, Default. Não exige nenhuma alteração na implementação existente.

// MvvmLight
IMessenger messenger = Messenger.Default;

// MVVM Toolkit
IMessenger messenger = WeakReferenceMessenger.Default;

Migração de tipos de mensagens

Os tipos de mensagem fornecidos no Kit de Ferramentas MvvmLight são projetados como uma base para você trabalhar, como desenvolvedor, se necessário.

Embora o Kit de Ferramentas MVVM forneça algumas alternativas, não há substituição direta para esses tipos de mensagem. Recomendamos examinar nossos tipos de mensagens disponíveis.

Como alternativa, se sua solução aproveitar os tipos de mensagem do MvvmLight, elas poderão ser facilmente portadas em sua própria base de código.

Migração de componentes específicos da plataforma

Na implementação atual do Kit de Ferramentas MVVM, não há substituições para componentes específicos da plataforma que existem no Kit de Ferramentas MvvmLight.

Os seguintes componentes e seus métodos auxiliares/de extensão associados não possuem uma substituição e precisarão ser considerados ao migrar para o Kit de Ferramentas MVVM.

Específico do Android/iOS/Windows

  • DialogService
  • DispatcherHelper
  • NavigationService

Específico do Android/iOS

  • ActivityBase
  • Binding
  • BindingMode
  • PropertyChangedEventManager
  • UpdateTriggerMode

Específico do Android

  • CachingViewHolder
  • ObservableAdapter
  • ObservableRecyclerAdapter

Específico do iOS

  • ObservableCollectionViewSource
  • ObservableTableViewController
  • ObservableTableViewSource

Auxiliares

  • Empty
  • WeakAction
  • WeakFunc