Migrera från MvvmLight

Den här artikeln beskriver några av de viktigaste skillnaderna mellan MvvmLight Toolkit och MVVM Toolkit för att underlätta migreringen.

Den här artikeln fokuserar specifikt på migreringarna från MvvmLight till MVVM Toolkit, men observera att det finns ytterligare förbättringar som har gjorts i MVVM Toolkit, så det är starkt att rekommendera att du tar en titt på dokumentationen för de enskilda nya API:erna.

API:er för plattformar:ObservableObject, ObservableRecipient, RelayCommand, RelayCommand<T>, AsyncRelayCommand, AsyncRelayCommand<T>, IMessenger, WeakReferenceMessenger, StrongReferenceMessenger, IRecipient<TMessage>, MessageHandler<TRecipient, TMessage>, IMessengerExtensions

Installera MVVM Toolkit-ը

För att kunna dra nytta av MVVM Toolkit måste du först installera det senaste NuGet-paketet i ditt befintliga .NET-program.

Installera via .NET CLI

dotnet add package CommunityToolkit.Mvvm --version 8.1.0

Installera via PackageReference

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

Migrering av ObservableObject

Följande steg fokuserar på att migrera dina befintliga komponenter som utnyttjar ObservableObject MvvmLight Toolkit. MVVM Toolkit tillhandahåller en ObservableObject typ som är liknande.

Den första ändringen här är att växla med hjälp av direktiv i dina komponenter.

// MvvmLight
using GalaSoft.MvvmLight;

// MVVM Toolkit
using CommunityToolkit.Mvvm.ComponentModel;

Nedan visas en lista över migreringar som måste utföras om de används i den aktuella lösningen.

ObservableObject-metoder

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

Set(Expression, ref T, T) inte har någon ersättning för en liknande metodsignatur.

Ger dock SetProperty(ref T, T, string) samma funktioner med ytterligare prestandafördelar.

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

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

Observera att parametern string inte krävs om metoden anropas från egenskapens setter som den härleds från namnet på anroparens medlem, vilket visas här. Om du vill anropa SetProperty för en egenskap som skiljer sig från den där metoden anropas kan du göra det med hjälp av operatorn nameof , vilket kan vara användbart för att göra koden mindre felbenägen genom att inte ha hårdkodade namn. Till exempel:

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

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

Set<T>(string, ref T, T) inte har någon ersättning för en liknande metodsignatur.

Dock ger SetProperty<T>(ref T, T, string) samma funktion med parametrarna i en annan ordning.

// 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) har en direkt ersättare med ett nytt namn, 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) har en direkt ersättare med nytt namn, OnPropertyChanged(string).

// MvvmLight
RaisePropertyChanged(nameof(MyProperty));

// MVVM Toolkit
OnPropertyChanged();

Precis som med SetPropertyhärleds namnet på den aktuella egenskapen automatiskt av OnPropertyChanged metoden. Om du vill använda den här metoden för att manuellt generera PropertyChanged händelsen för en annan egenskap kan du också ange namnet på den egenskapen manuellt med hjälp av operatorn nameof igen. Till exempel:

OnPropertyChanged(nameof(SomeProperty));

RaisePropertyChanged<T>(Expression)

RaisePropertyChanged<T>(Expression) har inte någon direkt ersättning.

För bättre prestanda rekommenderas att du ersätter RaisePropertyChanged<T>(Expression) med Toolkits OnPropertyChanged(string) och använder nyckelordet nameof i stället (eller utan parametrar, om målegenskapen är densamma som den som anropar metoden, så att namnet kan härledas automatiskt, som nämnts ovan).

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

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

VerifyPropertyName(string)

Det finns ingen direkt ersättning för VerifyPropertyName(string) metoden och all kod som använder detta bör ändras eller tas bort.

Anledningen till utelämnandet från MVVM Toolkit är att nyckelordet nameof för en egenskap verifierar att det finns. När MvvmLight skapades var nyckelordet nameof inte tillgängligt och den här metoden användes för att säkerställa att egenskapen fanns på objektet.

// MvvmLight
VerifyPropertyName(nameof(MyProperty));

// MVVM Toolkit
// No direct replacement, remove

ObservableObject-egenskaper

PropertyChangedHandler

PropertyChangedHandler har inte någon direkt ersättning.

Om du vill skapa en egenskaps ändrad händelse via PropertyChanged händelsehanteraren måste du anropa OnPropertyChanged metoden i stället.

// MvvmLight
PropertyChangedEventHandler handler = PropertyChangedHandler;

// MVVM Toolkit
OnPropertyChanged();

Migrering av ViewModelBase

Följande steg fokuserar på att migrera dina befintliga komponenter som utnyttjar ViewModelBase MvvmLight Toolkit.

MVVM Toolkit tillhandahåller en ObservableRecipient typ som ger liknande funktioner.

Nedan visas en lista över migreringar som måste utföras om de används i den aktuella lösningen.

ViewModelBase-metoder

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

Set<T>(string, ref T, T, bool) inte har någon ersättning för en liknande metodsignatur.

Dock erbjuder SetProperty<T>(ref T, T, bool, string) samma funktionalitet, men med parametrarna i en annan ordning.

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

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

Observera att värdet och de booleska parametrarna för sändning inte är valfria i MVVM Toolkits implementering och måste tillhandahållas för att använda den här metoden. Anledningen till den här ändringen är att genom att utelämna broadcast-parametern när du anropar den här metoden anropar den som standard ObservableObject-metoden SetProperty .

Parametern string krävs inte heller om metoden anropas från egenskapens setter eftersom den härleds från namnet på anroparens medlem, precis som med metoderna i basklassen ObservableObject .

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

Set<T>(ref T, T, bool, string) har en direkt ersättare med ett nytt namn, 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) har inte någon direkt ersättning.

Det rekommenderas för bättre prestanda att du ersätter detta med MVVM Toolkits SetProperty<T>(ref T, T, bool, string) med nyckelordet nameof i stället.

// 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) har en direkt ersättning som inte kräver ett namnbyte.

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

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

Observera att meddelandet som skickas via Messenger egenskapen när metoden anropas Broadcast har en direkt ersättning för PropertyChangedMessage i MVVM Toolkit-biblioteket.

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

Det finns ingen direkt ersättning för RaisePropertyChanged<T>(string, T, T, bool) metoden.

Det enklaste alternativet är att anropa OnPropertyChanged och sedan anropa Broadcast för att uppnå den här funktionen.

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

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

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

Det finns ingen direkt ersättning för RaisePropertyChanged<T>(Expression, T, T, bool) metoden.

Det enklaste alternativet är att anropa OnPropertyChanged och sedan anropa Broadcast för att uppnå den här funktionen.

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

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

ICleanup.Cleanup()

Det finns ingen direkt ersättning för ICleanup gränssnittet.

Tillhandahåller dock ObservableRecipient en OnDeactivated metod som ska användas för att tillhandahålla samma funktioner som Cleanup.

OnDeactivated I MVVM Toolkit avregistreras även alla registrerade messenger-händelser när de anropas.

// MvvmLight
Cleanup();

// MVVM Toolkit
OnDeactivated();

Observera att OnActivated metoderna och OnDeactivated kan anropas från din befintliga lösning som med Cleanup.

Men ObservableRecipient exponerar en IsActive egenskap som även styr anropet till dessa metoder när den har angetts.

Egenskaper för ViewModelBase

MessengerInstance

MessengerInstance har en direkt ersättare med det nya namnet Messenger.

// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;

IsInDesignMode

Det finns ingen direkt ersättning för egenskapen IsInDesignMode och all kod som använder detta bör ändras eller tas bort.

Orsaken till utelämnandet från MVVM Toolkit är att IsInDesignMode egenskapen exponerade plattformsspecifika implementeringar. MVVM Toolkit har utformats för att vara plattformsoberoende.

// MvvmLight
var isInDesignMode = IsInDesignMode;

// MVVM Toolkit
// No direct replacement, remove

Statiska egenskaper för ViewModelBase

IsInDesignModeStatic

Det finns ingen direkt ersättning för egenskapen IsInDesignModeStatic och all kod som använder detta bör ändras eller tas bort.

Orsaken till utelämnandet från MVVM Toolkit är att IsInDesignMode egenskapen exponerade plattformsspecifika implementeringar. MVVM Toolkit har utformats för att vara plattformsoberoende.

// MvvmLight
var isInDesignMode = ViewModelBase.IsInDesignModeStatic;

// MVVM Toolkit
// No direct replacement, remove

Migrering av RelayCommand

Följande steg fokuserar på att migrera dina befintliga komponenter som utnyttjar RelayCommand MvvmLight Toolkit.

MVVM Toolkit tillhandahåller en RelayCommand typ som ger liknande funktioner som utnyttjar ICommand systemgränssnittet.

Nedan visas en lista över migreringar som måste utföras om de används i den aktuella lösningen. Om en metod eller egenskap inte visas, finns det en direkt ersättning med samma namn i MVVM Toolkit och det krävs ingen ändring.

Den första ändringen här är att växla med hjälp av direktiv i dina komponenter.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Använda RelayCommand med asynkrona åtgärder

Om du för närvarande använder MvvmLight-implementeringen RelayCommand med asynkrona åtgärder exponerar MVVM Toolkit en förbättrad implementering för dessa scenarier.

Du kan helt enkelt ersätta din befintliga RelayCommand med den AsyncRelayCommand som har skapats för asynkrona syften.

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

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

RelayCommand-metoder

RaiseCanExecuteChanged()

Funktionaliteten hos RaiseCanExecuteChanged() kan uppnås med metoden NotifyCanExecuteChanged() i MVVM Toolkit.

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

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

Migrera RelayCommand<T>

Följande steg fokuserar på att migrera dina befintliga komponenter som utnyttjar RelayCommand<T> MvvmLight Toolkit.

MVVM Toolkit tillhandahåller en RelayCommand<T> typ som ger liknande funktioner som utnyttjar ICommand systemgränssnittet.

Nedan visas en lista över migreringar som måste utföras om de används i den aktuella lösningen. Om en metod eller egenskap inte visas, finns det en direkt ersättning med samma namn i MVVM Toolkit och det krävs ingen ändring.

Den första ändringen här är att växla med hjälp av direktiv i dina komponenter.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Använda RelayCommand med asynkrona åtgärder

Om du för närvarande använder MvvmLight-implementeringen RelayCommand<T> med asynkrona åtgärder exponerar MVVM Toolkit en förbättrad implementering för dessa scenarier.

Du kan helt enkelt ersätta din befintliga RelayCommand<T> med den AsyncRelayCommand<T> som har skapats för asynkrona syften.

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

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

RelayCommand<T> Metoder

RaiseCanExecuteChanged()

Funktionaliteten hos RaiseCanExecuteChanged() kan uppnås med metoden NotifyCanExecuteChanged() i MVVM Toolkit.

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

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

Migrera SimpleIoc

IoC-implementeringen i MVVM Toolkit innehåller ingen inbyggd logik för att hantera beroendeinmatning på egen hand, så du kan använda valfritt bibliotek från tredje part för att hämta en IServiceProvider instans som du sedan kan skicka till Ioc.ConfigureServices metoden. I exemplen nedan används typen ServiceCollection från biblioteket Microsoft.Extensions.DependencyInjection.

Detta är den största förändringen mellan MvvmLight och MVVM Toolkit.

Den här implementeringen känns bekant om du har implementerat beroendeinmatning med ASP.NET Core program.

Registrera dina beroenden

Med MvvmLight kan du ha registrerat dina beroenden som liknar dessa scenarier med hjälp av SimpleIoc.

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

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

Med MVVM Toolkit skulle du uppnå samma sak på följande sätt.

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

Lösa beroenden

När de har initierats kan tjänster hämtas från Ioc klassen precis som med SimpleIoc:

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

Om du migrerar till MVVM Toolkit uppnår du samma sak med:

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

Ta bort beroenden

Med SimpleIocavregistrerar du dina beroenden med följande metodanrop.

SimpleIoc.Default.Unregister<INavigationService>();

Det finns ingen direkt ersättning för att ta bort beroenden med MVVM Toolkit-implementeringen Ioc .

Önskad konstruktor

När du registrerar dina beroenden med MvvmLights SimpleIoc har du möjlighet att i dina klasser ange attributet PreferredConstructor för klasser som har flera konstruktorer.

Det här attributet behöver tas bort där det används, och du måste använda attribut från det bibliotek för beroendeinmatning från tredje part som används om det stöds.

Migrera Messenger

Följande steg fokuserar på att migrera dina befintliga komponenter som utnyttjar Messenger MvvmLight Toolkit.

MVVM Toolkit innehåller två messenger-implementeringar (WeakReferenceMessenger och StrongReferenceMessenger, se dokument här) som ger liknande funktioner, med några viktiga skillnader som beskrivs nedan.

Nedan visas en lista över migreringar som måste utföras om de används i den aktuella lösningen.

Den första ändringen här är att växla med hjälp av direktiv i dina komponenter.

// MvvmLight
using GalaSoft.MvvmLight.Messaging;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Messaging;

Messenger-metoder

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

Funktionerna i Register<TMessage>(object, Action<TMessage>) kan uppnås med MVVM Toolkits IMessenger tilläggsmetod 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));

Anledningen till denna signatur är att den gör det möjligt för budbäraren att använda svaga referenser för att korrekt spåra mottagare och för att undvika att skapa stängningar för att fånga mottagaren själv. Det innebär att indatamottagaren skickas som indata till lambda-uttrycket, så den behöver inte fångas upp av själva lambda-uttrycket. Detta resulterar också i effektivare kod eftersom samma hanterare kan återanvändas flera gånger utan allokering. Observera att detta bara är ett av de sätt som stöds för att registrera hanterare, och det är möjligt att också använda IRecipient<TMessage> gränssnittet i stället (beskrivs i messenger-dokumenten), vilket gör registreringen automatisk och mindre utförlig.

Dessutom använder det här exemplet och de nedan bara Messenger egenskapen från ObservableRecipient. Om du bara vill ha statisk åtkomst till en messenger-instans från någon annanstans i koden gäller samma exempel också, med den enda skillnaden som Messenger måste ersättas med t.ex. Använd i stället WeakReferenceMessenger.Default.

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

Det finns ingen direkt ersättning för den här registreringsmekanismen som gör att du kan ha stöd för att ta emot meddelanden för härledda meddelandetyper också. Den här ändringen är avsiktlig eftersom implementeringen Messenger syftar till att inte använda reflektion för att uppnå dess prestandafördelar.

Det finns också några alternativ som kan göras för att uppnå den här funktionen.

• Skapa en anpassad implementering av IMessenger.
• Registrera de ytterligare meddelandetyperna med en delad hanterare som sedan kontrollerar typen och anropar rätt metod.

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

Funktionaliteten i Register<TMessage>(object, object, Action<TMessage>) kan uppnås med metoden Register<TRecipient, TMessage, TToken>(object, TToken, MessageHandler<TRecipient, TMessage>) i 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>)

Det finns ingen direkt ersättning för den här registreringsmekanismen som gör att du kan ha stöd för att ta emot meddelanden för härledda meddelandetyper också. Den här ändringen är avsiktlig eftersom implementeringen Messenger syftar till att inte använda reflektion för att uppnå dess prestandafördelar.

Det finns också några alternativ som kan göras för att uppnå den här funktionen.

• Skapa en anpassad IMessenger-implementation.
• Registrera de ytterligare meddelandetyperna med hjälp av en gemensam hanterare som sedan kontrollerar typen och anropar rätt metod.

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

Funktionerna i Send<TMessage>(TMessage) kan uppnås med MVVM Toolkits IMessenger tilläggsmetod Send<TMessage>(TMessage).

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

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

I scenariot ovan där meddelandet som skickas har en parameterlös konstruktor har MVVM Toolkit ett förenklat tillägg för att skicka ett meddelande i det här formatet.

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

Send<TMessage>(TMessage, object)

Funktionaliteten i Send<TMessage>(TMessage, object) kan uppnås med metoden Send<TMessage, TToken>(TMessage, TToken) i 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)

Funktionaliteten hos Unregister(object) kan uppnås med metoden UnregisterAll(object) i MVVM Toolkit.

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

// MVVM Toolkit
Messenger.UnregisterAll(this);

Unregister<TMessage>(object)

Funktionerna i Unregister<TMessage>(object) kan uppnås med MVVM Toolkits IMessenger tilläggsmetod Unregister<TMessage>(object).

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

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

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

Det finns ingen direkt ersättning för Unregister<TMessage>(object, Action<TMessage>) metoden i MVVM Toolkit.

Orsaken till utelämnandet är att en meddelandemottagare bara kan ha en enda registrerad hanterare för en viss meddelandetyp.

Vi rekommenderar att du uppnår den här funktionen med MVVM Toolkits IMessenger tilläggsmetod Unregister<TMessage>(object).

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

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

Unregister<TMessage>(object, object)

Funktionen i Unregister<TMessage>(object, object) kan uppnås med MVVM Toolkits metod Unregister<TMessage, TToken>(object, TToken).

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

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

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

Det finns ingen direkt ersättning för Unregister<TMessage>(object, object, Action<TMessage>) metoden i MVVM Toolkit.

Orsaken till utelämnandet är att en meddelandemottagare bara kan ha en enda registrerad hanterare för en viss meddelandetyp.

Vi rekommenderar att du uppnår den här funktionen med MVVM Toolkit-metoden Unregister<TMessage, TToken>(object, TToken) .

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

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

Cleanup()

Metoden Cleanup har en direkt ersättning med samma namn i MVVM Toolkit. Observera att den här metoden bara är användbar när en budbärare som använder svaga referenser används, medan StrongReferenceMessenger typen helt enkelt inte gör någonting när den här metoden anropas, eftersom det interna tillståndet redan trimmas automatiskt när messenger används.

// MvvmLight
Messenger.Default.Cleanup();

// MVVM Toolkit
Messenger.Cleanup();

RequestCleanup()

Det finns ingen direkt ersättning för RequestCleanup metoden i MVVM Toolkit. I samband med MvvmLight RequestCleanup används för att initiera en begäran om att ta bort registreringar som inte längre är aktiva eftersom implementeringen drar nytta av svaga referenser.

Alla anrop till RequestCleanup metoden kan tas bort eller ersättas med Cleanup.

// MvvmLight
Messenger.Default.RequestCleanup();

// MVVM Toolkit
// No direct replacement, remove

ResetAll()

Funktionaliteten hos ResetAll() kan uppnås med MVVM Toolkits metod Reset().

Till skillnad från MvvmLights implementering som nollar instansen rensar MVVM Toolkit de registrerade kartorna.

// MvvmLight
Messenger.Default.ResetAll();

// MVVM Toolkit
Messenger.Reset();

Statiska metoder för Messenger

OverrideDefault(IMessenger)

Det finns ingen direkt ersättning för OverrideDefault(IMessenger) metoden i MVVM Toolkit.

Om du vill använda en anpassad implementering av IMessenger, kan du antingen registrera den anpassade implementeringen i tjänstregistreringarna för beroendeinjektion eller manuellt skapa en statisk instans och skicka den där det behövs.

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

// MVVM Toolkit
// No direct replacement

Reset()

Det finns ingen direkt ersättning för den statiska Reset metoden i MVVM Toolkit.

Samma funktioner kan uppnås genom att anropa Reset metoden för den statiska Default instansen av någon av messenger-typerna.

// MvvmLight
Messenger.Reset();

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

Statiska egenskaper för Messenger

Default

Default har en direkt ersättning, Default, som inte kräver någon ändring av din befintliga implementering.

// MvvmLight
IMessenger messenger = Messenger.Default;

// MVVM Toolkit
IMessenger messenger = WeakReferenceMessenger.Default;

Migrera meddelandetyper

Meddelandetyperna i MvvmLight-verktygslådan är utformade som en bas för dig som utvecklare att arbeta med om det behövs.

MVVM Toolkit innehåller vissa alternativ, men det finns ingen direkt ersättning för dessa meddelandetyper. Vi rekommenderar att du tittar på våra tillgängliga meddelandetyper.

Om din lösning kan dra nytta av MvvmLight-meddelandetyperna kan dessa enkelt portas till din egen kodbas.

Migrera plattformsspecifika komponenter

I den aktuella MVVM Toolkit-implementeringen finns det inga ersättningar för plattformsspecifika komponenter som finns i MvvmLight-verktygslådan.

Följande komponenter och tillhörande hjälp-/tilläggsmetoder har ingen ersättning och behöver övervägas vid migrering till MVVM Toolkit.

Android/iOS/Windows specifik

• DialogService
• DispatcherHelper
• NavigationService

Android/iOS-specifik

• ActivityBase
• Binding
• BindingMode
• PropertyChangedEventManager
• UpdateTriggerMode

Android-specifik

• CachingViewHolder
• ObservableAdapter
• ObservableRecyclerAdapter

iOS-specifik

• ObservableCollectionViewSource
• ObservableTableViewController
• ObservableTableViewSource

Hjälpare

• Empty
• WeakAction
• WeakFunc