Gerar código usando sugestões de conclusão de código do GitHub Copilot

6 minutos

O GitHub Copilot pode fornecer sugestões de preenchimento de código para várias linguagens de programação e uma ampla gama de estruturas, mas funciona muito bem para Python, JavaScript, TypeScript, Ruby, Go, C# e C++. Os preenchimentos de linha de código são gerados 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 oferece duas formas de gerar preenchimentos de linha de código:

A partir de um comentário: você pode gerar preenchimentos de linha de código escrevendo um comentário que descreva o código que desejar gerar. O GitHub Copilot oferece sugestões de preenchimento de código com base no comentário que você escreve.
A partir do código: você pode gerar preenchimentos de linha de código iniciando uma linha de código ou pressionando Enter depois de terminar uma linha. O GitHub Copilot oferece sugestões de preenchimento de código com base no código que você escreve.

Use o GitHub Copilot para gerar preenchimentos de linha de código a partir de um comentário

O GitHub Copilot gera sugestões de preenchimento de código baseadas no comentário e no contexto do seu aplicativo.

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

Suponha que você tenha o seguinte snippet 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 comentário a seguir 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 preenchimento de código com base nos comentários do seu código e em qualquer código que ele encontrar em seu aplicativo.

Captura de tela mostrando o preenchimento de código de 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 seu código e nos comentários do código. O GitHub Copilot 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 verificá-las selecionando as setas para a esquerda ou para a direita (> ou <) localizadas à esquerda do botão Aceitar. Isso permite que você examine e selecione a sugestão que melhor atenda às suas necessidades.

Não há problema em aceitar uma sugestão de preenchimento de código que não seja uma correspondência exata do que você deseja. 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ê quer, mas você pode ajustá-los depois de aceitar a preenchimento automático sugerido.

Se nenhuma das opções sugeridas for parecido com o que você precisa, você pode tentar duas coisas. Para abrir uma nova guia do editor que contém uma lista de outras sugestões, pressione as teclas Ctrl + Enter. Essa combinação de teclas de acesso abre uma nova guia que contém mais 10 sugestões. Cada sugestão é seguida por um botão que você pode usar para aceitar a sugestão. A guia é fechada automaticamente depois que você aceita uma sugestão. A outra opção é pressionar a tecla Esc para ignorar as sugestões e tentar novamente. Você pode ajustar o comentário de código para fornecer mais contexto para o GitHub Copilot usar.

Observação

Ocasionalmente, o GitHub Copilot poderá propor uma sugestão em etapas. Se isso acontecer, pressione Enter para ver as etapas adicionais da sugestão após pressionar a tecla Tab.

Para aceitar uma sugestão de estrutura de dados, pressione a tecla Tab ou selecione Aceitar.

Para modificar os tipos de dados dos campos, atualize o código da seguinte forma:

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 preenchimento de código ajuda a garantir que você esteja criando o código desejado. É especialmente importante fazer correções no início do processo de desenvolvimento quando grandes partes da base de código ainda precisam ser desenvolvidas. As conclusões de código subsequentes são baseadas no código que você já escreveu, portanto, é importante garantir que seu código seja o mais preciso possível.

Use o GitHub Copilot para gerar preenchimentos de linha de código a partir de um comentário

O GitHub Copilot gera sugestões de preenchimento de código baseadas no comentário e no contexto do seu aplicativo. Você pode usar comentários para descrever trechos de código, métodos, estruturas de dados e outros elementos do código.

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

No arquivo Program.cs, crie duas linhas de código em branco abaixo do método Main.
Para criar uma estrutura de dados que possa ser usada para gerar dados de teste, crie o seguinte comentário de código e, em seguida, 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 preenchimento de código com base nos comentários do seu código e em qualquer código que ele encontrar em seu aplicativo.
Reserve um minuto para analisar as sugestões de preenchimento de código 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 sugestão de preenchimento do código ser atualizada. 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 seu código e nos comentários do código. O GitHub Copilot 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 verificá-las selecionando as setas para a esquerda ou para a direita (> ou <) localizadas à esquerda do botão Aceitar. Isso permite que você examine e selecione a sugestão que melhor atenda às suas necessidades.

Não há problema em aceitar uma sugestão de preenchimento de código que não seja uma correspondência exata do que você deseja. 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ê quer, mas você pode ajustá-los depois de aceitar a preenchimento automático sugerido.

Se nenhuma das opções sugeridas for parecido com o que você precisa, você pode tentar duas coisas. Para abrir uma nova guia do editor que contém uma lista de outras sugestões, pressione as teclas Ctrl + Enter. Essa combinação de teclas de acesso abre uma nova guia que contém mais 10 sugestões. Cada sugestão é seguida por um botão que você pode usar para aceitar a sugestão. A guia é fechada automaticamente depois que você aceita uma sugestão. A outra opção é pressionar a tecla Esc para ignorar as sugestões e tentar novamente. Você pode ajustar o comentário de código para fornecer mais contexto para o GitHub Copilot usar.

Observação

Ocasionalmente, o GitHub Copilot poderá propor uma sugestão em etapas. Se isso acontecer, pressione Enter para ver as etapas adicionais da sugestão após pressionar a tecla Tab.
Para aceitar uma sugestão de estrutura de dados, pressione a tecla Tab ou selecione Aceitar.
Para modificar os tipos de dados dos campos, atualize o código da seguinte forma:
```
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 preenchimento de código ajuda a garantir que você esteja criando o código desejado. É especialmente importante fazer correções no início do processo de desenvolvimento quando grandes partes da base de código ainda precisam ser desenvolvidas. As conclusões de código são baseadas no código existente, portanto, é importante garantir que seu código seja o mais preciso possível.
Crie duas linhas de código vazias abaixo da estrutura de dados SalesData.
Para criar um método que gera dados de teste usando a estrutura de dados SalesData, escreva o seguinte comentário de código e, em seguida, pressione Enter:
```
/* the GenerateSalesData method returns 1000 SalesData records. It assigns random values to each field of the data structure */
```
Reserve um minuto para analisar as sugestões de preenchimento de código fornecidas pelo GitHub Copilot.

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

Você sempre deve examinar as sugestões propostas pelo GitHub Copilot e Chat do GitHub Copilot, mesmo quando elas parecem estar corretas.

Observação

Se o GitHub Copilot sugerir uma única linha de código em vez de um método GenerateSalesData concluído, pressione Ctrl + Enter para abrir a guia Sugestões do GitHub Copilot. Examine as sugestões na nova guia. Na próxima etapa, use o botão "Aceitar sugestão #" para aceitar a sugestão. O GitHub Copilot apresenta sugestões incrementalmente em algumas ocasiões. Embora você possa aceitar os preenchimentos de código incrementalmente, é melhor usar a guia Sugestões do GitHub Copilot para examinar a sugestão completa antes de tomar uma decisão de aceitar ou descartar.
Role as sugestões de conclusão de código e selecione a melhor correspondência para os requisitos.
Para aceitar o preenchimento de código, pressione a tecla Tab.

Observe que a sugestão de preenchimento de código inclui um erro de sintaxe no código usado para gerar o campo DateSold. O DateOnly aceita três valores inteiros que devem ser listados na ordem correta: Ano, Mês, Dia.
Para especificar um único ano no código usado para gerar o campo DateSold, atualize a linha de código da seguinte forma:
```
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 snippet 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 dos comentários é um recurso poderoso do GitHub Copilot. Com apenas dois comentários, você conseguiu gerar uma estrutura de dados e um método que gera dados de teste.

Use o GitHub Copilot para gerar preenchimentos de linha de código

O GitHub Copilot pode gerar preenchimentos de linha de código com base no código que você insere. Você pode gerar esses preenchimentos de duas maneiras:

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

Observação

O GitHub Copilot gera sugestões de preenchimentos com base no código inserido por você 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 tem ao gerar uma resposta. O GitHub Copilot pode basear respostas em seu código existente, portanto, a qualidade do código é importante. À medida que o volume e a qualidade do código existente aumentam, a qualidade e a confiabilidade dos preenchimentos de linha de código sugeridos pelo GitHub Copilot também melhoram. O GitHub Copilot é bom em gerar conclusõ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.

Nessa parte do exercício, você trabalha no método QuarterlySalesReport.

Estas são as tarefas que você deve concluir:

Atualize o construtor do método com um parâmetro que aceite sua coleção de objetos SalesData.
Use o GitHub Copilot para gerar preenchimentos de linhas de código que processem dados de vendas para o relatório trimestral.
Execute o aplicativo e analise o relatório de vendas do trimestre.

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

Atualize o construtor de métodos do QuarterlySalesReport da seguinte maneira:
```
public void QuarterlySalesReport(SalesData[] salesData)
```
Pense por um momento no código que você precisa desenvolver.

O conceito é bem simples. Você quer que seu código calcule as vendas trimestrais com base nos dados de vendas e depois crie um relatório. Para fazer isso, seu código precisa:
- Iterar através da coleção salesData.
- Calcular o valor de cada venda com base na quantidade vendida e no preço unitário.
- Usar a data da venda para determinar a qual trimestre uma venda pertence.
- Somar as vendas de cada trimestre.
- Escrever um relatório das vendas por trimestre.
Uma opção é começar programar um loop foreach e ver o que o GitHub Copilot sugere.
No método QuarterlySalesReport, crie uma 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 criar um preenchimento de linha de código, basta digitar foreach ( e aguardar as sugestões do GitHub Copilot.
Analise o preenchimento de código sugerido pelo GitHub Copilot.

O preenchimento de código sugerido não é o que você queria.

Embora o GitHub Copilot sugira um loop foreach que itera os salesData, não há nenhuma análise ou cálculo dentro do loop. O código sugerido inclui instruções Console.WriteLine que você não deseja ou precisa.
Pense por um momento sobre o motivo pelo qual o GitHub Copilot está sugerindo instruções Console.WriteLine.

Lembre-se de que o GitHub Copilot cria 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 que o GitHub Copilot analise. E a situação piora.

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

O GitHub Copilot funciona melhor quando seu código está limpo e direcionado. Se você vir comentários de código desnecessários ou instruções no seu código, considere removê-los antes de tentar usar os preenchimentos de código do GitHub Copilot.
Para limpar seu código antes de dar outra chance para o GitHub Copilot, conclua as seguintes etapas:
- Cancele o preenchimento de código foreach ( sugerido.
- Exclua a instrução foreach ( parcial que você inseriu.
- Exclua a instrução Console.WriteLine do seu método QuarterlySalesReport.
Agora é o momento de dar outra chance ao GitHub Copilot.
Verifique se o seu método QuarterlySalesReport é semelhante ao código a seguir:
```
public void QuarterlySalesReport(SalesData[] salesData)
{


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

Pode demorar um pouco para o GitHub Copilot gerar a sugestão de preenchimento de código.
Analise os preenchimentos de código sugeridos.

Importante

Os preenchimentos de código que você receber provavelmente serão diferentes dos sugestões mostrados na captura de tela a seguir. Mesmo que o GitHub Copilot tenha apenas um nome de método e um parâmetro para trabalhar, isso pode ser suficiente para gerar sugestões úteis. Você verá sugestões que calculam as vendas por trimestre. Rejeitar as sugestões e tentar novamente pode trazer resultados diferentes.

Você pode alternar entre as sugestões usando > ou <.

Observe que a sugestão de preenchimento de código itera por meio dos dados de vendas e faz os cálculos das vendas trimestrais.

Para aceitar a sugestão de preenchimento, pressione a tecla Tab.

A sugestão de preenchimento de código calcula e mostra a renda trimestral com base nos 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 método GetQuarter usa o mês da venda para determinar o trimestre da venda.

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

Com o contexto fornecido pelo método QuarterlySalesReport, o GitHub Copilot pode facilmente gerar um preenchimento para o método GetQuarter que determina o trimestre com base no mês da venda.
Dedique um momento para analisar a sugestão de preenchimento de linha de código para o método GetQuarter.

Para aceitar a sugestão de preenchimento, 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 método Main precisa ser concluído antes que você possa executar o código.

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

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

Seu método Main 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 minuto para analisar o código na sua 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";
            }
        }
    }
}

Lembre-se de que este código foi criado, quase inteiramente, usando preenchimento de linhas de código geradas pelo GitHub Copilot. No entanto, sua revisão das sugestões de código é importante e as correções eram necessárias. Você sempre deve examinar as conclusõ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 um Terminal no Visual Studio Code e insira o comando a seguir:
```
dotnet run
```
A saída deve mostrar o relatório de rendimentos trimestrais, mostrando o nome do departamento, o trimestre e a renda para cada departamento e trimestre representados nos dados de teste.
Revise a saída na janela Terminal.

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

Resumo

As conclusõ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 esforço mínimo. Além disso, o GitHub Copilot pode gerar conclusõ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?