Udostępnij przez

Samouczek: rozpoczynanie pracy System.CommandLine

  • Artykuł

Ważne

System.CommandLine jest obecnie dostępna w wersji zapoznawczej, a ta dokumentacja dotyczy wersji 2.0 beta 4. Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed jego wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

W tym samouczku pokazano, jak utworzyć aplikację wiersza polecenia platformy .NET korzystającą z System.CommandLine biblioteki. Zaczniesz od utworzenia prostego polecenia głównego, które ma jedną opcję. Następnie dodasz do tej bazy, tworząc bardziej złożoną aplikację zawierającą wiele podpolecenia i różne opcje dla każdego polecenia.

Ten samouczek zawiera informacje na temat wykonywania następujących czynności:

  • Utwórz polecenia, opcje i argumenty.
  • Określ wartości domyślne opcji.
  • Przypisz opcje i argumenty do poleceń.
  • Przypisz opcję cyklicznie do wszystkich poleceń podrzędnych w poleceniu.
  • Praca z wieloma poziomami zagnieżdżonych podpolecenia.
  • Utwórz aliasy dla poleceń i opcji.
  • Praca z typami stringopcji , string[], int, boolFileInfo i wyliczeniowych.
  • Powiąż wartości opcji z kodem procedury obsługi poleceń.
  • Użyj kodu niestandardowego do analizowania i sprawdzania poprawności opcji.

Wymagania wstępne

Lub

Tworzenie aplikacji

Utwórz projekt aplikacji konsolowej platformy .NET 6 o nazwie "scl".

  1. Utwórz folder o nazwie scl dla projektu, a następnie otwórz wiersz polecenia w nowym folderze.

  2. Uruchom następujące polecenie:

    dotnet new console --framework net6.0

Instalowanie pakietu System.CommandLine

  • Uruchom następujące polecenie:

    dotnet add package System.CommandLine --prerelease

    Opcja jest niezbędna --prerelease , ponieważ biblioteka jest nadal dostępna w wersji beta.

  1. Zastąp zawartość pliku Program.cs następującym kodem:

    using System.CommandLine;

namespace scl;

class Program
{
    static async Task<int> Main(string[] args)
    {
        var fileOption = new Option<FileInfo?>(
            name: "--file",
            description: "The file to read and display on the console.");

        var rootCommand = new RootCommand("Sample app for System.CommandLine");
        rootCommand.AddOption(fileOption);

        rootCommand.SetHandler((file) => 
            { 
                ReadFile(file!); 
            },
            fileOption);

        return await rootCommand.InvokeAsync(args);
    }

    static void ReadFile(FileInfo file)
    {
        File.ReadLines(file.FullName).ToList()
            .ForEach(line => Console.WriteLine(line));
    }
}

Powyższy kod ma następujące działanie:

  • Tworzy opcję o nazwie --file typu FileInfo i przypisuje ją do głównego polecenia:

    var fileOption = new Option<FileInfo?>(
    name: "--file",
    description: "The file to read and display on the console.");

var rootCommand = new RootCommand("Sample app for System.CommandLine");
rootCommand.AddOption(fileOption);

  • Określa, że ReadFile jest to metoda, która będzie wywoływana po wywołaniu polecenia głównego:

    rootCommand.SetHandler((file) => 
    { 
        ReadFile(file!); 
    },
    fileOption);

  • Wyświetla zawartość określonego pliku po wywołaniu polecenia głównego:

    static void ReadFile(FileInfo file)
{
    File.ReadLines(file.FullName).ToList()
        .ForEach(line => Console.WriteLine(line));
}

Testowanie aplikacji

Możesz użyć dowolnego z następujących sposobów testowania podczas tworzenia aplikacji wiersza polecenia:

  • dotnet build Uruchom polecenie, a następnie otwórz wiersz polecenia w folderze scl/bin/Debug/net6.0, aby uruchomić plik wykonywalny:

    dotnet build
cd bin/Debug/net6.0
scl --file scl.runtimeconfig.json

  • Użyj dotnet run i przekaż wartości opcji do aplikacji zamiast polecenia run , dołączając je po --, jak pokazano w poniższym przykładzie:

    dotnet run -- --file scl.runtimeconfig.json

    W wersji zapoznawczej zestawu SDK platformy .NET 7.0.100 można użyć commandLineArgs pliku launchSettings.json , uruchamiając polecenie dotnet run --launch-profile <profilename>.

  • Opublikuj projekt w folderze, otwórz wiersz polecenia w tym folderze i uruchom plik wykonywalny:

    dotnet publish -o publish
cd ./publish
scl --file scl.runtimeconfig.json

  • W programie Visual Studio 2022 wybierz pozycję Debugujwłaściwości debugowania> z menu, a następnie wprowadź opcje i argumenty w polu Argumenty wiersza polecenia. Na przykład:

    Argumenty wiersza polecenia w programie Visual Studio 2022

    Następnie uruchom aplikację, na przykład naciskając klawisze Ctrl+F5.

W tym samouczku założono, że używasz pierwszej z tych opcji.

Po uruchomieniu aplikacji wyświetla zawartość pliku określonego --file przez tę opcję.

{
  "runtimeOptions": {
    "tfm": "net6.0",
    "framework": {
      "name": "Microsoft.NETCore.App",
      "version": "6.0.0"
    }
  }
}

Dane wyjściowe pomocy

System.CommandLine automatycznie udostępnia dane wyjściowe pomocy:

scl --help

Description:
  Sample app for System.CommandLine

Usage:
  scl [options]

Options:
  --file <file>   The file to read and display on the console.
  --version       Show version information
  -?, -h, --help  Show help and usage information

Dane wyjściowe wersji

System.CommandLine automatycznie udostępnia dane wyjściowe wersji:

scl --version

1.0.0

Dodawanie podpolecenia i opcji

W tej sekcji omówiono następujące zagadnienia:

  • Utwórz więcej opcji.
  • Utwórz podpolecenia.
  • Przypisz nowe opcje do nowego podpolecenia.

Nowe opcje umożliwią skonfigurowanie kolorów tekstu pierwszego planu i tła oraz szybkości odczytu. Te funkcje będą używane do odczytywania kolekcji cudzysłowów pochodzących z samouczka aplikacji konsolowej Teleprompter.

  1. Skopiuj plik sampleQuotes.txt z repozytorium GitHub dla tego przykładu do katalogu projektu. Aby uzyskać informacje na temat pobierania plików, zobacz instrukcje w temacie Przykłady i samouczki.

  2. Otwórz plik projektu i dodaj <ItemGroup> element tuż przed tagiem zamykającym </Project> :

    <ItemGroup>
  <Content Include="sampleQuotes.txt">
    <CopyToOutputDirectory>Always</CopyToOutputDirectory>
  </Content>
</ItemGroup>

    Dodanie tego znacznika powoduje skopiowanie pliku tekstowego do folderu bin/debug/net6.0 podczas kompilowania aplikacji. Dlatego po uruchomieniu pliku wykonywalnego w tym folderze można uzyskać dostęp do pliku według nazwy bez określania ścieżki folderu.

  3. W pliku Program.cs po kodzie, który tworzy --file opcję, utwórz opcje kontrolowania szybkości odczytu i kolorów tekstu:

    var delayOption = new Option<int>(
    name: "--delay",
    description: "Delay between lines, specified as milliseconds per character in a line.",
    getDefaultValue: () => 42);

var fgcolorOption = new Option<ConsoleColor>(
    name: "--fgcolor",
    description: "Foreground color of text displayed on the console.",
    getDefaultValue: () => ConsoleColor.White);

var lightModeOption = new Option<bool>(
    name: "--light-mode",
    description: "Background color of text displayed on the console: default is black, light mode is white.");

  4. Po wierszu, który tworzy polecenie główne, usuń wiersz, który dodaje --file do niego opcję. Usuwasz go tutaj, ponieważ dodasz go do nowego podpolecenia.

    var rootCommand = new RootCommand("Sample app for System.CommandLine");
//rootCommand.AddOption(fileOption);

  5. Po wierszu, który tworzy polecenie główne, utwórz read podpolecenia. Dodaj opcje do tego podpolecenia i dodaj podpolecenia do polecenia głównego.

    var readCommand = new Command("read", "Read and display the file.")
    {
        fileOption,
        delayOption,
        fgcolorOption,
        lightModeOption
    };
rootCommand.AddCommand(readCommand);

  6. SetHandler Zastąp kod następującym SetHandler kodem dla nowego podpolecenia:

    readCommand.SetHandler(async (file, delay, fgcolor, lightMode) =>
    {
        await ReadFile(file!, delay, fgcolor, lightMode);
    },
    fileOption, delayOption, fgcolorOption, lightModeOption);

    Nie wywołujesz SetHandler już polecenia głównego, ponieważ polecenie główne nie wymaga już obsługi. Gdy polecenie ma podpolecenia, zazwyczaj trzeba określić jedno z podpolecenia podczas wywoływania aplikacji wiersza polecenia.

  7. Zastąp metodę ReadFile obsługi następującym kodem:

    internal static async Task ReadFile(
        FileInfo file, int delay, ConsoleColor fgColor, bool lightMode)
{
    Console.BackgroundColor = lightMode ? ConsoleColor.White : ConsoleColor.Black;
    Console.ForegroundColor = fgColor;
    List<string> lines = File.ReadLines(file.FullName).ToList();
    foreach (string line in lines)
    {
        Console.WriteLine(line);
        await Task.Delay(delay * line.Length);
    };
}

Aplikacja wygląda teraz następująco:

using System.CommandLine;

namespace scl;

class Program
{
    static async Task<int> Main(string[] args)
    {
        var fileOption = new Option<FileInfo?>(
            name: "--file",
            description: "The file to read and display on the console.");

        var delayOption = new Option<int>(
            name: "--delay",
            description: "Delay between lines, specified as milliseconds per character in a line.",
            getDefaultValue: () => 42);

        var fgcolorOption = new Option<ConsoleColor>(
            name: "--fgcolor",
            description: "Foreground color of text displayed on the console.",
            getDefaultValue: () => ConsoleColor.White);

        var lightModeOption = new Option<bool>(
            name: "--light-mode",
            description: "Background color of text displayed on the console: default is black, light mode is white.");

        var rootCommand = new RootCommand("Sample app for System.CommandLine");
        //rootCommand.AddOption(fileOption);

        var readCommand = new Command("read", "Read and display the file.")
            {
                fileOption,
                delayOption,
                fgcolorOption,
                lightModeOption
            };
        rootCommand.AddCommand(readCommand);

        readCommand.SetHandler(async (file, delay, fgcolor, lightMode) =>
            {
                await ReadFile(file!, delay, fgcolor, lightMode);
            },
            fileOption, delayOption, fgcolorOption, lightModeOption);

        return rootCommand.InvokeAsync(args).Result;
    }

    internal static async Task ReadFile(
            FileInfo file, int delay, ConsoleColor fgColor, bool lightMode)
    {
        Console.BackgroundColor = lightMode ? ConsoleColor.White : ConsoleColor.Black;
        Console.ForegroundColor = fgColor;
        List<string> lines = File.ReadLines(file.FullName).ToList();
        foreach (string line in lines)
        {
            Console.WriteLine(line);
            await Task.Delay(delay * line.Length);
        };
    }
}

Testowanie nowego podpolecenia

Teraz, jeśli spróbujesz uruchomić aplikację bez określenia podpolecenia, zostanie wyświetlony komunikat o błędzie, a następnie komunikat pomocy, który określa dostępne podpolecenia.

scl --file sampleQuotes.txt

'--file' was not matched. Did you mean one of the following?
--help
Required command was not provided.
Unrecognized command or argument '--file'.
Unrecognized command or argument 'sampleQuotes.txt'.

Description:
  Sample app for System.CommandLine

Usage:
  scl [command] [options]

Options:
  --version       Show version information
  -?, -h, --help  Show help and usage information

Commands:
  read  Read and display the file.

Tekst pomocy dla podpolecenia read pokazuje, że dostępne są cztery opcje. Wyświetla prawidłowe wartości wyliczenia.

scl read -h

Description:
  Read and display the file.

Usage:
  scl read [options]

Options:
  --file <file>                                               The file to read and display on the console.
  --delay <delay>                                             Delay between lines, specified as milliseconds per
                                                              character in a line. [default: 42]
  --fgcolor                                                   Foreground color of text displayed on the console.
  <Black|Blue|Cyan|DarkBlue|DarkCyan|DarkGray|DarkGreen|Dark  [default: White]
  Magenta|DarkRed|DarkYellow|Gray|Green|Magenta|Red|White|Ye
  llow>
  --light-mode                                                Background color of text displayed on the console:
                                                              default is black, light mode is white.
  -?, -h, --help                                              Show help and usage information

Uruchom polecenie podrzędne read , określając tylko --file opcję, a wartości domyślne dla pozostałych trzech opcji.

scl read --file sampleQuotes.txt

Domyślne opóźnienie 42 milisekund na znak powoduje spowolnienie szybkości odczytu. Możesz ją przyspieszyć, ustawiając --delay wartość na niższą liczbę.

scl read --file sampleQuotes.txt --delay 0

Możesz użyć --fgcolor polecenia i --light-mode ustawić kolory tekstu:

scl read --file sampleQuotes.txt --fgcolor red --light-mode

Podaj nieprawidłową wartość --delay i zostanie wyświetlony komunikat o błędzie:

scl read --file sampleQuotes.txt --delay forty-two

Cannot parse argument 'forty-two' for option '--int' as expected type 'System.Int32'.

Podaj nieprawidłową wartość i --file otrzymasz wyjątek:

scl read --file nofile

Unhandled exception: System.IO.FileNotFoundException:
Could not find file 'C:\bin\Debug\net6.0\nofile'.

Dodawanie podpolecenia i walidacji niestandardowej

Ta sekcja tworzy ostateczną wersję aplikacji. Po zakończeniu aplikacja będzie miała następujące polecenia i opcje:

  • polecenie główne z opcją global* o nazwie --file
    • Polecenie quotes
      • read polecenie z opcjami o nazwie --delay, --fgcolori --light-mode
      • add polecenie z argumentami o nazwie quote i byline
      • delete polecenie z opcją o nazwie --search-terms

* Opcja globalna jest dostępna dla polecenia przypisanego do polecenia i cyklicznie do wszystkich jego podpolecenia.

Oto przykładowe dane wejściowe wiersza polecenia, które wywołują każde z dostępnych poleceń z jego opcjami i argumentami:

scl quotes read --file sampleQuotes.txt --delay 40 --fgcolor red --light-mode
scl quotes add "Hello world!" "Nancy Davolio"
scl quotes delete --search-terms David "You can do" Antoine "Perfection is achieved"

  1. W pliku Program.cs zastąp kod, który tworzy --file opcję następującym kodem:

    var fileOption = new Option<FileInfo?>(
    name: "--file",
    description: "An option whose argument is parsed as a FileInfo",
    isDefault: true,
    parseArgument: result =>
    {
        if (result.Tokens.Count == 0)
        {
            return new FileInfo("sampleQuotes.txt");

        }
        string? filePath = result.Tokens.Single().Value;
        if (!File.Exists(filePath))
        {
            result.ErrorMessage = "File does not exist";
            return null;
        }
        else
        {
            return new FileInfo(filePath);
        }
    });

    Ten kod służy ParseArgument<T> do dostarczania niestandardowej analizy, walidacji i obsługi błędów.

    Bez tego kodu brakujące pliki są zgłaszane z wyjątkiem i śladem stosu. Po wyświetleniu tego kodu jest wyświetlany tylko określony komunikat o błędzie.

    Ten kod określa również wartość domyślną, dlatego ustawia isDefault wartość na true. Jeśli nie ustawiono wartości isDefaulttrue, parseArgument delegat nie zostanie wywołany, gdy nie podano żadnych danych wejściowych dla elementu --file.

  2. Po utworzeniu kodu lightModeOptiondodaj opcje i argumenty dla add poleceń i delete :

    var searchTermsOption = new Option<string[]>(
    name: "--search-terms",
    description: "Strings to search for when deleting entries.")
    { IsRequired = true, AllowMultipleArgumentsPerToken = true };

var quoteArgument = new Argument<string>(
    name: "quote",
    description: "Text of quote.");

var bylineArgument = new Argument<string>(
    name: "byline",
    description: "Byline of quote.");

    Ustawienie AllowMultipleArgumentsPerToken pozwala pominąć --search-terms nazwę opcji podczas określania elementów na liście po pierwszym. Sprawia to, że następujące przykłady danych wejściowych wiersza polecenia są równoważne:

    scl quotes delete --search-terms David "You can do"
scl quotes delete --search-terms David --search-terms "You can do"

  3. Zastąp kod, który tworzy polecenie główne i read polecenie następującym kodem:

    var rootCommand = new RootCommand("Sample app for System.CommandLine");
rootCommand.AddGlobalOption(fileOption);

var quotesCommand = new Command("quotes", "Work with a file that contains quotes.");
rootCommand.AddCommand(quotesCommand);

var readCommand = new Command("read", "Read and display the file.")
    {
        delayOption,
        fgcolorOption,
        lightModeOption
    };
quotesCommand.AddCommand(readCommand);

var deleteCommand = new Command("delete", "Delete lines from the file.");
deleteCommand.AddOption(searchTermsOption);
quotesCommand.AddCommand(deleteCommand);

var addCommand = new Command("add", "Add an entry to the file.");
addCommand.AddArgument(quoteArgument);
addCommand.AddArgument(bylineArgument);
addCommand.AddAlias("insert");
quotesCommand.AddCommand(addCommand);

    Ten kod wprowadza następujące zmiany:

    • Usuwa --file opcję z read polecenia .

    • --file Dodaje opcję jako opcję globalną do polecenia głównego.

    • quotes Tworzy polecenie i dodaje je do głównego polecenia.

    • read Dodaje polecenie do quotes polecenia zamiast do polecenia głównego.

    • Tworzy add polecenia i delete i dodaje je do quotes polecenia .

    Wynikiem jest następująca hierarchia poleceń:

    • Polecenie główne
      • quotes
        • read
        • add
        • delete

    Aplikacja implementuje teraz zalecany wzorzec, w którym polecenie nadrzędne (quotes) określa obszar lub grupę, a polecenia podrzędne (read, add, delete) są akcjami.

    Opcje globalne są stosowane do polecenia i cyklicznie do podpolecenia. Ponieważ --file znajduje się w poleceniu głównym, będzie on automatycznie dostępny we wszystkich podpoleceniach aplikacji.

  4. SetHandler Po kodzie dodaj nowy SetHandler kod dla nowych poleceń podrzędnych:

    deleteCommand.SetHandler((file, searchTerms) =>
    {
        DeleteFromFile(file!, searchTerms);
    },
    fileOption, searchTermsOption);

addCommand.SetHandler((file, quote, byline) =>
    {
        AddToFile(file!, quote, byline);
    },
    fileOption, quoteArgument, bylineArgument);

    Podpolecenia quotes nie ma procedury obsługi, ponieważ nie jest to polecenie liścia. Podpolecenia read, addi delete są poleceniami liści w obszarze quotesi SetHandler jest wywoływana dla każdego z nich.

  5. Dodaj programy obsługi dla elementów add i delete.

    internal static void DeleteFromFile(FileInfo file, string[] searchTerms)
{
    Console.WriteLine("Deleting from file");
    File.WriteAllLines(
        file.FullName, File.ReadLines(file.FullName)
            .Where(line => searchTerms.All(s => !line.Contains(s))).ToList());
}
internal static void AddToFile(FileInfo file, string quote, string byline)
{
    Console.WriteLine("Adding to file");
    using StreamWriter? writer = file.AppendText();
    writer.WriteLine($"{Environment.NewLine}{Environment.NewLine}{quote}");
    writer.WriteLine($"{Environment.NewLine}-{byline}");
    writer.Flush();
}

Gotowa aplikacja wygląda następująco:

using System.CommandLine;

namespace scl;

class Program
{
    static async Task<int> Main(string[] args)
    {
        var fileOption = new Option<FileInfo?>(
            name: "--file",
            description: "An option whose argument is parsed as a FileInfo",
            isDefault: true,
            parseArgument: result =>
            {
                if (result.Tokens.Count == 0)
                {
                    return new FileInfo("sampleQuotes.txt");

                }
                string? filePath = result.Tokens.Single().Value;
                if (!File.Exists(filePath))
                {
                    result.ErrorMessage = "File does not exist";
                    return null;
                }
                else
                {
                    return new FileInfo(filePath);
                }
            });

        var delayOption = new Option<int>(
            name: "--delay",
            description: "Delay between lines, specified as milliseconds per character in a line.",
            getDefaultValue: () => 42);

        var fgcolorOption = new Option<ConsoleColor>(
            name: "--fgcolor",
            description: "Foreground color of text displayed on the console.",
            getDefaultValue: () => ConsoleColor.White);

        var lightModeOption = new Option<bool>(
            name: "--light-mode",
            description: "Background color of text displayed on the console: default is black, light mode is white.");

        var searchTermsOption = new Option<string[]>(
            name: "--search-terms",
            description: "Strings to search for when deleting entries.")
            { IsRequired = true, AllowMultipleArgumentsPerToken = true };

        var quoteArgument = new Argument<string>(
            name: "quote",
            description: "Text of quote.");

        var bylineArgument = new Argument<string>(
            name: "byline",
            description: "Byline of quote.");

        var rootCommand = new RootCommand("Sample app for System.CommandLine");
        rootCommand.AddGlobalOption(fileOption);

        var quotesCommand = new Command("quotes", "Work with a file that contains quotes.");
        rootCommand.AddCommand(quotesCommand);

        var readCommand = new Command("read", "Read and display the file.")
            {
                delayOption,
                fgcolorOption,
                lightModeOption
            };
        quotesCommand.AddCommand(readCommand);

        var deleteCommand = new Command("delete", "Delete lines from the file.");
        deleteCommand.AddOption(searchTermsOption);
        quotesCommand.AddCommand(deleteCommand);

        var addCommand = new Command("add", "Add an entry to the file.");
        addCommand.AddArgument(quoteArgument);
        addCommand.AddArgument(bylineArgument);
        addCommand.AddAlias("insert");
        quotesCommand.AddCommand(addCommand);

        readCommand.SetHandler(async (file, delay, fgcolor, lightMode) =>
            {
                await ReadFile(file!, delay, fgcolor, lightMode);
            },
            fileOption, delayOption, fgcolorOption, lightModeOption);

        deleteCommand.SetHandler((file, searchTerms) =>
            {
                DeleteFromFile(file!, searchTerms);
            },
            fileOption, searchTermsOption);

        addCommand.SetHandler((file, quote, byline) =>
            {
                AddToFile(file!, quote, byline);
            },
            fileOption, quoteArgument, bylineArgument);

        return await rootCommand.InvokeAsync(args);
    }

    internal static async Task ReadFile(
                FileInfo file, int delay, ConsoleColor fgColor, bool lightMode)
    {
        Console.BackgroundColor = lightMode ? ConsoleColor.White : ConsoleColor.Black;
        Console.ForegroundColor = fgColor;
        var lines = File.ReadLines(file.FullName).ToList();
        foreach (string line in lines)
        {
            Console.WriteLine(line);
            await Task.Delay(delay * line.Length);
        };

    }
    internal static void DeleteFromFile(FileInfo file, string[] searchTerms)
    {
        Console.WriteLine("Deleting from file");
        File.WriteAllLines(
            file.FullName, File.ReadLines(file.FullName)
                .Where(line => searchTerms.All(s => !line.Contains(s))).ToList());
    }
    internal static void AddToFile(FileInfo file, string quote, string byline)
    {
        Console.WriteLine("Adding to file");
        using StreamWriter? writer = file.AppendText();
        writer.WriteLine($"{Environment.NewLine}{Environment.NewLine}{quote}");
        writer.WriteLine($"{Environment.NewLine}-{byline}");
        writer.Flush();
    }
}

Skompiluj projekt, a następnie spróbuj wykonać następujące polecenia.

Prześlij nieistnieny plik do --file polecenia read i zostanie wyświetlony komunikat o błędzie zamiast wyjątku i śledzenia stosu:

scl quotes read --file nofile

File does not exist

Spróbuj uruchomić polecenie podrzędne quotes i zostanie wyświetlony komunikat kierujący do użycia read, addlub delete:

scl quotes

Required command was not provided.

Description:
  Work with a file that contains quotes.

Usage:
  scl quotes [command] [options]

Options:
  --file <file>   An option whose argument is parsed as a FileInfo [default: sampleQuotes.txt]
  -?, -h, --help  Show help and usage information

Commands:
  read                          Read and display the file.
  delete                        Delete lines from the file.
  add, insert <quote> <byline>  Add an entry to the file.

Uruchom polecenie podrzędne add, a następnie spójrz na koniec pliku tekstowego, aby zobaczyć dodany tekst:

scl quotes add "Hello world!" "Nancy Davolio"

Uruchom polecenie podrzędne delete z ciągami wyszukiwania od początku pliku, a następnie spójrz na początek pliku tekstowego, aby zobaczyć, gdzie usunięto tekst:

scl quotes delete --search-terms David "You can do" Antoine "Perfection is achieved"

Uwaga

Jeśli korzystasz z folderu bin/debug/net6.0 , w tym folderze znajdziesz plik ze zmianami z add poleceń i delete . Kopia pliku w folderze projektu pozostaje niezmieniona.

Następne kroki

W tym samouczku utworzono prostą aplikację wiersza polecenia, która używa polecenia System.CommandLine. Aby dowiedzieć się więcej o bibliotece, zobacz System.CommandLine omówienie.