Så här använder du mellanprogram i System.CommandLine

Viktigt!

System.CommandLine är för närvarande i förhandsversion och den här dokumentationen är för version 2.0 beta 4. Viss information gäller förhandsversionsprodukt som kan ändras avsevärt innan den släpps. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Den här artikeln beskriver hur du arbetar med mellanprogram i kommandoradsappar som skapas med System.CommandLine biblioteket. Användning av mellanprogram är ett avancerat ämne som de flesta System.CommandLine användare inte behöver tänka på.

Introduktion till mellanprogram

Varje kommando har en hanterare som System.CommandLine dirigeras till baserat på indata, men det finns också en mekanism för att kortsluta eller ändra indata innan programlogiken anropas. Mellan parsning och anrop finns det en ansvarskedja som du kan anpassa. Ett antal inbyggda funktioner System.CommandLine för att använda den här funktionen. Så här anropar kortslutningsalternativen --help och --version till din hanterare.

Varje anrop i pipelinen kan vidta åtgärder baserat på ParseResult och returnera tidigt, eller välja att anropa nästa objekt i pipelinen. ParseResult Kan till och med ersättas under den här fasen. Det sista anropet i kedjan är hanteraren för det angivna kommandot.

Lägg till i pipelinen för mellanprogram

Du kan lägga till ett anrop till den här pipelinen genom att anropa CommandLineBuilderExtensions.AddMiddleware. Här är ett exempel på kod som möjliggör ett anpassat direktiv. När du har skapat ett rotkommando med namnet rootCommandlägger koden som vanligt till alternativ, argument och hanterare. Sedan läggs mellanprogrammet till:

var commandLineBuilder = new CommandLineBuilder(rootCommand);

commandLineBuilder.AddMiddleware(async (context, next) =>
{
    if (context.ParseResult.Directives.Contains("just-say-hi"))
    {
        context.Console.WriteLine("Hi!");
    }
    else
    {
        await next(context);
    }
});

commandLineBuilder.UseDefaults();
var parser = commandLineBuilder.Build();
await parser.InvokeAsync(args);

I föregående kod skriver mellanprogrammet ut "Hej!" om direktivet [just-say-hi] hittas i parsningsresultatet. När detta händer anropas inte kommandots normala hanterare. Det anropas inte eftersom mellanprogrammet inte anropar ombudet next .

I exemplet context är , InvocationContexten singleton-struktur som fungerar som "roten" för hela kommandohanteringsprocessen. Detta är den mest kraftfulla strukturen i System.CommandLine, när det gäller funktioner. Det finns två huvudsakliga användningsområden för det i mellanprogram:

• Den ger åtkomst till , BindingContextParser, Consoleoch HelpBuilder för att hämta beroenden som ett mellanprogram kräver för sin anpassade logik.
• Du kan ange InvocationResult egenskaperna eller ExitCode för att avsluta kommandobearbetningen på ett kortslutande sätt. Ett exempel är alternativet --help som implementeras på det här sättet.

Här är det fullständiga programmet, inklusive obligatoriska using direktiv.

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

class Program
{
    static async Task Main(string[] args)
    {
        var delayOption = new Option<int>("--delay");
        var messageOption = new Option<string>("--message");

        var rootCommand = new RootCommand("Middleware example");
        rootCommand.Add(delayOption);
        rootCommand.Add(messageOption);

        rootCommand.SetHandler((delayOptionValue, messageOptionValue) =>
            {
                DoRootCommand(delayOptionValue, messageOptionValue);
            },
            delayOption, messageOption);

        var commandLineBuilder = new CommandLineBuilder(rootCommand);

        commandLineBuilder.AddMiddleware(async (context, next) =>
        {
            if (context.ParseResult.Directives.Contains("just-say-hi"))
            {
                context.Console.WriteLine("Hi!");
            }
            else
            {
                await next(context);
            }
        });

        commandLineBuilder.UseDefaults();
        var parser = commandLineBuilder.Build();
        await parser.InvokeAsync(args);
    }

    public static void DoRootCommand(int delay, string message)
    {
        Console.WriteLine($"--delay = {delay}");
        Console.WriteLine($"--message = {message}");
    }
}

Här är ett exempel på en kommandorad och resulterande utdata från föregående kod:

myapp [just-say-hi] --delay 42 --message "Hello world!"

Hi!

Se även

System.CommandLine Översikt