Préambule
Dans une équipe .NET, tous les projets n’évoluent pas au même rythme. Une application poursuit son cycle de maintenance, une autre migre vers une version plus récente et un prototype explore les nouveautés à venir.
Sur le poste de développement, cela implique de conserver plusieurs SDK, de choisir celui qui convient à chaque dépôt et de garder les installations à jour. Ces tâches font partie de l’expérience de développement, même si elles contribuent rarement directement aux fonctionnalités que l’on souhaite livrer.
Avec l’annonce de dotnetup, publiée le 15 octobre 2026, Microsoft propose un gestionnaire pour installer et maintenir les SDK et les runtimes .NET dans l’environnement utilisateur.
L’outil est en préversion publique au moment de la rédaction. Son intérêt mérite néanmoins qu’on s’y attarde, particulièrement pour les équipes qui travaillent avec plusieurs versions de .NET.
Un gestionnaire pour l’environnement .NET
Selon la présentation de dotnetup sur Microsoft Learn, l’outil prend en charge l’installation, le suivi et la mise à jour des SDK et des runtimes. Il peut aussi installer le SDK demandé par le fichier global.json d’un dépôt.
Sa valeur apparaît surtout après l’installation initiale. Il conserve les exigences demandées, comme suivre une branche de versions ou maintenir une version précise, puis utilise ces informations pour les opérations suivantes.
La documentation sur son fonctionnement distingue ainsi deux éléments :
- L’exigence, par exemple suivre les SDK de la branche
10.0. - L’installation réelle qui satisfait cette exigence à un moment donné.
Plusieurs exigences peuvent partager une même installation. Ce modèle permet aussi de déterminer quels composants sont encore nécessaires lors du nettoyage.
Installer dotnetup
Le guide de démarrage décrit une installation sur Windows, macOS et Linux.
Sous macOS ou Linux, avec Bash :
1
curl -fsSL https://aka.ms/dotnetup/get-dotnetup.sh | bash
Sous Windows, avec PowerShell :
1
irm https://aka.ms/dotnetup/get-dotnetup.ps1 | iex
Le script fournit les instructions pour rendre dotnetup accessible dans le terminal. Une fois celles-ci appliquées, l’assistant interactif est disponible avec :
1
dotnetup init
Cet assistant permet de choisir le canal du SDK et la façon dont l’environnement accédera à .NET.
Il faut cependant examiner ce deuxième choix, particulièrement sur un poste Windows qui possède déjà des installations .NET.
Choisir comment accéder à .NET
La configuration de l’environnement propose trois modes :
| Mode | Comportement |
|---|---|
none | Exécuter le .NET géré par l’outil avec dotnetup dotnet |
shell | Configurer le profil du shell pour utiliser cette installation |
everywhere | Sur Windows, modifier le PATH système et le DOTNET_ROOT de l’utilisateur |
Dans la préversion actuelle, everywhere est le mode proposé par défaut sur Windows. Sa configuration exige une élévation et donne priorité à l’installation gérée par dotnetup. Des applications ou des projets peuvent alors ne plus trouver un runtime ou un SDK présent uniquement dans l’installation système.
Pour une première évaluation, je privilégierais le mode none.
Après le téléchargement de l’outil, on peut aussi procéder directement, sans passer par l’assistant :
1
2
3
4
dotnetup sdk install 10.0
dotnetup env set none
dotnetup dotnet -- --info
dotnetup list
La documentation sur l’accès à l’installation gérée précise que ce mode n’ajoute pas son exécutable dotnet au PATH et ne configure pas DOTNET_ROOT. L’outil dotnetup lui-même peut toutefois être ajouté au PATH.
Cette approche permet de choisir explicitement l’installation utilisée pour les essais.
Suivre un canal ou fixer une version
Les canaux de dotnetup définissent les versions admissibles lors des installations et des mises à jour.
| Exigence | Résultat attendu |
|---|---|
10.0 | Suivre les SDK de la branche .NET 10.0 |
10.0.1xx | Rester dans cette bande de fonctionnalités du SDK |
10.0.103 | Conserver cette version exacte |
latest | Suivre le SDK stable actif le plus récent |
lts | Suivre le SDK stable LTS le plus récent |
preview | Suivre la préversion active, avec repli sur une version active si aucune préversion n’est disponible |
La version exacte du tableau est un exemple de syntaxe, pas une recommandation de correctif à installer.
Le choix du canal constitue une décision d’équipe. latest peut changer de version majeure. Une branche comme 10.0 limite davantage l’évolution. Une version exacte apporte un contrôle plus strict, mais demande une intervention explicite pour progresser.
Pour un dépôt applicatif, je préfère que cette intention soit visible dans le code source.
Utiliser global.json comme point de référence
Le fichier global.json définit la sélection du SDK utilisé par les commandes .NET. Ce choix est distinct du framework ciblé par l’application.
Prenons cette configuration illustrative :
1
2
3
4
5
6
7
{
"sdk": {
"version": "10.0.103",
"rollForward": "latestPatch",
"allowPrerelease": false
}
}
Elle autorise un correctif plus récent dans la même bande de fonctionnalités et exclut les SDK de préversion de la sélection effectuée par .NET.
Depuis le répertoire du dépôt, on peut ensuite exécuter :
1
2
3
dotnetup sdk install
dotnetup dotnet -- --version
dotnetup dotnet build
Comme l’explique le guide d’installation à partir de global.json, dotnetup recherche le fichier le plus proche en remontant depuis le répertoire courant. Dans cet exemple, il enregistre une exigence sur la bande 10.0.1xx.
Sans global.json, la commande utilise le canal latest. La présence du fichier change donc directement le comportement attendu.
Pour exiger une version précise, rollForward: "disable" permet de verrouiller la sélection. Cela impose aussi d’organiser les mises à jour de cette version dans le dépôt.
La préversion comporte quelques particularités. La documentation de l’intégration aux dépôts indique notamment que allowPrerelease ne modifie pas le canal déduit par dotnetup et que les fichiers contenant des commentaires ne sont pas acceptés par son analyseur actuel.
Je retiens surtout une règle pratique : versionner le SDK attendu, rendre la politique d’évolution explicite et vérifier la version réellement sélectionnée dans les journaux de compilation.
Mettre à jour et nettoyer les installations
Pour actualiser les exigences suivies :
1
dotnetup update
Selon la documentation des mises à jour, l’outil résout de nouveau les canaux suivis et installe les versions correspondantes. Les exigences portant sur une version exacte restent fixes.
Après une mise à jour réussie, le nettoyage retire les composants dont aucune exigence n’a encore besoin. Une version reste présente si une autre exigence la conserve.
L’outil ne modifie pas automatiquement les fichiers global.json. Cette opération doit être demandée explicitement :
1
dotnetup sdk update --update-global-json
Cette commande peut toucher plusieurs dépôts suivis. Je traiterais ces modifications comme des changements de code, avec revue et validation des compilations et des tests.
Pour actualiser dotnetup lui-même :
1
dotnetup self update
Enfin, après une modification manuelle de global.json, il faut relancer dotnetup sdk install depuis le dépôt pour appliquer la nouvelle exigence avant les prochaines mises à jour.
Installer un runtime ou explorer une version à venir
La gestion des composants permet de cibler un runtime sans demander un SDK :
1
dotnetup runtime install aspnetcore@10.0
Pour explorer les nouveautés du SDK :
1
dotnetup sdk install preview
L’intérêt pour la modernisation est de pouvoir préparer une évaluation de compatibilité ou reproduire un problème avec une autre version.
Pour un build quotidien, la documentation des versions daily montre aussi comment utiliser un répertoire distinct :
1
dotnetup sdk install daily --install-path .dotnet-daily
On exécute alors directement son dotnet. Sous PowerShell sur Windows :
1
.\.dotnet-daily\dotnet.exe --version
Sous Linux ou macOS :
1
./.dotnet-daily/dotnet --version
Cette précision compte : dotnetup dotnet utilise l’installation gérée par défaut et ne sélectionne pas automatiquement ce répertoire personnalisé.
Je réserverais les builds quotidiens à des essais ciblés, dans un espace de travail séparé. Pour une comparaison de comportement, je noterais aussi la version exacte installée afin de conserver une trace exploitable du résultat.
Quelle place dans les pratiques d’équipe et les pipelines
Microsoft présente l’exécution non interactive comme un scénario possible pour les agents de compilation éphémères. L’annonce initiale évoque aussi une intégration future aux mécanismes de GitHub Actions et d’Azure DevOps.
Cette intention ne constitue pas une intégration déjà livrée.
À ce stade, je commencerais par un dépôt pilote ou un environnement de développement temporaire. J’évaluerais surtout trois aspects :
- La cohérence entre le SDK déclaré et celui réellement utilisé.
- La coexistence avec l’IDE et les installations déjà présentes.
- Le comportement après une mise à jour et le nettoyage qui l’accompagne.
La documentation sur les scénarios d’utilisation recommande encore les méthodes généralement disponibles pour les machines de production. Elle rappelle également que Visual Studio installe et maintient sa propre copie système de .NET.
Je conserverais donc les mécanismes établis dans les pipelines de livraison jusqu’à ce que l’évaluation démontre un bénéfice et une stabilité suffisants pour l’équipe.
Mettre à jour l’outillage ne corrige pas les applications déployées
L’annonce de Microsoft rappelle un point essentiel pour les applications autonomes, ou self-contained : leur runtime est livré avec l’application.
Mettre à jour le poste de développement ne corrige donc pas une application déjà déployée. Il faut republier et redéployer celle-ci avec le runtime corrigé.
Dans une pratique de maintenance, je distinguerais ainsi le suivi de l’outillage de développement du suivi des applications en exploitation. Les deux doivent avoir un responsable et un cycle de mise à jour explicites.
Conclusion
Avec dotnetup, Microsoft propose une façon plus cohérente de gérer les SDK et les runtimes .NET. Le suivi des exigences, l’intégration avec global.json et le nettoyage des installations répondent à des besoins récurrents dès qu’une équipe travaille sur plusieurs dépôts.
Ce qui m’intéresse particulièrement, c’est la possibilité de rapprocher la préparation du poste de développement des exigences versionnées du projet.
La préversion justifie une adoption progressive. Je commencerais par un usage ciblé, avec une politique de SDK explicite et un mode d’accès maîtrisé, puis j’élargirais l’utilisation selon les résultats observés.
L’objectif reste simple : consacrer moins de temps à entretenir l’environnement et davantage à faire évoluer les applications.