Aracılığıyla paylaş

Söz dizimine genel bakış: Komutlar, seçenekler ve argümanlar

Bu makale, System.CommandLine tarafından tanınan komut satırı söz dizimini açıklar. Bilgiler, .NET CLI dahil olmak üzere .NET komut satırı uygulamalarının hem kullanıcıları hem de geliştiricileri için yararlıdır.

Tokenlar

System.CommandLine komut satırı girişini, boşluklarla ayrılmış dizeler olan belirteçler halinde ayrıştırır. Örneğin, aşağıdaki komut satırını göz önünde bulundurun:

dotnet tool install dotnet-suggest --global --verbosity quiet

Bu giriş, uygulama tarafından dotnet belirteçler tool, , install, dotnet-suggest--global, --verbosityve quietiçine ayrıştırılır.

Belirteçler komut, seçenek veya bağımsız değişken olarak yorumlanır. Çağrılan komut satırı uygulaması, ilk belirteçlerden sonraki belirteçlerin nasıl yorumlandığını belirler. Aşağıdaki tablo, System.CommandLine'ın önceki örneği nasıl yorumladığını göstermektedir.

Jeton Olarak ayrıştırıldı
tool Altkomut
install Altkomut
dotnet-suggest Kurulum komutu için argüman
--global Yükleme komutu seçeneği
--verbosity Yükleme komutu seçeneği
quiet --verbosity seçeneği için argüman

Bir belirteç, tırnak işaretleri (") içine alınmışsa boşluklar içerebilir. İşte bir örnek:

dotnet tool search "ef migrations add"

Sembol hiyerarşisi (komutlar, seçenekler, bağımsız değişkenler) güvenilir giriş olarak kabul edilir; belirteç değerleri değildir.

Komutlar

Komut satırı girişindeki komut , bir eylemi belirten veya ilgili eylemler grubunu tanımlayan bir belirteçtir. Örneğin:

  • içinde dotnet run, run eylemi belirten bir komutdur.
  • dotnet tool install içindeinstall, bir eylemi belirten bir komut ve tool ilgili komutlardan oluşan bir grubu belirten bir komut. tool uninstall, tool list ve tool update gibi araçla ilgili başka komutlar da vardır.

Kök komutu

Kök komutu, uygulamanın yürütülebilir dosyasının adını belirten komutdur . Örneğin, dotnet komut dotnet.exe çalıştırılabilir dosyayı belirtir.

Command herhangi bir komut veya alt komutun genel amaçlı sınıfıdır, ancak RootCommand uygulamanın kök giriş noktası için tasarlanmış özel bir sürümdür. RootCommand tüm özelliklerini Command devralır ancak Köke özgü davranışı ve Yardım seçeneği, Sürüm seçeneği ve Öneri yönergesi gibi varsayılanları ekler.

Alt Komutlar

Komut satırı uygulamalarının çoğu fiil olarak da bilinen alt komutları destekler. Örneğin, dotnet komutunun, run girerek çağırdığınız bir dotnet run alt komutu vardır.

Alt komutların kendi alt komutları olabilir. dotnet tool install içinde, installtool'nin bir alt komutudur.

Aşağıdaki örnekte gösterildiği gibi alt komutları ekleyebilirsiniz:

RootCommand rootCommand = new();

Command sub1Command = new("sub1", "First-level subcommand");
rootCommand.Subcommands.Add(sub1Command);

Command sub1aCommand = new("sub1a", "Second level subcommand");
sub1Command.Subcommands.Add(sub1aCommand);

Bu örnekteki en içteki alt komut şu şekilde çağrılabilir:

myapp sub1 sub1a

Seçenekler

Seçenek, bir komuta geçirilebilen adlandırılmış bir parametredir. POSIX CLI'ler genellikle seçenek adının önüne iki kısa çizgi () ekler--. Aşağıdaki örnekte iki seçenek gösterilmektedir:

dotnet tool update dotnet-suggest --verbosity quiet --global
                                  ^---------^       ^------^

Bu örnekte gösterildiği gibi, seçeneğin değeri açık (quiet için --verbosity) veya örtük olabilir (aşağıda --globalhiçbir şey yoktur). Değeri belirtilmemiş seçenekler genellikle seçenek komut satırında belirtilirse varsayılan true olarak Boole parametreleridir.

Bazı Windows komut satırı uygulamalarında, bir seçeneği, seçenek adının önüne bir eğik çizgi (/) ekleyerek tanımlarsınız. Örneğin:

msbuild /version
        ^------^

System.CommandLine hem POSIX hem de Windows ön ek kurallarını destekler.

Bir seçeneği yapılandırırken, ön ekini içeren seçenek adını belirtirsiniz:

Option<int> delayOption = new("--delay", "-d")
{
    Description = "An option whose argument is parsed as an int",
    DefaultValueFactory = parseResult => 42,
};
Option<string> messageOption = new("--message", "-m")
{
    Description = "An option whose argument is parsed as a string"
};

RootCommand rootCommand = new();
rootCommand.Options.Add(delayOption);
rootCommand.Options.Add(messageOption);

Genel seçenekler

Bir komuta ve alt komutlarının tümüne tekrarlı olarak seçenek eklemek için Recursive özelliğini true olarak ayarlayın. Bu, ayrıntı düzeyi, çıkış biçimi veya yapılandırma dosyası yolları gibi uygulamanızın tamamında geçerli olan seçenekler için kullanışlıdır.

Aşağıdaki örnekte tüm komutlar için kullanılabilen genel bir seçeneğin nasıl oluşturulacağı gösterilmektedir:

static void GlobalOptionExample(string[] args)
{
    // Create a global option that applies to all commands.
    Option<bool> verboseOption = new("--verbose", "-v")
    {
        Description = "Show verbose output",
        Recursive = true
    };

    RootCommand rootCommand = new("Sample app demonstrating global options");
    rootCommand.Options.Add(verboseOption);

    Command buildCommand = new("build", "Build the project");
    Command testCommand = new("test", "Run tests");

    rootCommand.Subcommands.Add(buildCommand);
    rootCommand.Subcommands.Add(testCommand);

    buildCommand.SetAction(parseResult =>
    {
        bool isVerbose = parseResult.GetValue(verboseOption);
        Console.WriteLine($"Building project... (verbose: {isVerbose})");
    });

    testCommand.SetAction(parseResult =>
    {
        bool isVerbose = parseResult.GetValue(verboseOption);
        Console.WriteLine($"Running tests... (verbose: {isVerbose})");
    });

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

Bu örnekte, --verbose seçeneği, her birine ayrı ayrı eklemek zorunda kalmadan build ve test komutlarında kullanılabilir.

Ayrıntı seçeneği

Birçok komut satırı uygulaması, görüntülenen çıktı miktarını denetleme seçeneği sağlar --verbosity . Tasarım kılavuzu beş standart ayrıntı düzeyi önerir: Q[uiet], M[inimal], N[ormal], D[etailed]ve Diag[nostic].

Aşağıdaki örnekte hem tam hem de kısaltılmış adları kabul eden ve bir diğer adı (-v) olan ayrıntı seçeneğinin nasıl uygulandığı gösterilmektedir. Değer olmadan belirtildiğinde -v , varsayılan olarak tasarım yönergelerini izleyen tanılama ayrıntı düzeyine ayarlanır. Örnek ayrıca --verbosity quiet için bir kısaltma seçeneği (-q) içerir:

static void VerbosityOptionExample(string[] args)
{
    // Create verbosity option that accepts full and short names as strings.
    // -v without an argument defaults to diagnostic.
    Option<string> verbosityOption = new("--verbosity", "-v")
    {
        Description = "Output verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].",
        Recursive = true,
        Arity = ArgumentArity.ZeroOrOne,
        DefaultValueFactory = result =>
            {
                // This runs only when the option isn't specified at all.
                // If the option is specified without a value (for example, `-v`),
                // DefaultValueFactory isn't called and the value is an empty string,
                // which is handled later when mapping to "diagnostic".
                return "normal";
            }
    };

    // Add -q as a separate option for quiet verbosity.
    Option<bool> quietOption = new("-q")
    {
        Description = "Set verbosity to quiet (shorthand for --verbosity quiet)",
        Recursive = true
    };

    // Handle both short and long forms.
    verbosityOption.Validators.Add(result =>
    {
        if (result.Tokens.Count == 0)
        {
            return; // Allow default value.
        }

        string value = result.Tokens.Single().Value.ToLowerInvariant();
        string[] validValues = new[] { "quiet", "q", "minimal", "m", "normal", "n", "detailed", "d", "diagnostic", "diag" };

        if (!validValues.Contains(value))
        {
            result.AddError($"Argument '{value}' not recognized. Must be one of: 'q[uiet]', 'm[inimal]', 'n[ormal]', 'd[etailed]', 'diag[nostic]'");
        }
    });

    RootCommand rootCommand = new("Sample app with verbosity");
    rootCommand.Options.Add(verbosityOption);
    rootCommand.Options.Add(quietOption);

    Command processCommand = new("build", "Build the project");
    rootCommand.Subcommands.Add(processCommand);

    processCommand.SetAction(parseResult =>
    {
        string verbosityString;

        // Check if -q was specified.
        if (parseResult.GetValue(quietOption))
        {
            verbosityString = "quiet";
        }
        else
        {
            verbosityString = parseResult.GetValue(verbosityOption);

            // If the option was specified without an argument,
            // the value will be empty string.
            // Set it to diagnostic as per design guidance.
            if (string.IsNullOrEmpty(verbosityString))
            {
                verbosityString = "diagnostic";
            }
        }

        // Convert string to enum.
        VerbosityLevel verbosity = verbosityString switch
        {
            "quiet" or "q" => VerbosityLevel.Quiet,
            "minimal" or "m" => VerbosityLevel.Minimal,
            "normal" or "n" => VerbosityLevel.Normal,
            "detailed" or "d" => VerbosityLevel.Detailed,
            "diagnostic" or "diag" => VerbosityLevel.Diagnostic,
            _ => VerbosityLevel.Normal
        };

        Console.WriteLine($"Verbosity level: {verbosity}");
    });

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

enum VerbosityLevel
{
    Quiet,
    Minimal,
    Normal,
    Detailed,
    Diagnostic
}

Uygulamayı şu komut satırlarından herhangi biriyle çağırabilirsiniz:

myapp build -q
myapp build -v
myapp build --verbosity minimal
myapp build --verbosity m
myapp build

Gerekli seçenekler

Bazı seçeneklerde zorunlu argümanlar vardır. Örneğin, .NET CLI'da --output bir klasör adı argümanı gerektirir. Bağımsız değişken sağlanmazsa, komut başarısız olur. Bir seçeneğin gerekli olmasını sağlamak için, aşağıdaki örnekte gösterildiği gibi özelliğini Requiredolarak ayarlayıntrue:

Option<FileInfo> fileOption = new("--output")
{
    Required = true
};

Gerekli bir seçeneğin varsayılan değeri varsa (özelliğiyle DefaultValueFactory belirtilir), seçeneğin komut satırında belirtilmesi gerekmez. Bu durumda, varsayılan değer gerekli seçenek değerini sağlar.

Tartışmalar

Bağımsız değişken, bir komuta aktarılabilen isimsiz bir parametredir. Aşağıdaki örnek, build komutu için bir argüman göstermektedir.

dotnet build myapp.csproj
             ^----------^

Bir bağımsız değişkeni yapılandırırken bağımsız değişken adını belirtirsiniz (ayrıştırma için kullanılmaz, ancak ada göre ayrıştırılan değerleri almak veya yardım görüntülemek için kullanılabilir) ve şunu yazın:

Argument<int> delayArgument = new("delay")
{
    Description = "An argument that is parsed as an int.",
    DefaultValueFactory = parseResult => 42
};
Argument<string> messageArgument = new("message")
{
    Description = "An argument that is parsed as a string."
};

RootCommand rootCommand = new();
rootCommand.Arguments.Add(delayArgument);
rootCommand.Arguments.Add(messageArgument);

Varsayılan değerler

Hem bağımsız değişkenler hem de seçenekler, herhangi bir bağımsız değişken açıkça sağlanmazsa geçerli olan varsayılan değerlere sahip olabilir. Örneğin, birçok seçenek, seçenek adları komut satırında bulunduğunda, varsayılan değeri true olan örtük Boolean parametreleridir. Aşağıdaki komut satırı örnekleri eşdeğerdir:

dotnet tool update dotnet-suggest --global
                                  ^------^

dotnet tool update dotnet-suggest --global true
                                  ^-----------^

Varsayılan değer olmadan tanımlanan bir bağımsız değişken, gerekli bağımsız değişken olarak değerlendirilir.

Hataları ayrıştırma

Seçenekler ve bağımsız değişkenler beklenen türlere sahiptir ve değer ayrıştırılamayınca bir hata oluşturulur. Örneğin, silent geçerli değerlerden biri olmadığı için aşağıdaki komut hatası verir: --verbosity

dotnet build --verbosity silent

Option<string> verbosityOption = new("--verbosity", "-v")
{
    Description = "Set the verbosity level",
};
verbosityOption.AcceptOnlyFromAmong("quiet", "minimal", "normal", "detailed", "diagnostic");
RootCommand rootCommand = new() { verbosityOption };

ParseResult parseResult = rootCommand.Parse(args);
foreach (ParseError parseError in parseResult.Errors)
{
    Console.WriteLine(parseError.Message);
}

Argument 'silent' not recognized. Must be one of:
        'quiet'
        'minimal'
        'normal'
        'detailed'
        'diagnostic'

Bağımsız değişkenlerin kaç değer sağlanabileceği konusunda da beklentileri vardır. Örnekler, argüman arity bölümü içinde verilmiştir.

Seçeneklerin ve argümanların sırası

Komut satırında, bağımsız değişkenlerden önce seçenekler veya seçeneklerden önce bağımsız değişkenler sağlayabilirsiniz. Aşağıdaki komutlar eşdeğerdir:

dotnet add package System.CommandLine --no-restore
dotnet add package --no-restore System.CommandLine

Seçenekler herhangi bir sırada belirtilebilir. Aşağıdaki komutlar eşdeğerdir:

dotnet add package System.CommandLine --no-restore --source https://api.nuget.org/v3/index.json
dotnet add package System.CommandLine --source https://api.nuget.org/v3/index.json --no-restore

Birden çok parametre olduğunda sıra önemlidir. Aşağıdaki komutlar eşdeğer değildir; değerlerin sırasına göre farklılık gösterir ve bu da farklı sonuçlara yol açabilir:

myapp argument1 argument2
myapp argument2 argument1

Takma Adlar

Hem POSIX hem de Windows'ta bazı komutların ve seçeneklerin diğer adlara sahip olması yaygındır. Bunlar genellikle yazması daha kolay olan kısa formlardır. Diğer adlar, büyük/küçük harfe duyarsızlığın benzetimini yapmak ve bir sözcüğün alternatif yazımını desteklemek gibi başka amaçlar için de kullanılabilir.

POSIX kısa formlarının genellikle başında tek bir kısa çizgi ve ardından tek bir karakter bulunur. Aşağıdaki komutlar eşdeğerdir:

dotnet build --verbosity quiet
dotnet build -v quiet

GNU standardı otomatik takma adları önermektedir. Başka bir ifadeyle, uzun formlu bir komutun veya seçenek adının herhangi bir bölümünü girebilirsiniz ve kabul edilir. Bu davranış aşağıdaki komut satırlarını eşdeğer hale getirir:

dotnet publish --output ./publish
dotnet publish --outpu ./publish
dotnet publish --outp ./publish
dotnet publish --out ./publish
dotnet publish --ou ./publish
dotnet publish --o ./publish

System.CommandLine otomatik takma adları desteklemez. Her takma ad açıkça belirtilmelidir. Hem komutlar hem de seçenekler bir Aliases özelliğini kullanıma sunar. Option , diğer adları parametre olarak kabul eden bir oluşturucuya sahiptir, böylece tek bir satırda birden çok diğer ad içeren bir seçenek tanımlayabilirsiniz:

Option<bool> helpOption = new("--help", ["-h", "/h", "-?", "/?"]);
Command command = new("serialize") { helpOption };
command.Aliases.Add("serialise");

Tanımladığınız seçenek diğer adlarının sayısını en aza indirmenizi ve özellikle belirli diğer adları tanımlamaktan kaçınmanızı öneririz. Daha fazla bilgi için bkz. Kısa form takma adlar.

Büyük/küçük harf duyarlılığı

Komut ve seçenek adları ve diğer adları POSIX kuralına göre varsayılan olarak büyük/küçük harfe duyarlıdır ve System.CommandLine bu kuralı izler. CLI'nizin harf duyarsız olmasını istiyorsanız, çeşitli büyük/küçük harf alternatifleri için takma adlar tanımlayın. Örneğin, --additional-probing-path'ün --Additional-Probing-Path ve --ADDITIONAL-PROBING-PATH gibi adları olabilir.

Bazı komut satırı araçlarında, büyük/küçük harf farkı işlevdeki farkı belirtebilir. Örneğin, git clean -X değerinden git clean -xfarklı davranır. .NET CLI'nin tümü küçük harftir.

Büyük/küçük harf duyarlılığı, sabit listeleri temel alan seçenekler için bağımsız değişken değerlerine uygulanmaz. Enum adları büyük/küçük harfe bakılmaksızın eşleştirilir.

Belirteç --

POSIX kuralı, çift çizgili (--) belirteci bir kaçış mekanizması olarak yorumlar. Çift çizgi belirtecinden sonra gelen her şey, komutun argümanları olarak yorumlanır. Bu işlev, seçenekler gibi görünen bağımsız değişkenleri göndermek için kullanılabilir, çünkü bunların seçenek olarak yorumlanmasını önler.

Myapp'in bir message argüman aldığını ve message değerinin --interactive olmasını istediğinizi varsayalım. Aşağıdaki komut satırı beklenmeyen sonuçlar verebilir.

myapp --interactive

Eğer myapp bir --interactive seçeneğine sahip değilse, --interactive belirteci bir bağımsız değişken olarak yorumlanır. Ancak uygulamanın bir --interactive seçeneği varsa, bu giriş bu seçeneğe başvuru olarak yorumlanır.

Aşağıdaki komut satırı, message bağımsız değişkeninin değerini "--interactive" olarak ayarlamak için çift tire belirtecini kullanır:

myapp -- --interactive
      ^^

System.CommandLine bu çift çizgi işlevselliğini destekler.

Seçenek ve bağımsız değişken ayraçları

System.CommandLine bir seçenek adı ile bağımsız değişkeni arasında sınırlayıcı olarak boşluk, '=' veya ':' kullanmanıza olanak tanır. Örneğin, aşağıdaki komutlar eşdeğerdir:

dotnet build -v quiet
dotnet build -v=quiet
dotnet build -v:quiet

POSIX kuralı, tek karakterlik bir seçenek diğer adı belirtirken sınırlayıcıyı atlamanıza olanak tanır. Örneğin, aşağıdaki komutlar eşdeğerdir:

myapp -vquiet
myapp -v quiet

System.CommandLine varsayılan olarak bu söz dizimlerini destekler.

Bağımsız değişken sayısı

Bir seçeneğin veya komutun argümanlarının aritesi, bu seçenek veya komut belirtildiğinde geçirilebilecek değerlerin sayısını ifade eder.

Arity, aşağıdaki tabloda gösterildiği gibi en düşük değer ve en yüksek değerle ifade edilir:

Dakika Maks Örnek geçerlilik Örnek
0 0 Geçerli: --dosya
Geçersiz: --file a.json
Geçersiz: --file a.json --file b.json
0 1 Geçerli: --bayrak
Geçerli: --flag true
Geçerli: --bayrak false
Geçersiz: --flag false --flag false
1 1 Geçerli: --file a.json
Geçersiz: --dosya
Geçersiz: --file a.json --file b.json
0 n Geçerli: --dosya
Geçerli: --file a.json
Geçerli: --file a.json --file b.json
1 n Geçerli: --file a.json
Geçerli: --file a.json b.json
Geçersiz: --dosya

System.CommandLine arity tanımlamak için aşağıdaki değerlere sahip bir ArgumentArity yapısına sahiptir.

  • Zero - Hiçbir değere izin verilmez.
  • ZeroOrOne - Bir değere sahip olabilir veya hiç değer olamaz.
  • ExactlyOne - Tek bir değere sahip olmalıdır.
  • ZeroOrMore - Bir değere, birden çok değere veya değere sahip olamaz.
  • OneOrMore - Birden çok değere sahip olabilir; en az bir değere sahip olmalıdır.

özelliğini kullanarak Arity açıkça arity ayarlayabilirsiniz, ancak çoğu durumda bu gerekli değildir. System.CommandLine bağımsız değişken türünü temel alarak bağımsız değişken arity değerini otomatik olarak belirler:

Bağımsız değişken türü Varsayılan değer
Boolean ArgumentArity.ZeroOrOne
Koleksiyon türleri ArgumentArity.ZeroOrMore
Diğer her şey ArgumentArity.ExactlyOne

Seçenek geçersiz kılmaları

Maksimum değer 1 ise, System.CommandLine yine de bir seçeneğin birden çok örneğini kabul etmek üzere yapılandırılabilir. Bu durumda, yinelenen bir seçeneğin son örneği önceki örneklerin yerini alır. Aşağıdaki örnekte, 2 değeri myapp komutuna aktarılır.

myapp --delay 3 --message example --delay 2

Birden çok bağımsız değişken

Varsayılan olarak, bir komutu çağırdığınızda, bir seçenek adını yineleyerek maksimum arity değeri birden fazla olan bir seçenek için birden çok bağımsız değişken belirtebilirsiniz.

myapp --items one --items two --items three

Çoklu bağımsız değişkene izin vermek için seçenek ismini tekrar etmek zorunda kalmadan AllowMultipleArgumentsPerToken'yi true olarak ayarlayın. Bu ayar aşağıdaki komut satırını girmenizi sağlar.

myapp --items one two three

Maksimum bağımsız değişken sayısı 1 olduğunda, aynı ayar farklı bir etkiye sahip olur. Bir seçeneği yinelemenize olanak tanır, ancak satırdaki yalnızca son değeri alır. Aşağıdaki örnekte, değer three uygulamaya geçirilir.

myapp --item one --item two --item three

Seçenek paketleme

POSIX, yığınlama olarak da bilinen tek karakterli seçeneklerin paketlemesini desteklemenizi önerir. Paketlenmiş seçenekler, tek tire ön eki sonrasında birleşik olarak belirtilen tek karakterli seçenek takma adlarıdır. Yalnızca son seçenek bir bağımsız değişken belirtebilir. Örneğin, aşağıdaki komut satırları eşdeğerdir:

git clean -f -d -x
git clean -fdx

Bir seçenek paketi sonrası bir bağımsız değişken sağlanırsa, bu bağımsız değişken paketteki son seçeneğe uygulanır. Aşağıdaki komut satırları eşdeğerdir:

myapp -a -b -c arg
myapp -abc arg

Bu örnekteki her iki durumda da bağımsız değişken arg, yalnızca seçenek -c için uygulanır.

Boole seçenekleri (bayraklar)

true veya false, bool bağımsız değişkeni olan bir seçenek için geçilirse, beklendiği gibi ayrıştırılır. Ancak bağımsız değişken türü bool olan bir seçenek genellikle bir bağımsız değişken belirtmeye gerek duymaz. Bazen "bayraklar" olarak da adlandırılan Boole seçeneklerinin genellikle arity'si ZeroOrOne olur. Komut satırında seçenek adının varlığı, onu izleyen bağımsız değişken olmadan varsayılan değerini verir true. Komut satırı girişinde seçenek adının olmaması değerini verir false. Eğer myapp komutu --interactive adlı bir Boole seçeneğinin değerini yazdırıyorsa, aşağıdaki giriş aşağıdaki çıkışı oluşturur:

myapp
myapp --interactive
myapp --interactive false
myapp --interactive true

False
True
False
True

Sürüm seçeneği

Üzerinde System.CommandLine oluşturulan uygulamalar, kök komutuyla kullanılan seçeneğe --version yanıt olarak sürüm numarasını otomatik olarak sağlar. Örneğin:

dotnet --version

6.0.100

Yanıt dosyaları

Yanıt dosyası, komut satırı uygulaması için belirteç kümesi içeren bir dosyadır. Yanıt dosyaları, iki senaryoda yararlı olan bir özelliğidir System.CommandLine :

  • Terminalin karakter sınırından daha uzun bir giriş belirterek bir komut satırı uygulaması çağırmak için.
  • Satırın tamamını yeniden oluşturmadan aynı komutu art arda çağırmak için.

Yanıt dosyası kullanmak için, satıra komutları, seçenekleri ve bağımsız değişkenleri eklemek istediğiniz her yere, @ işareti ön eklenmiş dosya adını girin. .rsp dosya uzantısı yaygın bir kuraldır, ancak herhangi bir dosya uzantısını kullanabilirsiniz.

Aşağıdaki satırlar eşdeğerdir:

dotnet build --no-restore --output ./build-output/
dotnet @sample1.rsp
dotnet build @sample2.rsp --output ./build-output/

sample1.rsp içeriği:

build
--no-restore
--output
./build-output/

sample2.rsp içeriği:

--no-restore

Yanıt dosyasındaki metnin nasıl yorumlandığını belirleyen söz dizimi kuralları şunlardır:

  • Belirteçler boşluklarla sınırlandırılır. Günaydın! içeren bir satır iki belirteç olarak değerlendirilir: İyi ve sabah!.
  • Tırnak içine alınmış çok sayıda belirteç, tek bir belirteç olarak yorumlanır. "Günaydın!" içeren bir satır, bir belirteç olarak ele alınır, Günaydın!.
  • Simge # ile satırın sonu arasındaki tüm metinler açıklama olarak değerlendirilir ve yoksayılır.
  • @ ön ekiyle başlayan belirteçler, ek yanıt dosyalarına başvurabilir.
  • Yanıt dosyasında birden çok metin satırı olabilir. Satırlar birleştirilip bir belirteç dizisi olarak yorumlanır.

Yönergeler

System.CommandLine türüyle temsil edilen yönerge olarak adlandırılan bir sözdizimi öğesi tanıtır Directive . Örneğin,[diagram] yönergesi yerleşik bir yönergedir. Uygulamanın adından sonra eklediğinizde [diagram] , System.CommandLine komut satırı uygulamasını çağırmak yerine ayrıştırma sonucunun diyagramını görüntüler:

dotnet [diagram] build --no-restore --output ./build-output/
       ^-----^

[ dotnet [ build [ --no-restore <True> ] [ --output <./build-output/> ] ] ]

Yönergelerin amacı, komut satırı uygulamaları arasında uygulanabilecek çapraz kesme işlevleri sağlamaktır. Yönergeler, uygulamanın kendi söz diziminden farklı olduğu için, uygulamalar arasında geçerli olan işlevleri sağlayabilir.

Yönerge aşağıdaki söz dizimi kurallarına uymalıdır:

  • Komut satırında uygulama adından sonra gelen ancak alt komutlardan veya seçeneklerden önce gelen bir belirteçtir.
  • Kare parantez içine alınmış.
  • Boşluk içermez.

Tanınmayan yönerge ayrıştırma hatasına neden olmadan göz ardı edilir.

Yönerge, yönerge adından iki nokta ile ayrılmış bir bağımsız değişken içerebilir.

Aşağıdaki yönergeler yerleşik olarak bulunur:

[diagram] yönergesi

Hem kullanıcılar hem de geliştiriciler, bir uygulamanın belirli bir girişi nasıl yorumlayacaklarını görmek yararlı olabilir. Bir System.CommandLine uygulamanın varsayılan özelliklerinden biri, komut girişini ayrıştırma işleminin sonucunu önizlemenizi sağlayan yönergedir [diagram] . Örneğin:

myapp [diagram] --delay not-an-int --interactive --file filename.txt extra

![ myapp [ --delay !<not-an-int> ] [ --interactive <True> ] [ --file <filename.txt> ] *[ --fgcolor <White> ] ]   ???--> extra

Yukarıdaki örnekte:

  • Komutu (myapp), alt seçenekleri ve bu seçeneklerin bağımsız değişkenleri köşeli ayraçlar kullanılarak gruplandırılır.
  • seçenek sonucu [ --delay !<not-an-int> ]için , ! bir ayrıştırma hatası gösterir. Bir not-an-int seçeneğin değeri int beklenen türe ayrıştırılamaz. Hata, hata seçeneğini içeren komutun önündeki ! tarafından da işaretlenir: ![ myapp....
  • Seçenek sonucu *[ --fgcolor <White> ]için, seçenek komut satırında belirtilmedi, bu nedenle yapılandırılan varsayılan kullanıldı. White bu seçenek için geçerli değerdir. Yıldız işareti, değerin varsayılan değer olduğunu gösterir.
  • ???--> uygulama komutlarından veya seçeneklerinden hiçbirine eşleşmemiş girişi gösterir.

Öneri direktifi

Belirli [suggest] yönergesi, tam olarak hangi komut olduğunu bilmediğiniz durumlarda komutları aramanıza olanak tanır.

dotnet [suggest] buil

build
build-server
msbuild

Ayrıca bkz.

  • Last updated on