Modifications de code prises en charge (C# et Visual Basic)

Le mécanisme de Rechargement à chaud, précédemment appelé Modifier et continuer, gère la plupart des types de modifications de code dans les corps de méthode. Toutefois, la plupart des modifications en dehors du corps des méthodes et quelques autres à l’intérieur ne peuvent pas s’appliquer pendant le débogage. Pour appliquer ces modifications non prises en charge, vous devez arrêter le débogage et redémarrer avec une version nouvelle du code.

Modifications prises en charge pour coder

Le tableau suivant montre les modifications qui peuvent être apportées au code C# et Visual Basic pendant une session de débogage sans redémarrer la session.

Élément/fonctionnalité de langage	Opération de modification prise en charge	Limites
Types	Ajouter des méthodes, des champs, des constructeurs, et bien plus encore	Oui
Iterators	Ajouter ou modifier	Non
expressions async/await	Ajouter ou modifier	Oui
Objets dynamiques	Ajouter ou modifier	Non
expressions lambda	Ajouter ou modifier	Oui
expressions LINQ	Ajouter ou modifier	Identique aux expressions lambda
Génériques	Ajouter ou modifier	Oui

Notes

Les fonctionnalités de langage plus récentes telles que l’interpolation de chaîne et les opérateurs conditionnels Null sont généralement prises en charge par Modifier et continuer. Pour obtenir les informations les plus récentes, consultez la page Modifications prises en charge par Enc .

Améliorations de .NET 6+

Les améliorations apportées à .NET 6+ et Visual Studio 2022 et versions ultérieures incluent la prise en charge d’autres types de modifications qui vont au-delà de ce qui était initialement possible dans les versions antérieures de Visual Studio. Ces améliorations sont disponibles à la fois pour les expériences Rechargement à chaud et Modifier et continuer.

L’expérience de Rechargement à chaud .NET 6+ est alimentée par le mécanisme Modifier et continuer et Roslyn. Les modifications prises en charge répertorient les types de modifications actuellement prises en charge par Roslyn et les améliorations futures potentielles.

Modifications non prises en charge pour coder

Les modifications suivantes ne peuvent pas être appliquées à du code C# et Visual Basic pendant une session de débogage.

• Modifications à l'instruction en cours ou à toute autre instruction active.

  Une instruction active est une instruction dans une fonction de la pile des appels qui a été appelée pour accéder à l’instruction actuelle.

  L'instruction en cours s’affiche sur un arrière-plan jaune dans la fenêtre source. D'autres instructions actives s’affichent sur un arrière-plan grisé et sont en lecture seule. Ces couleurs par défaut peuvent être modifiées dans la boîte de dialogue Options.

• Toute modification non prise en charge du code par élément de langage, comme indiqué dans le tableau suivant.

  Élément/fonctionnalité de langage	Opération de modification non prise en charge
  Tous les éléments de code	Renommage
  Espaces de noms	Ajouter
  Espaces de noms, types, membres	Supprimer
  Interfaces	Modifier
  Types	Ajouter un membre abstrait ou virtuel, ajouter un remplacement (voir les détails)
  Types	Ajouter un destructeur
  Membres	- Modifier un membre référençant un type d’interopérabilité incorporé - Modifier un membre statique une fois qu’il a déjà été accédé en exécutant du code
  Membres (Visual Basic)	- Modifier un membre avec l’instruction On Error ou Resume - Modifier un membre contenant une clause de requête Aggregate, Group By, Simple Join ou Group Join LINQ
  Méthodes	- Modifier les signatures - Faire en sorte qu’une méthode abstraite devienne non abstraite en ajoutant un corps de méthode - Supprimer un corps de méthode
  Attributs	Ajouter ou modifier
  Événements ou propriétés	Modifier un paramètre de type, un type de base, un type délégué ou un type de retour
  Opérateurs ou indexeurs	Modifier un paramètre de type, un type de base, un type délégué ou un type de retour
  catch (blocs)	Modifier lorsqu’il contient une instruction active
  blocs try-catch-finally	Modifier lorsqu’il contient une instruction active
  instructions Using	Ajouter
  méthodes asynchrones/lambdas	Modifier une méthode asynchrone/lambda dans un projet ciblant .NET Framework 4 et versions antérieures (voir les détails)
  Itérateurs	Modifier un itérateur dans un projet ciblant .NET Framework 4 et versions antérieures (voir les détails)

Code unsafe

Les modifications apportées à du code non sécurisé présentent les mêmes restrictions que celles qui portent sur du code sécurisé, avec une restriction supplémentaire : Modifier et continuer ne prend pas en charge les modifications de code non sécurisé dans une méthode qui contient l’opérateur stackalloc.

Prise en charge des applications

Les applications prises en charge sont les suivantes :

• Applications UWP dans Windows 10 ou Windows 11
• Applications x86 et x64 qui ciblent le bureau .NET Framework 4.6 ou versions ultérieures (le .NET Framework est une version de bureau uniquement)

Pour .NET 6 et versions ultérieures, la modification est prise en charge pour les types de fichiers suivants :

• .cshtml
• .razor

Applications, plateformes et opérations non prises en charge

Les applications ou plateformes non prises en charge sont les suivantes :

• F#
• .NET Native
• Silverlight 5
• Windows 8.1
• Xamarin.Forms (iOS et Android)

Pour ASP.NET et ASP.NET Core, la modification n’est pas prise en charge pour les types de fichiers suivants :

• .aspx
• .ascx

Scénarios non pris en charge

Modifier et continuer n’est pas disponible dans les scénarios de débogage suivants :

• Débogage en mode mixte (natif/managé).

• Débogage sur Arm64 sans cibler .NET 7 ou version ultérieure.

• Débogage avec la variable d'environnement COR_ENABLE_PROFILING définie.

• Débogage d’une application à l’aide de l’attachement au processus (Déboguer > Attacher au processus) au lieu d’exécuter l’application en choisissant Démarrer dans le menu Déboguer. Si vous souhaitez utiliser Modifier et Continuer lors de l’attachement à un processus, la variable d’environnement COMPLUS_ForceENC doit être définie avant de lancer le processus (set COMPLUS_ForceENC=1).

• Débogage avec des versions d’assembly non déterministes (par exemple, basées sur le temps). Si vous souhaitez utiliser Modifier and Continuer, envisagez de définir la version uniquement dans les builds de Mise en production (ou Intégration continue) et conservez la version dans les builds Déboguer constante.

• Débogage de code optimisé.

• Débogage SQL.

• Débogage d'un fichier dump.

• Débogage d'une application runtime incorporée.

• Débogage d'une version ancienne de votre code après l'échec de génération d'une nouvelle version en raison d'erreurs de build.

Contenu connexe

• Modifier & Continuer (Visual C#)
• Guide pratique pour utiliser Modifier & Continuer (C#)