Gerar código usando as sugestões de preenchimento automático de código do GitHub Copilot

6 minutos

O GitHub Copilot pode fornecer sugestões de conclusão de código para várias linguagens de programação e uma ampla variedade de frameworks, mas funciona especialmente bem para Python, JavaScript, TypeScript, Ruby, Go, C# e C++. As completações de linha de código são geradas com base no contexto do código que você está escrevendo. Você pode aceitar, rejeitar ou aceitar parcialmente as sugestões fornecidas pelo GitHub Copilot.

O GitHub Copilot fornece duas maneiras de gerar completações de linha de código:

De um comentário: Você pode gerar completações de linha de código escrevendo um comentário que descreva o código que deseja gerar. O GitHub Copilot fornece sugestões de conclusão de código com base no comentário que escreves.
Do código: Você pode gerar completações de linha de código iniciando uma linha de código ou pressionando Enter após uma linha de código concluída. GitHub Copilot fornece sugestões de completação de código com base no código que escreves.

Use o GitHub Copilot para gerar completações de linha de código a partir de um comentário

O GitHub Copilot gera sugestões para completar automaticamente o código com base no comentário e no contexto existente da sua aplicação.

Você pode usar comentários para descrever trechos de código, métodos, estruturas de dados e outros elementos de código.

Suponha que você tenha o seguinte trecho de código:


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

Por exemplo, o seguinte comentário pode ser usado para criar uma estrutura de dados:


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

O GitHub Copilot gera uma ou mais sugestões de completação de código com base nos seus comentários no código e nos ficheiros de código que estão abertos no editor.

Captação de ecrã mostrando o autocompletar de código para um comentário que descreve uma estrutura de dados.

Observe os tipos de dados usados para declarar os campos da estrutura de dados. O GitHub Copilot seleciona tipos de dados e nomes de variáveis com base no código existente e no comentário do código. O Copilot do GitHub tenta determinar como o aplicativo usa variáveis e define os tipos de dados de acordo.

Quando o GitHub Copilot gera mais de uma sugestão, você pode percorrer as sugestões selecionando as setas para a esquerda ou para a direita (> ou <) localizadas à esquerda do botão Aceitar . Isto permite-lhe rever e selecionar a sugestão que melhor se adapta às suas necessidades.

Não há problema em aceitar uma sugestão de preenchimento automático de código que não corresponda exatamente ao que pretendes. No entanto, as alterações necessárias para "corrigir" a sugestão devem ser claras. Nesse caso, alguns dos tipos de dados não são o que você deseja, mas você pode ajustá-los depois de aceitar o preenchimento automático sugerido.

Se nenhuma das opções sugeridas se assemelhar ao que você precisa, há duas coisas que você pode tentar. Para abrir uma nova guia do editor contendo uma lista de outras sugestões, pressione as teclas Ctrl + Enter . Esta combinação de teclas de atalho abre um novo separador contendo até mais 10 sugestões. Cada sugestão é seguida por um botão que você pode usar para aceitar a sugestão. O separador fecha automaticamente depois de aceitar uma sugestão. Sua outra opção é pressionar a tecla Esc para rejeitar as sugestões e tentar novamente. Você pode ajustar o comentário de código para fornecer mais contexto para o GitHub Copilot trabalhar com.

Observação

O Copiloto do GitHub pode ocasionalmente propor uma sugestão em etapas. Se isso acontecer, você pode pressionar Enter para ver etapas adicionais da sugestão depois de pressionar a tecla Tab.

Para aceitar uma estrutura de dados sugerida, pressione a tecla Tab ou selecione Aceitar.

Para modificar os tipos de dados de campo, atualize o código da seguinte maneira:

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

Fazer ajustes rápidos nas sugestões de conclusão de código ajuda a garantir que está a criar o código desejado. É especialmente importante fazer correções no início do seu processo de desenvolvimento, quando grandes partes da sua base de código ainda precisam ser desenvolvidas. As compleções de código subsequentes são baseadas no código que você já escreveu, por isso é importante garantir que seu código seja o mais preciso possível.

Use o GitHub Copilot para gerar completações de linha de código a partir de um comentário

O GitHub Copilot gera sugestões para completar automaticamente o código com base no comentário e no contexto existente da sua aplicação. Você pode usar comentários para descrever trechos de código, métodos, estruturas de dados e outros elementos de código.

Use as seguintes etapas para concluir esta seção do exercício:

No arquivo Program.cs, crie duas linhas de código vazias abaixo do Main método.
Para criar uma estrutura de dados que possa ser usada para gerar dados de teste, crie o seguinte comentário de código e pressione Enter:
```
// public struct SalesData. Include the following fields: date sold, department name, product ID, quantity sold, unit price
```
O GitHub Copilot gera uma ou mais sugestões de conclusão de código com base no comentário do seu código e em qualquer código existente que encontre na sua aplicação.
Dedique um minuto para rever as sugestões de código autocompletar fornecidas pelo GitHub Copilot.

Observação

Se o GitHub Copilot gerar sugestões para um método em vez de uma estrutura de dados, digite public str e aguarde a atualização da sugestão de conclusão de código. O GitHub Copilot usa as informações adicionais para melhorar suas sugestões.

Observe os tipos de dados usados para declarar os campos da estrutura de dados. O GitHub Copilot seleciona tipos de dados e nomes de variáveis com base no código existente e no comentário do código. O Copilot do GitHub tenta determinar como o aplicativo usa variáveis e define os tipos de dados de acordo.

Quando o GitHub Copilot gera mais de uma sugestão, você pode percorrer as sugestões selecionando as setas para a esquerda ou para a direita (> ou <) localizadas à esquerda do botão Aceitar . Isto permite-lhe rever e selecionar a sugestão que melhor se adapta às suas necessidades.

Não há problema em aceitar uma sugestão de preenchimento automático de código que não corresponda exatamente ao que pretendes. No entanto, as alterações necessárias para "corrigir" a sugestão devem ser claras. Nesse caso, alguns dos tipos de dados não são o que você deseja, mas você pode ajustá-los depois de aceitar o preenchimento automático sugerido.

Se nenhuma das opções sugeridas se assemelhar ao que você precisa, há duas coisas que você pode tentar. Para abrir uma nova guia do editor contendo uma lista de outras sugestões, pressione as teclas Ctrl + Enter . Esta combinação de teclas de atalho abre um novo separador contendo até mais 10 sugestões. Cada sugestão é seguida por um botão que você pode usar para aceitar a sugestão. O separador fecha automaticamente depois de aceitar uma sugestão. Sua outra opção é pressionar a tecla Esc para rejeitar as sugestões e tentar novamente. Você pode ajustar o comentário de código para fornecer mais contexto para o GitHub Copilot trabalhar com.

Observação

O Copiloto do GitHub pode ocasionalmente propor uma sugestão em etapas. Se isso acontecer, você pode pressionar Enter para ver etapas adicionais da sugestão depois de pressionar a tecla Tab.
Para aceitar uma estrutura de dados sugerida, pressione a tecla Tab ou selecione Aceitar.
Para modificar os tipos de dados de campo, atualize o código da seguinte maneira:
```
public struct SalesData
{
    public DateOnly dateSold;
    public string departmentName;
    public int productID;
    public int quantitySold;
    public double unitPrice;
}
```
Fazer ajustes rápidos nas sugestões de conclusão de código ajuda a garantir que está a criar o código desejado. É especialmente importante fazer correções no início do seu processo de desenvolvimento, quando grandes partes da sua base de código ainda precisam ser desenvolvidas. As compleções de código são baseadas no código existente, por isso é importante garantir que o código seja o mais preciso possível.
Crie duas linhas de código vazias abaixo da estrutura de SalesData dados.
Para criar um método que gera dados de teste usando a estrutura de SalesData dados, escreva o seguinte comentário de código e pressione Enter:
```
/* the GenerateSalesData method returns 1000 SalesData records. It assigns random values to each field of the data structure */
```
Dedique um minuto para rever as sugestões de código autocompletar fornecidas pelo GitHub Copilot.

Observe que o GenerateSalesData método foi projetado para retornar uma matriz de SalesData objetos. O método gera 1.000 registros de dados de teste, com valores aleatórios atribuídos a cada campo da estrutura de SalesData dados.

Você deve sempre revisar as sugestões propostas pelo GitHub Copilot e GitHub Copilot Chat, mesmo quando elas parecerem corretas.

Observação

Se o GitHub Copilot sugerir uma única linha de código em vez de um método concluídoGenerateSalesData, pressione Ctrl + Enter para abrir a guia Sugestões do Copilot do GitHub. Reveja as sugestões no novo separador. Na próxima etapa, use o botão "Aceitar sugestão #" para aceitar a sugestão. O GitHub Copilot apresenta sugestões de forma incremental ocasionalmente. Embora você possa aceitar as completações de código incrementalmente, é melhor usar a guia Sugestões do Copiloto do GitHub para revisar a sugestão completa antes de tomar a decisão de aceitar ou descartar.
Percorra as sugestões de preenchimento automático de código e selecione a melhor correspondência para os requisitos.
Para aceitar a conclusão do código, pressione a tecla Tab.

Observe que a sugestão de conclusão de código inclui um erro de sintaxe no código usado para gerar o DateSold campo. DateOnlyaceita três valores inteiros que devem ser listados na ordem correta: Ano, Mês, Dia.
Para especificar um único ano para o código usado para gerar o DateSold campo, atualize a linha de código da seguinte maneira:
```
salesData[i].DateSold = new DateOnly(2023, random.Next(1, 13), random.Next(1, 29));
```

Se necessário, ajuste as outras linhas de código para corresponder ao seguinte trecho de código:

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

A capacidade de gerar código a partir de comentários de código é um recurso poderoso do GitHub Copilot. Com apenas dois comentários, você foi capaz de gerar uma estrutura de dados e um método que gera dados de teste.

Use o GitHub Copilot para gerar completações de linha de código

O GitHub Copilot pode gerar completações de linha de código com base no código inserido. Você pode gerar completações de linha de código de duas maneiras:

Comece a inserir uma linha de código e aguarde até que o GitHub Copilot sugira um preenchimento automático para sua linha de código inacabada.
Insira uma linha de código completa, pressione a tecla Enter e aguarde até que o GitHub Copilot sugira um preenchimento automático para a próxima linha de código.

Observação

O GitHub Copilot gera sugestões de conclusão de código com base no código inserido e no contexto definido pelo código em seu aplicativo. Quanto mais código você tiver disponível em seu aplicativo, mais contexto o GitHub Copilot terá ao gerar uma resposta. O GitHub Copilot pode basear as respostas no seu código existente, por isso a qualidade do seu código é importante. À medida que o volume e a qualidade do código existente aumentam, aumenta também a qualidade e a confiabilidade das completações da linha de código sugeridas pelo Copilot do GitHub. O GitHub Copilot é bom em gerar completações de linha de código para tarefas e padrões de programação comuns, especialmente quando uma sequência de componentes relacionados precisa ser gerada.

Nesta parte do exercício, trabalha-se no método QuarterlySalesReport.

Aqui estão as tarefas que você precisa concluir:

Atualize o construtor do método com um parâmetro que aceite sua coleção de SalesData objetos.
Use o GitHub Copilot para gerar completações de linha de código que processam dados de vendas para o relatório trimestral.
Execute o aplicativo e revise o relatório trimestral de vendas.

Use as seguintes etapas para concluir esta seção do exercício:

Atualize o construtor do método QuarterlySalesReport da seguinte maneira:
```
public void QuarterlySalesReport(SalesData[] salesData)
```
Reserve um minuto para considerar o código que você precisa desenvolver.

O conceito é simples. Você deseja que seu código calcule as vendas trimestrais com base em seus dados de vendas e, em seguida, escreva um relatório. Para fazer isso, seu código precisa:
- Itere sobre a coleção salesData.
- Calcule o valor de cada venda com base na quantidade vendida e no preço unitário.
- Use a data de venda para determinar a qual trimestre uma venda pertence.
- Somar as vendas de cada trimestre.
- Escreva um relatório das vendas por trimestre.
Uma opção é começar a inserir o código para um foreach loop e, em seguida, ver o que o GitHub Copilot sugere.
QuarterlySalesReport No método, crie uma nova linha de código na parte superior do bloco de código.

Deve haver pelo menos uma linha de código em branco entre a nova linha de código e a linha de código que contém Console.WriteLine().
Para gerar uma conclusão de linha de código, digite foreach ( e aguarde até que o GitHub Copilot sugira opções de conclusão de linha de código.
Analise o auto-completar de código sugerido pelo Copilot do GitHub.

A sugestão de autocompletar código não era a que te esperavas.

Embora o GitHub Copilot sugira um foreach loop que itera através do salesData, não há análise ou cálculos dentro do loop. O código sugerido inclui Console.WriteLine instruções que você não quer ou precisa.
Reserve um minuto para considerar por que o GitHub Copilot está sugerindo Console.WriteLine declarações.

Lembre-se de que o GitHub Copilot gera sugestões de preenchimento de código com base no contexto do seu código. Neste caso, você realmente não tem muito código para o Copilot do GitHub considerar. E a situação piora.

O código que o GitHub Copilot vê dentro do seu método é uma Console.WriteLine instrução. Sem nenhum outro contexto disponível dentro do método e nenhum método semelhante na sua base de código para servir de referência, o GitHub Copilot conclui que você pode quererConsole.WriteLine instruções dentro do foreach loop.

O GitHub Copilot funciona melhor quando seu código está limpo e focado. Se você vir comentários ou instruções de código supérfluos em seu código, convém removê-los antes de tentar usar as completações de código do GitHub Copilot.
Para limpar seu código antes de dar outra chance ao GitHub Copilot, conclua as seguintes etapas:
- Cancele o preenchimento do código sugerido foreach ( .
- Elimina a declaração parcial foreach ( que inseriste.
- Exclua a instrução Console.WriteLine do método QuarterlySalesReport.
Agora você deve estar pronto para tentar o GitHub Copilot novamente.
Certifique-se de que seu QuarterlySalesReport método seja semelhante ao código a seguir:
```
public void QuarterlySalesReport(SalesData[] salesData)
{


}
```
Posicione o cursor em uma linha de código em branco dentro do QuarterlySalesReport método e pressione Enter.

Pode levar um momento para o GitHub Copilot gerar a conclusão de código sugerida.
Reserve um minuto para revisar as sugestões de conclusão de código.

Importante

É provável que as conclusões de código recebidas sejam diferentes das sugestões mostradas na captura de tela a seguir. Embora o GitHub Copilot tenha apenas um nome de método e parâmetro para trabalhar, isso pode ser suficiente para gerar sugestões úteis. Você deverá ver sugestões que calculam as vendas por trimestre. Rejeitar as sugestões e tentar novamente pode fornecer resultados diferentes.

Você pode percorrer as sugestões selecionando > ou <.

Observe que o autocompletar de código sugerido itera através dos dados de vendas e executa cálculos de vendas trimestrais.

Para aceitar a sugestão de completar código automaticamente, pressione a tecla Tab.

A completação de código sugerida calcula e mostra a receita trimestral com base em dados de vendas.

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

Observe que o GetQuarter método usa o mês da venda para determinar o trimestre da venda.

O GetQuarter método é criado em seguida.
Crie duas linhas de código em branco abaixo do QuarterlySalesReport método.
Observe que o GitHub Copilot sugere um auto-completar de código para o GetQuarter método.

Com o contexto fornecido pelo método QuarterlySalesReport, o GitHub Copilot pode facilmente gerar uma completação de código para o método GetQuarter que determina o trimestre com base no mês da venda.
Reserve um minuto para revisar o preenchimento automático sugerido da linha de código para o método GetQuarter.

Para aceitar a sugestão de completar código automaticamente, pressione a tecla 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";
    }
}

Observe que o Main método precisa ser concluído antes que você possa executar o código.

Você pode usar os comentários do método Main para atualizar seu código.
Posicione o cursor no final do // call the GenerateSalesData method comentário de código e pressione Enter.

O Copilot do GitHub usa o comentário para propor uma instrução de chamada para o método.
Revise e aceite a conclusão de código sugerida pelo GitHub Copilot.
Repita o processo para o código de comentário // call the QuarterlySalesReport method.

Seu Main método deve conter o seguinte código:

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

Reserve um momento para rever o código da sua QuarterlyIncomeReport classe.

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

Este código foi criado, quase inteiramente, usando completações de linha de código geradas pelo GitHub Copilot. No entanto, sua revisão das sugestões de código é importante, e correções foram necessárias. Você deve sempre revisar as completações de código sugeridas pelo GitHub Copilot para garantir que o código atenda aos seus requisitos.

Para revisar a saída do relatório, execute o aplicativo.

Abra uma janela do Terminal no Visual Studio Code e digite o seguinte comando:
```
dotnet run
```
A saída deve exibir o relatório de resultados trimestral, mostrando o nome do departamento, o trimestre e a receita de cada departamento e trimestre representado nos dados do teste.
Revise a saída na janela Terminal.

Embora os resultados trimestrais sejam baseados em valores numéricos aleatórios, você verá um relatório formatado de forma semelhante à seguinte saída:
```
Quarterly Sales Report
----------------------
Q3: $635637.5019563352
Q4: $672247.315297204
Q2: $667269.194630603
Q1: $642769.2700531208
```

Resumo

As completações de linha de código são um recurso poderoso do GitHub Copilot que pode ajudá-lo a gerar código de forma rápida e eficiente. Usando comentários para descrever o código que você deseja gerar, você pode criar estruturas de dados, métodos e outros elementos de código com o mínimo de esforço. Além disso, o GitHub Copilot pode gerar completações de linha de código com base no código inserido, permitindo que você crie aplicativos complexos com facilidade.

Comentários

Esta página foi útil?