GMA.ArgumentsMarshalerLib 1.0.0

ArgumentReader

Description

With Argument Reader command line argumets can be passed into a .net core application. The standard project assist 4 types of argumnets:

• Boolean
• Strings (*)
• Integer (#)
• Doubles (##)

Own argument tyoes can be build with own classes. They need to inherit form the ArgumentMarshalerLib. Libraries are loading dynamicaly on startup. It is not necessary to recompile the complete solution.

Structure

Arguments paramenter = new Arguments("Path to Marshaler Liraries", "Schema", "Arugment Array")

Available Marshalers (Standards)

• BooleanMarshalerLib.dll
• StringMarsahlerLib.dll
• IntegerMarshalerLib.dll
• DoubleMarshalerLib.dll

Schema

1. Parameter name
2. Marshaler type

Example

Arguments parameter = new Arguments("...", "enabled, text*, number#, decimal##")

enabled b = parameter.GetValue<bool>("enabled") // false
text b = parameter.GetValue<string>("text") // false
number b = parameter.GetValue<int>("number") // false
decimal b = parameter.GetValue<double>("decimal") // false

Boolean:

Arguments.exe -a -b

static void Main(string[] args)
{
    parameter = new Arguments(@".\Marshaler", "a, b*", args);

    bool a = parameter.GetValue<bool>("a") // true
    bool b = parameter.GetValue<bool>("b") // false
    //...
}  

String:

Arguments.exe -a "This is a text"

static void Main(string[] args)
{
    parameter = new Arguments(@".\Marshaler", "a*", args);

    string a = parameter.GetValue<string>("a") // This is a Text
    //...
}  

Integer:

Arguments.exe -a 1234

static void Main(string[] args)
{
    parameter = new Arguments(@".\Marshaler", "a#", args);

    int a = parameter.GetValue<int>("a") // 1234
    //...
}  

Double:

Arguments.exe -a 123,456

static void Main(string[] args)
{
    parameter = new Arguments(@".\Marshaler", "a##", args);

    double a = parameter.GetValue<double>("a") // 123,456
    //...
}  

Build your own Marshaler

1. Create a new VisualStudio .net Standard Class (??MarshalerLib)
2. Link a new projekt reference to ArgumentMarshalerLib.dll (in this repository)
3. Write Marshaler (See example code below)
4. Copy the TestMarshalerLib.dll to the Marshaler directory in your project
5. Implement the ? in your schema (e.g "mymarshaler?")

public class TestMarshalerLib : ArgumentMarshalerLib.ArgumentMarshaler
    {
        // Only schemas allowed that are not used (string.empty, *, #, ## are already used form standard marshalers)
        public override string Schema => "?";

        public override void Set(Iterator<string> currentArgument)
        {
            try
            {
                // If implementation should be use an argument behind the command (e.g -a ??),
                // it is neccassary to move the Iterator to the nex position
                Value = currentArgument.Next();

            }
            catch (ArgumentOutOfRangeException)
            {
                throw new TestgMarshalerException(ErrorCode.MISSING);
            }
                // If no argument behind the command is used just add your value
                Value = "This is my personal marshaler";
        }

        public class TestgMarshalerException : ArgumentMarshalerLib.ArgumentsException
        {
            public TestgMarshalerException() { }

            public TestgMarshalerException(ErrorCode errorCode) : base(errorCode) { }

            public override string ErrorMessage()
            {
                switch (ErrorCode)
                {
                    case ErrorCode.MISSING:
                        return $"Could not find string parameter for -{ErrorArgumentId}";
                    default:
                        return string.Empty;
                }
            }
        }
    }

Reference

The original Argument Marshaler was written in Java and published by Robert c. Martin in his book Clean Code. This project adapt his implementation and extends it dynamically.