Bagikan melalui

Tutorial: Mulai menggunakan System.CommandLine

Tutorial ini menunjukkan cara membuat aplikasi baris perintah .NET yang menggunakan pustaka System.CommandLine. Anda akan mulai dengan membuat perintah root sederhana yang memiliki satu opsi. Kemudian Anda akan membangun di dasar itu, membuat aplikasi yang lebih kompleks yang berisi beberapa sub-perintah dan opsi yang berbeda untuk setiap perintah.

Dalam tutorial ini, Anda mempelajari cara:

  • Membuat perintah, opsi, dan argumen.
  • Tentukan nilai default untuk opsi.
  • Tetapkan opsi dan argumen ke perintah.
  • Tetapkan opsi secara rekursif ke semua sub perintah di bawah perintah.
  • Bekerja dengan beberapa tingkat subperintah bertingkat.
  • Buat alias untuk perintah dan opsi.
  • Bekerja dengan string, string[], int, bool, FileInfo, dan jenis opsi enum.
  • Membaca nilai opsi dalam kode tindakan perintah.
  • Gunakan kode kustom untuk memilah dan memvalidasi opsi.

Prasyarat

Atau

  • Visual Studio dengan beban kerja pengembangan desktop .NET terinstal.

Membuat aplikasi

Buat proyek aplikasi konsol .NET 9 bernama "scl".

  1. Buat folder bernama scl untuk proyek, lalu buka prompt perintah di folder baru.

  2. Jalankan perintah berikut:

    dotnet new console --framework net9.0

Pasang paket System.CommandLine

  • Jalankan perintah berikut:

    dotnet add package System.CommandLine

    Atau, di .NET 10+:

    dotnet package add System.CommandLine

Mengurai argumen

Ganti konten Program.cs dengan kode berikut:

using System.CommandLine;
using System.CommandLine.Parsing;

namespace scl;

class Program
{
    static int Main(string[] args)
    {
        Option<FileInfo> fileOption = new("--file")
        {
            Description = "The file to read and display on the console"
        };

        RootCommand rootCommand = new("Sample app for System.CommandLine");
        rootCommand.Options.Add(fileOption);

        ParseResult parseResult = rootCommand.Parse(args);
        if (parseResult.Errors.Count == 0 && parseResult.GetValue(fileOption) is FileInfo parsedFile)
        {
            ReadFile(parsedFile);
            return 0;
        }
        foreach (ParseError parseError in parseResult.Errors)
        {
            Console.Error.WriteLine(parseError.Message);
        }
        return 1;
    }

    static void ReadFile(FileInfo file)
    {
        foreach (string line in File.ReadLines(file.FullName))
        {
            Console.WriteLine(line);
        }
    }
}

Kode sebelumnya:

Option<FileInfo> fileOption = new("--file")
{
    Description = "The file to read and display on the console"
};

RootCommand rootCommand = new("Sample app for System.CommandLine");
rootCommand.Options.Add(fileOption);
  • Mengurai args dan memeriksa apakah ada nilai yang disediakan untuk opsi tersebut --file . Jika demikian, metode ReadFile dipanggil menggunakan nilai yang terurai dan mengembalikan kode keluar 0.
ParseResult parseResult = rootCommand.Parse(args);
if (parseResult.Errors.Count == 0 && parseResult.GetValue(fileOption) is FileInfo parsedFile)
{
    ReadFile(parsedFile);
    return 0;
}
  • Jika tidak ada nilai yang disediakan untuk --file, maka akan mencetak kesalahan parse yang ada dan mengembalikan kode keluar 1.
foreach (ParseError parseError in parseResult.Errors)
{
    Console.Error.WriteLine(parseError.Message);
}
return 1;
  • Metode membaca ReadFile file yang ditentukan dan menampilkan kontennya di konsol:
static void ReadFile(FileInfo file)
{
    foreach (string line in File.ReadLines(file.FullName))
    {
        Console.WriteLine(line);
    }
}

Menguji aplikasi

Anda dapat menggunakan salah satu cara berikut untuk menguji saat mengembangkan aplikasi baris perintah:

  • Jalankan perintah dotnet build, lalu buka Command Prompt di folder output build untuk menjalankan executable.

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

  • Gunakan dotnet run dan lalukan nilai opsi ke aplikasi alih-alih ke perintah run dengan menyertakannya setelah --, seperti dalam contoh berikut:

    dotnet run -- --file bin/Debug/net9.0/scl.runtimeconfig.json

(Tutorial ini mengasumsikan Anda menggunakan opsi pertama dari opsi ini.)

Saat Anda menjalankan aplikasi, aplikasi akan menampilkan konten file yang ditentukan oleh opsi --file.

{
  "runtimeOptions": {
    "tfm": "net9.0",
    "framework": {
      "name": "Microsoft.NETCore.App",
      "version": "9.0.0"
    }
  }
}

Tetapi jika Anda memintanya untuk menampilkan bantuan dengan memberikan --help, tidak ada yang akan dicetak ke konsol. Itu karena aplikasi belum menangani skenario di mana --file tidak disediakan dan tidak ada kesalahan penguraian.

Mengurai argumen dan memanggil ParseResult

System.CommandLine memungkinkan Anda menentukan tindakan yang dipanggil ketika simbol tertentu (perintah, direktif, atau opsi) berhasil diurai. Aksi ini adalah delegate yang menerima parameter ParseResult dan mengembalikan kode keluar int. (Tindakan asinkron juga tersedia). Kode keluar dikembalikan oleh ParseResult.Invoke(InvocationConfiguration) metode dan dapat digunakan untuk menunjukkan apakah perintah berhasil dijalankan atau tidak.

Ganti konten Program.cs dengan kode berikut:

using System.CommandLine;

namespace scl;

class Program
{
    static int Main(string[] args)
    {
        Option<FileInfo> fileOption = new("--file")
        {
            Description = "The file to read and display on the console"
        };

        RootCommand rootCommand = new("Sample app for System.CommandLine");
        rootCommand.Options.Add(fileOption);

        rootCommand.SetAction(parseResult =>
        {
            FileInfo parsedFile = parseResult.GetValue(fileOption);
            ReadFile(parsedFile);
            return 0;
        });

        ParseResult parseResult = rootCommand.Parse(args);
        return parseResult.Invoke();
    }

    static void ReadFile(FileInfo file)
    {
        foreach (string line in File.ReadLines(file.FullName))
        {
            Console.WriteLine(line);
        }
    }
}

Kode sebelumnya:

  • Menentukan bahwa ReadFile adalah metode yang akan dipanggil ketika perintah root dipanggil:

    rootCommand.SetAction(parseResult =>
{
    FileInfo parsedFile = parseResult.GetValue(fileOption);
    ReadFile(parsedFile);
    return 0;
});

  • Mengurai args dan memanggil hasilnya:

    ParseResult parseResult = rootCommand.Parse(args);
return parseResult.Invoke();

Saat Anda menjalankan aplikasi, aplikasi akan menampilkan konten file yang ditentukan oleh opsi --file.

Jika Anda memintanya untuk menampilkan bantuan dengan menentukan scl --help, output berikut akan dicetak:

Description:
  Sample app for System.CommandLine

Usage:
  scl [options]

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

RootCommand secara default menyediakan opsi Bantuan, opsi Versi, dan Sarankan direktif. Metode ParseResult.Invoke(InvocationConfiguration) ini bertanggung jawab untuk memanggil tindakan simbol yang diurai. Ini bisa menjadi tindakan yang secara eksplisit didefinisikan untuk perintah atau tindakan bantuan yang ditentukan oleh System.CommandLine untuk System.CommandLine.Help.HelpOption.

Selain itu, ketika metode Invoke mendeteksi kesalahan penguraian, fungsi tersebut mengeluarkannya ke kesalahan standar output, dan mengeluarkan bantuan ke output standar, serta mengembalikan 1 sebagai kode keluar.

scl --invalid bla

Unrecognized command or argument '--invalid'.
Unrecognized command or argument 'bla'.

Menambahkan sub perintah dan opsi

Di bagian ini, Anda:

  • Buat opsi lainnya.
  • Buat sub-perintah.
  • Tetapkan opsi baru pada sub-perintah baru.

Opsi baru memungkinkan pengguna akhir mengonfigurasi warna teks latar depan dan latar belakang serta kecepatan baca-baca. Fitur-fitur ini akan digunakan untuk membaca kumpulan kutipan yang berasal dari tutorial aplikasi konsol Teleprompter.

  1. Salin file sampleQuotes.txt dari repositori sampel dotnet ke direktori proyek Anda.

    (Untuk informasi tentang cara mengunduh file, lihat instruksi dalam Sampel dan tutorial.)

  2. Buka file proyek dan tambahkan elemen <ItemGroup> tepat sebelum tag </Project> penutup:

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

    Menambahkan markup ini menyebabkan file teks disalin ke folder output saat Anda membuat aplikasi. Jadi, ketika Anda menjalankan executable di folder tersebut, Anda dapat mengakses file berdasarkan nama tanpa menentukan jalur folder.

  3. Di Program.cs, setelah kode yang membuat opsi --file, buat opsi untuk mengontrol kecepatan baca-baca dan warna teks:

    Option<int> delayOption = new("--delay")
{
    Description = "Delay between lines, specified as milliseconds per character in a line",
    DefaultValueFactory = parseResult => 42
};
Option<ConsoleColor> fgcolorOption = new("--fgcolor")
{
    Description = "Foreground color of text displayed on the console",
    DefaultValueFactory = parseResult => ConsoleColor.White
};
Option<bool> lightModeOption = new("--light-mode")
{
    Description = "Background color of text displayed on the console: default is black, light mode is white"
};

  4. Setelah baris yang membentuk perintah root, hapus kode yang menambahkan opsi --file ke dalamnya. Anda menghapusnya di sini karena Anda akan menambahkannya ke subkomando baru.

  5. Setelah baris yang membuat perintah root, buat sub-perintah read. Tambahkan opsi ke sub perintah ini (dengan menggunakan sintaks penginisialisasi koleksi daripada Options properti), dan tambahkan sub perintah ke perintah akar.

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

  6. Ganti kode SetAction dengan kode SetAction berikut untuk sub-perintah baru:

    readCommand.SetAction(parseResult => ReadFile(
    parseResult.GetValue(fileOption),
    parseResult.GetValue(delayOption),
    parseResult.GetValue(fgcolorOption),
    parseResult.GetValue(lightModeOption)));

    Anda tidak perlu lagi memanggil SetAction pada perintah root karena perintah root tidak lagi dibutuhkan tindakan. Saat perintah memiliki sub-perintah, Anda biasanya harus menentukan salah satu sub-perintah saat memanggil aplikasi baris perintah.

  7. ReadFile Ganti metode tindakan dengan kode berikut:

    internal static void ReadFile(FileInfo file, int delay, ConsoleColor fgColor, bool lightMode)
{
    Console.BackgroundColor = lightMode ? ConsoleColor.White : ConsoleColor.Black;
    Console.ForegroundColor = fgColor;
    foreach (string line in File.ReadLines(file.FullName))
    {
        Console.WriteLine(line);
        Thread.Sleep(TimeSpan.FromMilliseconds(delay * line.Length));
    }
}

Aplikasi sekarang terlihat seperti ini:

using System.CommandLine;

namespace scl;

class Program
{
    static int Main(string[] args)
    {
        Option<FileInfo> fileOption = new("--file")
        {
            Description = "The file to read and display on the console"
        };

        Option<int> delayOption = new("--delay")
        {
            Description = "Delay between lines, specified as milliseconds per character in a line",
            DefaultValueFactory = parseResult => 42
        };
        Option<ConsoleColor> fgcolorOption = new("--fgcolor")
        {
            Description = "Foreground color of text displayed on the console",
            DefaultValueFactory = parseResult => ConsoleColor.White
        };
        Option<bool> lightModeOption = new("--light-mode")
        {
            Description = "Background color of text displayed on the console: default is black, light mode is white"
        };

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

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

        readCommand.SetAction(parseResult => ReadFile(
            parseResult.GetValue(fileOption),
            parseResult.GetValue(delayOption),
            parseResult.GetValue(fgcolorOption),
            parseResult.GetValue(lightModeOption)));

        return rootCommand.Parse(args).Invoke();
    }

    internal static void ReadFile(FileInfo file, int delay, ConsoleColor fgColor, bool lightMode)
    {
        Console.BackgroundColor = lightMode ? ConsoleColor.White : ConsoleColor.Black;
        Console.ForegroundColor = fgColor;
        foreach (string line in File.ReadLines(file.FullName))
        {
            Console.WriteLine(line);
            Thread.Sleep(TimeSpan.FromMilliseconds(delay * line.Length));
        }
    }
}

Uji subperintah baru

Sekarang jika Anda mencoba menjalankan aplikasi tanpa menentukan subperintah, Anda mendapatkan pesan kesalahan diikuti dengan pesan bantuan yang menentukan subperintah yang tersedia.

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:
  -?, -h, --help  Show help and usage information
  --version       Show version information

Commands:
  read  Read and display the file.

Teks bantuan untuk sub-perintah read menunjukkan bahwa empat opsi tersedia. Ini menunjukkan nilai yang valid untuk enum.

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

Jalankan sub-perintah read hanya menentukan opsi --file, dan Anda mendapatkan nilai default untuk tiga opsi lainnya.

scl read --file sampleQuotes.txt

Penundaan default 42 milidetik per karakter menyebabkan kecepatan baca-baca yang lambat. Anda dapat mempercepatnya dengan mengatur --delay ke angka yang lebih rendah.

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

Anda dapat menggunakan --fgcolor dan --light-mode untuk mengatur warna teks:

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

Jika Anda memberikan nilai yang tidak valid untuk --delay, Anda mendapatkan pesan kesalahan:

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

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

Jika Anda memberikan nilai yang tidak valid untuk --file, Anda mendapatkan pengecualian:

scl read --file nofile

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

Menambahkan sub perintah dan validasi kustom

Bagian ini membuat versi akhir aplikasi. Setelah selesai, aplikasi akan memiliki perintah dan opsi berikut:

Command Opsi Arguments
Perintah root --file (rekursif)
quotes
read --delay --fgcolor --light-mode
add quote dan byline
delete --search-terms

(Opsi rekursif tersedia untuk perintah yang ditetapkan dan secara rekursif ke semua sub-perintahnya.)

Berikut adalah contoh input baris perintah yang memanggil setiap perintah yang tersedia dengan opsi dan argumennya:

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. Di Program.cs, ganti kode yang membuat opsi --file dengan kode berikut:

    Option<FileInfo> fileOption = new("--file")
{
    Description = "An option whose argument is parsed as a FileInfo",
    Required = true,
    DefaultValueFactory = result =>
    {
        if (result.Tokens.Count == 0)
        {
            return new FileInfo("sampleQuotes.txt");

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

    Kode ini menggunakan ArgumentResult untuk menyediakan penguraian kustom, validasi, dan penanganan kesalahan.

    Tanpa kode ini, file yang hilang dilaporkan dengan pengecualian dan pelacakan tumpukan. Dengan kode ini, hanya pesan kesalahan yang ditentukan yang ditampilkan.

    Kode ini juga menentukan nilai default, itulah sebabnya diatur Option<T>.DefaultValueFactory ke metode penguraian kustom.

  2. Setelah kode yang membuat lightModeOption, tambahkan opsi dan argumen untuk perintah add dan delete:

    Option<string[]> searchTermsOption = new("--search-terms")
{
    Description = "Strings to search for when deleting entries",
    Required = true,
    AllowMultipleArgumentsPerToken = true
};
Argument<string> quoteArgument = new("quote")
{
    Description = "Text of quote."
};
Argument<string> bylineArgument = new("byline")
{
    Description = "Byline of quote."
};

    Pengaturan AllowMultipleArgumentsPerToken memungkinkan Anda menghilangkan nama opsi --search-terms saat menentukan elemen dalam daftar setelah yang pertama. Ini menjadikan contoh input baris perintah berikut setara:

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

  3. Ganti kode yang membuat perintah root dan perintah read dengan kode berikut:

    RootCommand rootCommand = new("Sample app for System.CommandLine");
fileOption.Recursive = true;
rootCommand.Options.Add(fileOption);

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

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

Command deleteCommand = new("delete", "Delete lines from the file.");
deleteCommand.Options.Add(searchTermsOption);
quotesCommand.Subcommands.Add(deleteCommand);

Command addCommand = new("add", "Add an entry to the file.");
addCommand.Arguments.Add(quoteArgument);
addCommand.Arguments.Add(bylineArgument);
addCommand.Aliases.Add("insert");
quotesCommand.Subcommands.Add(addCommand);

    Kode ini membuat perubahan berikut:

    • Menghapus opsi --file dari perintah read.

    • Menambahkan opsi --file sebagai opsi rekursif ke perintah root.

    • Membuat perintah quotes dan menambahkannya ke perintah root.

    • Menambahkan perintah read ke perintah quotes alih-alih ke perintah root.

    • Membuat perintah add dan delete dan menambahkannya ke perintah quotes.

    Hasilnya adalah hierarki perintah berikut:

    Perintah root └──quotes └──read └──add └──delete

    Aplikasi sekarang menerapkan pola yang direkomendasikan di mana perintah induk (quotes) menentukan area atau grup, dan perintah turunannya (read, add, delete) adalah tindakan.

    Opsi rekursif diterapkan ke perintah dan secara rekursif ke sub-perintah. Karena --file ada di perintah root, perintah tersebut akan tersedia secara otomatis di semua sub-perintah aplikasi.

  4. Setelah kode SetAction, tambahkan kode SetAction baru untuk sub-perintah baru:

    deleteCommand.SetAction(parseResult => DeleteFromFile(
    parseResult.GetValue(fileOption),
    parseResult.GetValue(searchTermsOption)));

addCommand.SetAction(parseResult => AddToFile(
    parseResult.GetValue(fileOption),
    parseResult.GetValue(quoteArgument),
    parseResult.GetValue(bylineArgument))
    );

    Subperintah quotes tidak memiliki fungsi karena bukan merupakan perintah akhir dalam hierarki. Sub perintah read, add, dan delete adalah perintah akhir di bawah quotes, dan SetAction dipanggil untuk masing-masing.

  5. Tambahkan tindakan untuk add dan delete.

    internal static void DeleteFromFile(FileInfo file, string[] searchTerms)
{
    Console.WriteLine("Deleting from file");

    var lines = File.ReadLines(file.FullName).Where(line => searchTerms.All(s => !line.Contains(s)));
    File.WriteAllLines(file.FullName, lines);
}
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}");
}

Aplikasi yang sudah selesai terlihat seperti ini:

using System.CommandLine;

namespace scl;

class Program
{
    static int Main(string[] args)
    {
        Option<FileInfo> fileOption = new("--file")
        {
            Description = "An option whose argument is parsed as a FileInfo",
            Required = true,
            DefaultValueFactory = result =>
            {
                if (result.Tokens.Count == 0)
                {
                    return new FileInfo("sampleQuotes.txt");

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

        Option<int> delayOption = new("--delay")
        {
            Description = "Delay between lines, specified as milliseconds per character in a line",
            DefaultValueFactory = parseResult => 42
        };
        Option<ConsoleColor> fgcolorOption = new("--fgcolor")
        {
            Description = "Foreground color of text displayed on the console",
            DefaultValueFactory = parseResult => ConsoleColor.White
        };
        Option<bool> lightModeOption = new("--light-mode")
        {
            Description = "Background color of text displayed on the console: default is black, light mode is white"
        };

        Option<string[]> searchTermsOption = new("--search-terms")
        {
            Description = "Strings to search for when deleting entries",
            Required = true,
            AllowMultipleArgumentsPerToken = true
        };
        Argument<string> quoteArgument = new("quote")
        {
            Description = "Text of quote."
        };
        Argument<string> bylineArgument = new("byline")
        {
            Description = "Byline of quote."
        };

        RootCommand rootCommand = new("Sample app for System.CommandLine");
        fileOption.Recursive = true;
        rootCommand.Options.Add(fileOption);

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

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

        Command deleteCommand = new("delete", "Delete lines from the file.");
        deleteCommand.Options.Add(searchTermsOption);
        quotesCommand.Subcommands.Add(deleteCommand);

        Command addCommand = new("add", "Add an entry to the file.");
        addCommand.Arguments.Add(quoteArgument);
        addCommand.Arguments.Add(bylineArgument);
        addCommand.Aliases.Add("insert");
        quotesCommand.Subcommands.Add(addCommand);

        readCommand.SetAction(parseResult => ReadFile(
            parseResult.GetValue(fileOption),
            parseResult.GetValue(delayOption),
            parseResult.GetValue(fgcolorOption),
            parseResult.GetValue(lightModeOption)));

        deleteCommand.SetAction(parseResult => DeleteFromFile(
            parseResult.GetValue(fileOption),
            parseResult.GetValue(searchTermsOption)));

        addCommand.SetAction(parseResult => AddToFile(
            parseResult.GetValue(fileOption),
            parseResult.GetValue(quoteArgument),
            parseResult.GetValue(bylineArgument))
            );

        return rootCommand.Parse(args).Invoke();
    }

    internal static void ReadFile(FileInfo file, int delay, ConsoleColor fgColor, bool lightMode)
    {
        Console.BackgroundColor = lightMode ? ConsoleColor.White : ConsoleColor.Black;
        Console.ForegroundColor = fgColor;
        foreach (string line in File.ReadLines(file.FullName))
        {
            Console.WriteLine(line);
            Thread.Sleep(TimeSpan.FromMilliseconds(delay * line.Length));
        }
    }
    internal static void DeleteFromFile(FileInfo file, string[] searchTerms)
    {
        Console.WriteLine("Deleting from file");

        var lines = File.ReadLines(file.FullName).Where(line => searchTerms.All(s => !line.Contains(s)));
        File.WriteAllLines(file.FullName, lines);
    }
    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}");
    }
}

Bangun proyek, lalu coba perintah berikut.

Kirim file yang tidak eksis ke --file dengan perintah read, dan Anda mendapatkan pesan kesalahan, bukan pengecualian dan pelacakan tumpukan.

scl quotes read --file nofile

File does not exist

Jika Anda mencoba menjalankan sub-perintah quotes, Anda mendapatkan pesan yang mengarahkan Anda untuk menggunakan read, , addatau 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.

Jalankan sub-perintah add, lalu lihat akhir file teks untuk melihat teks yang ditambahkan:

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

Jalankan subperintah delete dengan string pencarian dari awal file, lalu lihat bagian awal file teks untuk melihat di mana teks dihapus:

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

Nota

File dalam folder output mencerminkan perubahan dari perintah add dan delete. Salinan file dalam folder proyek tetap tidak berubah.

Langkah berikutnya

Dalam tutorial ini, Anda membuat aplikasi baris perintah sederhana yang menggunakan System.CommandLine. Untuk mempelajari selengkapnya tentang pustaka, lihat gambaran umum System.CommandLine. Untuk mengaktifkan kemampuan penyelesaian tab, lihat Penyelesaian tab untuk System.CommandLine.

  • Last updated on