Nested options

[pnarimani]

Is it possible to have nested options?
For example:.

class O1
{
    [Option]
    public string Option1 { get; set; }
}
class O2
{
    [Option]
    public string Option2 { get; set; }

    [Option]
    public O1 Nested { get; set; }
}

Is it possible to parse O2?

[moh-hassan]

O1 is a custom Type and should have a constructor with string parameter.
To be supported, I modified your class as given below:

class O1
{   
    //[Option] //not allowed
    public string Option1 { get; set; } //it's filled from the O2.Nested option
	public O1 (string text)
	{
	  Option1=text;
	}
	
}
class O2
{
    [Option]
    public string Option2 { get; set; }

    [Option("nested")]
    public O1 Nested { get; set; } //O1 should have a constructor with only one string parameter
}

[hadzhiyski]

@moh-hassan What do you think about dot notation support?
This will allow to parse multiple nested options in a safe way.

Example:

myapp.exe --nested.option1 test

[moh-hassan]

@hadzhiyski
Dot notation for the command line isn't standard (GNU standard) as option names.
These types are not nested classes and can be considered as custom types and used as I explain in the previous comment.
Custom types are very valuable.

[weeco]

@moh-hassan Is there a reason why you could not support nested classes for command line parsing?

Once you have nested options classes (because you have lots of "namespaced cli arguments") you can literally not use this library anymore I think?

[moh-hassan]

@weeco
Nested classes/interfaces are supported, example:

 internal class C1
        {
            [Option]
            public string Option1 { get; set; }
        }
        internal class C2 : C1
        {
            [Option]
            public string Option2 { get; set; }
        }
        internal class C3 : C2
        {
            [Option]
            public string Option3 { get; set; }
        }

This commandline is working:

$ myapp --option1 xyz --option2 abc --option3 value3

[weeco]

@moh-hassan I am sorry I didn't mean nested classes in that sense. Here's what I've tried and which did not work:

As you can see in the screenshot I have a "root" class Options which contains some other options classes. When I tried to parse the arguments it did not recognize any options from the LogOptions or ServerOptions classes. Am I missing something here?

[moh-hassan]

ServiceOptions class is considered as a custom type for parser and should have a string constructor for parser to get the string argument. Parser don't inspect Attributes of `ServiceOptions' properties.

Custom types are working as I explained above

Modify options as below;

class Options
{
[Option("configPath")]
public string ConfigPath { get; set; }
[Option("loglevel")]
public LogOptions Logger { get; set; } //custom type, not a nested class and should have a ctor with string param
[Option("serverPort")]
public ServerOptions Server {get;set;}  //custom type, not a nested class
}

class LogOptions
{
public string LogOptionsValue;
 public LogOptions(string log)
 {
   LogOptionsValue=log;
 }
//[Option("loglevel")]  //attributes of custom types not supported
public LogLevel Level { get; set; } = Loglevel.Info;
}


class ServerOptions
{
//todo add ctor with string parameter 
//[Option("serverPort")]
public int Port { get; set; } = 3000;
}
enum Loglevel { Debug, Info, Warn, Error }

Then you can access the property of custom Type which is filled by the ctor.
Try it and let me know if this is working with you.