Examinar o chat embutido do GitHub Copilot, ações inteligentes e chat rápido

Além da exibição de chat, o GitHub Copilot Chat oferece várias outras maneiras de interagir com o programador de pares de IA. Isso inclui chat embutido, ações inteligentes e chat rápido.

Chats embutido

Um dos principais recursos do Chat do GitHub Copilot é responder a perguntas embutidas enquanto você está codificando. Isso permite que você aproveite o poder da IA diretamente no editor de código, com interrupção mínima no fluxo de trabalho de desenvolvimento.

O recurso de chat embutido só estará acessível quando um arquivo for aberto no editor. Há várias formas de abrir uma sessão de chat embutido:

• Selecione o Chat Embutido do Editor no menu Chat do Copilot.
• Use um atalho de teclado: Ctrl+I.
• Clique com o botão direito do mouse dentro do editor de código, selecione Copilot no menu de contexto e selecione Chat Embutido do Editor.

Você pode usar uma sessão de chat embutida para fazer perguntas do Copilot enquanto escreve ou itera seu código.

Quando você abre uma sessão de chat embutida, a interface a seguir é apresentada no Editor.

Considere o seguinte cenário:

• Você está desenvolvendo um aplicativo C# que processa uma lista numérica. Os dados são processados em lotes de 100.
• Use o snippet de código abaixo para criar uma lista de 100 inteiros aleatórios entre 1 e 1000 que você pode usar para teste.

// create a list of 100 random number between 1 and 1000
List<int> numbers = new List<int>();
Random random = new Random();
for (int i = 0; i < 100; i++)
{
    numbers.Add(random.Next(1, 1000));
}

O código está funcionando bem. No entanto, e se os requisitos forem alterados? E se você precisar garantir que a lista não inclua números duplicados?

Para atualizar seu código usando as conclusões automáticas do GitHub Copilot, você precisaria:

1. Exclua o código existente.
2. Criar um novo comentário que reflita seu requisito atualizado.
3. Usar o GitHub Copilot para gerar um novo snippet de código do comentário atualizado.
4. Examinar as sugestões e selecione a melhor opção.

Felizmente isso não é necessário. Uma solução melhor é usar o GitHub Copilot Chat para sugerir as atualizações de código necessárias.

Você pode usar uma sessão de chat embutida para sugerir uma atualização de código da seguinte maneira:

1. Realce o snippet de código que você deseja atualizar.
2. Pressione Ctrl + I para abrir o chat embutido.
3. Pergunte ao GitHub Copilot Chat como concluir a atualização.
4. Examinar as sugestões e selecione a melhor opção.

Nesse caso, você pode perguntar: Update this code to ensure that numbers doesn't include any duplicates

Se você gostar das atualizações de código propostas, pode selecionar Aceitar e continuar a codificação.

Se você não gostar das atualizações propostas, peça ao Copilot Chat para gerar outra sugestão selecionando o ícone Executar novamente.... O ícone Executar novamente é exibido como uma seta circular que aparece abaixo da caixa de texto do prompt.

Se você executar novamente o prompt e ainda não receber os resultados necessários, tente atualizar o prompt com contexto adicional. O Copilot Chat gera melhores sugestões quando o prompt é claro, sucinto e preciso. Você pode escolher Descartar para fechar o chat embutido sem fazer nenhuma alteração.

Ações inteligentes

Algumas tarefas são tão comuns que podem ser automatizadas. O Chat do GitHub Copilot inclui ações inteligentes que permitem concluir determinadas tarefas sem precisar escrever um prompt. Ações inteligentes são ações predefinidas que você pode executar diretamente do editor do Visual Studio Code para executar tarefas comuns de codificação de forma rápida e fácil.

As seguintes ações inteligentes estão disponíveis:

• Explicar: a ação Explain gera uma descrição de linguagem natural do código selecionado. Isso pode ser útil para entender a finalidade e a funcionalidade de um snippet de código. A ação Explain é especialmente útil se você estiver trabalhando com código desconhecido ou precisar explicar o código para outras pessoas.
• Consertar: a ação Fix sugere uma correção para o código selecionado. Isso pode ser útil se você encontrar um erro ou problema em seu código e precisar de orientação sobre como resolvê-lo. O Chat do Copilot pode sugerir alterações em variáveis, estruturas de controle ou chamadas de função que podem resolver o problema.
• Revisão e Comentário: a ação Review and Comment fornece uma revisão de código do código selecionado. Isso pode ser útil para identificar possíveis problemas, melhorar a qualidade do código e garantir que as práticas recomendadas sejam seguidas. A ação Review and Comment pode ajudá-lo a identificar bugs, gargalos de desempenho e vulnerabilidades de segurança no seu código.
• Gerar Docs: a ação Generate Docs cria documentação para o código selecionado. Isso pode ser útil para documentar sua base de código, especialmente se você estiver trabalhando em um projeto com vários colaboradores ou precisar compartilhar seu código com outras pessoas.
• Gerar testes: a ação Generate Tests cria testes de unidade para o código selecionado. Isso pode ser útil para garantir a correção e a confiabilidade do código, especialmente se você estiver trabalhando em um projeto com lógica complexa ou funcionalidade crítica.

Para acessar as ações inteligentes, clique com o botão direito do mouse em um snippet de código no editor e selecione a ação desejada no menu de contexto do Copilot.

Mais uma vez, vamos considerar o aplicativo de números principais.

Na seção anterior, o chat embutido sugeria o seguinte código para garantir que numbers não incluísse duplicatas:

// create a list of 100 random numbers between 1 and 1000
List<int> numbers = new List<int>();
Random random = new Random();
while (numbers.Count < 100)
{
    int randomNumber = random.Next(1, 1000);
    if (!numbers.Contains(randomNumber))
    {
        numbers.Add(randomNumber);
    }
}

Embora esse código garanta uma coleção de elementos exclusivos, pode haver oportunidades de melhoria.

Você pode usar a ação inteligente Review This para verificar as seleções de código. Para usar a ação inteligente Review This :

1. Selecione um snippet de código que precisa de análise. Nesse caso, o código que gera a lista de números aleatórios.

2. Selecione Review This no menu de contexto do Copilot.

3. Examine as atualizações sugeridas e selecione Aceitar para aplicar as alterações.

Para o snippet de código que gera números aleatórios, a ação inteligente Review This sugere o seguinte:

• Inicializar List<int> numbers com capacidade de 100 para evitar vários redimensionamentos durante a população.
• Usar um HashSet<int> em vez de um List<int> para pesquisas mais rápidas ao verificar se há duplicatas.

Nesse caso, a ação inteligente Review This leva você a usar HashSet<int> em vez de List<int> para melhorar o desempenho.

// create a list of 100 random numbers between 1 and 1000
HashSet<int> numbers = new HashSet<int>();
Random random = new Random();
while (numbers.Count < 100)
{
    int randomNumber = random.Next(1, 1000);
    if (!numbers.Contains(randomNumber))
    {
        numbers.Add(randomNumber);
    }
}

int sum = addPrimeNumbersInNumericList(numbers);
Console.WriteLine(sum);

Embora o uso de um HashSet funcione com eficiência para garantir uma coleção de elementos exclusivos, a atualização cria um novo problema. O método addPrimeNumbersInNumericList espera um List<int> como entrada, mas o código atualizado cria um HashSet<int>. Isso resulta no seguinte erro de compilação:

Felizmente, você pode usar a ação inteligente Corrigir para corrigir o erro. Para usar a ação inteligente Corrigir:

1. Clique com o botão direito do mouse no snippet de código que precisa ser corrigido. Nesse caso, o código sublinhado em vermelho.

2. Selecione Corrigir no menu de contexto do Copilot.

3. Examine a correção sugerida e selecione Aceitar para aplicar as alterações.

A ação inteligente Fix gera uma ou mais sugestões para corrigir um erro. Nesse caso, uma das sugestões usa o método ToList() para converter HashSet em List dentro da chamada para addPrimeNumbersInNumericList. O código resultante será semelhante ao seguinte snippet de código:

// create a list of 100 random numbers between 1 and 1000
HashSet<int> numbers = new HashSet<int>();
Random random = new Random();
while (numbers.Count < 100)
{
    int randomNumber = random.Next(1, 1000);
    if (!numbers.Contains(randomNumber))
    {
        numbers.Add(randomNumber);
    }
}

int sum = addPrimeNumbersInNumericList(numbers.ToList());
Console.WriteLine(sum);

Como sempre, examine a sugestão fornecida pelo Copilot Chat. Pode haver soluções melhores. Você pode selecionar Aceitar atualizar seu código com a correção proposta.

Chat rápido

A terceira opção que o Chat do GitHub Copilot fornece para interações de chat é o Chat rápido.

Você pode usar o recurso de Chat rápido do Chat do GitHub Copilot quando quiser ter uma conversa rápida e interativa com a IA. Isso pode ser útil quando você está tentando resolver um problema, precisa de ajuda para entender um código ou quer discutir ideias. Ele foi projetado para parecer que você está conversando com um colega desenvolvedor, tornando-o uma ótima ferramenta para a resolução de problemas colaborativa.

Para abrir uma janela de Chat Rápido, você pode pressionar Ctrl+Shift+Alt+L no editor do Visual Studio Code ou abrir o Chat Rápido no menu Chat do Copilot.

Resumo

O GitHub Copilot Chat fornece várias maneiras de interagir com o programador de pares de IA, incluindo chat embutido, ações inteligentes e Chat Rápido. Esses recursos permitem que você faça perguntas, obtenha sugestões de código e execute tarefas comuns de codificação de forma rápida e fácil.