Microsoft annonce la bote outils communautaire .NET 8.0, MVVM, diagnostics, performances, et plus encore, Une version majeure comprenant de nombreuses nouvelles fonctionnalits

Microsoft annonce la bote outils communautaire .NET 8.0, MVVM, diagnostics, performances, et plus encore, Une version majeure comprenant de nombreuses nouvelles fonctionnalits


Microsoft a annonc le 4 aot la nouvelle version du Community Toolkit. Nous sommes heureux d’annoncer le lancement officiel du nouveau .NET Community Toolkit, qui est maintenant en ligne sur NuGet avec la version 8.0.0 , dclare Sergio Pedri, Ingnieur logiciel de l’quipe client Microsoft Store. Il s’agit d’une version majeure comprenant de nombreuses nouvelles fonctionnalits, d’amliorations, d’optimisations, de corrections de bogues et de nombreux remaniements pour reflter galement la nouvelle structure et organisation du projet.

Microsoft a annonc le mois dernier .NET 7 Preview 6, la version du framework pour la cration des applications. Elle amliore les convertisseurs de type, personnalise des contrats JSON. .NET 7 s’appuie sur la base tablie par .NET 6, qui comprend un ensemble unifi de bibliothques de base, de runtime et de SDK, une exprience de dveloppement simplifie et une productivit accrue des dveloppeurs. Les principaux domaines d’intrt de .NET 7 comprennent une meilleure prise en en charge des scnarios cloud native, des outils facilitant la mise niveau des projets existants et la simplification de l’exprience du dveloppeur en facilitant le travail avec les conteneurs , a crit Jeremy Likness de l’quipe .NET propos de cette version. En gros, .NET 7 vise faciliter le dveloppement d’applications cloud natives et la conteneurisation.

La bote outils de la communaut .NET est une collection d’aides et d’API qui fonctionnent pour tous les dveloppeurs .NET et qui sont indpendants de toute plate-forme d’interface utilisateur spcifique. La bote outils est maintenue et publie par Microsoft, et fait partie de la Fondation .NET. Elle est galement utilise par plusieurs projets internes et applications en bote, comme le Microsoft Store. partir de la nouvelle version 8.0.0, le projet se trouve dsormais dans le dpt CommunityToolkit/dotnet sur GitHub, qui comprend toutes les bibliothques faisant partie de la bote outils.

Toutes les API disponibles ne dpendent d’aucun runtime ou framework spcifique et peuvent donc tre utilises par tous les dveloppeurs .NET. Ces bibliothques sont multi-cibles, de .NET Standard 2.0 .NET 6, ce qui leur permet de prendre en charge le plus grand nombre de plateformes possible et d’tre optimises pour obtenir les meilleures performances lorsqu’elles sont utilises sur des moteurs d’excution plus rcents.

Comme pour chaque version du Community Toolkit, toutes les modifications ont t influences par les commentaires reus la fois par les quipes de Microsoft qui utilisent le Toolkit et par les autres dveloppeurs de la communaut. Les bibliothques du .NET Community Toolkit sont les suivantes :

  • CommunityToolkit.Common ;
  • CommunityToolkit.Mvvm (alias “Microsoft MVVM Toolkit”) ;
  • CommunityToolkit.Diagnostics ;
  • CommunityToolkit.HighPerformance.

Un peu d’histoire

Vous vous demandez peut-tre pourquoi la premire version du .NET Community Toolkit est la version 8.0.0. Bonne question ! La raison en est que toutes les bibliothques du .NET Community Toolkit faisaient l’origine partie du Windows Community Toolkit, qui est une collection d’aides, d’extensions et de contrles personnaliss qui simplifient et dmontrent les tches courantes des dveloppeurs crant des applications UWP et .NET pour Windows 10 et Windows 11.

Au fil du temps, le nombre d’API ciblant uniquement .NET et ne comportant aucune dpendance spcifique Windows a augment, et Microsoft a dcid de les sparer dans un projet distinct afin qu’elles puissent voluer indpendamment et tre plus faciles trouver pour les dveloppeurs .NET qui ne dveloppent pas sous Windows. C’est ainsi qu’est n le .NET Community Toolkit. Cela a galement permis de mieux organiser la documentation, qui comporte dsormais des sections distinctes pour chaque bote outils spcifique une plateforme.

tant donn que la dernire version du Windows Community Toolkit avant de se ramifier tait 7.1.x, Microsoft a dcid de suivre la smantique de ce numro de version pour rendre la transition plus facile comprendre pour les utilisateurs, et c’est pourquoi la premire version du .NET Community Toolkit est 8.0.0. l’avenir, il sera versionn sparment du Windows Community Toolkit, car chaque projet aura sa propre feuille de route et son propre calendrier de publication.

Ceci tant clairci, plongeons maintenant dans toutes les nouvelles fonctionnalits de cette nouvelle version majeure des bibliothques du .NET Community Toolkit !

MVVM Toolkit

Comme annonc prcdemment dans la version 7.0, l’un des principaux composants du .NET Community Toolkit est le MVVM Toolkit : une bibliothque MVVM moderne, rapide, agnostique en termes de plateforme et modulaire. Il s’agit de la mme bibliothque MVVM que celle utilise par le Microsoft Store, l’application Photos, etc.

MVVM Toolkit s’inspire de MvvmLight, et est galement son remplaant officiel maintenant que la bibliothque a t dprcie. Microsoft a galement collabor avec Laurent Bugnion lors du dveloppement de la bote outils MVVM, et il a approuv la bote outils MVVM comme la voie suivre pour les utilisateurs actuels de MvvmLight. Laurent Bugnion travaille en tant que Senior Cloud Developer Advocate pour Microsoft aprs avoir travaill pendant prs de 10 ans pour IdentityMine et Valorem.

La bote outils MVVM repose sur quelques principes cls :

  • Plateforme agnostique : cela signifie qu’il ne dpend d’aucun framework d’interface utilisateur spcifique. Il peut tre utilis pour partager du code entre UWP, WinUI 3, MAUI, WPF, Avalonia, Uno, et bien plus ;
  • Agnostique en matire de runtime : la bibliothque est multicible et prend en charge jusqu’ .NET Standard 2.0, ce qui signifie que vous pouvez bnficier d’amliorations des performances lors de l’excution sur des runtimes modernes (par exemple .NET 6), tout en continuant l’utiliser mme sur .NET Framework ;
  • Simplicit de prise en main et d’utilisation : il n’y a pas d’exigences strictes concernant la structure de l’application ou les modles de codage utiliser. Vous pouvez utiliser la bibliothque en fonction de votre propre architecture et de votre style ;
  • la carte : tous les composants sont indpendants et peuvent galement tre utiliss sparment. Il n’y a pas d’approche “tout compris” laquelle vous tes contraint : si vous ne souhaitez utiliser qu’un seul type de la bibliothque, vous pouvez le faire sans problme, puis utiliser progressivement d’autres fonctionnalits selon vos besoins ;
  • Implmentation de rfrence : toutes les API disponibles sont conues pour tre lgres et performantes, en fournissant des “implmentations de rfrence” pour les interfaces qui sont incluses dans la bibliothque de classes de base .NET, mais ne disposent pas de types concrets pour les utiliser directement. Par exemple, vous pourrez trouver une mise en uvre de rfrence pour des interfaces telles que INotifyPropertyChanged ou ICommand.

Gnrateurs de sources MVVM Toolkit

La plus grande nouveaut de la version 8.0.0 de la bote outils MVVM sont les nouveaux gnrateurs de sources MVVM, qui sont destins rduire considrablement le code passe-partout ncessaire pour configurer une application utilisant MVVM. Par rapport aux gnrateurs de prvisualisation que Microsoft a livr dans la version 7.1.0, ils ont galement t compltement rcrits pour tre des gnrateurs incrmentiels, ce qui signifie qu’ils fonctionneront beaucoup plus rapidement qu’avant et qu’ils aideront maintenir l’EDI rapide et ractif, mme lorsque vous travaillez sur des projets grande chelle.

La cration de commandes peut tre assez rptitive, avec la ncessit de configurer une proprit pour chaque mthode que nous voulons exposer de manire abstraite aux diffrents composants de l’interface utilisateur de nos applications qui sont censs les invoquer (comme les boutons). C’est l que le nouvel attribut [RelayCommand] entre en jeu : il permettra la bote outils MVVM de gnrer automatiquement des commandes (en utilisant les types RelayCommand inclus dans la bibliothque) avec la bonne signature, en fonction de la mthode annote.

titre de comparaison, voici comment on procde habituellement pour mettre en place une commande :

1
2
3
4
5
6
7
8

private IRelayCommand<User> greetUserCommand;
 
public IRelayCommand<User> GreetUserCommand => greetUserCommand ??= new RelayCommand<User>(GreetUser);
 
private void GreetUser(User user)
{
    Console.WriteLine($"Hello {user.Name}!");
}

Cela peut maintenant tre simplifi ceci :

1
2
3
4
5

[RelayCommand]
private void GreetUser(User user)
{
    Console.WriteLine($"Hello {user.Name}!");
}

Le gnrateur de sources se chargera de crer la bonne proprit GreetUserCommand en fonction de la mthode annote. En outre, une mthode CanExecute peut galement tre spcifie, et il est galement possible de contrler le niveau de concurrence pour les commandes asynchrones. Il existe galement d'autres options permettant d'affiner le comportement des commandes gnres.

Proprits observables

L'criture de proprits observables peut tre extrmement verbeuse, surtout lorsqu'il faut galement ajouter une logique supplmentaire pour grer les proprits dpendantes qui sont notifies. Tout cela peut tre grandement simplifi en utilisant les nouveaux attributs du MVVM Toolkit et en laissant le gnrateur de sources crer des proprits observables en coulisse.

Les nouveaux attributs sont [ObservableProperty], [NotifyPropertyChangedFor] et [NotifyCanExecuteChangedFor], [NotifyDataErrorInfo] et [NotifyPropertyChangedRecipients]. Passons rapidement en revue ce que tous ces nouveaux attributs peuvent faire.

Considrons un scnario dans lequel il existe deux proprits observables, une proprit dpendante et la commande dfinie ci-dessus, et dans lequel la proprit dpendante et la commande doivent tre notifies lorsque l'une des deux proprits observables change. Autrement dit, lorsque FirstName ou LastName changent, FullName est galement notifi, ainsi que la commande GreetUserCommand.

C'est ainsi que cela aurait t fait dans le pass :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

private string? firstName;
 
 
public string? FirstName
{
    get => firstName;
    set
    {
        if (SetProperty(ref firstName, value))
        {
            OnPropertyChanged(nameof(FullName));
            GreetUserCommand.NotifyCanExecuteChanged();
        }
    }
}
 
private string? lastName;
 
public string? LastName
{
    get => lastName;
    set
    {
        if (SetProperty(ref lastName, value))
        {
            OnPropertyChanged(nameof(FullName));
            GreetUserCommand.NotifyCanExecuteChanged();
        }
    }
}
 
public string? FullName => $"{FirstName} {LastName}";

Tout cela peut maintenant tre rcrit comme suit :

1
2
3
4
5
6
7
8
9
10
11

[ObservableProperty]
[NotifyPropertyChangedFor(nameof(FullName))]
[NotifyCanExecuteChangedFor(nameof(GreetUserCommand))]
private string? firstName;
 
[ObservableProperty]
[NotifyPropertyChangedFor(nameof(FullName))]
[NotifyCanExecuteChangedFor(nameof(GreetUserCommand))]
private string? lastName;
 
public string? FullName => $"{FirstName} {LastName}";

La bote outils MVVM se chargera de la gnration du code pour ces proprits, y compris l'insertion de toute la logique permettant de dclencher les vnements de changement de proprit spcifis ou d'excuter les vnements de changement.

Mais attendez, il y a plus ! Lorsque vous utilisez [ObservableProperty] pour gnrer des proprits observables, la bote outils MVVM gnre galement deux mthodes partielles sans implmentation : On<PROPERTY_NAME>Changing et On<PROPERTY_NAME>Changed. Ces mthodes peuvent tre utilises pour injecter une logique supplmentaire lorsqu'une proprit est modifie, sans avoir recourir une proprit manuelle. Notons qu'tant donn que ces deux mthodes sont partielles, retour nul et sans dfinition, le compilateur C# les supprimera compltement si elles ne sont pas implmentes, ce qui signifie que lorsqu'elles ne sont pas utilises, elles disparaissent tout simplement et n'ajoutent aucune surcharge l'application.

Voici un exemple de la faon dont ils peuvent tre utiliss :

1
2
3
4
5
6
7
8
9
10
11
12

[ObservableProperty]
private string name;
 
partial void OnNameChanging(string name)
{
    Console.WriteLine($"The name is about to change to {name}!");
}
 
partial void OnNameChanged(string name)
{
    Console.WriteLine($"The name just changed to {name}!");
}

Bien entendu, vous tes galement libre de n'implmenter qu'une seule de ces deux mthodes, ou aucune. partir de l'extrait ci-dessus, le gnrateur de sources produira un code analogue celui-ci :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public string Name
{
    get => name;
    set
    {
        if (!EqualityComparer<string>.Default.Equals(name, value))
        {
            OnNameChanging(value);
            OnPropertyChanging();
            name = value;
            OnNameChanged();
            OnPropertyChanged();
        }
    }
}
 
partial void OnNameChanging(string name);
 
partial void OnNameChanged(string name);

L'attribut [ObservableProperty] prend galement en charge la validation : si l'un des champs reprsentant une proprit possde un ou plusieurs attributs hritant de ValidationAttribute, ceux-ci seront automatiquement copis dans les proprits gnres. Cette approche est donc entirement prise en charge lorsque vous utilisez ObservableValidator pour crer des formulaires validables. Si vous souhaitez que la proprit soit valide chaque fois que sa valeur est dfinie, vous pouvez galement ajouter [NotifyDataErrorInfo] pour que le code de validation soit galement gnr dans le paramtre de la proprit.

D'autres fonctionnalits sont disponibles pour [ObservableProperty] et, comme pour les commandes.

Prise en charge de l'annulation pour les commandes

Une nouvelle proprit a t ajoute l'attribut [RelayCommand], qui peut tre utilise pour demander au gnrateur de source de gnrer une commande d'annulation en plus de la commande originale. Cette commande d'annulation peut tre utilise pour annuler l'excution d'une commande asynchrone.

Cela montre galement comment [RelayCommand] peut s'adapter automatiquement aux mthodes asynchrones et aux mthodes qui acceptent galement des paramtres, et crer des implmentations de commandes asynchrones en coulisse. Cela permet galement de mettre en place des fonctionnalits supplmentaires, comme des liaisons faciles configurer pour afficher des indicateurs de progression, etc.

Voici un exemple de la faon dont ils peuvent tre utiliss :

1
2
3
4
5

[RelayCommand(IncludeCancelCommand = true)]
private async Task DoWorkAsync(CancellationToken token)
{
    // Do some long running work with cancellation support
}

partir de ce petit extrait, le gnrateur produira le code suivant :

1
2
3
4
5
6
7

private AsyncRelayCommand? doWorkCommand;
 
public IAsyncRelayCommand DoWorkCommand => doWorkCommand ??= new AsyncRelayCommand(DoWorkAsync);
 
ICommand? doWorkCancelCommand;
 
public ICommand DoWorkCancelCommand => doWorkCancelCommand ??= IAsyncRelayCommandExtensions.CreateCancelCommand(UpdateSomethingCommand);

Ce code gnr, combin la logique de l'API IAsyncRelayCommandExtensions.CreateCancelCommand, permet de n'avoir besoin que d'une seule ligne de code pour qu'une commande soit gnre, notifiant l'interface utilisateur ds que le travail a commenc ou est en cours d'excution, avec un contrle automatique de la concurrence (la commande est dsactive par dfaut lorsqu'elle est dj en cours d'excution). La commande d'annulation spare sera notifie chaque fois que la commande primaire commencera ou finira de s'excuter, et lorsqu'elle sera excute, elle signalera l'annulation au jeton pass la mthode enveloppe par la commande primaire. Tout ceci est compltement abstrait et facilement accessible avec un seul attribut.

Prise en charge des changements de diffusion pour les proprits gnres

Microsoft a galement ajout un nouvel attribut [NotifyPropertyChangedRecipients] qui peut tre utilis sur une proprit observable gnre partir d'un type qui hrite de ObservableRecipient (ou qui est annot avec [ObservableRecipient]). Son utilisation gnrera un appel la mthode Broadcast, afin d'envoyer un message tous les autres composants abonns au sujet du changement de proprit qui vient de se produire. Cela peut tre utile dans les scnarios o un changement de proprit d'un modle de vue doit galement tre notifi d'autres composants de l'application (Supposons qu'il y ait une proprit boolenne IsLoggedIn qui se met jour lorsqu'un utilisateur se connecte ; cela peut notifier et dclencher le rafrachissement de certains autres composants de l'application avec le message diffus).

Il peut tre utilis comme suit :

1
2
3

[ObservableProperty]
[NotifyPropertyChangedRecipients]
private string name;

Et cela produira un code analogue celui-ci :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public string Name
{
    get => name;
    set
    {
        if (!EqualityComparer<string>.Default.Equals(name, value))
        {
            OnNameChanging(value);
            OnPropertyChanging();
            string oldValue = name;
            name = value;
            Broadcast(oldValue, value, nameof(Name));
            OnNameChanged();
            OnPropertyChanged();
        }
    }
}

Il s'agit d'une autre fonctionnalit permettant d'augmenter les proprits gnres et de garantir qu'elles peuvent tre utilises dans presque tous les scnarios, sans tre oblig de se rabattre sur des proprits manuelles.

Composition du ViewModel

Le C# ne dispose pas de l'hritage multiple, ce qui peut parfois poser problme. Que faire si un modle de vue doit hriter d'un type spcifique, mais que vous souhaitez galement injecter la prise en charge de INotifyPropertyChanged ou qu'il hrite galement de ObservableRecipient pour avoir accs ses API ?

Le MVVM Toolkit permet dsormais de contourner ce problme en introduisant des attributs pour la gnration de code qui permettent d'injecter la logique de ces types dans des classes arbitraires. Il s'agit de [INotifyPropertyChanged], [ObservableObject] et [ObservableRecipient]. En les ajoutant une classe, le gnrateur de sources MVVM Toolkit inclura toute la logique de ce type dans cette classe, comme si cette classe avait galement hrit de ce type. Par exemple :

1
2
3
4

[INotifyPropertyChanged]
partial class MyObservableViewModel : DatabaseItem
{
}

Ce MyObservableViewModel hritera de DatabaseItem comme vous vous y attendez, mais l'utilisation de [INotifyPropertyChanged] lui permettra galement de bnficier du support de INotifyPropertyChanged, ainsi que de toutes les API d'aide que ObservableObject inclut par lui-mme.

Il est toujours recommand d'hriter des types de base tels que ObservableObject chaque fois que cela est ncessaire, car cela peut galement aider rduire la taille binaire, mais avoir la possibilit d'injecter du code de cette faon lorsque cela est ncessaire peut aider contourner les limitations de C# dans les cas o le changement du type de base d'un viewmodel est tout simplement impossible, comme dans l'exemple ci-dessus.

Amlioration des API de messagerie

Une autre fonctionnalit couramment utilise dans le MVVM Toolkit est l'interface IMessenger, qui est un contrat pour les types qui peuvent tre utiliss pour changer des messages entre diffrents objets. Cela peut tre utile pour dcoupler diffrents modules d'une application sans avoir conserver des rfrences fortes aux types rfrencs. Il est galement possible d'envoyer des messages des canaux spcifiques, identifis de manire unique par un jeton, et d'avoir diffrents messagers dans diffrentes sections d'une application.

Le MVVM Toolkit fournit deux implmentations de cette interface :

  • WeakReferenceMessenger : qui n'enracine pas les destinataires et les autorise tre collects. Ceci est mis en uvre par le biais de handles dpendants, qui sont un type spcial de rfrences GC permettant ce messager de s'assurer qu'il autorise toujours les destinataires enregistrs tre collects, mme si un gestionnaire enregistr les renvoie, mais qu'il n'existe pas d'autres rfrences fortes eux ;
  • StrongReferenceMessenger : il s'agit d'une implmentation de messager qui enracine les destinataires enregistrs pour s'assurer qu'ils restent en vie mme si le messager est le seul objet les rfrencer.

Voici un petit exemple de la faon dont cette interface peut tre utilise :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Declare a message
public sealed record LoggedInUserChangedMessage(User user);
 
// Register a recipient explicitly...
messenger.Register<MyViewModel, LoggedInUserChangedMessage>(this, static (r, m) =>
{
    // Handle the message here, with r being the recipient and m being the
    // input message. Using the recipient passed as input makes it so that
    // the lambda expression doesn't capture "this", improving performance.
});
 
// ...or have the viewmodel implement IRecipient<TMessage>...
class MyViewModel : IRecipient<LoggedInUserChangedMessage>
{
    public void Receive(LoggedInUserChangedMessage message)
    {
        // Handle the message here
    }
}
 
// ...and then register through the interface (other APIs are available too)
messenger.Register<LoggedInuserChangedMessage>(this);
 
// Send a message from some other module
messenger.Send(new LoggedInUserChangedMessage(user));

Les implmentations des messagers dans cette nouvelle version du MVVM Toolkit ont t hautement optimises dans .NET 6 grce la nouvelle API publique DependentHandle, qui permet aux types de messagers d'tre encore plus rapides qu'auparavant et d'offrir une diffusion de messages totalement sans allocation. Voici quelques benchmarks montrant comment les messagers de la MVVM Toolkit se comportent par rapport plusieurs autres types quivalents d'autres bibliothques MVVM largement utilises :

Chaque excution du benchmark consiste envoyer 4 messages diffrents 1000 fois, 100 destinataires. Comme vous pouvez le constater, WeakReferenceMessenger et StrongReferenceMessenger sont tous deux de loin les plus rapides, et les seuls ne pas allouer ne serait-ce qu'un seul octet lors de la diffusion des messages....

API de collecte remanie

Cette nouvelle version du MVVM Toolkit dplace galement tous les types de collections groupes observables du paquet CommunityToolkit.Common vers CommunityToolkit.Mvvm, tout en effectuant quelques changements majeurs pour amliorer la surface de l'API et la rendre utile dans davantage de scnarios. Ces API sont particulirement utiles lorsqu'on travaille avec des lments groups (par exemple, pour afficher une liste de contacts), et elles comprennent maintenant des extensions qui facilitent grandement les oprations courantes telles que l'insertion d'un lment la bonne position dans un groupe (en utilisant soit le comparateur par dfaut, soit un comparateur en entre, et en crant un nouveau groupe si ncessaire).

Annonce de l'application type de la bote outils MVVM

Pour accompagner la nouvelle version, Microsoft a galement publi l'application type dans le Microsoft Store ! Elle comprend toute la documentation galement disponible sur MS Docs, ainsi que des chantillons interactifs pour de nombreuses API disponibles. Il s'agit d'un accessoire de la MVVM Toolkit.

Amlioration des API de diagnostic

Le paquet CommunityToolkit.Diagnostics a galement reu quelques nouvelles amliorations, tirant parti des nouvelles fonctionnalits du gestionnaire de chanes interpoles et de l'expression des arguments de l'appelant de C# 10. Plusieurs API de garde qui prenaient auparavant une chane de caractres acceptent dsormais galement un gestionnaire personnalis, ce qui permet aux sites d'appel de sauter compltement l'tape d'interpolation si aucune exception n'est leve, et il n'est plus ncessaire d'indiquer manuellement le nom de l'argument.

Voici une comparaison rapide avant et aprs :

/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/ Diagnostics 7.1
public static void SampleMethod(int[] array, int index, Span<int> span, string text)
{
    Guard.IsNotNull(array, nameof(array));
    Guard.HasSizeGreaterThanOrEqualTo(array, 10, nameof(array));
    Guard.IsInRangeFor(index, array, nameof(index));
    Guard.HasSizeLessThanOrEqualTo(array, span, nameof(span));
    Guard.IsNotNullOrEmpty(text, nameof(text));
}
 
// Diagnostics 8.0
public static void SampleMethod(int[] array, int index, Span<int> span, string text)
{
    Guard.IsNotNull(array);
    Guard.HasSizeGreaterThanOrEqualTo(array, 10);
    Guard.IsInRangeFor(index, array);
    Guard.HasSizeLessThanOrEqualTo(array, span);
    Guard.IsNotNullOrEmpty(text);
}

Prise en charge de .NET 6

Cette nouvelle version du .NET Community Toolkit ajoute galement la prise en charge de .NET 6 comme nouvelle cible dans toutes les bibliothques disponibles. Cela apporte plusieurs amliorations lors de l'excution sur le dernier runtime .NET :

La prise en charge du trimming est maintenant active pour toutes les bibliothques. Pour soutenir cela, tous les paquets ont galement des annotations de dcoupage complet pour toutes les API, afin de s'assurer que tout est soit convivial pour le linker, soit affiche explicitement les avertissements corrects au moment de la compilation (par exemple, c'est le cas pour certaines API de validation dans le MVVM Toolkit, qui utilisent certaines API de la BCL qui ncessitent intrinsquement une certaine rflexion pour fonctionner).

L'extension Count() du paquetage HighPerformance prend dsormais galement en charge nint et nuint. Plusieurs autres optimisations ont t introduites dans tous les paquets pour .NET 6. Bien entendu, toutes les bibliothques continueront tre prises en charge jusqu' .NET Standard 2.0, de sorte que vous pourrez continuer les rfrencer dans des projets utilisant des frameworks cibles diffrents.

Et grce au fonctionnement de la rsolution des paquets NuGet, si vous crez une bibliothque l'aide de l'un de ces paquets et d'un framework cible infrieur (par exemple, .NET Standard 2.0) et qu'un utilisateur la rfrence partir d'un projet ciblant une nouvelle version de .NET (par exemple, .NET 6), il obtiendra toujours automatiquement la version la plus optimise des assemblages du .NET Community Toolkit qui est disponible pour lui.

Source : Microsoft

Et vous ?

Quel es votre avis sur le sujet ?

Voir aussi :

Microsoft annonce .NET 7 Preview 6, la version du framework pour la cration des applications, amliore les convertisseurs de type, personnalise des contrats JSON

Microsoft annonce .NET 7 Preview 3, la version du framework pour la cration des applications, apporte une amlioration du temps de dmarrage avec la fonction Write-Xor-Execute active de 10 15 %

Microsoft annonce .NET 7 Preview 4, la version du framework pour la cration des applications, elle corrige les bogues et comprend des MAJ

Microsoft publie le premier aperu de .NET 7 avec des optimisations continues du compilateur JIT, de nouvelles API et la prise en charge de plus de scnarios de rechargement chaud

Leave a Comment

Your email address will not be published.