Migrando do MvvmLight

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>AsyncRelayCommandAsyncRelayCommand<T>IMessengerWeakReferenceMessengerStrongReferenceMessengerIRecipient<TMessage>, , MessageHandler<TRecipient, TMessage>IMessengerExtensions

Instalando o Kit de Ferramentas do MVVM

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

Instalar por meio da CLI .NET

dotnet add package CommunityToolkit.Mvvm --version 8.1.0

Instalar por meio de PackageReference

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

Migrando ObservableObject

As etapas a seguir focam na migração dos componentes existentes que fazem uso do ObservableObject do MvvmLight Toolkit. O Kit de Ferramentas MVVM fornece um ObservableObject tipo 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 tem uma substituição de assinatura de 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 string parâmetro não será necessário se o método estiver sendo chamado do setter da propriedade, pois ele é inferido do nome do membro do chamador, como pode ser visto aqui. Se você quiser invocar SetProperty uma propriedade diferente daquela em que o método está sendo invocado, poderá fazer isso usando o operador, o nameof que pode ser útil para tornar o código menos propenso 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 tem um método equivalente com a mesma assinatura.

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

// 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) tem como substituto direto renomeado 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) tem uma substituição direta renomeada, OnPropertyChanged(string).

// MvvmLight
RaisePropertyChanged(nameof(MyProperty));

// MVVM Toolkit
OnPropertyChanged();

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

OnPropertyChanged(nameof(SomeProperty));

RaisePropertyChanged<T>(Expression)

RaisePropertyChanged<T>(Expression) não tem uma substituição direta.

Recomenda-se, para melhorar o desempenho, substituir RaisePropertyChanged<T>(Expression) por OnPropertyChanged(string) do Toolkit usando a palavra-chave nameof (ou sem parâmetros, se a propriedade de destino for a mesma que 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 VerifyPropertyName(string) método e qualquer código que use isso deve ser alterado ou removido.

O motivo da omissão no MVVM Toolkit é que o uso da palavra-chave nameof em uma propriedade verifica se ela existe. Quando mvvmLight foi criado, a nameof palavra-chave não estava disponível e esse método foi usado para garantir que a propriedade existia no objeto.

// MvvmLight
VerifyPropertyName(nameof(MyProperty));

// MVVM Toolkit
// No direct replacement, remove

Propriedades de ObservableObject

PropertyChangedHandler

PropertyChangedHandler não tem um equivalente direto.

Para disparar um evento de alteração de propriedade por meio do manipulador de eventos PropertyChanged, você precisa chamar o método OnPropertyChanged em vez disso.

// MvvmLight
PropertyChangedEventHandler handler = PropertyChangedHandler;

// MVVM Toolkit
OnPropertyChanged();

Migrando ViewModelBase

As etapas a seguir focam na migração dos componentes existentes que fazem uso do ViewModelBase do MvvmLight Toolkit.

O Kit de Ferramentas MVVM fornece um ObservableRecipient tipo que fornece funcionalidade semelhante.

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

Métodos de ViewModelBase

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

Set<T>(string, ref T, T, bool) não possui um método equivalente com a mesma assinatura.

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

// 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 observableObject SetProperty .

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

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

Set<T>(ref T, T, bool, string) tem 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 tem um equivalente direto.

Para melhorar o desempenho, é recomendável substituir isto por SetProperty<T>(ref T, T, bool, string) do MVVM Toolkit, 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) tem 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 um equivalente direto na biblioteca PropertyChangedMessage do MVVM Toolkit.

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

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

A alternativa mais simples é chamar OnPropertyChanged e chamar Broadcast posteriormente 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 RaisePropertyChanged<T>(Expression, T, T, bool) método.

A alternativa mais simples é chamar OnPropertyChanged e chamar Broadcast posteriormente 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 ICleanup interface.

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

OnDeactivated no MVVM Toolkit também cancelará o registro de todos os eventos registrados no Messenger quando for chamado.

// MvvmLight
Cleanup();

// MVVM Toolkit
OnDeactivated();

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

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

Propriedades de ViewModelBase

MessengerInstance

MessengerInstance tem como substituição direta renomeada Messenger.

// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;

IsInDesignMode

Não há substituição direta para a IsInDesignMode propriedade e qualquer código que use isso deve ser alterado ou removido.

O motivo da omissão do Kit de Ferramentas MVVM é que a IsInDesignMode propriedade 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 de ViewModelBase

IsInDesignModeStatic

Não há substituição direta para a IsInDesignModeStatic propriedade e qualquer código que use isso deve ser alterado ou removido.

O motivo da omissão do Kit de Ferramentas MVVM é que a IsInDesignMode propriedade 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

Migrando o RelayCommand

As etapas a seguir focam na migração dos componentes existentes que fazem uso do RelayCommand do MvvmLight Toolkit.

O Toolkit do MVVM fornece um tipo RelayCommand que oferece funcionalidade equivalente, aproveitando a interface System 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;

Usando RelayCommand com ações assíncronas

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

Você pode simplesmente substituir o RelayCommand existente pelo AsyncRelayCommand, que foi criado para uso assíncrono.

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

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

Métodos de RelayCommand

RaiseCanExecuteChanged()

A funcionalidade de RaiseCanExecuteChanged() pode ser alcançada usando o método NotifyCanExecuteChanged() do MVVM Toolkit.

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

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

Migrando RelayCommand<T>

As etapas a seguir focam na migração dos componentes existentes que fazem uso do RelayCommand<T> do MvvmLight Toolkit.

O MVVM Toolkit fornece um tipo RelayCommand<T> que oferece funcionalidade equivalente, aproveitando a interface System do 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 RelayCommand com ações assíncronas

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

Você pode simplesmente substituir o RelayCommand<T> existente pelo AsyncRelayCommand<T>, que foi desenvolvido 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 de RaiseCanExecuteChanged() pode ser alcançada usando o método NotifyCanExecuteChanged() do MVVM Toolkit.

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

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

Migrando SimpleIoc

A implementação de 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ê está livre para usar qualquer biblioteca de terceiros para recuperar uma IServiceProvider instância que você pode passar para o Ioc.ConfigureServices método. Nos exemplos abaixo, o tipo ServiceCollection da biblioteca Microsoft.Extensions.DependencyInjection será usado.

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

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

Registrando 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ê alcançaria o mesmo que segue.

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

Resolvendo dependências

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

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

Migrando para o Kit de Ferramentas MVVM, você alcançará o mesmo com:

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

Removendo dependências

Com SimpleIoc, você desregistraria suas dependências com a seguinte chamada de método.

SimpleIoc.Default.Unregister<INavigationService>();

Não há um equivalente direto para remover dependências com a implementação Ioc do MVVM Toolkit.

Construtor preferencial

Ao registrar suas dependências com o SimpleIoc do MvvmLight, você pode, em suas classes, fornecer um atributo PreferredConstructor para aquelas que têm 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.

Migrando Messenger

As etapas a seguir focam na migração dos componentes existentes que fazem uso do Messenger do MvvmLight Toolkit.

O Kit de Ferramentas do MVVM fornece duas implementações de mensageiro (WeakReferenceMessenger e StrongReferenceMessenger, veja documentos aqui) que fornecem 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 Messenger

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

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

// 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 esta é apenas uma das formas suportadas de registrar manipuladores, e também é possível usar a interface IRecipient<TMessage> em vez disso (detalhada na documentação do messenger), o que torna o registro automático e menos verboso.

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

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

Não há substituição direta para esse mecanismo de registro que permite que você dê suporte ao recebimento de mensagens para tipos de mensagens derivadas também. Essa alteração é intencional, pois a Messenger implementação visa não usar a reflexão para obter seus benefícios de desempenho.

Como alternativa, há algumas opções que podem ser feitas para obter essa funcionalidade.

• Crie uma implementação personalizada IMessenger .
• Registre os tipos de mensagem adicionais usando um manipulador compartilhado do que verifica o tipo e invoca o método certo.

// 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 de Register<TMessage>(object, object, Action<TMessage>) pode ser obtida com o método Register<TRecipient, TMessage, TToken>(object, TToken, MessageHandler<TRecipient, TMessage>) do MVVM Toolkit.

// 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á substituição direta para esse mecanismo de registro que permite que você dê suporte ao recebimento de mensagens para tipos de mensagens derivadas também. Essa alteração é intencional, pois a Messenger implementação visa não usar a reflexão para obter seus benefícios de desempenho.

Como alternativa, há algumas opções que podem ser feitas para obter essa funcionalidade.

• Crie uma implementação personalizada IMessenger .
• Registre os tipos de mensagem adicionais usando um manipulador compartilhado do que verifica o tipo e invoca o método certo.

// 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 de Send<TMessage>(TMessage) pode ser obtida com o método de extensão Send<TMessage>(TMessage) do MVVM Toolkit IMessenger.

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

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

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

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

Send<TMessage>(TMessage, object)

A funcionalidade de 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 de Unregister(object) pode ser alcançada com o método UnregisterAll(object) do MVVM Toolkit.

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

// MVVM Toolkit
Messenger.UnregisterAll(this);

Unregister<TMessage>(object)

A funcionalidade de Unregister<TMessage>(object) pode ser obtida com o método de extensão IMessenger do MVVM Toolkit 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 Unregister<TMessage>(object, Action<TMessage>) método no Kit de Ferramentas MVVM.

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

Recomendamos implementar essa funcionalidade com o IMessengermétodo de extensão Unregister<TMessage>(object) do MVVM Toolkit.

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

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

Unregister<TMessage>(object, object)

A funcionalidade de Unregister<TMessage>(object, object) pode ser alcançada usando o método Unregister<TMessage, TToken>(object, TToken) do MVVM Toolkit.

// 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 Unregister<TMessage>(object, object, Action<TMessage>) método no Kit de Ferramentas MVVM.

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

Recomendamos alcançar essa funcionalidade com o método Unregister<TMessage, TToken>(object, TToken) do MVVM Toolkit.

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

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

Cleanup()

O Cleanup método tem 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 StrongReferenceMessenger tipo simplesmente não fará nada quando esse método é chamado, pois o estado interno já é cortado automaticamente à medida que o mensageiro está sendo usado.

// MvvmLight
Messenger.Default.Cleanup();

// MVVM Toolkit
Messenger.Cleanup();

RequestCleanup()

Não há substituição direta para o RequestCleanup método 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 RequestCleanup método podem ser removidas ou substituídas por Cleanup.

// MvvmLight
Messenger.Default.RequestCleanup();

// MVVM Toolkit
// No direct replacement, remove

ResetAll()

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

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 Messenger

OverrideDefault(IMessenger)

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

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

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

// MVVM Toolkit
// No direct replacement

Reset()

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

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

// MvvmLight
Messenger.Reset();

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

Propriedades estáticas do Messenger

Default

Default tem uma substituição direta, Defaultnão exigindo nenhuma alteração na implementação existente.

// MvvmLight
IMessenger messenger = Messenger.Default;

// MVVM Toolkit
IMessenger messenger = WeakReferenceMessenger.Default;

Migrando tipos de mensagens

Os tipos de mensagem fornecidos no kit de ferramentas MvvmLight são projetados como uma base para você como desenvolvedor trabalhar com, 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 MvvmLight, elas poderão ser facilmente portadas em sua própria base de código.

Migrando componentes específicos da plataforma

Na implementação atual do MVVM Toolkit, 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 e métodos de extensão associados não têm substituto e precisarão ser considerados ao migrar para o MVVM Toolkit.

Específico do Android/iOS/Windows

• DialogService
• DispatcherHelper
• NavigationService

Específico para Android/iOS

• ActivityBase
• Binding
• BindingMode
• PropertyChangedEventManager
• UpdateTriggerMode

Específico do Android

• CachingViewHolder
• ObservableAdapter
• ObservableRecyclerAdapter

Específico do iOS

• ObservableCollectionViewSource
• ObservableTableViewController
• ObservableTableViewSource

Helpers

• Empty
• WeakAction
• WeakFunc