Migrazione da MvvmLight

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

Installazione di MVVM Toolkit

Per sfruttare i vantaggi di MVVM Toolkit, è prima necessario installare il pacchetto NuGet più recente nell'applicazione di .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 si concentrano sulla migrazione dei componenti esistenti che si avvalgono di ObservableObject del MvvmLight 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 un sostituto equivalente per la firma di metodo.

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. Per esempio:

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

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

Set<T>(string, ref T, T) non dispone di un metodo sostitutivo con la stessa firma.

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 . Per 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 dall'MVVM Toolkit è che l'uso della parola chiave nameof per una proprietà ne verifica l'esistenza. 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à di ObservableObject

PropertyChangedHandler

PropertyChangedHandler non ha una sostituzione diretta.

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

// MvvmLight
PropertyChangedEventHandler handler = PropertyChangedHandler;

// MVVM Toolkit
OnPropertyChanged();

Migrazione di ViewModelBase

I passaggi seguenti si concentrano sulla migrazione dei componenti esistenti che sfruttano il ViewModelBase del Toolkit MvvmLight.

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 un metodo sostitutivo con una firma equivalente.

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 OnPropertyChanged e successivamente Broadcast 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 OnPropertyChanged e successivamente Broadcast 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 nel MVVM Toolkit annulla anche la registrazione di tutti gli eventi del messenger registrati quando viene chiamato.

// MvvmLight
Cleanup();

// MVVM Toolkit
OnDeactivated();

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

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

Proprietà di ViewModelBase

MessengerInstance

MessengerInstance ha una sostituzione diretta rinominata, Messenger.

// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;

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 si concentrano sulla migrazione dei componenti esistenti che sfruttano il RelayCommand di MvvmLight Toolkit.

MVVM Toolkit fornisce un tipo RelayCommand che offre funzionalità equivalenti sfruttando l'interfaccia di sistema ICommand.

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 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 di 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 in corso RelayCommand<T>

I passaggi seguenti si concentrano sulla migrazione dei componenti esistenti che sfruttano il RelayCommand<T> di MvvmLight Toolkit.

MVVM Toolkit mette a disposizione un tipo RelayCommand<T> che offre funzionalità equivalenti, sfruttando l'interfaccia di sistema ICommand.

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 di RelayCommand con 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 in corso 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 tipo ServiceCollection della libreria Microsoft.Extensions.DependencyInjection.

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

Questa implementazione risulterà familiare se hai implementato l'iniezione delle dipendenze nelle 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 il MVVM Toolkit, otterresti lo stesso risultato come segue.

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

Risoluzione delle dipendenze

Una volta inizializzati, i servizi possono essere ottenuti dalla classe Ioc proprio 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, puoi annullare la registrazione delle dipendenze con la seguente chiamata al metodo.

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 SimpleIoc di MvvmLight, nelle classi è possibile specificare un attributo PreferredConstructor per quelle che dispongono di più costruttori.

Questo attributo dovrà essere rimosso laddove utilizzato e sarà necessario usare gli eventuali attributi della libreria di dependency injection di terze parti in uso, se supportati.

Migrazione in corso Messenger

I passaggi seguenti si concentrano sulla migrazione dei componenti esistenti che sfruttano il Messenger di MvvmLight 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 tramite il metodo di estensione IMessenger del MVVM Toolkit 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));

Il motivo di questa firma è che consente al messaggero di utilizzare riferimenti deboli per tracciare correttamente i destinatari ed evitare di creare closure per catturare 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 invece l'interfaccia IRecipient<TMessage>, come descritto nella documentazione di Messenger, che rende la registrazione automatica e più concisa.

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, poiché l'implementazione Messenger ha l'obiettivo di non usare la riflessione per garantire i relativi 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 Messenger mira a non utilizzare la 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 di estensione IMessenger del MVVM Toolkit Send<TMessage>(TMessage).

// 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 di estensione IMessenger del MVVM Toolkit Unregister<TMessage>(object).

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

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

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

Si consiglia di implementare questa funzionalità con il metodo Unregister<TMessage, TToken>(object, TToken) di MVVM Toolkit.

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

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

Cleanup()

Il metodo Cleanup ha un equivalente diretto con lo stesso nome nel MVVM Toolkit. Si noti che questo metodo è utile solo quando si utilizza un messenger che usa riferimenti deboli, mentre il tipo StrongReferenceMessenger non farà semplicemente nulla quando questo metodo viene chiamato, poiché lo stato interno viene già ripulito automaticamente durante l’uso del 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 nella configurazione dei servizi per l'iniezione delle dipendenze oppure creare manualmente un'istanza statica e passarla dove richiesto.

// 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 concepiti per fungere da base che tu, in qualità di sviluppatore, puoi utilizzare 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/di estensione associati non hanno un sostituto e andranno presi in considerazione durante la migrazione al MVVM Toolkit.

specifico per Android/iOS/Windows

• DialogService
• DispatcherHelper
• NavigationService

Specifico per Android/iOS

• ActivityBase
• Binding
• BindingMode
• PropertyChangedEventManager
• UpdateTriggerMode

Specifico per Android

• CachingViewHolder
• ObservableAdapter
• ObservableRecyclerAdapter

Specifico per iOS

• ObservableCollectionViewSource
• ObservableTableViewController
• ObservableTableViewSource

Helpers

• Empty
• WeakAction
• WeakFunc