Migration à partir de MvvmLight

Cet article décrit certaines des principales différences entre MvvmLight Toolkit et MVVM Toolkit pour faciliter votre migration.

Bien que cet article se concentre spécifiquement sur les migrations de MvvmLight vers le kit de ressources MVVM, notez qu’il existe des améliorations supplémentaires qui ont été apportées dans le kit de ressources MVVM. Il est donc vivement recommandé de consulter la documentation relative aux nouvelles API individuelles.

API de plateforme : , , ObservableObject, ObservableRecipient, RelayCommandRelayCommand<T>AsyncRelayCommandAsyncRelayCommand<T>IMessengerWeakReferenceMessengerStrongReferenceMessenger, , IRecipient<TMessage>MessageHandler<TRecipient, TMessage>IMessengerExtensions

Installation du kit de ressources MVVM

Pour tirer parti du kit de ressources MVVM, vous devez d'abord installer le dernier package NuGet sur votre application .NET existante.

Installer via l’interface CLI .NET

dotnet add package CommunityToolkit.Mvvm --version 8.1.0

Installer à l’aide de PackageReference

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

Migration d’ObservableObject

Les étapes suivantes se concentrent sur la migration de vos composants existants qui tirent parti du ObservableObject kit de ressources MvvmLight. La boîte à outils MVVM propose un type ObservableObject similaire.

La première modification à apporter ici consistera à remplacer les directives using dans vos composants.

// MvvmLight
using GalaSoft.MvvmLight;

// MVVM Toolkit
using CommunityToolkit.Mvvm.ComponentModel;

Vous trouverez ci-dessous la liste des migrations qui devront être effectuées si elles sont utilisées dans votre solution actuelle.

Méthodes ObservableObject

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

Set(Expression, ref T, T) n’a pas de méthode de remplacement ayant une signature strictement identique.

Toutefois, SetProperty(ref T, T, string) fournit les mêmes fonctionnalités avec des avantages supplémentaires en termes de performances.

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

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

Notez que le string paramètre n’est pas obligatoire si la méthode est appelée à partir du setter de la propriété, car elle est déduite du nom du membre de l’appelant, comme indiqué ici. Si vous souhaitez appeler SetProperty une propriété différente de celle où la méthode est appelée, vous pouvez le faire à l’aide de l’opérateur nameof , ce qui peut être utile pour rendre le code moins sujet aux erreurs en n’ayant pas de noms codés en dur. Exemple :

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

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

Set<T>(string, ref T, T) ne dispose pas d’une signature de méthode de remplacement strictement équivalente.

Toutefois, SetProperty<T>(ref T, T, string) fournit la même fonctionnalité avec des paramètres réécrits.

// 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) a un remplacement direct renommé, 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) a un remplacement direct renommé, OnPropertyChanged(string).

// MvvmLight
RaisePropertyChanged(nameof(MyProperty));

// MVVM Toolkit
OnPropertyChanged();

Comme avec SetProperty, le nom de la propriété actuelle est automatiquement déduit par la OnPropertyChanged méthode. Si vous souhaitez utiliser cette méthode pour déclencher manuellement l’événement PropertyChanged pour une autre propriété, vous pouvez également spécifier manuellement le nom de cette propriété à l’aide de l’opérateur nameof à nouveau. Exemple :

OnPropertyChanged(nameof(SomeProperty));

RaisePropertyChanged<T>(Expression)

RaisePropertyChanged<T>(Expression) n’a pas de remplacement direct.

Pour de meilleures performances, il est recommandé de remplacer RaisePropertyChanged<T>(Expression) par OnPropertyChanged(string) du Toolkit en utilisant plutôt le mot-clé nameof (ou sans paramètre, si la propriété cible est la même que celle qui appelle la méthode, afin que le nom puisse être déduit automatiquement, comme indiqué ci-dessus).

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

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

VerifyPropertyName(string)

Il n’existe aucun remplacement direct pour la VerifyPropertyName(string) méthode et tout code utilisant ce code doit être modifié ou supprimé.

La raison de l’omission du kit de ressources MVVM est que l’utilisation du nameof mot clé pour une propriété vérifie qu’elle existe. Lorsque MvvmLight a été généré, le nameof mot clé n’était pas disponible et cette méthode était utilisée pour s’assurer que la propriété existait sur l’objet.

// MvvmLight
VerifyPropertyName(nameof(MyProperty));

// MVVM Toolkit
// No direct replacement, remove

Propriétés ObservableObject

PropertyChangedHandler

PropertyChangedHandler n’a pas de remplacement direct.

Pour déclencher un événement de changement de propriété via le gestionnaire d’événements PropertyChanged, vous devez appeler la méthode OnPropertyChanged à la place.

// MvvmLight
PropertyChangedEventHandler handler = PropertyChangedHandler;

// MVVM Toolkit
OnPropertyChanged();

Migration de ViewModelBase

Les étapes suivantes se concentrent sur la migration de vos composants existants qui tirent parti du ViewModelBase kit de ressources MvvmLight.

Le kit de ressources MVVM fournit un ObservableRecipient type qui fournit des fonctionnalités similaires.

Vous trouverez ci-dessous la liste des migrations qui devront être effectuées si elles sont utilisées dans votre solution actuelle.

Méthodes ViewModelBase

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

Set<T>(string, ref T, T, bool) n’a pas de méthode de remplacement ayant une signature identique.

Toutefois, SetProperty<T>(ref T, T, bool, string) fournit la même fonctionnalité avec des paramètres réécrits.

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

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

Notez que les paramètres booléens de valeur et de diffusion ne sont pas facultatifs dans l’implémentation du kit de ressources MVVM et doivent être fournis pour utiliser cette méthode. La raison de cette modification est qu’en omettant le paramètre de diffusion lors de l’appel SetProperty de cette méthode, elle appelle par défaut la méthode ObservableObject.

En outre, le string paramètre n’est pas obligatoire si la méthode est appelée à partir du setter de la propriété, car elle est déduite du nom du membre de l’appelant, comme avec les méthodes de la classe de base ObservableObject .

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

Set<T>(ref T, T, bool, string) a un remplacement direct renommé, 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’a pas de remplacement direct.

Pour de meilleures performances, il est recommandé de remplacer ceci par le SetProperty<T>(ref T, T, bool, string) du Toolkit MVVM, en utilisant le mot-clé nameof à la place.

// 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) a un remplacement direct qui ne nécessite pas de renommage.

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

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

Notez que le message envoyé via la propriété Messenger lors de l’appel de la méthode Broadcast dispose d’un remplacement direct dans la bibliothèque MVVM Toolkit PropertyChangedMessage.

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

Il n’existe aucun remplacement direct pour la RaisePropertyChanged<T>(string, T, T, bool) méthode.

L’alternative la plus simple consiste à appeler OnPropertyChanged et à appeler Broadcast par la suite pour obtenir cette fonctionnalité.

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

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

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

Il n’existe aucun remplacement direct pour la RaisePropertyChanged<T>(Expression, T, T, bool) méthode.

L’alternative la plus simple consiste à appeler OnPropertyChanged et à appeler Broadcast par la suite pour obtenir cette fonctionnalité.

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

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

ICleanup.Cleanup()

Il n’existe aucun remplacement direct pour l’interface ICleanup .

Toutefois, la ObservableRecipient méthode fournit une OnDeactivated méthode qui doit être utilisée pour fournir les mêmes fonctionnalités que Cleanup.

OnDeactivated dans le kit de ressources MVVM, annule également l’inscription de tous les événements de messager inscrits lors de l’appel.

// MvvmLight
Cleanup();

// MVVM Toolkit
OnDeactivated();

Notez que les méthodes OnActivated et OnDeactivated peuvent être appelées depuis votre solution existante, comme avec Cleanup.

Toutefois, l’objet ObservableRecipient expose une IsActive propriété qui contrôle également l’appel à ces méthodes lorsqu’elle est définie.

Propriétés de ViewModelBase

MessengerInstance

MessengerInstance a un remplacement direct renommé, Messenger.

// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;

IsInDesignMode

Il n’existe aucun remplacement direct pour la IsInDesignMode propriété et tout code utilisant ce code doit être modifié ou supprimé.

La raison de l’omission de la boîte à outils MVVM est que la propriété IsInDesignMode exposait des implémentations propres à la plateforme. Le kit de ressources MVVM a été conçu pour être indépendant de la plateforme.

// MvvmLight
var isInDesignMode = IsInDesignMode;

// MVVM Toolkit
// No direct replacement, remove

Propriétés statiques de ViewModelBase

IsInDesignModeStatic

Il n’existe aucun remplacement direct pour la IsInDesignModeStatic propriété et tout code utilisant ce code doit être modifié ou supprimé.

La raison de l’omission de la boîte à outils MVVM est que la propriété IsInDesignMode exposait des implémentations spécifiques à la plateforme. Le kit de ressources MVVM a été conçu pour être indépendant de la plateforme.

// MvvmLight
var isInDesignMode = ViewModelBase.IsInDesignModeStatic;

// MVVM Toolkit
// No direct replacement, remove

Migration de RelayCommand

Les étapes suivantes se concentrent sur la migration de vos composants existants qui tirent parti du RelayCommand kit de ressources MvvmLight.

La boîte à outils MVVM fournit un type RelayCommand offrant des fonctionnalités équivalentes, tirant parti de l’interface système ICommand.

Vous trouverez ci-dessous la liste des migrations qui devront être effectuées si elles sont utilisées dans votre solution actuelle. Lorsqu’une méthode ou une propriété n’est pas répertoriée, il existe un remplacement direct portant le même nom dans le kit de ressources MVVM et aucune modification n’est requise.

La première modification à apporter ici consistera à remplacer les directives using dans vos composants.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Utilisation de RelayCommand avec des actions asynchrones

Si vous utilisez actuellement l’implémentation MvvmLight RelayCommand avec des actions asynchrones, le kit de ressources MVVM expose une implémentation améliorée pour ces scénarios.

Vous pouvez simplement remplacer votre existant RelayCommand par celui AsyncRelayCommand qui a été créé à des fins asynchrones.

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

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

Méthodes de RelayCommand

RaiseCanExecuteChanged()

La fonctionnalité de RaiseCanExecuteChanged() peut être obtenue à l’aide de la méthode NotifyCanExecuteChanged() du kit de ressources MVVM.

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

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

Migration en cours RelayCommand<T>

Les étapes suivantes se concentrent sur la migration de vos composants existants qui tirent parti du RelayCommand<T> kit de ressources MvvmLight.

La boîte à outils MVVM fournit un type RelayCommand<T> qui offre des fonctionnalités équivalentes en tirant parti de l’interface système ICommand.

Vous trouverez ci-dessous la liste des migrations qui devront être effectuées si elles sont utilisées dans votre solution actuelle. Lorsqu’une méthode ou une propriété n’est pas répertoriée, il existe un remplacement direct portant le même nom dans le kit de ressources MVVM et aucune modification n’est requise.

La première modification à apporter ici consistera à remplacer les directives using dans vos composants.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

Utilisation RelayCommand avec des actions asynchrones

Si vous utilisez actuellement l’implémentation MvvmLight RelayCommand<T> avec des actions asynchrones, le kit de ressources MVVM expose une implémentation améliorée pour ces scénarios.

Vous pouvez simplement remplacer votre existant RelayCommand<T> par celui AsyncRelayCommand<T> qui a été créé à des fins asynchrones.

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

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

RelayCommand<T> Méthodes

RaiseCanExecuteChanged()

La fonctionnalité de RaiseCanExecuteChanged() peut être obtenue avec la méthode NotifyCanExecuteChanged() du kit de ressources MVVM.

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

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

Migrer SimpleIoc

L’implémentation IoC dans le kit de ressources MVVM n’inclut aucune logique intégrée pour gérer l’injection de dépendances par elle-même. Vous êtes donc libre d’utiliser n’importe quelle bibliothèque tierce pour récupérer une IServiceProvider instance que vous pouvez ensuite passer à la Ioc.ConfigureServices méthode. Dans les exemples ci-dessous, le type ServiceCollection de la bibliothèque Microsoft.Extensions.DependencyInjection sera utilisé.

Il s’agit du plus grand changement entre MvvmLight et MVVM Toolkit.

Cette implémentation se sentira familière si vous avez implémenté l'injection de dépendances avec ASP.NET Core applications.

Enregistrement de vos dépendances

Avec MvvmLight, vous avez peut-être enregistré vos dépendances comme dans les scénarios suivants à l’aide de SimpleIoc.

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

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

Avec le kit de ressources MVVM, vous obtiendrez la même chose que ce qui suit.

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

Résolution des dépendances

Une fois initialisés, les services peuvent être récupérés à partir de la Ioc classe comme avec SimpleIoc:

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

La migration vers le kit de ressources MVVM vous permet d’obtenir la même chose avec :

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

Suppression des dépendances

Avec SimpleIoc, vous annulez l’inscription de vos dépendances avec l’appel de méthode suivant.

SimpleIoc.Default.Unregister<INavigationService>();

Il n’existe aucun remplacement direct pour supprimer les dépendances dans l’implémentation du Toolkit MVVM Ioc.

Constructeur préféré

Lors de l’enregistrement de vos dépendances auprès de SimpleIoc de MvvmLight, vous pouvez, dans vos classes, fournir un attribut PreferredConstructor pour celles qui possèdent plusieurs constructeurs.

Cet attribut devra être supprimé partout où il est utilisé, et vous devrez utiliser, le cas échéant, les attributs de la bibliothèque tierce partie d’injection de dépendances que vous utilisez, si elle les prend en charge.

Migrer Messenger

Les étapes suivantes se concentrent sur la migration de vos composants existants qui tirent parti du Messenger kit de ressources MvvmLight.

Le kit de ressources MVVM fournit deux implémentations de messager (WeakReferenceMessenger et StrongReferenceMessenger, voir la documentation ici) qui fournit des fonctionnalités similaires, avec quelques différences clés détaillées ci-dessous.

Vous trouverez ci-dessous la liste des migrations qui devront être effectuées si elles sont utilisées dans votre solution actuelle.

La première modification à apporter ici consistera à remplacer les directives using dans vos composants.

// MvvmLight
using GalaSoft.MvvmLight.Messaging;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Messaging;

Méthodes Messenger

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

La fonctionnalité de Register<TMessage>(object, Action<TMessage>) peut être obtenue avec la méthode d’extension IMessenger de la boîte à outils MVVM Register<TRecipient, TMessage>(object, MessageHandler<TRecipient, TMessage>).

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

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

La raison de cette signature est qu’elle permet au messager d’utiliser des références faibles pour suivre correctement les destinataires et d’éviter de créer des fermetures pour capturer le destinataire lui-même. Autrement dit, le destinataire d’entrée est passé en tant qu’entrée à l’expression lambda. Il n’a donc pas besoin d’être capturé par l’expression lambda elle-même. Cela entraîne également un code plus efficace, car le même gestionnaire peut être réutilisé plusieurs fois sans allocations. Notez qu’il ne s’agit que de l’une des méthodes prises en charge pour enregistrer des gestionnaires, et qu’il est également possible d’utiliser à la place l’interface IRecipient<TMessage> (décrite dans la documentation de Messenger), ce qui rend l’enregistrement automatique et moins verbeux.

En outre, cet exemple et ceux ci-dessous utilisent simplement la Messenger propriété à partir de ObservableRecipient. Si vous souhaitez simplement accéder statiquement à une instance messenger à partir de n’importe où dans votre code, les mêmes exemples s’appliquent également, avec la seule différence qui Messenger doit être remplacée par exemple. WeakReferenceMessenger.Default à la place.

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

Il n’existe aucun remplacement direct pour ce mécanisme d’inscription qui vous permet également de prendre en charge la réception de messages pour les types de messages dérivés. Ce changement est intentionnel, car l’implémentation Messenger vise à ne pas utiliser la réflexion pour obtenir ses avantages en matière de performances.

Il existe également quelques options qui peuvent être effectuées pour obtenir cette fonctionnalité.

• Créez une implémentation personnalisée IMessenger .
• Inscrivez les types de messages supplémentaires à l’aide d’un gestionnaire partagé, puis vérifiez le type et appelle la méthode appropriée.

// 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 fonctionnalité de Register<TMessage>(object, object, Action<TMessage>) peut être obtenue à l’aide de la méthode Register<TRecipient, TMessage, TToken>(object, TToken, MessageHandler<TRecipient, TMessage>) du kit de ressources MVVM.

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

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

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

Il n’existe aucun remplacement direct pour ce mécanisme d’inscription qui vous permet également de prendre en charge la réception de messages pour les types de messages dérivés. Ce changement est intentionnel, car l’implémentation Messenger vise à ne pas utiliser la réflexion pour obtenir ses avantages en matière de performances.

Il existe également quelques options qui peuvent être effectuées pour obtenir cette fonctionnalité.

• Créez une implémentation personnalisée IMessenger .
• Inscrivez les types de messages supplémentaires à l’aide d’un gestionnaire partagé, puis vérifiez le type et appelle la méthode appropriée.

// 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 fonctionnalité de Send<TMessage>(TMessage) peut être obtenue à l’aide de la méthode d’extension IMessenger du kit de ressources MVVM Send<TMessage>(TMessage).

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

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

Dans le scénario ci-dessus où le message envoyé a un constructeur sans paramètre, le kit de ressources MVVM a une extension simplifiée pour envoyer un message dans ce format.

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

Send<TMessage>(TMessage, object)

La fonctionnalité de Send<TMessage>(TMessage, object) peut être obtenue à l’aide de la méthode Send<TMessage, TToken>(TMessage, TToken) du toolkit 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)

La fonctionnalité de Unregister(object) peut être obtenue à l’aide de la méthode UnregisterAll(object) du toolkit MVVM.

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

// MVVM Toolkit
Messenger.UnregisterAll(this);

Unregister<TMessage>(object)

La fonctionnalité de Unregister<TMessage>(object) peut être obtenue à l’aide de la méthode d’extension IMessengerUnregister<TMessage>(object) du kit d’outils MVVM.

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

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

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

Il n’existe aucun remplacement direct pour la Unregister<TMessage>(object, Action<TMessage>) méthode dans le kit de ressources MVVM.

La raison de l’omission est qu’un destinataire de message ne peut avoir qu’un seul gestionnaire inscrit pour n’importe quel type de message donné.

Nous vous recommandons d’implémenter cette fonctionnalité à l’aide de la méthode d’extension IMessenger de la boîte à outils MVVM Unregister<TMessage>(object).

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

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

Unregister<TMessage>(object, object)

La fonctionnalité de Unregister<TMessage>(object, object) peut être obtenue à l’aide de la méthode Unregister<TMessage, TToken>(object, TToken) du kit d’outils MVVM.

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

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

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

Il n’existe aucun remplacement direct pour la Unregister<TMessage>(object, object, Action<TMessage>) méthode dans le kit de ressources MVVM.

La raison de l’omission est qu’un destinataire de message ne peut avoir qu’un seul gestionnaire inscrit pour n’importe quel type de message donné.

Nous vous recommandons d’implémenter cette fonctionnalité à l’aide de la méthode Unregister<TMessage, TToken>(object, TToken) du MVVM Toolkit.

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

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

Cleanup()

La Cleanup méthode a un remplacement direct avec le même nom dans le kit de ressources MVVM. Notez que cette méthode est utile uniquement lorsqu’un messager utilisant des références faibles est utilisé, tandis que le StrongReferenceMessenger type ne fera simplement rien lorsque cette méthode est appelée, car l’état interne est déjà supprimé automatiquement à mesure que le messager est utilisé.

// MvvmLight
Messenger.Default.Cleanup();

// MVVM Toolkit
Messenger.Cleanup();

RequestCleanup()

Il n’existe aucun remplacement direct pour la RequestCleanup méthode dans le kit de ressources MVVM. Dans le contexte de MvvmLight, RequestCleanup est utilisé pour lancer une demande de suppression des inscriptions qui ne sont plus actives, car l’implémentation tire parti des références faibles.

Tous les appels à la RequestCleanup méthode peuvent être supprimés ou remplacés par Cleanup.

// MvvmLight
Messenger.Default.RequestCleanup();

// MVVM Toolkit
// No direct replacement, remove

ResetAll()

La fonctionnalité de ResetAll() peut être obtenue à l’aide de la méthode Reset() du kit d’outils MVVM.

Contrairement à l’implémentation de MvvmLight, qui met l’instance à null, la boîte à outils MVVM efface les mappages enregistrés.

// MvvmLight
Messenger.Default.ResetAll();

// MVVM Toolkit
Messenger.Reset();

Méthodes statiques de Messenger

OverrideDefault(IMessenger)

Il n’existe aucun remplacement direct pour la OverrideDefault(IMessenger) méthode dans le kit de ressources MVVM.

Pour utiliser une implémentation personnalisée du IMessenger, inscrivez l’implémentation personnalisée dans les inscriptions de service pour l’injection de dépendances ou construisez manuellement une instance statique et transmettez-la si nécessaire.

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

// MVVM Toolkit
// No direct replacement

Reset()

Il n’existe aucun remplacement direct pour la méthode statique Reset dans le kit de ressources MVVM.

La même fonctionnalité peut être obtenue en appelant la Reset méthode de l’instance statique Default de l’un des types messagers.

// MvvmLight
Messenger.Reset();

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

Propriétés statiques Messenger

Default

Default dispose d’un remplacement direct, Default, sans nécessiter de modification de votre implémentation existante.

// MvvmLight
IMessenger messenger = Messenger.Default;

// MVVM Toolkit
IMessenger messenger = WeakReferenceMessenger.Default;

Migration des types de messages

Les types de messages fournis dans le kit de ressources MvvmLight sont conçus comme une base pour vous en tant que développeur pour travailler si nécessaire.

Bien que le kit de ressources MVVM offre certaines alternatives, il n’existe aucun remplacement direct pour ces types de messages. Nous vous recommandons d’examiner nos types de messages disponibles.

Sinon, si votre solution tire parti des types de messages MvvmLight, ceux-ci peuvent facilement être portés dans votre propre codebase.

Migration de composants spécifiques à la plateforme

Dans l’implémentation actuelle de MVVM Toolkit, il n’existe aucun remplacement pour les composants spécifiques à la plateforme qui existent dans le kit de ressources MvvmLight.

Les composants suivants et leurs méthodes d’assistance/extension associées n’ont pas de remplacement et doivent être pris en compte lors de la migration vers le kit de ressources MVVM.

spécifique à Android/iOS/Windows

• DialogService
• DispatcherHelper
• NavigationService

Spécifique à Android/iOS

• ActivityBase
• Binding
• BindingMode
• PropertyChangedEventManager
• UpdateTriggerMode

Spécifique à Android

• CachingViewHolder
• ObservableAdapter
• ObservableRecyclerAdapter

Spécifique à iOS

• ObservableCollectionViewSource
• ObservableTableViewController
• ObservableTableViewSource

Helpers

• Empty
• WeakAction
• WeakFunc