Esercizio: sviluppare funzionalità del codice usando gli strumenti di GitHub Copilot

  • 20 minuti

L'utente e un collega si incontrano per discutere gli obiettivi dell'applicazione per la biblioteca. Si desidera migliorare l'esperienza utente per i bibliotecari e i clienti. Verranno illustrate diverse nuove funzionalità che potrebbero essere aggiunte all'applicazione.

Si concorda di lavorare sulle funzionalità seguenti:

  • Disponibilità libro: consente a un'utilità di gestione archiviazione di determinare lo stato di disponibilità di un libro. Questa funzionalità deve visualizzare un messaggio indicante se un libro è disponibile per il prestito o la data di scadenza della restituzione se il libro attualmente è stato prestato a un altro cliente.

  • Prestiti libro: consentire a un'utilità di gestione archiviazione di prestare un libro a un cliente (se il libro è disponibile). Questa funzionalità deve visualizzare l'opzione per la ricezione di un libro in prestito da parte di un cliente, aggiornare Loans.json con il nuovo prestito e visualizzare i dettagli del prestito aggiornati per il cliente.

  • Prenotazioni libro: consentire a un'utilità di gestione archiviazione di prenotare un libro per un cliente (a meno che il libro non sia già prenotato). Questa funzionalità deve implementare un nuovo processo di prenotazione dei libri. Questa funzionalità può richiedere la creazione di un nuovo file Reservations.json insieme alle nuove classi e interfacce necessarie per supportare il processo di prenotazione.

Ognuno lavorerà su una delle nuove funzionalità e quindi verranno riaggruppate. L'utente lavorerà sulla funzionalità per determinare lo stato di disponibilità di un libro. Un collega lavorerà sulla funzionalità per assegnare in presto un libro a un cliente. La funzionalità finale, per prenotare un libro per un cliente, verrà sviluppata dopo aver completato le altre due funzionalità.

Durante questo esercizio verranno completate le attività seguenti:

  1. Creare un ramo "disponibilità libro" nel repository di codici.

  2. Sviluppare una nuova funzionalità di "disponibilità libro".

    • Usare i suggerimenti di GitHub Copilot per implementare il codice in modo più rapido e accurato.
    • Sincronizzare gli aggiornamenti del codice con il ramo "disponibilità libro" del repository remoto.

  3. Creare una richiesta pull per unire le modifiche nel ramo principale del repository.

Creare un nuovo ramo nel repository

Prima di iniziare a sviluppare la nuova funzionalità "disponibilità libro", è necessario creare un nuovo ramo nel repository. Ciò consente di lavorare sulla nuova funzionalità senza influire sul ramo principale del repository. È possibile unire la nuova funzionalità nel ramo principale quando è pronta.

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

  1. Assicurarsi di avere la soluzione AccelerateDevGitHubCopilot aperta in Visual Studio Code.

  2. Selezionare la vista Controllo del codice sorgente e assicurarsi che il repository locale sia sincronizzato con il repository remoto (pull o sincronizzazione).

  3. Nell'angolo inferiore sinistro della finestra selezionare main.

  4. Per creare un nuovo ramo, digitare disponibilità libro e quindi selezionare + Crea nuovo ramo.

  5. Per eseguire il push del nuovo ramo nel repository remoto, selezionare Pubblica ramo.

Sviluppare una funzionalità che consente a un bibliotecario di determinare lo stato di disponibilità di un libro

In questa sezione dell'esercizio si usa GitHub Copilot per implementare una nuova funzionalità per l'applicazione della biblioteca. La nuova funzionalità consente a un bibliotecario di determinare lo stato di disponibilità di un libro.

La funzionalità di disponibilità dei libri deve includere gli aggiornamenti del codice seguenti:

  • Aggiungere una nuova azione SearchBooks a CommonActions.
  • Aggiornare il metodo WriteInputOptions in ConsoleApp.cs. Aggiungere il supporto per la nuova opzione CommonActions.SearchBooks. Visualizzare l'opzione per verificare se un libro è disponibile per il prestito.
  • Aggiornare il metodo ReadInputOptions in ConsoleApp.cs. Aggiungere il supporto per la nuova opzione CommonActions.SearchBooks.
  • Aggiornare il metodo PatronDetails in ConsoleApp.cs. Aggiungere CommonActions.SearchBooks a options prima di chiamare ReadInputOptions. Aggiungere un else if per gestire l'azione SearchBooks. Il blocco else if deve chiamare un nuovo metodo denominato SearchBooks.
  • Creare un nuovo metodo SearchBooks in ConsoleApp.cs. Il metodo SearchBooks deve leggere il titolo di un libro fornito dall'utente. Controllare se un libro è disponibile per il prestito e visualizzare un messaggio indicante "book.title è disponibile per il prestito" o "book.title è stato prestato a un altro cliente. La data di scadenza della restituzione è loan.DueDate.

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

  1. Aprire la vista Esplora soluzioni.

  2. Aprire il file CommonActions.cs e quindi selezionare l'enumerazione CommonActions.

    È necessario aggiungere una nuova azione SearchBooks a CommonActions.

  3. Aprire una chat inline e quindi immettere il prompt seguente:

    Update selection to include a new `SearchBooks` action.

    GitHub Copilot dovrebbe suggerire un aggiornamento del codice che aggiunge la nuova azione SearchBooks all'enumerazione CommonActions.

  4. Esaminare l'aggiornamento suggerito e quindi selezionare Accetta.

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

  5. Aprire il file ConsoleApp.cs.

  6. Trovare e selezionare il metodo WriteInputOptions.

    È necessario aggiungere il supporto per la nuova opzione CommonActions.SearchBooks. Visualizzare l'opzione per verificare se un libro è disponibile per il prestito.

  7. Aprire una chat inline e quindi immettere il prompt seguente:

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

    GitHub Copilot dovrebbe suggerire un aggiornamento del codice che aggiunge un nuovo blocco if per l'azione SearchBooks.

  8. Esaminare l'aggiornamento suggerito e quindi selezionare Accetta.

    L'aggiornamento suggerito dovrebbe essere simile al frammento di codice seguente:

    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. Scorrere leggermente verso l'alto per trovare e selezionare il metodo ReadInputOptions.

    È necessario aggiungere il supporto per la nuova opzione CommonActions.SearchBooks. Includere un caso che gestisce l'utente che seleziona l'azione SearchBooks.

  10. Aprire una chat inline e quindi immettere il prompt seguente:

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

    GitHub Copilot dovrebbe suggerire un aggiornamento del codice che aggiunge un nuovo case che gestisce l'utente che seleziona l'azione SearchBooks.

  11. Esaminare l'aggiornamento suggerito e quindi selezionare Accetta.

    L'aggiornamento suggerito dovrebbe essere simile al frammento di codice seguente:

    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. Scorrere verso il basso per trovare e selezionare il metodo PatronDetails.

    È necessario eseguire due operazioni:

    • È necessario aggiungere CommonActions.SearchBooks a options prima di chiamare ReadInputOptions.
    • È anche necessario aggiungere un else if per gestire l'azione SearchBooks. Il blocco else if deve chiamare un nuovo metodo denominato SearchBooks.

    È possibile gestire entrambi questi problemi insieme.

  13. Aprire una chat inline e quindi immettere il prompt seguente:

    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`.

    GitHub Copilot dovrebbe suggerire un aggiornamento del codice che aggiunge CommonActions.SearchBooks a options prima di chiamare ReadInputOptions.

  14. Esaminare l'aggiornamento suggerito e quindi selezionare Accetta.

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

    Nota

    I suggerimenti della chat inline possono anche creare codice stub per il metodo SearchBooks.

  15. Prendere in considerazione i requisiti di processo per il metodo SearchBooks.

    Che cosa deve fare il metodo? Cosa deve restituire? Richiede parametri?

    Il metodo SearchBooks deve implementare il processo seguente:

    1. Chiedere all'utente il titolo di un libro.

    2. Leggere il titolo del libro fornito dall'utente.

    3. Controllare se un libro è disponibile per il prestito

    4. Visualizzare un messaggio che indica una delle opzioni seguenti:

      • "book.title è disponibile per il prestito"
      • "book.title è stato prestato a un altro cliente. La data di scadenza della restituzione è loan.DueDate.

    Per compilare le opzioni del messaggio, il codice dovrà accedere ai file JSON seguenti:

    • Books.json è necessario per trovare Title e BookId corrispondenti.
    • Loans.json è necessario per trovare ReturnDate e DueDate per BookItemIdcorrispondente. BookItemId è lo stesso di BookId in Books.json.

  16. Assicurarsi di avere creato il metodo SearchBooks seguente nel file ConsoleApp.cs:

    async Task<ConsoleState> SearchBooks()
{

    return ConsoleState.PatronDetails;
}

    Nota

    Assicurarsi di rimuovere eventuali commenti del codice creati da GitHub Copilot. Commenti inutili e imprecisi possono influire negativamente sui suggerimenti di GitHub Copilot.

  17. Selezionare il metodo SearchBooks.

  18. Aprire una chat inline e quindi immettere il prompt seguente:

    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.

    GitHub Copilot dovrebbe suggerire un aggiornamento del codice che acquisisce il titolo del libro fornito dall'utente.

  19. Esaminare l'aggiornamento suggerito e quindi selezionare Accetta.

    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. Selezionare il metodo SearchBooks.

    Nota

    GitHub Copilot può creare un metodo separato per gestire l'input dell'utente di un titolo di un libro. È possibile continuare a sviluppare la logica primaria nel metodo SearchBooks.

  21. Aprire la vista Chat.

  22. Aggiungere i file seguenti al contesto chat: ConsoleApp.cs, JsonData.cs, JsonLoanRepository.cs, Books.json, Loans.json, BookItems.json, .

  23. Immettere il prompt seguente:

    @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. Rivedere gli aggiornamenti suggeriti.

    GitHub Copilot dovrebbe proporre aggiornamenti simili ai suggerimenti seguenti:

    Per aggiornare il metodo SearchBooks e la classe ConsoleApp per trovare un titolo del libro corrispondente nel file Books.json e verificare se il libro è disponibile per il prestito, seguire questa procedura:

    a) Aggiungere un metodo per cercare i libri per titolo nella classe JsonData. b. Aggiornare il metodo SearchBooks nella classe ConsoleApp per usare questo nuovo metodo. c. Controllare lo stato del prestito del libro e visualizzare il messaggio appropriato.

    Ecco il codice aggiornato:

    Passaggio 1: aggiungere un metodo per cercare i libri per titolo nella classe JsonData

    public class JsonData
{
    // Existing code...

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

    Passaggio 2: aggiornare il metodo SearchBooks nella 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...
}

    Passaggio 3: aggiornare il Program.cs per passare JsonData a 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();

    Con queste modifiche, il metodo SearchBooks nella classe ConsoleApp ora cercherà un libro per titolo nel file di Books.json e ne verificherà lo stato del prestito nel file Loans.json. Se il libro è disponibile per il prestito, verrà visualizzato un messaggio che informa che il libro è disponibile. Se il libro è in prestito, verrà visualizzato un messaggio che informa che il libro è in prestito e ne indica la data di scadenza del reso.

  25. Aggiungere il metodo suggerito alla fine della classe JsonData.

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

  26. Aggiornare il file Program.cs usando gli aggiornamenti suggeriti.

    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. Aggiungere la dichiarazione di campo JsonData _jsonData; alla classe ConsoleApp prima del costruttore della classe.

  28. Aggiungere un parametro JsonData jsonData al costruttore della classe ConsoleApp e usarlo per inizializzare il campo _jsonData all'interno del costruttore.

    Il costruttore della classe aggiornato dovrebbe essere simile al frammento di codice seguente:

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

  29. Si noti che JsonData non è riconosciuto nella classe ConsoleApp.

    È necessario aggiungere using Library.Infrastructure.Data; all'inizio del file ConsoleApp.cs.

  30. Assicurarsi che l'istruzione using Library.Infrastructure.Data; venga aggiunta all'inizio del file di ConsoleApp.cs.

  31. Usare i suggerimenti del codice per aggiornare il metodo SearchBooks:

    Il codice suggerito deve usare una query LINQ per cercare il libro in base al titolo. Se il libro viene trovato, viene usata un'altra query LINQ per determinare se il libro è in prestito. Il codice include anche la logica per visualizzare lo stato di disponibilità del libro in base ai risultati della ricerca. La logica usata per visualizzare i messaggi di risposta può essere implementata in diversi modi. Nel frammento di codice seguente viene fornito un esempio.

    Il frammento di codice seguente mostra una possibile implementazione del metodo 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. Selezionare il metodo SearchBooks.

  33. Aprire la visualizzazione Chat e quindi immettere il prompt seguente:

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

  34. Esaminare la spiegazione fornita da GitHub Copilot.

    Per la query che controlla se il libro è in prestito, dovrebbe essere visualizzata una descrizione simile alla spiegazione seguente:

    **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. Verificare la logica implementata dalla query Verifica se il libro è in prestito .

    Operatore condizionale Null: l'operatore ?. è un operatore condizionale Null. Garantisce che se _jsonData.Loans è null, l'intera espressione restituirà null senza generare un NullReferenceException.

    Espressione lambda: l'espressione lambda l => l.BookItemId == book.Id && l.ReturnDate == null definisce la condizione per il metodo FirstOrDefault. Controlla ogni loan oggetto l per verificare se il relativo BookItemId corrisponde a Id dell'oggetto book e se il relativo ReturnDate è null.

    Questo codice tenta di trovare il primo loan nella raccolta _jsonData.Loans in cui BookItemId corrisponde a Id di book specificato e ReturnDate è null. Se non viene trovato alcun loan di questo tipo o se _jsonData.Loans è null, loan verrà impostato su null.

    Nota

    La maggior parte delle moderne biblioteche ha più copie dello stesso libro. Questo codice presuppone che esista una sola copia di ogni libro. Se la biblioteca ha più copie dello stesso libro, il codice dovrà essere aggiornato per gestire più prestiti per lo stesso libro. Ai fini di questa formazione, si presuppone che esista una sola copia di ogni libro e che la logica fornita sia sufficiente.

  36. Compilare la soluzione per assicurarsi che non siano presenti errori.

    Verranno visualizzati diversi avvisi, ma non dovrebbero essere presenti errori.

    Per compilare la soluzione nella visualizzazione Esplora soluzioni, fare clic con il pulsante destro del mouse su AccelerateDevGitHubCopilot e quindi scegliere Compila.

Sincronizzare le modifiche con il repository remoto

  1. Selezionare la vista Controllo del codice sorgente.

  2. Assicurarsi che i file aggiornati siano elencati in Modifiche.

  3. Usare GitHub Copilot per generare un messaggio per il commit.

  4. Per preparare ed eseguire il commit delle modifiche, selezionare Commit e quindi selezionare Sì.

  5. Eseguire la sincronizzazione o il push delle modifiche nel repository remoto.

Eseguire il test di quanto fatto finora

In questa sezione dell'esercizio, vengono completate le attività seguenti:

  1. Assicurarsi che la nuova funzionalità determini correttamente lo stato di disponibilità di un libro.
  2. Creare una richiesta pull per unire le modifiche nel ramo principale del repository.

Assicurarsi che la nuova funzionalità funzioni come previsto

Poiché non esistono test automatizzati, è possibile usare test manuali per assicurarsi che la nuova funzionalità funzioni come previsto. L'uso di un'origine dati che può essere verificata è importante. In questo caso, si usano i file Books.json e Loans.json per assicurarsi che la nuova funzionalità riporti correttamente lo stato di disponibilità di un libro.

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

  1. Aprire la vista Esplora soluzioni.

  2. Per eseguire l'applicazione, fare clic con il pulsante destro del mouse su Library.Console, scegliere Debug e quindi avvia nuova istanza.

  3. Quando viene richiesto un nome di patrono, digitare One e quindi premere INVIO.

    Verrà visualizzato un elenco di clienti che corrispondono alla query di ricerca.

  4. Al prompt "Opzioni di input", digitare 2 e quindi premere INVIO.

    Inserendo 2 si seleziona il secondo cliente nell'elenco.

    Deve essere visualizzato il nome e lo stato di adesione del cliente seguito dai dettagli del prestito del libro.

  5. Al prompt "Opzioni di input", digitare b e quindi premere INVIO.

    Se si immette b , viene selezionata l'opzione per cercare lo stato di disponibilità di un libro.

    Verrà visualizzato un prompt per l'immissione del titolo di un libro.

  6. Digitare Book One e quindi premere INVIO.

    Nei dati originali scaricati, Book One è attualmente in prestito a Patron Forty-Nine, quindi non dovrebbe essere disponibile.

  7. Verificare che l'applicazione visualizzi un messaggio indicante che il libro è in prestito a un altro cliente.

  8. Verificare che Book Nine sia stato restituito da Patron One.

    Nell'esercizio precedente, durante un test dell'applicazione Libreria, hai fatto restituire Book Nine da Patron One. Se l'applicazione mostra che Book Nine non è stato restituito da Patron One, usare le opzioni di input per selezionare e restituire Book Nine prima di continuare.

    Nota

    Il file Library.Console.csproj garantisce che i file di dati JSON vengano copiati nella directory di output quando viene compilata l'applicazione. Tuttavia, l'esecuzione di operazioni di pulizia o ricompilazione reimposterà essenzialmente i dati. Operazioni di compilazione ripetute non reimpostano i dati nella directory di output (/bin/Debug/net8.0/).

  9. Al prompt "Opzioni di input", digitare b e quindi premere INVIO.

  10. Digitare Book Nine e quindi premere INVIO.

  11. Assicurarsi che l'applicazione visualizzi un messaggio indicante che il libro è disponibile per il prestito.

  12. Al prompt "Opzioni di input" digitare q e quindi premere INVIO.

  13. Arrestare la sessione di debug

  14. Aprire il file Loans.json.

    Il file Loans.json viene utilizzato per tenere traccia dello stato del prestito di ogni libro. È possibile utilizzare il file Loans.json per assicurarsi che lo stato di disponibilità di Libro Uno e Libro Nove sia corretto.

    Il file Loans.json aggiornato deve trovarsi nella cartella Library.Console\bin\Debug\net8.0\Json o Library.Console\Json.

    • Se si usa il debugger di Visual Studio Code per eseguire l'app, il file Loans.json aggiornato deve trovarsi nella cartella Library.Console\bin\Debug\net8.0\Json.

    • Se si usa un comando dotnet run dalla cartella AccelerateDevGitHubCopilot\src\Library.Console> per eseguire l'app, il file Loans.json aggiornato deve trovarsi nella cartella Library.Console\Json.

  15. Assicurarsi che l'ID prestito 37 e l'ID prestito 46 siano entrambi per Libro Uno ("BookItemId": 1).

    • L'ID prestito 37 deve avere un valore ReturnDate (2024-01-17)
    • L'ID prestito 46 non deve avere un valore ReturnDate. Il valore ReturnDate deve essere null.

    Il valore ReturnDate viene utilizzato per determinare se il libro è attualmente in prestito. Se il valore ReturnDate è null, il libro viene considerato in prestito.

  16. Assicurarsi che l'ID prestito 22 sia per Libro Nove ("BookItemId": 9) e che il valore ReturnDate sia impostato sulla data odierna.

    Se l'esecuzione avviene nel debugger e la soluzione è stata pulita dopo aver apportato modifiche al file Loans.json, tali modifiche vengono perse. Dopo aver pulito la soluzione, il file Loans.json viene reimpostato sui dati originali alla successivo esecuzione dell'applicazione. È possibile aggiornare manualmente il file Loans.json per testare lo stato di disponibilità di Libro Uno e Libro Nove.

Creare una richiesta pull per unire le modifiche nel ramo principale

È stata completata la nuova funzionalità che consente a un bibliotecario di determinare lo stato di disponibilità di un libro. A questo punto, è necessario unire le modifiche nel ramo principale del repository. È possibile creare una richiesta pull per unire le modifiche nel ramo principale.

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

  1. Aprire il repository GitHub in un Web browser.

  2. Aprire la scheda Richieste pull.

  3. Selezionare Nuova pull request.

  4. In Confronta modifiche verificare che la base sia configurata per il ramo principale .

  5. Assicurarsi che confronta sia configurato per il ramo disponibilità libro.

    Dopo aver configurato i rami, viene visualizzato un confronto delle modifiche tra il branch main e il branch book-availability. Verranno visualizzate le modifiche per ogni file aggiornato.

  6. Selezionare Crea pull request.

  7. Immettere un titolo e una descrizione per la richiesta pull.

    È possibile usare il titolo e la descrizione seguenti:

    • Titolo: impresa: Aggiungere la funzionalità di ricerca per i libri in ConsoleApp
    • Descrizione: questa richiesta pull aggiunge una nuova funzionalità che consente a un bibliotecario di determinare lo stato di disponibilità di un libro. La funzionalità include una nuova azione SearchBooks in CommonActions, aggiornamenti ai metodi WriteInputOptions, ReadInputOptions e PatronDetails in ConsoleApp e aggiunge un nuovo metodo SearchBooks in ConsoleApp.

    Nota

    I membri di un'azienda con una sottoscrizione a GitHub Copilot Enterprise possono usare GitHub Copilot per generare un riepilogo di una richiesta pull in GitHub.com. È possibile usare il riepilogo per aiutare i revisori a comprendere le modifiche o per comprendere rapidamente le modifiche in una richiesta pull che si sta esaminando. Selezionare GitHub Actions e quindi Riepilogo per generare un riepilogo della richiesta pull.

    Di seguito è riportato un esempio di riepilogo delle richieste pull generato usando un account GitHub Copilot Enterprise:

    Screenshot che mostra un riepilogo delle richieste pull generato con un account GitHub Copilot Enterprise.

  8. Assicurarsi che il titolo e la descrizione riflettano gli aggiornamenti del codice e quindi selezionare Crea richiesta pull.

  9. Attendere il completamento dei controlli e assicurarsi che tutti i controlli siano stati superati e che non siano presenti conflitti con il ramo di base.

    Il completamento dei controlli può richiedere un minuto. Prima di poter unire le modifiche nel ramo principale, è necessario risolvere eventuali problemi identificati.

  10. Per unire le modifiche nel ramo principale, selezionare Unisci richiesta pull e quindi selezionare Conferma unione.

    Si noti che è possibile eliminare il ramo book-availability dopo l'unione delle modifiche.

  11. Aprire Visual Studio Code.

  12. Passare al ramo principale del repository.

  13. Eseguire il pull delle modifiche dal repository remoto.

  14. Verifica che le modifiche apportate nel ramo di disponibilità del libro siano ora nel ramo principale.