Refactoriser des conditions complexes à l’aide du mode Agent de GitHub Copilot

Terminée

Les développeurs peuvent utiliser le mode Agent de GitHub Copilot pour refactoriser en toute sécurité des conditions complexes tout en garantissant que les fonctionnalités sont conservées et que la qualité du code est améliorée.

Note

Utilisez le mode Demander de GitHub Copilot pour analyser des conditions complexes et formuler un plan de refactorisation avant d’utiliser le mode Agent pour implémenter des modifications. Cette approche garantit que la refactorisation est effectuée de manière réfléchie et sécurisée.

Qu’est-ce que le mode Agent ?

Le mode Agent de GitHub Copilot fonctionne de manière autonome pour exécuter des tâches de refactorisation complexes dans votre base de code. Contrairement au mode Demander, qui fournit des conseils et des suggestions dans le panneau de conversation, le mode Agent implémente les mises à jour suggérées en tant que modifications directement dans vos fichiers de code.

Le mode Agent peut modifier des fichiers, appliquer des modifications, exécuter des tests et exécuter des commandes en fonction de vos instructions. Il comprend le contexte du projet et peut maintenir la cohérence entre plusieurs fichiers, ce qui garantit que la refactorisation des modifications n’interrompt pas les fonctionnalités existantes.

Le mode agent est idéal pour implémenter des stratégies de refactorisation à plusieurs étapes qui nécessitent une gestion minutieuse des dépendances, des cas de périphérie et des tests. Le mode agent définit automatiquement le contexte requis et exécute les étapes nécessaires pour atteindre vos objectifs de refactorisation.

Refactoriser des conditions complexes à l’aide du mode Agent

Vous pouvez utiliser le mode Agent pour implémenter les stratégies de refactorisation identifiées lors de l’analyse du mode Demander. Le mode Agent peut exécuter automatiquement plusieurs étapes de refactorisation tout en préservant les fonctionnalités d’origine et en améliorant la qualité du code.

Stratégies de refactorisation des conditions complexes

Voici les principales stratégies d’utilisation du mode Agent pour refactoriser les conditions complexes :

• Appliquer des clauses de garde : demandez au mode Agent d’ajouter des retours anticipés qui gèrent les cas de périphérie et les états non valides, afin de réduire les niveaux d’imbrication.

• Méthodes d’extraction : le mode Agent décompose les conditions complexes en méthodes plus petites et ciblées avec des noms descriptifs.

• Éliminer la duplication : utilisez le mode Agent pour identifier et consolider une logique conditionnelle répétée en composants réutilisables.

• Simplifier les expressions booléennes : Laissez le mode Agent refactoriser les conditions booléennes complexes en utilisant les principes de la logique mathématique (tels que les « lois de De Morgan ») et la simplification logique.

• Remplacez les chaînes conditionnelles : le mode Agent convertit les chaînes si-else complexes en modèles plus gérables comme la stratégie ou les modèles d’état.

• Garantir la sécurité : demandez au mode Agent de vérifier que la refactorisation n’introduit pas de vulnérabilités de sécurité ni contourne les vérifications de sécurité existantes.

• Maintenir les performances : utilisez le mode Agent pour conserver ou améliorer les caractéristiques de performances pendant la refactorisation.

Le mode Agent invite à refactoriser des conditions complexes

Lorsque vous utilisez le mode Agent pour refactoriser des conditions complexes, vos invites doivent être spécifiques, exploitables et inclure des considérations de sécurité. Voici quelques exemples de texte en langage naturel que vous pouvez inclure dans votre invite lors de la refactorisation de conditions complexes :

Préparation et sécurité

• « Avant de refactoriser, créez des tests unitaires qui vérifient le comportement actuel de la logique conditionnelle sélectionnée. »
• « Analysez la condition sélectionnée pour les implications de sécurité et assurez-vous que la refactorisation gère toutes les vérifications de sécurité. »
• « Créez une branche de sauvegarde et exécutez des tests existants avant d’apporter des modifications à la condition sélectionnée. »

Opérations de refactorisation de base

• « Refactorisez le conditionnel sélectionné à l’aide de clauses de garde pour réduire l’imbrication et améliorer la lisibilité. »
• « Extrayez la logique conditionnelle complexe en méthodes distinctes et bien nommées. »
• « Simplifiez l’expression booléenne sélectionnée tout en conservant le même comportement logique. »
• « Remplacez la chaîne si-else imbriquée sélectionnée par un modèle plus gérable. »

Modèles de refactorisation avancés

• « Refactoriser le conditionnel sélectionné à l’aide du modèle de stratégie pour éliminer plusieurs branches if-else . »
• « Convertir la logique de vérification d’état complexe sélectionnée en modèle d’ordinateur d’état . »
• « Remplacez la chaîne conditionnelle sélectionnée par une table de recherche ou une approche basée sur un dictionnaire ».
• « Refactoriser le conditionnel sélectionné pour utiliser le polymorphisme au lieu de la vérification de type. »

Qualité et validation

• « Après refactorisation, exécutez tous les tests et vérifiez que le comportement est identique au code d’origine. »
• « Vérifiez que le conditionnel refactorisé suit les conventions de codage C# de Microsoft. »
• « Vérifiez que le code refactorisé conserve les mêmes caractéristiques de performances. »
• Créez des cas de test supplémentaires pour couvrir les cas limites exposés lors du refactoring.

Flux de travail en mode agent pour la refactorisation des conditions complexes

Le flux de travail suivant montre comment utiliser le mode Agent pour refactoriser en toute sécurité des conditions complexes :

1. Préparer votre espace de travail

   Assurez-vous de travailler dans une branche Git propre et que tout travail existant est enregistré. L’utilisation d’une branche nette vous permet de rétablir facilement des modifications, le cas échéant. Accédez au fichier contenant le conditionnel complexe que vous avez analysé en mode Demander.

2. Configurer des mesures de sécurité

   Avant d’apporter des modifications, demandez au mode Agent de créer ou d’exécuter des tests unitaires existants :

   « Créez des tests unitaires complets pour la CalculateDiscount méthode pour vérifier le comportement actuel avant la refactorisation. »

   Cette étape garantit que vous disposez d’un filet de sécurité pour vérifier que votre refactorisation conserve les fonctionnalités.

3. Commencer par des étapes de refactorisation simples

   Commencez par les modifications à faible risque, telles que l’ajout de clauses guard :

   « Refactorisez la méthode CalculateDiscount en ajoutant des clauses de garde pour la commande nulle et le coupon non valide au début de la méthode. »

   Le mode agent analyse le code et ajoute les retours anticipés appropriés, ce qui réduit la complexité de la logique restante.

4. Extraire une logique complexe dans des méthodes

   Poursuivez avec l’extraction de méthode :

   « Extrayez la logique de validation des coupons et de calcul de remise dans une méthode distincte ApplyCouponDiscount . Assurez-vous que tous les cas en périphérie sont correctement gérés. »

   Le mode Agent crée la nouvelle méthode, déplace le code approprié et met à jour la méthode d’origine pour appeler la logique extraite.

5. Consolider et simplifier

   Traitez la duplication et la logique booléenne complexe.

   « Consolidez la logique de remise des membres Premium afin que la logique soit appliquée à un seul endroit et simplifie les expressions booléennes complexes . »

   Le mode Agent identifie la logique éparse et la consolide tout en conservant le même comportement.

6. Valider les modifications

   Après chaque étape de refactorisation majeure, validez les modifications :

   « Exécutez tous les tests unitaires et vérifiez que le code refactorisé produit des résultats identiques à l’implémentation d’origine. »

   Le mode Agent peut exécuter des tests et signaler les échecs qui doivent être résolus.

7. Examiner et itérer

   Si des problèmes sont détectés, fournissez des instructions spécifiques pour les correctifs :

   « Le test des remises de vacances échoue. Passez en revue la logique refactorisée et vérifiez que les multiplicateurs de congés sont appliqués correctement.

   Le mode Agent analyse le test défaillant et apporte les corrections nécessaires.

Cette approche structurée garantit que la refactorisation est effectuée en toute sécurité et systématiquement, avec validation à chaque étape.

Considérations relatives à la sécurité et à la qualité

Lorsque vous utilisez le mode Agent pour la refactorisation, tenez toujours compte des implications de sécurité et de qualité :

Bonnes pratiques de sécurité

Tenez compte des pratiques de sécurité suivantes lors de la refactorisation des conditions :

• Valider la gestion des entrées : assurez-vous que les conditionnels refactorisés ne contournent pas la validation des entrées ou n'introduisent pas de vulnérabilités d’injection.

• Conserver les vérifications d’autorisation : vérifiez que les conditions liées à la sécurité ne sont pas supprimées ou affaiblies accidentellement pendant la refactorisation.

• Maintenir les pistes d’audit : assurez-vous que la logique de journalisation et de surveillance dans les instructions conditionnelles est conservée.

Normes de qualité du code

Les entreprises adoptent généralement un ensemble spécifique de normes de codage. Si vous n’avez pas de recommandations, Microsoft publie des recommandations pour les conventions de codage C# que vous pouvez suivre.

Conservez une qualité de code élevée en suivant les instructions suivantes :

• Suivez les modèles établis : assurez-vous que le code refactorisé suit les normes de codage et les modèles architecturaux de votre équipe.

• Gérez la lisibilité : vérifiez que le code refactorisé est plus lisible et facile à maintenir que l’original.

• Conserver les performances : assurez-vous que la refactorisation n’introduit pas de régressions de performances.

Recommandations en matière de sécurité en mode agent

Le mode agent est puissant, mais nécessite une surveillance minutieuse :

Avant la refactorisation

• Travaillez toujours dans une branche de fonctionnalité.
• Vérifiez que la couverture complète des tests existe.
• Passez en revue le plan de refactorisation à partir de l’analyse du mode Ask.
• Comprendre la logique métier et les cas de périphérie.

Pendant la refactorisation

• Apportez des modifications incrémentielles plutôt que des transformations volumineuses.
• Validez chaque étape avant de passer à la suivante.
• Examinez le code généré pour son exactitude et son style.
• Testez fréquemment pour détecter les problèmes tôt.

Après la refactorisation

• Exécutez des tests complets, notamment des cas de périphérie.
• Effectuez une révision du code avec les membres de l’équipe.
• Valider les performances et les caractéristiques de sécurité.
• Mettez à jour la documentation si nécessaire.

Traitez le mode Agent comme un puissant assistant

Bien que le mode Agent puisse effectuer des tâches de refactorisation complexes, il nécessite une supervision humaine :

• Passez en revue toutes les modifications avant de les accepter.
• Vérifiez que la logique métier est conservée.
• Vérifiez que les exigences de sécurité et de performances sont remplies.
• Testez soigneusement pour détecter les changements comportementaux subtils.

Le mode agent accélère la refactorisation, mais ne remplace pas la nécessité d’un examen et d’un test minutieux.

Résumé

L’utilisation du mode Agent de GitHub Copilot permet aux développeurs de refactoriser efficacement des conditions complexes tout en conservant la qualité et les fonctionnalités du code. En combinant les insights analytiques à partir du mode Ask avec les fonctionnalités d’exécution du mode Agent, vous pouvez améliorer systématiquement la maintenance du code, la lisibilité et les performances. La clé du succès consiste à fournir des instructions claires, à maintenir les pratiques de sécurité et à valider soigneusement toutes les modifications.