Blazor Basics: WebAssembly AVANT ENTERNET (AOT) Compilation

Découvrez comment le travail de compilation juste en temps (JIT) et à l’avance (AOT) dans le contexte des applications Blazor WebAssembly.

Depuis l’introduction de .NET Framework en 2002 aux premiers jours de .NET (Core) en 2016, Compilation juste à temps (JIT) est ainsi que la plate-forme .NET a fonctionné.

Avec JIT, nous écrivons nos applications en utilisant l’un des langages de programmation .NET disponibles, principalement C #, F # ou Visual Basic .NET. Le compilateur transforme le code source en code de langue intermédiaire (IL) stocké dans des fichiers .dll. Au démarrage du programme, le runtime .NET charge les fichiers .dll contenant le code IL, et Just-in-Time (JIT) les compile en code machine.

Disponible depuis .NET 7 et s’améliorant avec .NET 8 et .NET 9, nous avons une autre option pour compiler notre application .NET en utilisant compilation native à l’avance (AOT).

Quel est l’avantage de la compilation Just in Time (JIT)?

Avant de découvrir la compilation AOT, regardons les forces de la compilation JIT et pourquoi elle a été la seule option depuis longtemps.

Lors de l’utilisation de la compilation JIT, le Exécution de la langue commune (CLR) exécute le Langue intermédiaire (IL) Code en le compilant dans le code machine natif à l’exécution.

Cela signifie que nous pouvons expédier les mêmes DLL sur toutes les plates-formes prises en charge, et le CLR compilera le code d’application dans le code machine natif pendant le démarrage de l’application. Non seulement cela aide à portabilité des DLL, mais aussi accélérer l’application parce que le CLR peut optimiser dynamiquement L’exécution de l’architecture du processeur et de la plate-forme sur laquelle il fonctionne.

Jit est également le fondement de Réflexion. Sans Jit, nous ne pouvions pas utiliser la réflexion parce que nous n’aurions pas le Informations sur le type .NET Disponible au moment de l’exécution.

Qu’est-ce que la compilation à l’avance (AOT)?

Avec compilation à l’avance (AOT)nous compilons le code .net C #, F # ou Visual. code machine au lieu de Langue intermédiaire (IL) code.

En utilisant AOT, nous obtenons un Exécutable autonome. Les applications peuvent fonctionner sur des systèmes qui n’ont pas le .NET Runtime installé.

Nous obtenons également des temps de démarrage plus rapides parce que Aucune compilation d’exécution est requis – l’étape de la compilation du code IL vers le code natif l’offre. L’application consomme également Moins de mémoire En raison du manque de compilation d’exécution.

Avec garniture et d’autres optimisations, les applications compilées AOT peuvent être plus petit que les applications compilées JIT. Cela profite aux déploiements cloud car moins de bande passante est consommée lors du déploiement de l’application. Il n’est généralement pertinent que dans des situations à grande échelle où vous devez déployer plusieurs instances d’application.

AOT est souvent idéal pour déploiements cloud à grande échelle ou des environnements avec des ressources limitées, telles que des systèmes intégrés ou des appareils IoT.

Dans le contexte des applications Web Blazor à l’aide du mode d’interactivité WebAssembly, le code d’application est compilé en Webassemblyle code natif pour la plate-forme du navigateur. Il fait que l’application s’exécute plus rapidement dans le navigateur, mais est souvent livrée avec l’inconvénient de plus grandes tailles, ce qui entraîne une durée de téléchargement plus longue.

Comment activer et configurer AOT dans Blazor WebAssembly

Maintenant, disons que nous voulons utiliser la compilation AOT pour un Blazor webassembly application. Passons par les étapes requises une par une.

Tout d’abord, nous devons installer le .NET WebAssembly Build Tools Utilisation du programme d’installation Visual Studio ou exécutez la commande suivante dans un shell:

dotnet workload install wasm-tools

Ensuite, nous ouvrons le dossier de projet du projet Blazor WebAssembly et ajoutez la configuration suivante:

<PropertyGroup> 
    <RunAOTCompilation>true</RunAOTCompilation>
</PropertyGroup>

Le RunAOTCompilation Le réglage active compilation AOT native Pour les applications Blazor WebAssembly.

Maintenant, quand édition l’application utilisant le Release Configuration, nous devrions obtenir un seul exécutable contenant du code WebAssembly.

Vous pouvez compiler et publier en utilisant la commande suivante à partir de la ligne de commande:

dotnet publish -c Release

Vous pouvez également utiliser Visual Studio et un clic droit de publication du projet WebAssembly.

Remarquez que la compilation et l’édition prendront considérablement plus long que les applications régulières Blazor WebAssembly compilées JIT. Un projet simple prend au moins deux à trois minutes sur un ordinateur moderne.

C’est aussi pourquoi la compilation AOT n’est effectuée que lorsque édition l’application et uniquement dans le Release configuration.

Si l’application ne s’exécute pas comme prévu, il se pourrait que la réduction du code .NET IL après la compilation AOT soit le problème. C’est une technique utilisée pour réduire la taille du _framework dossier.

Tu peux Désactiver le code de la coupe Dans la configuration du projet avec le paramètre suivant:

<PropertyGroup>
  <RunAOTCompilation>true</RunAOTCompilation>
  <WasmStripILAfterAOT>false</WasmStripILAfterAOT>
</PropertyGroup>

Le WasmStripILAfterAOT Le réglage est true par défaut, et vous pouvez le définir sur false pour empêcher la coupe.

Compilation de compilation AOT et juste à temps (JIT)

AOT promet des temps de démarrage plus rapides, de l’empreinte de la mémoire inférieure et des tailles d’application plus grandes. Cependant, selon le code de l’application, le temps de démarrage peut ne pas s’améliorer autant, ou la taille de l’application peut ne pas augmenter par rapport aux autres applications. Vous devez l’essayer avec votre application pour voir comment le résultat est dans un cas d’utilisation particulier.

Lorsque vous utilisez AOT, il y en a limitations et compromis Nous devons être conscients.

Par exemple, nous Impossible de charger dynamiquement en utilisant Assembly.LoadFileutilisez une réflexion, comme .GetType().GetProperty("Name")ou émettre du code en utilisant System.Reflection.Emit.

Depuis les exécutables compilés Inclure les bibliothèques d’exécutionils augmentent considérablement leur taille par rapport aux applications compilées par JIT qui s’exécutent sur le runtime .NET du système cible.

Lors de l’expédition des applications .NET autonomes, l’inverse est souvent vrai. La taille diminue car une grande partie du code est coupée pendant la compilation.

Un autre inconvénient inconnu de l’AOT est que System.Linq.Expressions Utilisez toujours le forme interprétée au lieu de Code compilé généré par l’exécution. Il rend l’évaluation de ces expressions plus lentes.

Certaines des fonctionnalités de base ASP.NET ne sont pas prises en charge avec .NET 9. Par exemple, Blazor Server et MVC ne sont pas pris en charge, tandis que les API et Signals minimaux sont partiellement pris en charge. Cependant, cela pourrait changer à l’avenir. En savoir plus à ce sujet dans le Documentation officielle de Microsoft sur l’AOT natif dans ASP.NET Core.

Supposons que vous souhaitiez prendre en charge plusieurs plates-formes et utiliser la capacité multiplateforme de .NET. Dans ce cas, vous devez fournir plusieurs exécutables, un pour chaque plate-forme cible, ce qui rend le processus de construction et le déploiement plus complexe par rapport au partage d’une application .NET portable.

Cependant, nous obtenons toujours des avantages multiplateformes en utilisant la compilation AOT pour les applications Blazor WebAssembly. WebAssembly est déjà un format multiplateforme car les navigateurs fournissent la plate-forme.

Conclusion

Avec le .NET moderne, nous avons maintenant la possibilité de continuer à utiliser les éprouvés Compilation juste à temps (JIT) ou utiliser compilation native à l’avance (AOT) pour Blazor webassembly applications.

Cela dépend de plusieurs facteurs, notamment votre code d’application et votre stratégie de déploiement, laquelle des deux options est le plus logique pour votre situation spécifique.

Activer la compilation AOT pour Blazor WebAssembly est aussi simple que d’ajouter le RunAOTCompilation Définition dans le fichier du projet. Cependant, assurez-vous d’installer le .NET WebAssembly Build Tools Sur la machine, vous souhaitez effectuer une compilation AOT.

La compilation AOT est lente et, par conséquent, exécutée uniquement lorsque édition l’application utilisant le Release Configuration et non lors du démarrage de l’application en mode développement.

Il y a compromis Lorsque vous activez la compilation AOT que vous devez savoir. Cet article vous donne un excellent point de départ pour essayer de déterminer si votre projet bénéficiera de la compilation AOT ou si la compilation JIT reste la meilleure stratégie à l’avenir.

D’après mon expérience, les applications principalement natives et hautement évolutives (telles que les API .NET) fonctionnent dans le cloud bénéficient d’AOT. Cependant, dans certains cas, il est également bénéfique pour les applications Blazor WebAssembly.

Si vous voulez en savoir plus sur le développement du blazor, vous pouvez regarder mon Cours crash gratuit du blazor sur youtube. Et restez à l’écoute du blog Telerik pour en savoir plus Bases du blazor.