Exercício: Desenvolver recursos de código usando ferramentas do GitHub Copilot

  • 20 minutos

Você e seu colega de trabalho se encontram para conversar sobre seus objetivos para o aplicativo de biblioteca. Você quer aprimorar a experiência do usuário para bibliotecários e leitores. Você aborda vários novos recursos que poderiam ser adicionados ao aplicativo.

Você concorda em trabalhar nos seguintes recursos:

  • Disponibilidade de um livro: Permitir que um bibliotecário determine o status de disponibilidade de um livro. Esse recurso deve exibir uma mensagem indicando se um livro está disponível para empréstimo ou a data-limite da devolução se o livro estiver atualmente emprestado para um outro leitor.

  • Empréstimos de livros: Permitir que um bibliotecário empreste um livro a um leitor (se o livro estiver disponível). Esse recurso deve exibir a opção para um leitor retirar um livro emprestado, atualizar o arquivo Loans.json com o novo empréstimo e exibir os detalhes do empréstimo atualizados para o leitor.

  • Reservas de livros: Permitir que um bibliotecário reserve um livro para um leitor (a menos que o livro já esteja reservado). Esse recurso deve implementar um novo processo de reserva de livro. Esse recurso poderá requerer a criação de um novo arquivo Reservations.json, juntamente com as novas classes e interfaces necessárias para dar suporte ao processo de reserva.

Cada um de vocês irá trabalhar em um dos novos recursos e, em seguida, vocês devem se reunir novamente. Você vai trabalhar no recurso para determinar o status de disponibilidade de um livro. Seu colega de trabalho vai trabalhar no recurso de emprestar um livro a um leitor. O recurso final, reservar um livro para um leitor, será desenvolvido após os outros dois recursos terem sido concluídos.

Durante esse exercício, você vai efetuar as seguintes tarefas:

  1. Criar um branch de "disponibilidade do livro" no repositório de código.

  2. Desenvolver um novo recurso de "disponibilidade do livro".

    • Usar sugestões do GitHub Copilot para ajudar a implementar o código com mais rapidez e precisão.
    • Sincronizar as atualizações de código com o branch de "disponibilidade do livro" do seu repositório remoto.

  3. Criar uma solicitação de pull para mesclar suas alterações no branch principal do repositório.

Criar um novo branch no repositório

Antes de começar a desenvolver o novo recurso de "disponibilidade do livro", você precisa criar um novo branch no repositório. Isso permitirá que você trabalhe no novo recurso sem afetar o branch principal do repositório. Você pode mesclar o novo recurso no branch principal quando estiver pronto.

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

  1. Certifique-se de que você esteja com a solução AccelerateDevGitHubCopilot aberta no Visual Studio Code.

  2. Selecione o modo de exibição Controle do Código-Fonte e certifique-se de que o repositório local esteja sincronizado com o repositório remoto (Pull ou Sincronização).

  3. No canto inferior esquerdo da janela, selecione principal.

  4. Para criar uma nova ramificação, digite book availability e selecione + Create new branch.

  5. Para enviar o novo branch por push para o repositório remoto, selecione Publicar Branch.

Desenvolver um recurso que permita que um bibliotecário determine o status de disponibilidade de um livro

Nesta seção do exercício, você vai usar o GitHub Copilot como uma ajuda para implementar um novo recurso do aplicativo de biblioteca. Seu novo recurso permite que um bibliotecário determine o status de disponibilidade de um livro.

O recurso de disponibilidade do livro deve incluir as seguintes atualizações de código:

  • Adicionar uma nova ação SearchBooks a CommonActions.
  • Atualizar o método WriteInputOptions em ConsoleApp.cs. Adicionar suporte para a nova opção CommonActions.SearchBooks. Mostrar a opção para verificar se um livro está disponível para empréstimo.
  • Atualizar o método ReadInputOptions em ConsoleApp.cs. Adicionar suporte para a nova opção CommonActions.SearchBooks.
  • Atualizar o método PatronDetails em ConsoleApp.cs. Adicionar CommonActions.SearchBooks a options antes de chamar ReadInputOptions. Adicionar um else if para se encarregar da ação SearchBooks. O bloco else if deverá chamar um novo método chamado SearchBooks.
  • Criar um novo método SearchBooks em ConsoleApp.cs. O método SearchBooks deverá ler um título de livro fornecido pelo usuário. Verificar se um livro está disponível para empréstimo e mostrar uma mensagem informando que "book.title está disponível para empréstimo" ou "book.title está emprestado para outro leitor. A data-limite da devolução é loan.DueDate".

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

  1. Abra a exibição do GERENCIADOR DE SOLUÇÕES.

  2. Abra o arquivo CommonActions.cs e, a seguir, selecione a enumeração CommonActions.

    Você precisa adicionar uma nova ação SearchBooks a CommonActions.

  3. Abra o chat embutido e insira o seguinte prompt:

    Update selection to include a new `SearchBooks` action.

    O GitHub Copilot deverá sugerir uma atualização de código que adicione a nova ação SearchBooks à enumeração CommonActions.

  4. Reveja a atualização sugerida e, a seguir, selecione Aceitar.

    public enum CommonActions
{
    Repeat = 0,
    Select = 1,
    Quit = 2,
    SearchPatrons = 4,
    RenewPatronMembership = 8,
    ReturnLoanedBook = 16,
    ExtendLoanedBook = 32,
    SearchBooks = 64
}

  5. Abra o arquivo ConsoleApp.cs.

  6. Localize e, em seguida, selecione o método WriteInputOptions.

    Você precisa adicionar suporte para a nova opção CommonActions.SearchBooks. Mostrar a opção para verificar se um livro está disponível para empréstimo.

  7. Abra o chat embutido e insira o seguinte prompt:

    Update selection to include an option for the `CommonActions.SearchBooks` action. Use the letter "b" and the message "to check for book availability".

    O GitHub Copilot deverá sugerir uma atualização de código que adicione um novo bloco if para a ação SearchBooks.

  8. Reveja a atualização sugerida e, a seguir, selecione Aceitar.

    A atualização sugerida deve ser semelhante ao seguinte trecho de código:

    static void WriteInputOptions(CommonActions options)
{
    Console.WriteLine("Input Options:");
    if (options.HasFlag(CommonActions.ReturnLoanedBook))
    {
        Console.WriteLine(" - \"r\" to mark as returned");
    }
    if (options.HasFlag(CommonActions.ExtendLoanedBook))
    {
        Console.WriteLine(" - \"e\" to extend the book loan");
    }
    if (options.HasFlag(CommonActions.RenewPatronMembership))
    {
        Console.WriteLine(" - \"m\" to extend patron's membership");
    }
    if (options.HasFlag(CommonActions.SearchPatrons))
    {
        Console.WriteLine(" - \"s\" for new search");
    }
    if (options.HasFlag(CommonActions.SearchBooks))
    {
        Console.WriteLine(" - \"b\" to check for book availability");
    }
    if (options.HasFlag(CommonActions.Quit))
    {
        Console.WriteLine(" - \"q\" to quit");
    }
    if (options.HasFlag(CommonActions.Select))
    {
        Console.WriteLine("Or type a number to select a list item.");
    }
}

  9. Role levemente para cima para localizar e, a seguir, selecionar o método ReadInputOptions.

    Você precisa adicionar suporte para a nova opção CommonActions.SearchBooks. Inclua um caso que envolva o usuário selecionando a ação SearchBooks.

  10. Abra o chat embutido e insira o seguinte prompt:

    Update selection to include an option for the `CommonActions.SearchBooks` action.

    O GitHub Copilot deverá sugerir uma atualização de código que adicione um novo case envolvendo o usuário que está selecionando a ação SearchBooks.

  11. Reveja a atualização sugerida e, a seguir, selecione Aceitar.

    A atualização sugerida deve ser semelhante ao seguinte trecho de código:

    static CommonActions ReadInputOptions(CommonActions options, out int optionNumber)
{
    CommonActions action;
    optionNumber = 0;
    do
    {
        Console.WriteLine();
        WriteInputOptions(options);
        string? userInput = Console.ReadLine();

        action = userInput switch
        {
            "q" when options.HasFlag(CommonActions.Quit) => CommonActions.Quit,
            "s" when options.HasFlag(CommonActions.SearchPatrons) => CommonActions.SearchPatrons,
            "m" when options.HasFlag(CommonActions.RenewPatronMembership) => CommonActions.RenewPatronMembership,
            "e" when options.HasFlag(CommonActions.ExtendLoanedBook) => CommonActions.ExtendLoanedBook,
            "r" when options.HasFlag(CommonActions.ReturnLoanedBook) => CommonActions.ReturnLoanedBook,
            "b" when options.HasFlag(CommonActions.SearchBooks) => CommonActions.SearchBooks,
            _ when int.TryParse(userInput, out optionNumber) => CommonActions.Select,
            _ => CommonActions.Repeat
        };

        if (action == CommonActions.Repeat)
        {
            Console.WriteLine("Invalid input. Please try again.");
        }
    } while (action == CommonActions.Repeat);
    return action;
}

  12. Role para baixo para localizar e, a seguir, selecionar o método PatronDetails.

    Existem duas coisas que você precisa fazer:

    • Precisa adicionar CommonActions.SearchBooks a options antes de chamar ReadInputOptions.
    • Também precisa adicionar um else if para se encarregar da ação SearchBooks. O bloco else if deverá chamar um novo método chamado SearchBooks.

    Você pode abordar essas duas coisas juntas.

  13. Abra o chat embutido e insira o seguinte prompt:

    Update selection to add `CommonActions.SearchBooks` to `options` before calling `ReadInputOptions`. Add an `else if` block to handle the `SearchBooks` action. The `else if` block should call a new method named `SearchBooks`.

    O GitHub Copilot deverá sugerir uma atualização de código que adicione CommonActions.SearchBooks a options antes de chamar ReadInputOptions.

  14. Reveja a atualização sugerida e, a seguir, selecione Aceitar.

    async Task<ConsoleState> PatronDetails()
{
    Console.WriteLine($"Name: {selectedPatronDetails.Name}");
    Console.WriteLine($"Membership Expiration: {selectedPatronDetails.MembershipEnd}");
    Console.WriteLine();
    Console.WriteLine("Book Loans:");
    int loanNumber = 1;
    foreach (Loan loan in selectedPatronDetails.Loans)
    {
        Console.WriteLine($"{loanNumber}) {loan.BookItem!.Book!.Title} - Due: {loan.DueDate} - Returned: {(loan.ReturnDate != null).ToString()}");
        loanNumber++;
    }

    CommonActions options = CommonActions.SearchPatrons | CommonActions.Quit | CommonActions.Select | CommonActions.RenewPatronMembership | CommonActions.SearchBooks;
    CommonActions action = ReadInputOptions(options, out int selectedLoanNumber);
    if (action == CommonActions.Select)
    {
        if (selectedLoanNumber >= 1 && selectedLoanNumber <= selectedPatronDetails.Loans.Count())
        {
            var selectedLoan = selectedPatronDetails.Loans.ElementAt(selectedLoanNumber - 1);
            selectedLoanDetails = selectedPatronDetails.Loans.Where(l => l.Id == selectedLoan.Id).Single();
            return ConsoleState.LoanDetails;
        }
        else
        {
            Console.WriteLine("Invalid book loan number. Please try again.");
            return ConsoleState.PatronDetails;
        }
    }
    else if (action == CommonActions.Quit)
    {
        return ConsoleState.Quit;
    }
    else if (action == CommonActions.SearchPatrons)
    {
        return ConsoleState.PatronSearch;
    }
    else if (action == CommonActions.RenewPatronMembership)
    {
        var status = await _patronService.RenewMembership(selectedPatronDetails.Id);
        Console.WriteLine(EnumHelper.GetDescription(status));
        // reloading after renewing membership
        selectedPatronDetails = (await _patronRepository.GetPatron(selectedPatronDetails.Id))!;
        return ConsoleState.PatronDetails;
    }
    else if (action == CommonActions.SearchBooks)
    {
        return await SearchBooks();
    }

    throw new InvalidOperationException("An input option is not handled.");
}

    Observação

    As sugestões do chat embutido talvez também possam criar um stub para o método SearchBooks.

  15. Reserve um minuto para refletir sobre os requisitos do processo para o método SearchBooks.

    O que o método precisa fazer? O que ele deverá retornar? Isso requer algum parâmetro?

    O método SearchBooks deve implementar o seguinte processo:

    1. Solicitar ao usuário um título de livro.

    2. Ler o título do livro fornecido pelo usuário.

    3. Verificar se um livro está disponível para empréstimo

    4. Exibir uma mensagem informando uma das seguintes opções:

      • "book.title está disponível para empréstimo"
      • "book.title está emprestado para outro leitor. A data-limite da devolução é loan.DueDate".

    Para criar as opções de mensagem, seu código precisará acessar os seguintes arquivos JSON:

    • Books.json é necessário para encontrar o Title e a BookId correspondentes.
    • Loans.json é necessário para encontrar a ReturnDate e a DueDate para o BookItemId correspondente. O BookItemId é igual ao BookId no Books.json.

  16. Certifique-se de que você tenha o seguinte método SearchBooks criado no arquivo ConsoleApp.cs:

    async Task<ConsoleState> SearchBooks()
{

    return ConsoleState.PatronDetails;
}

    Observação

    Certifique-se de remover todos os comentários de código criados pelo GitHub Copilot. Os comentários desnecessários e incorretos podem influenciar as sugestões do GitHub Copilot negativamente.

  17. Selecione o método SearchBooks.

  18. Abra o chat embutido e insira o seguinte prompt:

    Update selection to obtain a book title. Prompt the user to "Enter a book title to search for". Read the user input and ensure the book title isn't null.

    O GitHub Copilot deverá sugerir uma atualização de código que capture o título do livro fornecido pelo usuário.

  19. Reveja a atualização sugerida e, a seguir, selecione Aceitar.

    async Task<ConsoleState> SearchBooks()
{
    string? bookTitle = null;
    while (String.IsNullOrWhiteSpace(bookTitle))
    {
        Console.Write("Enter a book title to search for: ");
        bookTitle = Console.ReadLine();
    }

    // Perform book search logic here

    return ConsoleState.PatronDetails;
}

  20. Selecione o método SearchBooks.

    Observação

    O GitHub Copilot pode criar um método separado para lidar com a entrada do usuário de um título de livro. Você pode continuar a desenvolver a lógica primária no método SearchBooks.

  21. Abra o modo de exibição de chat.

  22. Adicione os seguintes arquivos ao contexto de chat: ConsoleApp.cs, JsonData.cs, JsonLoanRepository.cs, Books.json, Loans.json e BookItems.json.

  23. Digite a seguinte solicitação:

    @workspace  Explain how to update the `SearchBooks` method and ConsoleApps class to find a matching book title in the `Books.json` file. Use the user supplied book title to find a matching book. If a book is found, use Loans.json to check if the book is available for loan. If the book has been returned, display a message stating "`book.title` is available for loan". If the book is on loan, display a message stating "`book.title` is on loan to another patron. The return due date is `loan.DueDate`".

  24. Reserve um minuto para rever as atualizações sugeridas.

    O GitHub Copilot deve propor atualizações semelhantes às seguintes sugestões:

    Para atualizar o método SearchBooks e a classe ConsoleApp para encontrar um título de livro correspondente no arquivo Books.json e verificar se o livro está disponível para empréstimo, siga estas etapas:

    a. Adicione um método para pesquisar livros por título na classe JsonData. b. Atualize o método SearchBooks na classe ConsoleApp para usar esse novo método. c. Verifique o status do empréstimo do livro e exiba a mensagem apropriada.

    Aqui está o código atualizado:

    Etapa 1: Adicionar um método para pesquisar livros por título na classe JsonData

    public class JsonData
{
    // Existing code...

    public Book? SearchBookByTitle(string title)
    {
        return Books?.FirstOrDefault(b => b.Title.Equals(title, StringComparison.OrdinalIgnoreCase));
    }
}

    Etapa 2: Atualizar o método SearchBooks na classe ConsoleApp

    public class ConsoleApp
{
    // Existing fields...

    JsonData _jsonData;

    public ConsoleApp(ILoanService loanService, IPatronService patronService, IPatronRepository patronRepository, ILoanRepository loanRepository, JsonData jsonData)
    {
        _patronRepository = patronRepository;
        _loanRepository = loanRepository;
        _loanService = loanService;
        _patronService = patronService;
        _jsonData = jsonData;
    }

    // Existing methods...

    async Task<ConsoleState> SearchBooks()
    {
        string bookTitle = ReadBookTitle();

        Book? book = _jsonData.SearchBookByTitle(bookTitle);

        if (book == null)
        {
            Console.WriteLine($"No book found with title: {bookTitle}");
            return ConsoleState.PatronDetails;
        }

        Loan? loan = _jsonData.Loans?.FirstOrDefault(l => l.BookItemId == book.Id && l.ReturnDate == null);

        if (loan == null)
        {
            Console.WriteLine($"{book.Title} is available for loan.");
        }
        else
        {
            Console.WriteLine($"{book.Title} is on loan to another patron. The return due date is {loan.DueDate}.");
        }

        return ConsoleState.PatronDetails;
    }

    // Existing methods...
}

    Etapa 3: Atualizar o Program.cs para passar JsonData para ConsoleApp

    using Microsoft.Extensions.DependencyInjection;
using Library.Infrastructure.Data;
using Library.ApplicationCore;
using Microsoft.Extensions.Configuration;

var services = new ServiceCollection();

var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appSettings.json")
.Build();

services.AddSingleton<IConfiguration>(configuration);

services.AddScoped<IPatronRepository, JsonPatronRepository>();
services.AddScoped<ILoanRepository, JsonLoanRepository>();
services.AddScoped<ILoanService, LoanService>();
services.AddScoped<IPatronService, PatronService>();

services.AddSingleton<JsonData>();
services.AddSingleton<ConsoleApp>();

var servicesProvider = services.BuildServiceProvider();

var consoleApp = servicesProvider.GetRequiredService<ConsoleApp>();
consoleApp.Run().Wait();

    Com essas alterações, o método SearchBooks na classe ConsoleApp agora procurará um livro por título no arquivo Books.json e verificará seu status de empréstimo no arquivo Loans.json. Se o livro estiver disponível para empréstimo, ele exibirá uma mensagem informando que o livro está disponível. Se o livro estiver emprestado, ele exibirá uma mensagem informando que o livro está emprestado e fornecerá a data da devolução.

  25. Adicione o método sugerido ao final da classe JsonData.

    public Book? SearchBookByTitle(string title)
{
    return Books?.FirstOrDefault(b => b.Title.Equals(title, StringComparison.OrdinalIgnoreCase));
}

  26. Atualize o arquivo Program.cs usando as atualizações sugeridas.

    using Microsoft.Extensions.DependencyInjection;
using Library.Infrastructure.Data;
using Library.ApplicationCore;
using Microsoft.Extensions.Configuration;

var services = new ServiceCollection();

var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appSettings.json")
.Build();

services.AddSingleton<IConfiguration>(configuration);

services.AddScoped<IPatronRepository, JsonPatronRepository>();
services.AddScoped<ILoanRepository, JsonLoanRepository>();
services.AddScoped<ILoanService, LoanService>();
services.AddScoped<IPatronService, PatronService>();

services.AddSingleton<JsonData>();
services.AddSingleton<ConsoleApp>();

var servicesProvider = services.BuildServiceProvider();

var consoleApp = servicesProvider.GetRequiredService<ConsoleApp>();
consoleApp.Run().Wait();

  27. Adicione a declaração de campo JsonData _jsonData; à classe ConsoleApp antes do construtor da classe.

  28. Adicione um parâmetro JsonData jsonData ao construtor da classe ConsoleApp e use-o para inicializar o campo _jsonData dentro do construtor.

    O construtor da classe atualizado deve se parecer com o seguinte trecho de código:

    public ConsoleApp(ILoanService loanService, IPatronService patronService, IPatronRepository patronRepository, ILoanRepository loanRepository, JsonData jsonData)
{
    _patronRepository = patronRepository;
    _loanRepository = loanRepository;
    _loanService = loanService;
    _patronService = patronService;
    _jsonData = jsonData;
}

  29. Observe que JsonData não é reconhecido na classe ConsoleApp.

    Você precisará adicionar using Library.Infrastructure.Data; à parte superior do arquivo ConsoleApp.cs.

  30. Verifique se a instrução using Library.Infrastructure.Data; é adicionada à parte superior do arquivo ConsoleApp.cs.

  31. Use as sugestões de código para atualizar o método SearchBooks:

    O código sugerido deve usar uma consulta LINQ para pesquisar o livro por título. Se o livro for encontrado, outra consulta LINQ será usada para determinar se o livro está emprestado. O código também inclui uma lógica para exibir o status de disponibilidade do livro com base nos resultados da pesquisa. A lógica usada para exibir mensagens de resposta pode ser implementada de várias maneiras. Um exemplo é fornecido no trecho de código abaixo.

    O trecho de código a seguir mostra uma possível implementação do método SearchBooks:

    async Task<ConsoleState> SearchBooks()
{
    string bookTitle = ReadBookTitle();

    Book? book = _jsonData.SearchBookByTitle(bookTitle);

    if (book == null)
    {
        Console.WriteLine($"No book found with title: {bookTitle}");
        return ConsoleState.PatronDetails;
    }

    Loan? loan = _jsonData.Loans?.FirstOrDefault(l => l.BookItemId == book.Id && l.ReturnDate == null);

    if (loan == null)
    {
        Console.WriteLine($"{book.Title} is available for loan.");
    }
    else
    {
        Console.WriteLine($"{book.Title} is on loan to another patron. The return due date is {loan.DueDate}.");
    }

    return ConsoleState.PatronDetails;
}

  32. Selecione o método SearchBooks.

  33. Abra o modo de exibição de Chat e, em seguida, insira o seguinte prompt:

    Explain the LINQ queries and the evaluation of the book's availability status.

  34. Reserve um minuto para rever as explicações fornecidas pelo GitHub Copilot.

    Para a consulta que verifica se o livro está emprestado, você deve ver uma descrição semelhante à seguinte explicação:

    **Search for the Loan Status of the Book**

    Loan? loan = _jsonData.Loans?.FirstOrDefault(l => l.BookItemId == book.Id && l.ReturnDate == null);

    - _jsonData.Loans: Accesses the list of loans from the JsonData class.

- ?.: The null-conditional operator ensures that if _jsonData.Loans is null, the entire expression will return null without throwing a NullReferenceException.

- FirstOrDefault: A LINQ method that returns the first element in the collection that matches the specified condition, or null if no such element is found.

- Lambda Expression: l => l.BookItemId == book.Id && l.ReturnDate == null

    - l.BookItemId == book.Id: Checks if the BookItemId of the loan matches the Id of the book being searched.

    - l.ReturnDate == null: Checks if the loan's ReturnDate is null, indicating that the book is currently on loan and has not been returned.

- Result: If a matching loan is found, it is assigned to the loan variable. If no matching loan is found, loan is null.

**Evaluation of the Book's Availability Status**

After executing the LINQ queries, the method evaluates the availability status of the book:

  - If `loan` is `null`, the book has been returned. The method prints that the book is available for loan.
  - If `loan` is not `null`, the book is currently on loan (no return date). The method prints that the book is on loan and provides the date when the book should be returned.

  35. Verifique a lógica implementada pela consulta Verificar se o Livro está Emprestado.

    Operador Condicional Nulo: O operador ?. é um operador condicional nulo e garante que, se _jsonData.Loans for null, a expressão inteira será avaliada como null sem gerar uma NullReferenceException.

    Expressão Lambda: A expressão lambda l => l.BookItemId == book.Id && l.ReturnDate == null define a condição do método FirstOrDefault e verifica cada objeto de loanl para ver se seu BookItemId corresponde à Id do objeto book e se a ReturnDate é null.

    Esse código tenta localizar o primeiro loan na coleção _jsonData.Loans, onde o BookItemId corresponde à Id do book fornecido e a ReturnDate é null. Se nenhum loan como esse for encontrado ou se _jsonData.Loans for null, o loan será definido como null.

    Observação

    A maioria das bibliotecas modernas tem várias cópias do mesmo livro. Esse código pressupõe que haja apenas uma cópia de cada livro. Se a biblioteca tiver várias cópias do mesmo livro, o código precisará ser atualizado para lidar com vários empréstimos para o mesmo livro. Para os fins desse treinamento, estamos pressupondo que exista apenas uma cópia de cada livro e que a lógica fornecida seja suficiente.

  36. Crie a solução para garantir que não haja nenhum erro.

    Você verá mensagens de Aviso, mas não deverá haver nenhum erro.

    Para criar a solução no modo de exibição Gerenciador de Soluções, clique com o botão direito do mouse em AccelerateDevGitHubCopilot e, a seguir, selecione Compilar.

Sincronizar suas alterações com o repositório remoto

  1. Selecione o modo de exibição Controle do Código-Fonte.

  2. Verifique se os arquivos atualizados estão listados em Alterações.

  3. Use o GitHub Copilot para gerar uma mensagem para o Commit.

  4. Para preparar e fazer o commit de suas alterações, selecione Commit e, a seguir, selecione Sim.

  5. Faça a sincronização (ou Efetue Push) das alterações para o repositório remoto.

Verifique seu trabalho

Nesta seção do exercício, você irá executar as seguintes tarefas:

  1. Certificar-se de que o novo recurso determine corretamente o status de disponibilidade de um livro.
  2. Criar uma solicitação de pull para mesclar suas alterações no branch principal do repositório.

Certificar-se de que o novo recurso funcione conforme o esperado

Como você não tem testes automatizados, um teste manual pode ser usado para verificar se o novo recurso funciona conforme o esperado. O uso de uma fonte de dados que possa ser verificada é importante. Nesse caso, você usa os arquivos Books.json e Loans.json para verificar se o novo recurso reporta o status de disponibilidade de um livro corretamente.

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

  1. Abra a exibição do Gerenciador de Soluções.

  2. Para executar o aplicativo, clique com o botão direito do mouse em Library.Console, selecione Depurar e, em seguida, selecione Iniciar Nova Instância.

  3. Quando solicitado a obter um nome de leitor, digite Um e, em seguida, pressione Enter.

    Você deverá ver uma lista de leitores que correspondam à consulta da pesquisa.

  4. No prompt "Opções de Entrada", digite 2 e, a seguir, pressione Enter.

    Inserir 2 selecionará o segundo leitor da lista.

    Você deverá ver o nome do leitor e o status de filiação seguidos dos detalhes do empréstimo do livro.

  5. No prompt "Opções de Entrada", digite b e, a seguir, pressione Enter.

    Inserir b seleciona a opção de pesquisar o status de disponibilidade de um livro.

    Você deverá ver um prompt para inserir um título de livro.

  6. Digite Livro 1 e pressione Enter.

    Nos dados originais que você baixou, o Livro 1 está atualmente emprestado ao Leitor 49 e, portanto, não deve estar disponível.

  7. Certifique-se de que o aplicativo esteja mostrando uma mensagem indicando que o livro está emprestado para outro leitor.

  8. Certifique-se de que o Livro 9 foi devolvido pelo Leitor 1.

    No exercício anterior, durante um teste do aplicativo Biblioteca, você fez com que o Leitor 1 devolvesse o Livro 9. Se o aplicativo mostrar que o Livro 9 não foi devolvido pelo Leitor 1, use as opções de entrada para selecionar e devolver o Livro 9 antes de prosseguir.

    Observação

    O arquivo Library.Console.csproj garante que os arquivos de dados JSON sejam copiados para o diretório de saída quando o aplicativo for compilado. No entanto, executar as operações Limpar ou Reconstruir irá, essencialmente, redefinir os dados. As operações repetidas Compilar não redefinem os dados no diretório de saída (/bin/Debug/net8.0/).

  9. No prompt "Opções de Entrada", digite b e, a seguir, pressione Enter.

  10. Digite Livro 9 e pressione Enter.

  11. Certifique-se de que o aplicativo mostre uma mensagem indicando que o livro está disponível para empréstimo.

  12. No prompt "Opções de Entrada", digite q e, a seguir, pressione Enter.

  13. Interrompa a sessão de depuração.

  14. Abra o arquivo Loans.json .

    O arquivo Loans.json é usado para acompanhar o status do empréstimo de cada livro. Você pode usar o arquivo Loans.json para verificar se os status de disponibilidade do Livro 1 e do Livro 9 estão corretos.

    O arquivo Loans.json atualizado deve estar localizado na pasta Library.Console\bin\Debug\net8.0\Json ou na pasta Library.Console\Json.

    • Se você estiver usando o depurador do Visual Studio Code para executar o aplicativo, o arquivo Loans.json atualizado deverá estar localizado na pasta Library.Console\bin\Debug\net8.0\Json.

    • Se você estiver usando um comando dotnet run a partir da pasta AccelerateDevGitHubCopilot\src\Library.Console> para executar o aplicativo, o arquivo Loans.json atualizado deverá estar localizado na pasta Library.Console\Json.

  15. Certifique-se de que tanto a ID de empréstimo 37 quanto a ID de empréstimo 46 se destinem ao Livro 1 ("BookItemId": 1).

    • A ID de empréstimo 37 deverá ter um valor ReturnDate (2024-01-17)
    • A ID de empréstimo 46 não deverá ter um valor ReturnDate. O valor ReturnDate deverá ser null.

    O valor ReturnDate é usado para determinar se o livro está emprestado atualmente. Se o valor ReturnDate for null, o livro será considerado como estando emprestado.

  16. Certifique-se de que a ID de empréstimo 22 se destine ao Livro 9 ("BookItemId": 9) e de que o valor ReturnDate esteja definido como a data de hoje.

    Se você estiver executando no depurador e tiver limpado a solução após fazer alterações no arquivo Loans.json, essas alterações serão perdidas. Após você limpar a solução, o arquivo Loans.json será redefinido para os dados originais da próxima vez que você executar o aplicativo. Você pode atualizar o arquivo Loans.json manualmente para testar o status de disponibilidade do Livro 1 e do Livro 9.

Criar uma solicitação de pull para mesclar suas alterações no branch principal

Você concluiu o novo recurso que permite que um bibliotecário determine o status de disponibilidade de um livro. Agora, você precisa mesclar suas alterações no branch principal do repositório. Você pode criar uma solicitação de pull para mesclar suas alterações no branch principal.

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

  1. Abra seu repositório do GitHub no seu navegador da web.

  2. Abra a guia Solicitações de pull.

  3. Selecione Nova solicitação de pull.

  4. Em Comparar alterações, certifique-se de que a base esteja configurada para o branch principal.

  5. Certifique-se de que comparar esteja configurado para o branch disponibilidade de livros.

    Após você configurar os branches, uma comparação das alterações entre o branch principal e o branch disponibilidade de livros será exibida. Você deve ver as alterações de cada um dos arquivos que você atualizou.

  6. Selecione Criar solicitação de pull.

  7. Digite um título e uma descrição para a solicitação de pull.

    Você pode usar o seguinte título e descrição:

    • Título: feat: Adicionar uma funcionalidade de pesquisa para livros no ConsoleApp
    • Descrição: Essa solicitação de pull adiciona um novo recurso que permite que um bibliotecário determine o status de disponibilidade de um livro. O recurso inclui uma nova ação SearchBooks em CommonActions, atualiza para os métodos WriteInputOptions, ReadInputOptions e PatronDetails no ConsoleApp e adiciona um novo método SearchBooks no ConsoleApp.

    Observação

    Os membros de uma empresa com uma assinatura do GitHub Copilot Enterprise podem usar o GitHub Copilot para gerar um resumo de uma solicitação de pull no site GitHub.com. Você pode usar o resumo para ajudar os revisores a entender suas alterações ou para entender rapidamente as alterações em uma solicitação de pull que você está revisando. Selecione GitHub Actions e, em seguida, selecione Resumo para gerar um resumo da pull request.

    Aqui temos um exemplo de um resumo de solicitação de pull que foi gerado usando uma conta do GitHub Copilot Enterprise:

    Captura de tela mostrando um resumo da solicitação de pull gerado usando uma conta do GitHub Copilot Enterprise.

  8. Certifique-se de que o título e a descrição reflitam as atualizações do seu código e, a seguir, selecione Criar uma solicitação de pull.

  9. Aguarde a conclusão das verificações e, a seguir, certifique-se de que todas as verificações tenham sido aprovadas e de que não haja nenhum conflito com o branch base.

    Pode levar um minuto para que as verificações sejam concluídas. Você precisa resolver todos os problemas identificados antes de mesclar as alterações no branch principal.

  10. Para mesclar suas alterações no branch principal, selecione Mesclar solicitação de pull e, a seguir, selecione Confirmar mesclagem.

    Observe que você pode excluir o branch book-availability após mesclar as alterações.

  11. Abra o Visual Studio Code.

  12. Alterne para o branch principal do repositório.

  13. Efetue pull das alterações a partir do repositório remoto.

  14. Certifique-se de que as alterações que você fez no branch disponibilidade de livros agora estejam no branch principal.