Generare codice usando i suggerimenti di completamento del codice di GitHub Copilot

6 minuti

GitHub Copilot può fornire suggerimenti di completamento del codice per numerosi linguaggi di programmazione e un'ampia gamma di framework, ma funziona particolarmente bene per Python, JavaScript, TypeScript, Ruby, Go, C# e C++. I completamenti della riga di codice vengono generati in base al contesto del codice che si sta scrivendo. È possibile accettare, rifiutare o accettare parzialmente i suggerimenti forniti da GitHub Copilot.

GitHub Copilot offre due modi per generare completamenti della riga di codice:

Da un commento: è possibile generare completamenti della riga di codice scrivendo un commento che descrive il codice da generare. GitHub Copilot fornisce suggerimenti di completamento del codice in base al commento scritto.
Dal codice: è possibile generare completamenti della riga di codice avviando una riga di codice o premendo INVIO dopo una riga di codice completata. GitHub Copilot fornisce suggerimenti di completamento del codice in base al codice scritto.

Usare GitHub Copilot per generare completamenti della riga di codice da un commento

GitHub Copilot genera suggerimenti di completamento del codice in base al commento e al contesto esistente dell'app.

È possibile usare i commenti per descrivere frammenti di codice, metodi, strutture di dati e altri elementi di codice.

Si supponga di avere il frammento di codice seguente:


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");
    }
}

Ad esempio, è possibile usare il commento seguente per creare una struttura di dati:


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

GitHub Copilot genera uno o più suggerimenti di completamento del codice in base al commento del codice e ai file di codice aperti nell'editor.

Screenshot che mostra il completamento del codice per un commento che descrive una struttura di dati.

Si notino i tipi di dati usati per dichiarare i campi della struttura dei dati. GitHub Copilot seleziona i tipi di dati e i nomi delle variabili in base al codice esistente e al commento del codice. GitHub Copilot tenta di determinare il modo in cui l'applicazione usa le variabili e definisce di conseguenza i tipi di dati.

Quando GitHub Copilot genera più suggerimenti, è possibile scorrere i suggerimenti selezionando le frecce sinistra o destra (> o <) a sinistra del pulsante Accetta . In questo modo è possibile esaminare e selezionare il suggerimento più adatto alle proprie esigenze.

È possibile accettare un suggerimento di completamento del codice che non corrisponde esattamente a ciò che si vuole. Tuttavia, le modifiche necessarie per "correggere" il suggerimento deve essere chiaro. In questo caso, alcuni tipi di dati non sono quello desiderato, ma è possibile modificarli dopo aver accettato il completamento automatico suggerito.

Se nessuna delle opzioni suggerite è simile a quella necessaria, è possibile provare due cose. Per aprire una nuova scheda dell'editor contenente un elenco di altri suggerimenti, premere i tasti CTRL + INVIO . Questa combinazione di tasti di scelta rapida apre una nuova scheda contenente fino a 10 altri suggerimenti. Ogni suggerimento è seguito da un pulsante che è possibile usare per accettare il suggerimento. La scheda viene chiusa automaticamente dopo aver accettato un suggerimento. L'altra opzione consiste nel premere ESC per ignorare i suggerimenti e riprovare. È possibile modificare il commento del codice per fornire più contesto per GitHub Copilot da usare.

Annotazioni

GitHub Copilot può occasionalmente proporre un suggerimento in più fasi. In questo caso è possibile premere INVIO per visualizzare le fasi aggiuntive del suggerimento dopo aver premuto il tasto TAB.

Per accettare una struttura di dati suggerita, premere TAB o selezionare Accetta.

Per modificare i tipi di dati dei campi, aggiornare il codice nel modo seguente:

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

Apportare modifiche rapide ai suggerimenti di completamento del codice consente di assicurarsi di compilare il codice desiderato. È particolarmente importante apportare correzioni all'inizio del processo di sviluppo quando è ancora necessario sviluppare parti elevate della codebase. I completamenti del codice successivi sono basati sul codice già scritto, quindi è importante assicurarsi che il codice sia il più accurato possibile.

Usare GitHub Copilot per generare completamenti della riga di codice da un commento

GitHub Copilot genera suggerimenti di completamento del codice in base al commento e al contesto esistente dell'app. È possibile usare i commenti per descrivere frammenti di codice, metodi, strutture di dati e altri elementi di codice.

Per completare questa sezione dell'esercizio, seguire questa procedura:

Nel file Program.cs creare due righe di codice vuote sotto il Main metodo .
Per creare una struttura dei dati che può essere usata per generare dati di test, creare il commento di codice seguente e quindi premere INVIO:
```
// public struct SalesData. Include the following fields: date sold, department name, product ID, quantity sold, unit price
```
GitHub Copilot genera uno o più suggerimenti di completamento del codice in base al commento del codice e a tutto il codice esistente trovato nell'app.
Esaminare i suggerimenti di completamento del codice forniti da GitHub Copilot.

Annotazioni

Se GitHub Copilot genera suggerimenti per un metodo anziché una struttura di dati, digitare str pubblico e attendere l'aggiornamento del suggerimento di completamento del codice. GitHub Copilot usa le informazioni aggiuntive per migliorarne i suggerimenti.

Si notino i tipi di dati usati per dichiarare i campi della struttura dei dati. GitHub Copilot seleziona i tipi di dati e i nomi delle variabili in base al codice esistente e al commento del codice. GitHub Copilot tenta di determinare il modo in cui l'applicazione usa le variabili e definisce di conseguenza i tipi di dati.

Quando GitHub Copilot genera più suggerimenti, è possibile scorrere i suggerimenti selezionando le frecce sinistra o destra (> o <) a sinistra del pulsante Accetta . In questo modo è possibile esaminare e selezionare il suggerimento più adatto alle proprie esigenze.

È possibile accettare un suggerimento di completamento del codice che non corrisponde esattamente a ciò che si vuole. Tuttavia, le modifiche necessarie per "correggere" il suggerimento deve essere chiaro. In questo caso, alcuni tipi di dati non sono quello desiderato, ma è possibile modificarli dopo aver accettato il completamento automatico suggerito.

Se nessuna delle opzioni suggerite è simile a quella necessaria, è possibile provare due cose. Per aprire una nuova scheda dell'editor contenente un elenco di altri suggerimenti, premere i tasti CTRL + INVIO . Questa combinazione di tasti di scelta rapida apre una nuova scheda contenente fino a 10 altri suggerimenti. Ogni suggerimento è seguito da un pulsante che è possibile usare per accettare il suggerimento. La scheda viene chiusa automaticamente dopo aver accettato un suggerimento. L'altra opzione consiste nel premere ESC per ignorare i suggerimenti e riprovare. È possibile modificare il commento del codice per fornire più contesto per GitHub Copilot da usare.

Annotazioni

GitHub Copilot può occasionalmente proporre un suggerimento in più fasi. In questo caso è possibile premere INVIO per visualizzare le fasi aggiuntive del suggerimento dopo aver premuto il tasto TAB.
Per accettare una struttura di dati suggerita, premere TAB o selezionare Accetta.
Per modificare i tipi di dati dei campi, aggiornare il codice nel modo seguente:
```
public struct SalesData
{
    public DateOnly dateSold;
    public string departmentName;
    public int productID;
    public int quantitySold;
    public double unitPrice;
}
```
Apportare modifiche rapide ai suggerimenti di completamento del codice consente di assicurarsi di compilare il codice desiderato. È particolarmente importante apportare correzioni all'inizio del processo di sviluppo quando è ancora necessario sviluppare parti elevate della codebase. I completamenti del codice sono basati sul codice esistente, quindi è importante assicurarsi che il codice sia il più accurato possibile.
Creare due righe di codice vuote sotto la struttura dei dati SalesData.
Per creare un metodo che genera dati di test usando la struttura dei dati SalesData, scrivere il commento di codice seguente e quindi premere INVIO:
```
/* the GenerateSalesData method returns 1000 SalesData records. It assigns random values to each field of the data structure */
```
Esaminare i suggerimenti di completamento del codice forniti da GitHub Copilot.

Si noti che il metodo GenerateSalesData è progettato per restituire una matrice di oggetti SalesData. Il metodo genera 1.000 record di dati di test, con valori casuali assegnati a ogni campo della struttura dei dati SalesData.

È consigliabile esaminare sempre i suggerimenti proposti da GitHub Copilot e GitHub Copilot Chat, anche quando sembrano essere corretti.

Annotazioni

Se GitHub Copilot suggerisce una singola riga di codice anziché un metodo completato GenerateSalesData , premere CTRL + INVIO per aprire la scheda Suggerimenti di GitHub Copilot. Esaminare i suggerimenti nella nuova scheda. Nel passaggio successivo usare il pulsante "Accetta suggerimento #" per accettare il suggerimento. GitHub Copilot presenta suggerimenti in modo incrementale in occasione. Anche se è possibile accettare i completamenti del codice in modo incrementale, è preferibile usare la scheda Suggerimenti di GitHub Copilot per esaminare il suggerimento completo prima di prendere una decisione di accettare o ignorare.
Scorrere i suggerimenti di completamento del codice e selezionare l'opzione ottimale per i requisiti.
Per accettare il completamento del codice, premere TAB.

Si noti che il suggerimento di completamento del codice include un errore di sintassi nel codice usato per generare il campo DateSold. DateOnly accetta tre valori interi che devono essere elencati nell'ordine corretto: Anno, Mese, Giorno.
Per specificare un singolo anno per il codice usato per generare il campo DateSold, aggiornare la riga di codice come indicato di seguito:
```
salesData[i].DateSold = new DateOnly(2023, random.Next(1, 13), random.Next(1, 29));
```

Se necessario, modificare le altre righe di codice in modo che corrispondano al frammento di codice seguente:

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à di generare codice dai commenti del codice è una funzionalità avanzata di GitHub Copilot. Con due soli commenti è stato possibile generare una struttura dei dati e un metodo che genera dati di test.

Usare GitHub Copilot per generare completamenti della riga di codice

GitHub Copilot può generare completamenti della riga di codice in base al codice immesso. È possibile generare completamenti della riga di codice in due modi:

Iniziare a immettere una riga di codice e quindi attendere che GitHub Copilot suggerisca un completamento automatico per la riga di codice non completata.
Immettere una riga di codice completa, premere INVIO e quindi attendere che GitHub Copilot suggerisca un completamento automatico per la riga di codice successiva.

Annotazioni

GitHub Copilot genera completamenti del codice suggeriti in base al codice immesso e al contesto definito dal codice all'interno dell'app. Più codice è disponibile nell'app, più contesto ha GitHub Copilot durante la generazione di una risposta. GitHub Copilot può basare le risposte sul codice esistente, quindi la qualità del codice è importante. La qualità e l'affidabilità dei completamenti della riga di codice suggeriti da GitHub Copilot aumentano con l'incremento di volume e di qualità del codice esistente. GitHub Copilot è utile per generare completamenti della riga di codice per attività e modelli di programmazione comuni, soprattutto quando deve essere generata una sequenza di componenti correlati.

In questa parte dell'esercizio si lavora sul metodo QuarterlySalesReport.

Ecco le attività da completare:

Aggiornare il costruttore del metodo con un parametro che accetta la raccolta di oggetti SalesData.
Usare GitHub Copilot per generare completamenti della riga di codice che elaborano i dati sulle vendite per il report trimestrale.
Eseguire l'app ed esaminare il report sulle vendite trimestrali.

Per completare questa sezione dell'esercizio, seguire questa procedura:

Aggiornare il costruttore del metodo per QuarterlySalesReport come indicato di seguito:
```
public void QuarterlySalesReport(SalesData[] salesData)
```
Valutare con attenzione il codice da sviluppare.

Il concetto è semplice. Si vuole che il codice calcoli le vendite trimestrali in base ai dati delle vendite e quindi scriva un report. A tale scopo, il codice deve:
- Scorrere la raccolta salesData.
- Calcolare il valore di ogni vendita in base alla quantità venduta e al prezzo unitario.
- Usare la data di vendita per determinare a quale trimestre appartiene una vendita.
- Sommare le vendite per ogni trimestre.
- Scrivere un report delle vendite per trimestre.
Un'opzione consiste nell'iniziare a immettere il codice per un ciclo foreach e quindi vedere cosa suggerisce GitHub Copilot.
Nel metodo QuarterlySalesReport creare una nuova riga di codice nella parte superiore del blocco di codice.

Deve essere presente almeno una riga di codice vuota tra la nuova riga di codice e la riga di codice contenente Console.WriteLine().
Per generare un completamento della riga di codice, digitare foreach ( e quindi attendere che GitHub Copilot suggerisca le opzioni di completamento della riga di codice.
Esaminare il completamento del codice suggerito da GitHub Copilot.

Il completamento del codice suggerito non è quello desiderato.

Anche se GitHub Copilot suggerisce un ciclo foreach che esegue l'iterazione di salesData, non sono presenti analisi o calcoli all'interno del ciclo. Il codice suggerito include Console.WriteLine istruzioni non desiderate o necessarie.
Provare a esaminare il motivo per cui GitHub Copilot suggerisce istruzioni Console.WriteLine.

Tenere presente che GitHub Copilot genera suggerimenti di completamento del codice in base al contesto del codice. In questo caso GitHub Copilot non ha a disposizione molto codice da esaminare. E la situazione peggiora.

Il codice visualizzato da GitHub Copilot all'interno del metodo è un'istruzione Console.WriteLine. Senza altri contesti disponibili all'interno del metodo e senza metodi simili su cui basarsi nella codebase, GitHub Copilot pensa che lo sviluppatore vogliaConsole.WriteLine istruzioni all'interno del ciclo foreach.

GitHub Copilot funziona al meglio quando il codice è pulito e preciso. Se si notano commenti di codice superflui o istruzioni superflue nel codice, è consigliabile rimuoverli prima di provare a usare i completamenti del codice di GitHub Copilot.
Per pulire il codice prima di passare a un altro tentativo con GitHub Copilot, seguire questa procedura:
- Annullare il completamento del codice suggerito foreach (.
- Eliminare l'istruzione parziale foreach ( immessa.
- Eliminare l'istruzione Console.WriteLine dal metodo QuarterlySalesReport.
A questo punto si dovrebbe essere pronti per provare di nuovo GitHub Copilot.
Assicurarsi che il metodo QuarterlySalesReport sia simile al codice seguente:
```
public void QuarterlySalesReport(SalesData[] salesData)
{


}
```
Posizionare il cursore su una riga di codice vuota all'interno del metodo QuarterlySalesReport e quindi premere INVIO.

La generazione del completamento del codice suggerito da GitHub Copilot potrebbe richiedere qualche istante.
Esaminare i completamenti del codice suggeriti.

Importante

È probabile che i completamenti del codice ricevuti siano diversi dai suggerimenti mostrati nello screenshot seguente. Anche se GitHub Copilot ha solo un nome di metodo e un parametro su cui basarsi, questo può essere sufficiente per generare suggerimenti utili. Dovrebbero essere visualizzati suggerimenti per calcolare le vendite per trimestre. Rifiutare i suggerimenti e riprovare può fornire risultati diversi.

È possibile scorrere i suggerimenti selezionando > o <.

Si noti che il completamento del codice suggerito scorre i dati sulle vendite ed esegue calcoli trimestrali delle vendite.

Per accettare il completamento del codice suggerito, premere TAB.

Il completamento del codice suggerito calcola e visualizza il reddito trimestrale in base ai dati sulle vendite.

// 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);
}

Si noti che il GetQuarter metodo usa il mese della vendita per determinare il trimestre della vendita.

Il GetQuarter metodo viene creato successivamente.
Creare due righe di codice vuote sotto il metodo QuarterlySalesReport.
Si noti che GitHub Copilot suggerisce un completamento del codice per il metodo GetQuarter.

Con il contesto fornito dal metodo QuarterlySalesReport, GitHub Copilot può generare facilmente un completamento del codice per il metodo GetQuarter che determina il trimestre in base al mese della vendita.
Esaminare il completamento della riga di codice suggerito per il metodo GetQuarter.

Per accettare il completamento del codice suggerito, premere 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";
    }
}

Si noti che il metodo Main deve essere completato prima di poter eseguire il codice.

È possibile usare i commenti nel metodo Main per aggiornare il codice.
Posizionare il cursore alla fine del commento del codice // call the GenerateSalesData method e quindi premere INVIO.

GitHub Copilot usa il commento per proporre un'istruzione chiamante per il metodo.
Esaminare e quindi accettare il completamento del codice suggerito da GitHub Copilot.
Ripetere il processo per il commento del codice // call the QuarterlySalesReport method.

Il metodo Main non deve contenere il codice seguente:

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);
}

Esaminare il codice nella 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";
            }
        }
    }
}

Questo codice è stato creato, quasi interamente, usando i completamenti della riga di codice generati da GitHub Copilot. Tuttavia, la revisione dei suggerimenti del codice è importante e sono state necessarie correzioni. È sempre consigliabile rivedere i completamenti di codice suggeriti da GitHub Copilot per garantire che il codice soddisfi i requisiti.

Per esaminare l'output del report, eseguire l'app.

Aprire una finestra Terminale in Visual Studio Code e quindi immettere il comando seguente:
```
dotnet run
```
L'output dovrebbe visualizzare il report sul reddito trimestrale, che mostra il nome del reparto, il trimestre e il reddito per ogni reparto e trimestre rappresentato nei dati di test.
Esaminare l'output nella finestra Terminale.

Benché i risultati trimestrali siano basati su valori numerici casuali, dovrebbe essere visualizzato un report con formattazione simile all'output seguente:
```
Quarterly Sales Report
----------------------
Q3: $635637.5019563352
Q4: $672247.315297204
Q2: $667269.194630603
Q1: $642769.2700531208
```

Riassunto

I completamenti della riga di codice sono una potente funzionalità di GitHub Copilot che consente di generare codice in modo rapido ed efficiente. Usando i commenti per descrivere il codice da generare, è possibile creare strutture di dati, metodi e altri elementi di codice con un impegno minimo. Inoltre, GitHub Copilot può generare completamenti della riga di codice in base al codice immesso, consentendo di creare applicazioni complesse con facilità.

Commenti e suggerimenti

Questa pagina è stata utile?