Megosztás a következőn keresztül:

Elemzés és ellenőrzés testreszabása a(z) System.CommandLine -ben/-ban

Alapértelmezés szerint beépített elemzőket biztosít, System.CommandLine amelyek számos gyakori típust elemezhetnek:

  • bool
  • byte és sbyte
  • short és ushort
  • int és uint
  • long és ulong
  • float és double
  • decimal
  • DateTime és DateTimeOffset
  • DateOnlyés TimeOnly
  • Guid
  • FileSystemInfo, FileInfoés DirectoryInfo
  • felsorolási típusok
  • a felsorolt típusok tömbjei és listái

Más típusok nem támogatottak, de egyéni elemzőket is létrehozhat hozzájuk. Az elemzési értékeket is érvényesítheti, ami akkor hasznos, ha meg szeretné győződni arról, hogy a bemenet megfelel bizonyos feltételeknek.

Érvényesítők

Minden beállításnak, argumentumnak és parancsnak lehet egy vagy több érvényesítője. Az érvényesítők segítségével biztosítható, hogy az elemzési érték megfeleljen bizonyos feltételeknek. Ellenőrizheti például, hogy egy szám pozitív-e, vagy hogy egy sztring nem üres-e. Összetett érvényesítőket is létrehozhat, amelyek több feltételt is ellenőriznek.

Minden szimbólumtípushoz System.CommandLine tartozik egy Validators tulajdonság, amely az érvényesítők listáját tartalmazza. Az érvényesítők a bemenet elemzése után lesznek végrehajtva, és hibajelentést tehetnek, ha az ellenőrzés sikertelen.

Egyéni érvényesítési kód megadásához hívja meg System.CommandLine.Option.Validators.Add a beállítást vagy az argumentumot (vagy parancsot), ahogyan az alábbi példában látható:

Option<int> delayOption = new("--delay");
delayOption.Validators.Add(result =>
{
    if (result.GetValue(delayOption) < 1)
    {
        result.AddError("Must be greater than 0");
    }
});

System.CommandLine beépített érvényesítők készletét biztosítja, amelyek a gyakori típusok ellenőrzésére használhatók:

  • AcceptExistingOnly - a megadott beállítást vagy argumentumot úgy konfigurálja, hogy csak egy meglévő fájlnak vagy könyvtárnak megfelelő értékeket fogadjon el.
  • AcceptLegalFileNamesOnly - a megadott beállítást vagy argumentumot úgy konfigurálja, hogy csak a jogi fájlneveket képviselő értékeket fogadja el.
  • AcceptOnlyFromAmong - a megadott beállítást vagy argumentumot úgy konfigurálja, hogy csak egy megadott értékkészlet értékeit fogadja el.

Egyéni elemzők

Az alapértelmezett elemző nélküli típusok( például összetett típusok) elemzéséhez egyéni elemzőre van szükség. Az egyéni elemzők a támogatott típusok más módon történő elemzésére is használhatók, mint a beépített elemzők.

Tegyük fel, hogy van egy Person típusa:

public class Person
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
}

Elolvashatja az értékeket, és létrehozhat egy példányt Person a parancsműveletben:

rootCommand.SetAction(parseResult =>
{
    Person person = new()
    {
        FirstName = parseResult.GetValue(firstNameOption),
        LastName = parseResult.GetValue(lastNameOption)
    };
    DoRootCommand(parseResult.GetValue(fileOption), person);
});

Testreszabott elemzővel ugyanúgy hozzáférhet egy testreszabott típushoz, mint a primitív értékekhez.

Option<Person?> personOption = new("--person")
{
    Description = "An option whose argument is parsed as a Person",
    CustomParser = result =>
    {
        if (result.Tokens.Count != 2)
        {
            result.AddError("--person requires two arguments");
            return null;
        }
        return new Person
        {
            FirstName = result.Tokens.First().Value,
            LastName = result.Tokens.Last().Value
        };
    }
};

Ha elemezni és ellenőrizni szeretné a bemenetet, használja a CustomParser delegáltat az alábbi példában látható módon:

Option<int> delayOption = new("--delay")
{
    Description = "An option whose argument is parsed as an int.",
    CustomParser = result =>
    {
        if (!result.Tokens.Any())
        {
            return 42;
        }

        if (int.TryParse(result.Tokens.Single().Value, out var delay))
        {
            if (delay < 1)
            {
                result.AddError("Must be greater than 0");
            }
            return delay;
        }
        else
        {
            result.AddError("Not an int.");
            return 0; // Ignored.
        }
    }
};

Íme néhány példa arra, hogy mit tehet a CustomParser-vel, amit egy érvényesítővel nem lehet megtenni:

  • Más típusú bemeneti sztringek feldolgozása (például az "1,2,3" értelmezése int[] formátumba).
  • Dinamikus aritás. Ha például két argumentumot definiál sztringtömbként, és a parancssori bemenetben sztringsorozatot kell kezelnie, a System.CommandLine.Parsing.ArgumentResult.OnlyTake metódus lehetővé teszi a bemeneti sztringek dinamikus felosztását az argumentumok között.

Lásd még

  • Last updated on