Générer du code à l'aide des suggestions de complétion de code GitHub Copilot

6 minutes

GitHub Copilot peut fournir des suggestions de complétion de code pour de nombreux langages de programmation et un large éventail d’infrastructures, mais fonctionne particulièrement bien pour Python, JavaScript, TypeScript, Ruby, Go, C# et C++. Les complétions de ligne de code sont générées en fonction du contexte du code que vous écrivez. Vous pouvez accepter, rejeter ou accepter partiellement les suggestions fournies par GitHub Copilot.

GitHub Copilot fournit deux façons de générer des complétions de ligne de code :

Depuis un commentaire : Vous pouvez générer des complétions de ligne de code en écrivant un commentaire qui décrit le code que vous souhaitez générer. GitHub Copilot fournit des suggestions de complétion de code basées sur le commentaire que vous écrivez.
Depuis le code : Vous pouvez générer des complétions de ligne de code en commençant une ligne de code ou en appuyant sur Entrée après une ligne de code terminée. GitHub Copilot fournit des suggestions de complétion de code basées sur le code que vous écrivez.

Utiliser GitHub Copilot pour générer des complétions de ligne de code depuis un commentaire

GitHub Copilot génère des suggestions de complétion de code basées sur le commentaire et le contexte existant de votre application.

Vous pouvez utiliser les commentaires pour décrire des extraits de code, des méthodes, des structures de données et d’autres éléments de code.

Supposons que vous disposiez de l’extrait de code suivant :


namespace ReportGenerator;

class QuarterlyIncomeReport
{
    static void Main(string[] args)
    {
        // create a new instance of the class
        QuarterlyIncomeReport report = new QuarterlyIncomeReport();

        // call the GenerateSalesData method

        // call the QuarterlySalesReport method
        
    }

    public void QuarterlySalesReport()
    {

        Console.WriteLine("Quarterly Sales Report");
    }
}

Par exemple, le commentaire suivant peut être utilisé pour créer une structure de données :


// public struct SalesData. Include the following fields: date sold, department name, product ID, quantity sold, unit price

GitHub Copilot génère une ou plusieurs suggestions de saisie semi-automatique de code en fonction de votre commentaire de code et des fichiers de code ouverts dans l’éditeur.

Capture d’écran montrant la complétion du code pour un commentaire qui décrit une structure de données.

Remarquez les types de données utilisés pour déclarer les champs de la structure de données. GitHub Copilot sélectionne les types de données et les noms des variables en fonction de votre code existant et du commentaire de code. GitHub Copilot tente de déterminer comment l’application utilise des variables puis définit les types de données en conséquence.

Lorsque GitHub Copilot génère plusieurs suggestions, vous pouvez parcourir les suggestions en sélectionnant les flèches gauche ou droite (> ou <) situées à gauche du bouton Accepter. Cela vous permet d’évaluer et de sélectionner la suggestion qui convient le mieux à vos besoins.

Il est possible d’accepter une suggestion de complétion de code qui n’est pas une correspondance exacte pour ce que vous voulez. Les modifications requises pour « corriger » la suggestion doivent toutefois être claires. Dans ce cas, certains des types de données ne correspondent pas à votre besoin, mais vous pouvez les ajuster après avoir accepté la saisie automatique suggérée.

Si aucune des options suggérées ne satisfait vos besoins, vous pouvez essayer deux choses. Pour ouvrir un nouvel onglet de l’éditeur contenant une liste d’autres suggestions, appuyez sur les touches Ctrl + Entrer. Cette combinaison de touches rapides ouvre un nouvel onglet contenant jusqu’à 10 suggestions supplémentaires. Chaque suggestion est suivie d’un bouton à utiliser pour accepter la suggestion. L’onglet se ferme automatiquement après l’acceptation d’une suggestion. Votre autre option consiste à appuyer sur la touche Échap pour ignorer les suggestions et réessayer. Vous pouvez ajuster le commentaire de code pour fournir davantage de contexte que GitHub Copilot peut utiliser.

Remarque

GitHub Copilot peut parfois proposer une suggestion par étapes. Si cela se produit, vous pouvez appuyer sur Entrer pour afficher les étapes supplémentaires de la suggestion après l’appui sur la touche Tab.

Pour accepter une structure de données suggérée, appuyez sur la touche Tab ou sélectionnez Accepter.

Pour modifier les types de données de champ, mettez à jour votre code comme suit :

public struct SalesData
{
    public DateOnly dateSold;
    public string departmentName;
    public int productID;
    public int quantitySold;
    public double unitPrice;
}

L’ajustement rapide des suggestions de complétion de code vous permet de vous assurer de la génération du code souhaité. Il est particulièrement important d’apporter des corrections au début de votre processus de développement, lorsque de grandes parties de votre codebase doivent encore être développées. Les saisies semi-automatiques de code suivantes sont basées sur le code déjà écrit. Il est donc important de veiller à ce que votre code soit aussi précis que possible.

Utiliser GitHub Copilot pour générer des complétions de ligne de code depuis un commentaire

GitHub Copilot génère des suggestions de complétion de code basées sur le commentaire et le contexte existant de votre application. Vous pouvez utiliser les commentaires pour décrire des extraits de code, des méthodes, des structures de données et d’autres éléments de code.

Utilisez les étapes suivantes pour terminer cette section de l’exercice :

Dans le fichier Program.cs, créez deux lignes de code vides sous la méthode Main.
Pour créer une structure de données qui peut être utilisée pour générer des données de test, créez le commentaire de code suivant, puis appuyez sur Entrée :
```
// public struct SalesData. Include the following fields: date sold, department name, product ID, quantity sold, unit price
```
GitHub Copilot génère une ou plusieurs suggestions de complétion de code en fonction de votre commentaire de code et de tout code existant qu’il trouve dans votre application.
Prenez un moment pour examiner les suggestions de complétion de code fournies par GitHub Copilot.

Remarque

Si GitHub Copilot génère des suggestions pour une méthode plutôt qu’une structure de données, tapez public str et attendez que la suggestion de complétion du code soit mise à jour. GitHub Copilot utilise les informations supplémentaires pour améliorer ses suggestions.

Remarquez les types de données utilisés pour déclarer les champs de la structure de données. GitHub Copilot sélectionne les types de données et les noms des variables en fonction de votre code existant et du commentaire de code. GitHub Copilot tente de déterminer comment l’application utilise des variables puis définit les types de données en conséquence.

Lorsque GitHub Copilot génère plusieurs suggestions, vous pouvez parcourir les suggestions en sélectionnant les flèches gauche ou droite (> ou <) situées à gauche du bouton Accepter. Cela vous permet d’évaluer et de sélectionner la suggestion qui convient le mieux à vos besoins.

Il est possible d’accepter une suggestion de complétion de code qui n’est pas une correspondance exacte pour ce que vous voulez. Les modifications requises pour « corriger » la suggestion doivent toutefois être claires. Dans ce cas, certains des types de données ne correspondent pas à votre besoin, mais vous pouvez les ajuster après avoir accepté la saisie automatique suggérée.

Si aucune des options suggérées ne satisfait vos besoins, vous pouvez essayer deux choses. Pour ouvrir un nouvel onglet de l’éditeur contenant une liste d’autres suggestions, appuyez sur les touches Ctrl + Entrer. Cette combinaison de touches rapides ouvre un nouvel onglet contenant jusqu’à 10 suggestions supplémentaires. Chaque suggestion est suivie d’un bouton à utiliser pour accepter la suggestion. L’onglet se ferme automatiquement après l’acceptation d’une suggestion. Votre autre option consiste à appuyer sur la touche Échap pour ignorer les suggestions et réessayer. Vous pouvez ajuster le commentaire de code pour fournir davantage de contexte que GitHub Copilot peut utiliser.

Remarque

GitHub Copilot peut parfois proposer une suggestion par étapes. Si cela se produit, vous pouvez appuyer sur Entrer pour afficher les étapes supplémentaires de la suggestion après l’appui sur la touche Tab.
Pour accepter une structure de données suggérée, appuyez sur la touche Tab ou sélectionnez Accepter.
Pour modifier les types de données de champ, mettez à jour votre code comme suit :
```
public struct SalesData
{
    public DateOnly dateSold;
    public string departmentName;
    public int productID;
    public int quantitySold;
    public double unitPrice;
}
```
L’ajustement rapide des suggestions de complétion de code vous permet de vous assurer de la génération du code souhaité. Il est particulièrement important d’apporter des corrections au début de votre processus de développement, lorsque de grandes parties de votre codebase doivent encore être développées. Les saisies semi-automatiques de code sont basées sur votre code existant. Il est donc important de s’assurer que votre code soit aussi précis que possible.
Créez deux lignes de code vides sous la structure de données SalesData.
Pour créer une méthode qui génère des données de test en utilisant la structure de données SalesData, écrivez le commentaire de code suivant, puis appuyez sur Entrée :
```
/* the GenerateSalesData method returns 1000 SalesData records. It assigns random values to each field of the data structure */
```
Prenez un moment pour examiner les suggestions de complétion de code fournies par GitHub Copilot.

Remarquez que la méthode GenerateSalesData est conçue pour retourner un tableau d’objets SalesData. La méthode génère 1 000 enregistrements de données de test, avec des valeurs aléatoires affectées à chaque champ de la structure de données SalesData.

Vous devez toujours évaluer les suggestions proposées par GitHub Copilot et GitHub Copilot Chat, même lorsqu’elles semblent correctes.

Remarque

Si GitHub Copilot suggère une seule ligne de code plutôt qu’une méthode GenerateSalesData terminée, appuyez sur Ctrl + Entrer pour ouvrir l’onglet Suggestions de GitHub Copilot. Passez en revue les suggestions dans le nouvel onglet. À l’étape suivante, utilisez le bouton « Accepter une suggestion # » pour accepter la suggestion. GitHub Copilot présente des suggestions incrémentielles à l’occasion. Bien que vous puissiez accepter les complétions de code de manière incrémentielle, il est préférable d’utiliser l’onglet Suggestions de GitHub Copilot pour évaluer les suggestions complètes avant de prendre une décision d’accepter ou d’ignorer.
Faites défiler les suggestions de saisie semi-automatique de code et sélectionnez celle qui correspond le mieux aux besoins.
Pour accepter la complétion de code, appuyez sur la touche Tab.

Notez que la suggestion de complétion du code inclut une erreur de syntaxe dans le code utilisé pour générer le champ DateSold. DateOnly accepte trois valeurs entières à répertorier dans le bon ordre : Année, Mois, Jour.
Pour spécifier une année unique pour le code utilisé pour générer le champ DateSold, mettez à jour la ligne de code comme suit :
```
salesData[i].DateSold = new DateOnly(2023, random.Next(1, 13), random.Next(1, 29));
```

Si nécessaire, ajustez les autres lignes de code pour qu’elles correspondent à l’extrait de code suivant :

public SalesData[] GenerateSalesData()
{
    SalesData[] salesData = new SalesData[1000];
    Random random = new Random();

    for (int i = 0; i < salesData.Length; i++)
    {
        salesData[i].dateSold = new DateOnly(2023, random.Next(1, 13), random.Next(1, 29));
        salesData[i].departmentName = "Department " + random.Next(1, 11);
        salesData[i].productID = random.Next(1, 101);
        salesData[i].quantitySold = random.Next(1, 101);
        salesData[i].unitPrice = random.NextDouble() * 100;
    }

    return salesData;
}

La possibilité de générer du code depuis des commentaires de code est une fonctionnalité puissante de GitHub Copilot. Avec seulement deux commentaires, vous avez pu générer une structure de données et une méthode qui génère des données de test.

Utiliser GitHub Copilot pour générer des complétions de ligne de code

GitHub Copilot peut générer des complétions de ligne de code en fonction du code que vous entrez. Vous pouvez générer des complétions de ligne de code de deux façons :

Commencez à entrer une ligne de code, puis attendez que GitHub Copilot suggère une autocomplétion pour votre ligne de code non terminée.
Entrez une ligne de code complète, appuyez sur la touche Entrée, puis attendez que GitHub Copilot suggère une autocomplétion pour la ligne de code suivante.

Remarque

GitHub Copilot génère les complétions de code suggérées en fonction du code que vous entrez et du contexte défini par le code au sein de votre application. Plus vous avez de code disponible dans votre application, plus GitHub Copilot a de contexte lors de la génération d’une réponse. GitHub Copilot peut baser des réponses sur votre code existant, de sorte que la qualité de votre code est importante. À mesure que le volume et la qualité du code existant augmentent, il en va de même de la qualité et de la fiabilité des complétions de ligne de code suggérés par GitHub Copilot. GitHub Copilot excelle pour générer des complétions de ligne de code pour les tâches et modèles de programmation courants, en particulier quand une séquence de composants connexes doit être générée.

Dans cette partie de l’exercice, vous travaillez sur la méthode QuarterlySalesReport.

Voici les tâches que vous devez effectuer :

Mettre à jour le constructeur de méthode avec un paramètre qui accepte votre collection d’objets SalesData.
Utiliser GitHub Copilot pour générer des complétions de ligne de code qui traitent les données de ventes pour le rapport trimestriel.
Exécutez l’application et examinez le rapport sur le chiffre de ventes trimestrielles.

Utilisez les étapes suivantes pour terminer cette section de l’exercice :

Mettre à jour le constructeur de méthode pour QuarterlySalesReport, comme suit :
```
public void QuarterlySalesReport(SalesData[] salesData)
```
Prenez un moment pour réfléchir au code que vous devez développer.

Le concept est simple. Vous souhaitez que votre code calcule les ventes trimestrielles en fonction de vos données de ventes, puis écrive un rapport. Pour ce faire, votre code doit :
- Itérez via la collection salesData.
- Calculez la valeur de chaque vente en fonction de la quantité vendue et du prix unitaire.
- Utilisez la date de vente pour déterminer le trimestre auquel appartient une vente.
- Additionnez les ventes der chaque trimestre.
- Écrivez un rapport sur les ventes par trimestre.
Une option consiste à commencer à entrer le code d’une boucle foreach, puis à voir ce que GitHub Copilot suggère.
Dans la méthode QuarterlySalesReport, créez une ligne de code en haut du bloc de code.

Il doit y avoir au moins une ligne de code vide entre la nouvelle ligne de code et celle contenant Console.WriteLine().
Pour générer une complétion de ligne de code, tapez foreach ( et attendez que GitHub Copilot suggère des options de complétion de ligne de code.
Examinez la complétion de code suggérée par GitHub Copilot.

La complétion de code suggérée n’est pas ce que vous vouliez.

Bien que GitHub Copilot suggère une boucle foreach qui itère dans les salesData, il n’y a aucune analyse ni aucun calcul à l’intérieur de la boucle. Le code suggéré inclut des instructions Console.WriteLine dont vous ne souhaitez pas ou n’avez pas besoin.
Prenez un moment pour réfléchir à la raison pour laquelle GitHub Copilot suggère des instructions Console.WriteLine.

Rappelez-vous que GitHub Copilot génère des suggestions de complétion de code en fonction du contexte de votre code. Dans ce cas, vous n’avez pas vraiment beaucoup de code à prendre en compte par GitHub Copilot. Et la situation empire.

Le code que GitHub Copilot voit dans votre méthode est une instruction Console.WriteLine. Sans aucun autre contexte disponible dans la méthode et aucune méthode semblable dans votre codebase à partir duquel dessiner, GitHub Copilot conclut que vous souhaitez peut-être des instructions Console.WriteLine dans la boucle foreach.

GitHub Copilot fonctionne mieux lorsque votre code est propre et ciblé. Si vous remarquez des commentaires ou des instructions superflus dans votre code, il pourrait être judicieux de les retirer avant d'essayer d'utiliser les complétions de code de GitHub Copilot.
Pour nettoyer votre code avant de demander à GitHub Copilot de refaire un autre essai, procédez comme suit :
- Annulez la complétion de code suggérée foreach (.
- Supprimez l’instruction foreach ( partielle que vous avez entrée.
- Supprimez l’instruction Console.WriteLine de votre méthode QuarterlySalesReport.
Vous devriez maintenant être prêt à réessayer GitHub Copilot.
Vérifiez que votre méthode QuarterlySalesReport ressemble au code suivant :
```
public void QuarterlySalesReport(SalesData[] salesData)
{


}
```
Positionnez le curseur sur une ligne de code vide à l’intérieur de la méthode QuarterlySalesReport, puis appuyez sur Entrée.

GitHub Copilot peut prendre un certain temps pour générer la complétion de code suggérée.
Prenez un moment pour examiner les complétions de code suggérées.

Important

Les complétions de code que vous recevez sont susceptibles d’être différentes des suggestions présentées dans la capture d’écran suivante. Bien que GitHub Copilot n’ait qu’un nom de méthode et un paramètre à utiliser, cela peut être suffisant pour générer des suggestions utiles. Vous devriez voir des suggestions qui calculent les ventes par trimestre. Rejeter les suggestions et réessayer peut fournir des résultats différents.

Vous pouvez parcourir les suggestions en sélectionnant > ou <.

Notez que la complétion de code suggérée effectue une itération dans les données de ventes et effectue des calculs trimestriels des ventes.

Pour accepter la complétion de code suggérée, appuyez sur la touche Tab.

La complétion de code suggérée calcule et affiche le chiffre d’affaires trimestriel en fonction des données de ventes.

// create a dictionary to store the quarterly sales data
Dictionary<string, double> quarterlySales = new Dictionary<string, double>();

// iterate through the sales data
foreach (SalesData data in salesData)
{
    // calculate the total sales for each quarter
    string quarter = GetQuarter(data.dateSold.Month);
    double totalSales = data.quantitySold * data.unitPrice;

    if (quarterlySales.ContainsKey(quarter))
    {
        quarterlySales[quarter] += totalSales;
    }
    else
    {
        quarterlySales.Add(quarter, totalSales);
    }
}

// display the quarterly sales report
Console.WriteLine("Quarterly Sales Report");
Console.WriteLine("----------------------");
foreach (KeyValuePair<string, double> quarter in quarterlySales)
{
    Console.WriteLine(entry.Key + ": $" + entry.Value);
}

Notez que la méthode GetQuarter utilise le mois de la vente pour déterminer le trimestre de la vente.

La méthode GetQuarter est créée ensuite.
Créez deux lignes de code vide sous la méthode QuarterlySalesReport.
Notez que GitHub Copilot suggère une complétion de code pour la méthode GetQuarter.

Avec le contexte fourni par la méthode QuarterlySalesReport, GitHub Copilot peut facilement générer une complétion de code pour la méthode GetQuarter, qui détermine le trimestre en fonction du mois de la vente.
Prenez un moment pour examiner la complétion de la ligne de code suggérée pour la méthode GetQuarter.

Pour accepter la complétion de code suggérée, appuyez sur la touche Tab.

public string GetQuarter(int month)
{
    if (month >= 1 && month <= 3)
    {
        return "Q1";
    }
    else if (month >= 4 && month <= 6)
    {
        return "Q2";
    }
    else if (month >= 7 && month <= 9)
    {
        return "Q3";
    }
    else
    {
        return "Q4";
    }
}

Notez que la méthode Main doit être terminée avant de pouvoir exécuter le code.

Vous pouvez utiliser les commentaires de la méthode Main pour mettre à jour votre code.
Positionnez le curseur à la fin du commentaire de code // call the GenerateSalesData method, puis appuyez sur Entrée.

GitHub Copilot utilise le commentaire pour proposer une instruction appelante pour la méthode.
Examinez, puis acceptez la complétion de code suggérée par GitHub Copilot.
Répétez le processus pour le commentaire de code // call the QuarterlySalesReport method.

Votre méthode Main doit contenir le code suivant :

static void Main(string[] args)
{
    // create a new instance of the class
    QuarterlyIncomeReport report = new QuarterlyIncomeReport();

    // call the GenerateSalesData method
    SalesData[] salesData = report.GenerateSalesData();

    // call the QuarterlySalesReport method
    report.QuarterlySalesReport(salesData);
}

Prenez un moment pour examiner le code de votre classe QuarterlyIncomeReport.

namespace ReportGenerator
{
    class QuarterlyIncomeReport
    {
        static void Main(string[] args)
        {
            // create a new instance of the class
            QuarterlyIncomeReport report = new QuarterlyIncomeReport();

            // call the GenerateSalesData method
            SalesData[] salesData = report.GenerateSalesData();

            // call the QuarterlySalesReport method
            report.QuarterlySalesReport(salesData);
        }

        /* public struct SalesData includes the following fields: date sold, department name, product ID, quantity sold, unit price */
        public struct SalesData
        {
            public DateOnly dateSold;
            public string departmentName;
            public int productID;
            public int quantitySold;
            public double unitPrice;
        }

        /* the GenerateSalesData method returns 1000 SalesData records. It assigns random values to each field of the data structure */
        public SalesData[] GenerateSalesData()
        {
            SalesData[] salesData = new SalesData[1000];
            Random random = new Random();

            for (int i = 0; i < 1000; i++)
            {
                salesData[i].dateSold = new DateOnly(2023, random.Next(1, 13), random.Next(1, 29));
                salesData[i].departmentName = "Department " + random.Next(1, 11);
                salesData[i].productID = random.Next(1, 101);
                salesData[i].quantitySold = random.Next(1, 101);
                salesData[i].unitPrice = random.NextDouble() * 100;
            }

            return salesData;
        }

        public void QuarterlySalesReport(SalesData[] salesData)
        {
            // create a dictionary to store the quarterly sales data
            Dictionary<string, double> quarterlySales = new Dictionary<string, double>();

            // iterate through the sales data
            foreach (SalesData data in salesData)
            {
                // calculate the total sales for each quarter
                string quarter = GetQuarter(data.dateSold.Month);
                double totalSales = data.quantitySold * data.unitPrice;

                if (quarterlySales.ContainsKey(quarter))
                {
                    quarterlySales[quarter] += totalSales;
                }
                else
                {
                    quarterlySales.Add(quarter, totalSales);
                }
            }

            // display the quarterly sales report
            Console.WriteLine("Quarterly Sales Report");
            Console.WriteLine("----------------------");
            foreach (KeyValuePair<string, double> quarter in quarterlySales)
            {
                Console.WriteLine(entry.Key + ": $" + entry.Value);
            }
        }

        public string GetQuarter(int month)
        {
            if (month >= 1 && month <= 3)
            {
                return "Q1";
            }
            else if (month >= 4 && month <= 6)
            {
                return "Q2";
            }
            else if (month >= 7 && month <= 9)
            {
                return "Q3";
            }
            else
            {
                return "Q4";
            }
        }
    }
}

Ce code a été créé presque entièrement grâce aux complétions de lignes de code générées par GitHub Copilot. Or, il est important que vous examiniez les suggestions de code, car des corrections peuvent être nécessaires, comme dans le cas présent. Vous devriez toujours examiner les suggestions de code proposées par GitHub Copilot pour vous assurer que le code répond à vos exigences.

Pour examiner la sortie du rapport, exécutez l’application.

Ouvrez une fenêtre du Terminal dans Visual Studio Code, puis entrez la commande suivante :
```
dotnet run
```
La sortie devrait afficher le rapport de chiffre d’affaires trimestriel, en indiquant le nom du service, le trimestre et le chiffre d’affaires pour chaque service et trimestre représenté dans les données de test.
Examinez la sortie dans la fenêtre du Terminal.

Même si les résultats trimestriels sont basés sur des valeurs numériques aléatoires, vous devez obtenir un rapport dont la mise en forme est semblable à la sortie suivante :
```
Quarterly Sales Report
----------------------
Q3: $635637.5019563352
Q4: $672247.315297204
Q2: $667269.194630603
Q1: $642769.2700531208
```

Résumé

Les achèvements de ligne de code sont une fonctionnalité puissante de GitHub Copilot qui peut vous aider à générer du code rapidement et efficacement. En utilisant des commentaires pour décrire le code que vous souhaitez générer, vous pouvez créer des structures de données, des méthodes et d’autres éléments de code avec un effort minimal. En outre, GitHub Copilot peut générer des saisies de ligne de code en fonction du code que vous entrez, ce qui vous permet de créer facilement des applications complexes.

Commentaires

Cette page a-t-elle été utile ?