Migrazione da MvvmLight

  • Articolo

Questo articolo illustra alcune delle differenze principali tra MvvmLight Toolkit e MVVM Toolkit per semplificare la migrazione.

Anche se questo articolo è incentrato in modo specifico sulle migrazioni da MvvmLight a MVVM Toolkit, si noti che sono stati apportati miglioramenti aggiuntivi all'interno di MVVM Toolkit, quindi è consigliabile esaminare la documentazione per le singole API.

API della piattaforma:ObservableObject, ObservableRecipient, RelayCommand, RelayCommand<T>, AsyncRelayCommand, AsyncRelayCommand<T>, , MessageHandler<TRecipient, TMessage>IMessengerWeakReferenceMessengerStrongReferenceMessengerIRecipient<TMessage>IMessengerExtensions

Installazione di MVVM Toolkit

Per sfruttare i vantaggi di MVVM Toolkit, è prima necessario installare il pacchetto NuGet più recente nell'applicazione .NET esistente.

Eseguire l'installazione tramite l'interfaccia della riga di comando di .NET

dotnet add package CommunityToolkit.Mvvm --version 8.1.0

Eseguire l'installazione tramite PackageReference

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

Migrazione di ObservableObject

I passaggi seguenti sono incentrati sulla migrazione dei componenti esistenti che sfruttano mvvmLight ObservableObject Toolkit. MVVM Toolkit fornisce un ObservableObject tipo simile.

La prima modifica in questo caso verrà scambiata usando le direttive nei componenti.

// MvvmLight
using GalaSoft.MvvmLight;

// MVVM Toolkit
using CommunityToolkit.Mvvm.ComponentModel;

Di seguito è riportato un elenco di migrazioni che dovranno essere eseguite se usate nella soluzione corrente.

Metodi ObservableObject

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

Set(Expression, ref T, T) non dispone di una sostituzione della firma del metodo di tipo like.does not have a like-for-like method signature replacement.

Tuttavia, SetProperty(ref T, T, string) offre le stesse funzionalità con vantaggi aggiuntivi in termini di prestazioni.

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

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

Si noti che il string parametro non è obbligatorio se il metodo viene chiamato dal setter della proprietà, come viene dedotto dal nome del membro chiamante, come si può vedere qui. Se si desidera richiamare SetProperty per una proprietà diversa da quella in cui viene richiamato il metodo, è possibile farlo usando l'operatore nameof , che può essere utile per rendere il codice meno soggetto a errori non avendo nomi hardcoded. Ad esempio:

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

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

Set<T>(string, ref T, T) non dispone di una sostituzione della firma del metodo di tipo like.does not have a like-for-like method signature replacement.

Fornisce tuttavia SetProperty<T>(ref T, T, string) la stessa funzionalità con parametri riordinati.

// 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) ha una sostituzione diretta rinominata, 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) ha una sostituzione diretta rinominata, OnPropertyChanged(string).

// MvvmLight
RaisePropertyChanged(nameof(MyProperty));

// MVVM Toolkit
OnPropertyChanged();

Come con SetProperty, il nome della proprietà corrente viene dedotto automaticamente dal OnPropertyChanged metodo . Se si desidera utilizzare questo metodo per generare manualmente l'evento PropertyChanged per un'altra proprietà, è anche possibile specificare manualmente il nome di tale proprietà usando di nuovo l'operatore nameof . Ad esempio:

OnPropertyChanged(nameof(SomeProperty));

RaisePropertyChanged<T>(Expression)

RaisePropertyChanged<T>(Expression) non ha una sostituzione diretta.

È consigliabile migliorare le prestazioni sostituendo RaisePropertyChanged<T>(Expression) con la parola chiave del Toolkit OnPropertyChanged(string) usando invece la nameof parola chiave (o senza parametri, se la proprietà di destinazione è uguale a quella che chiama il metodo, in modo che il nome possa essere dedotto automaticamente come indicato in precedenza).

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

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

VerifyPropertyName(string)

Non esiste alcuna sostituzione diretta per il VerifyPropertyName(string) metodo e qualsiasi codice che usa questa operazione deve essere modificato o rimosso.

Il motivo dell'omissione di MVVM Toolkit è che l'uso della nameof parola chiave per una proprietà verifica che esista. Al momento della compilazione di MvvmLight, la nameof parola chiave non era disponibile e questo metodo è stato usato per assicurarsi che la proprietà esista nell'oggetto .

// MvvmLight
VerifyPropertyName(nameof(MyProperty));

// MVVM Toolkit
// No direct replacement, remove

Proprietà ObservableObject

PropertyChangedHandler

PropertyChangedHandler non ha una sostituzione diretta.

Per generare un evento modificato di proprietà tramite il PropertyChanged gestore eventi, è invece necessario chiamare il OnPropertyChanged metodo .

// MvvmLight
PropertyChangedEventHandler handler = PropertyChangedHandler;

// MVVM Toolkit
OnPropertyChanged();

Migrazione di ViewModelBase

I passaggi seguenti sono incentrati sulla migrazione dei componenti esistenti che sfruttano mvvmLight ViewModelBase Toolkit.

MVVM Toolkit fornisce un ObservableRecipient tipo che fornisce funzionalità simili.

Di seguito è riportato un elenco di migrazioni che dovranno essere eseguite se usate nella soluzione corrente.

Metodi ViewModelBase

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

Set<T>(string, ref T, T, bool) non dispone di una sostituzione della firma del metodo di tipo like.does not have a like-for-like method signature replacement.

Fornisce tuttavia SetProperty<T>(ref T, T, bool, string) la stessa funzionalità con parametri riordinati.

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

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

Si noti che il valore e i parametri booleani broadcast non sono facoltativi nell'implementazione di MVVM Toolkit e devono essere forniti per usare questo metodo. Il motivo di questa modifica è che omettendo il parametro broadcast quando si chiama questo metodo, per impostazione predefinita chiamerà il metodo ObservableObject SetProperty .

Inoltre, il string parametro non è obbligatorio se il metodo viene chiamato dal setter della proprietà come viene dedotto dal nome del membro chiamante, proprio come con i metodi nella classe base ObservableObject .

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

Set<T>(ref T, T, bool, string) ha una sostituzione diretta rinominata, 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) non ha una sostituzione diretta.

Per migliorare le prestazioni, è consigliabile sostituirlo con MVVM Toolkit SetProperty<T>(ref T, T, bool, string) usando invece la nameof parola chiave .

// 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) ha una sostituzione diretta che non richiede una ridenominazione.

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

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

Si noti che il messaggio inviato tramite la Messenger proprietà quando si chiama il Broadcast metodo ha una sostituzione diretta per PropertyChangedMessage all'interno della libreria MVVM Toolkit.

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

Non esiste alcuna sostituzione diretta per il RaisePropertyChanged<T>(string, T, T, bool) metodo .

L'alternativa più semplice consiste nel chiamare e successivamente chiamare OnPropertyChangedBroadcast per ottenere questa funzionalità.

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

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

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

Non esiste alcuna sostituzione diretta per il RaisePropertyChanged<T>(Expression, T, T, bool) metodo .

L'alternativa più semplice consiste nel chiamare e successivamente chiamare OnPropertyChangedBroadcast per ottenere questa funzionalità.

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

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

ICleanup.Cleanup()

Non esiste alcuna sostituzione diretta per l'interfaccia ICleanup .

Tuttavia, ObservableRecipient fornisce un OnDeactivated metodo che deve essere usato per fornire la stessa funzionalità di Cleanup.

OnDeactivated in MVVM Toolkit annulla anche la registrazione di tutti gli eventi di messenger registrati quando viene chiamato.

// MvvmLight
Cleanup();

// MVVM Toolkit
OnDeactivated();

Si noti che i OnActivated metodi e OnDeactivated possono essere chiamati dalla soluzione esistente come con Cleanup.

Tuttavia, ObservableRecipient espone una IsActive proprietà che controlla anche la chiamata a questi metodi quando è impostata.

Proprietà ViewModelBase

MessengerInstance

MessengerInstance ha una sostituzione diretta rinominata, Messenger.

// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;

Nota

Il valore predefinito della Messenger proprietà sarà l'istanza WeakReferenceMessenger.Default di , ovvero l'implementazione standard di reference messenger debole in MVVM Toolkit. Questa operazione può essere personalizzata semplicemente inserendo un'istanza diversa IMessenger nel ObservableRecipient costruttore.

IsInDesignMode

Non vi è alcuna sostituzione diretta per la IsInDesignMode proprietà e qualsiasi codice che usa questa operazione deve essere modificato o rimosso.

Il motivo dell'omissione di MVVM Toolkit è che la IsInDesignMode proprietà espone implementazioni specifiche della piattaforma. MVVM Toolkit è stato progettato per essere indipendente dalla piattaforma.

// MvvmLight
var isInDesignMode = IsInDesignMode;

// MVVM Toolkit
// No direct replacement, remove

Proprietà statiche ViewModelBase

IsInDesignModeStatic

Non vi è alcuna sostituzione diretta per la IsInDesignModeStatic proprietà e qualsiasi codice che usa questa operazione deve essere modificato o rimosso.

Il motivo dell'omissione di MVVM Toolkit è che la IsInDesignMode proprietà espone implementazioni specifiche della piattaforma. MVVM Toolkit è stato progettato per essere indipendente dalla piattaforma.

// MvvmLight
var isInDesignMode = ViewModelBase.IsInDesignModeStatic;

// MVVM Toolkit
// No direct replacement, remove

Migrazione di RelayCommand

I passaggi seguenti sono incentrati sulla migrazione dei componenti esistenti che sfruttano mvvmLight RelayCommand Toolkit.

MVVM Toolkit fornisce un RelayCommand tipo che fornisce funzionalità simili a quella che sfruttano l'interfaccia ICommand di sistema.

Di seguito è riportato un elenco di migrazioni che dovranno essere eseguite se usate nella soluzione corrente. Se non è elencato un metodo o una proprietà, esiste una sostituzione diretta con lo stesso nome in MVVM Toolkit e non è necessaria alcuna modifica.

La prima modifica in questo caso verrà scambiata usando le direttive nei componenti.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Nota

MvvmLight usa riferimenti deboli per stabilire il collegamento tra il comando e l'azione chiamata dalla classe associata. Questa operazione non è richiesta dall'implementazione di MVVM Toolkit e, se questo parametro facoltativo è stato impostato su true in uno dei costruttori, questo verrà rimosso.

Uso di RelayCommand con azioni asincrone

Se attualmente si usa l'implementazione di MvvmLight RelayCommand con azioni asincrone, MVVM Toolkit espone un'implementazione migliorata per questi scenari.

È sufficiente sostituire il esistente RelayCommand con l'oggetto AsyncRelayCommand creato per scopi asincroni.

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

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

Metodi RelayCommand

RaiseCanExecuteChanged()

La funzionalità di RaiseCanExecuteChanged() può essere ottenuta con il metodo di NotifyCanExecuteChanged() MVVM Toolkit.

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

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

Migrazione RelayCommand<T>

I passaggi seguenti sono incentrati sulla migrazione dei componenti esistenti che sfruttano mvvmLight RelayCommand<T> Toolkit.

MVVM Toolkit fornisce un RelayCommand<T> tipo che fornisce funzionalità simili a quella che sfruttano l'interfaccia ICommand di sistema.

Di seguito è riportato un elenco di migrazioni che dovranno essere eseguite se usate nella soluzione corrente. Se non è elencato un metodo o una proprietà, esiste una sostituzione diretta con lo stesso nome in MVVM Toolkit e non è necessaria alcuna modifica.

La prima modifica in questo caso verrà scambiata usando le direttive nei componenti.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Uso con RelayCommand azioni asincrone

Se attualmente si usa l'implementazione di MvvmLight RelayCommand<T> con azioni asincrone, MVVM Toolkit espone un'implementazione migliorata per questi scenari.

È sufficiente sostituire il esistente RelayCommand<T> con l'oggetto AsyncRelayCommand<T> creato per scopi asincroni.

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

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

RelayCommand<T> Metodi

RaiseCanExecuteChanged()

La funzionalità di RaiseCanExecuteChanged() può essere ottenuta con il metodo di NotifyCanExecuteChanged() MVVM Toolkit.

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

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

Migrazione SimpleIoc

L'implementazione IoC in MVVM Toolkit non include alcuna logica predefinita per gestire autonomamente l'inserimento delle dipendenze, quindi è possibile usare qualsiasi libreria di terze parti per recuperare un'istanza IServiceProvider che è quindi possibile passare al Ioc.ConfigureServices metodo. Negli esempi seguenti verrà usato il ServiceCollection tipo della Microsoft.Extensions.DependencyInjection libreria.

Questo è il cambiamento più importante tra MvvmLight e MVVM Toolkit.

Questa implementazione avrà familiarità se è stata implementata l'inserimento delle dipendenze con applicazioni ASP.NET Core.

Registrazione delle dipendenze

Con MvvmLight, è possibile che le dipendenze siano state registrate in modo simile a questi scenari usando SimpleIoc.

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

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

Con MVVM Toolkit, si otterrebbe lo stesso risultato del seguente.

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

Risoluzione delle dipendenze

Dopo l'inizializzazione Ioc , i servizi possono essere recuperati dalla classe esattamente come con SimpleIoc:

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

La migrazione a MVVM Toolkit consente di ottenere lo stesso risultato con:

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

Rimozione delle dipendenze

Con SimpleIoc, annullare la registrazione delle dipendenze con la chiamata al metodo seguente.

SimpleIoc.Default.Unregister<INavigationService>();

Non esiste alcuna sostituzione diretta per la rimozione delle dipendenze con l'implementazione di MVVM Toolkit Ioc .

Costruttore preferito

Quando si registrano le dipendenze con MvvmLight, SimpleIocè possibile usare le classi per fornire un PreferredConstructor attributo per quelli con più costruttori.

Questo attributo dovrà rimuovere dove viene usato e sarà necessario usare qualsiasi attributo della libreria di inserimento delle dipendenze di terze parti, se supportato.

Migrazione Messenger

I passaggi seguenti sono incentrati sulla migrazione dei componenti esistenti che sfruttano mvvmLight Messenger Toolkit.

MVVM Toolkit fornisce due implementazioni di messenger (WeakReferenceMessenger e StrongReferenceMessenger, vedere la documentazione qui) che fornisce funzionalità simili, con alcune differenze chiave descritte di seguito.

Di seguito è riportato un elenco di migrazioni che dovranno essere eseguite se usate nella soluzione corrente.

La prima modifica in questo caso verrà scambiata usando le direttive nei componenti.

// MvvmLight
using GalaSoft.MvvmLight.Messaging;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Messaging;

Metodi di Messenger

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

La funzionalità di Register<TMessage>(object, Action<TMessage>) può essere ottenuta con il metodo Register<TRecipient, TMessage>(object, MessageHandler<TRecipient, TMessage>)di estensione di IMessenger MVVM Toolkit .

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

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

Il motivo di questa firma è che consente al messaggero di utilizzare riferimenti deboli per tenere traccia correttamente dei destinatari e di evitare di creare chiuse per acquisire il destinatario stesso. Ovvero, il destinatario di input viene passato come input all'espressione lambda, quindi non deve essere acquisito dall'espressione lambda stessa. Ciò comporta anche codice più efficiente, poiché lo stesso gestore può essere riutilizzato più volte senza allocazioni. Si noti che questo è solo uno dei modi supportati per registrare i gestori ed è anche possibile usare l'interfaccia IRecipient<TMessage> (dettagliata nella documentazione messenger), che rende la registrazione automatica e meno dettagliata.

Nota

Il static modificatore per le espressioni lambda richiede C# 9 ed è facoltativo. È utile usarlo qui per assicurarsi di non acquisire accidentalmente il destinatario o un altro membro, causando quindi l'allocazione di una chiusura, ma non è obbligatorio. Se non è possibile usare C# 9, è sufficiente rimuovere static qui e prestare attenzione per assicurarsi che il codice non acquisisca nulla.

Inoltre, questo esempio e quelli seguenti usano solo la Messenger proprietà da ObservableRecipient. Se si vuole solo accedere in modo statico a un'istanza di Messenger da qualsiasi altra parte del codice, si applicano anche gli stessi esempi, con l'unica differenza che Messenger deve essere sostituita con es. WeakReferenceMessenger.Default Invece.

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

Non esiste alcuna sostituzione diretta per questo meccanismo di registrazione che consente di supportare anche la ricezione di messaggi per i tipi di messaggi derivati. Questa modifica è intenzionale perché l'implementazione mira a non usare la Messenger reflection per ottenere i vantaggi in termini di prestazioni.

In alternativa, sono disponibili alcune opzioni che è possibile eseguire per ottenere questa funzionalità.

  • Creare un'implementazione personalizzata IMessenger .
  • Registrare i tipi di messaggio aggiuntivi usando un gestore condiviso, quindi controlla il tipo e richiama il metodo corretto.
// 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>)

La funzionalità di Register<TMessage>(object, object, Action<TMessage>) può essere ottenuta con il metodo di Register<TRecipient, TMessage, TToken>(object, TToken, MessageHandler<TRecipient, TMessage>) 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>)

Non esiste alcuna sostituzione diretta per questo meccanismo di registrazione che consente di supportare anche la ricezione di messaggi per i tipi di messaggi derivati. Questa modifica è intenzionale perché l'implementazione mira a non usare la Messenger reflection per ottenere i vantaggi in termini di prestazioni.

In alternativa, sono disponibili alcune opzioni che è possibile eseguire per ottenere questa funzionalità.

  • Creare un'implementazione personalizzata IMessenger .
  • Registrare i tipi di messaggio aggiuntivi usando un gestore condiviso, quindi controlla il tipo e richiama il metodo corretto.
// 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)

La funzionalità di Send<TMessage>(TMessage) può essere ottenuta con il metodo Send<TMessage>(TMessage)di estensione di IMessenger MVVM Toolkit .

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

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

Nello scenario precedente in cui il messaggio inviato ha un costruttore senza parametri, MVVM Toolkit ha un'estensione semplificata per inviare un messaggio in questo formato.

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

Send<TMessage>(TMessage, object)

La funzionalità di Send<TMessage>(TMessage, object) può essere ottenuta con il metodo di Send<TMessage, TToken>(TMessage, TToken) MVVM Toolkit.

// 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)

La funzionalità di Unregister(object) può essere ottenuta con il metodo di UnregisterAll(object) MVVM Toolkit.

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

// MVVM Toolkit
Messenger.UnregisterAll(this);

Unregister<TMessage>(object)

La funzionalità di Unregister<TMessage>(object) può essere ottenuta con il metodo Unregister<TMessage>(object)di estensione di IMessenger MVVM Toolkit .

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

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

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

Non esiste alcuna sostituzione diretta per il Unregister<TMessage>(object, Action<TMessage>) metodo in MVVM Toolkit.

Il motivo dell'omissione è che un destinatario del messaggio può avere un solo gestore registrato per qualsiasi tipo di messaggio specificato.

È consigliabile ottenere questa funzionalità con il metodo Unregister<TMessage>(object)di estensione di IMessenger MVVM Toolkit.

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

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

Unregister<TMessage>(object, object)

La funzionalità di Unregister<TMessage>(object, object) può essere ottenuta con il metodo di Unregister<TMessage, TToken>(object, TToken) 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>)

Non esiste alcuna sostituzione diretta per il Unregister<TMessage>(object, object, Action<TMessage>) metodo in MVVM Toolkit.

Il motivo dell'omissione è che un destinatario del messaggio può avere un solo gestore registrato per qualsiasi tipo di messaggio specificato.

È consigliabile ottenere questa funzionalità con il metodo di Unregister<TMessage, TToken>(object, TToken) MVVM Toolkit.

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

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

Cleanup()

Il Cleanup metodo ha una sostituzione diretta con lo stesso nome in MVVM Toolkit. Si noti che questo metodo è utile solo quando viene usato un messenger che usa riferimenti deboli, mentre il StrongReferenceMessenger tipo non esegue semplicemente alcuna operazione quando questo metodo viene chiamato, poiché lo stato interno viene già tagliato automaticamente mentre viene usato messenger.

// MvvmLight
Messenger.Default.Cleanup();

// MVVM Toolkit
Messenger.Cleanup();

RequestCleanup()

Non esiste alcuna sostituzione diretta per il RequestCleanup metodo in MVVM Toolkit. Nel contesto di MvvmLight, RequestCleanup viene usato per avviare una richiesta di rimozione delle registrazioni che non sono più attive perché l'implementazione sfrutta i riferimenti deboli.

Tutte le chiamate al RequestCleanup metodo possono essere rimosse o sostituite con Cleanup.

// MvvmLight
Messenger.Default.RequestCleanup();

// MVVM Toolkit
// No direct replacement, remove

ResetAll()

La funzionalità di ResetAll() può essere ottenuta con il metodo di Reset() MVVM Toolkit.

A differenza dell'implementazione di MvvmLight che annulla l'istanza, MVVM Toolkit cancella le mappe registrate.

// MvvmLight
Messenger.Default.ResetAll();

// MVVM Toolkit
Messenger.Reset();

Metodi statici di Messenger

OverrideDefault(IMessenger)

Non esiste alcuna sostituzione diretta per il OverrideDefault(IMessenger) metodo in MVVM Toolkit.

Per usare un'implementazione personalizzata di IMessenger, registrare l'implementazione personalizzata nelle registrazioni del servizio per l'inserimento delle dipendenze o costruire manualmente un'istanza statica e passarla dove necessario.

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

// MVVM Toolkit
// No direct replacement

Reset()

Non esiste alcuna sostituzione diretta per il metodo statico Reset in MVVM Toolkit.

La stessa funzionalità può essere ottenuta chiamando il Reset metodo dell'istanza statica Default di uno dei tipi messenger.

// MvvmLight
Messenger.Reset();

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

Proprietà statiche di Messenger

Default

Default ha una sostituzione diretta, Default, che non richiede alcuna modifica all'implementazione esistente.

// MvvmLight
IMessenger messenger = Messenger.Default;

// MVVM Toolkit
IMessenger messenger = WeakReferenceMessenger.Default;

Migrazione dei tipi di messaggio

I tipi di messaggio forniti nel toolkit MvvmLight sono progettati come base per gli sviluppatori, se necessario.

Sebbene MVVM Toolkit fornisca alcune alternative, non esistono sostituzioni dirette per questi tipi di messaggio. È consigliabile esaminare i tipi di messaggio disponibili.

In alternativa, se la soluzione sfrutta i tipi di messaggio MvvmLight, è possibile convertirli facilmente nella propria codebase.

Migrazione di componenti specifici della piattaforma

Nell'implementazione corrente di MVVM Toolkit non esistono sostituzioni per i componenti specifici della piattaforma presenti nel toolkit MvvmLight.

I componenti seguenti e i relativi metodi helper/estensioni associati non hanno una sostituzione e dovranno prendere in considerazione quando si esegue la migrazione a MVVM Toolkit.

Android/iOS/Windows specifico

  • DialogService
  • DispatcherHelper
  • NavigationService

Specifico di Android/iOS

  • ActivityBase
  • Binding
  • BindingMode
  • PropertyChangedEventManager
  • UpdateTriggerMode

Android specifico

  • CachingViewHolder
  • ObservableAdapter
  • ObservableRecyclerAdapter

Specifico di iOS

  • ObservableCollectionViewSource
  • ObservableTableViewController
  • ObservableTableViewSource

Helper

  • Empty
  • WeakAction
  • WeakFunc