0x776d-ArgumentMarshalerLib 1.0.0

Argument Reader

Description:

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

• Boolean
• Strings (*)
• Integers (#)

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

Structure

Arguments parameter = new Arguments("SCHEMA", "ARGUMENT ARRAY", "PATH TO MARSHALER LIBRARIES");

Download all available Packages

Available Marshalers (Standard)

• BooleanMarshalerLib.dll
• StringMarshalerLib.dll
• IntegerMarshalerLib.dll

Schema

1. Parameter name
2. Marshaler type

Example

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

Parse Arguments

Boolean:

Arguments.exe -a

static void Main(string[] args)
{
Arguments parameter = new Arguments("a,b", args, @".\Marshaler");
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)
{
Arguments parameter = new Arguments("a*", args, @".\Marshaler");
string a = parameter.GetValue<string>("a");     // This is a Text
}

Integer:

Arguments.exe -a 1234

static void Main(string[] args)
{
Arguments parameter = new Arguments("a#", args, @".\Marshaler");
int a = parameter.GetValue<int>("a");     // 1234
}

Build your own Marshaler

1. Create a new VisualStudio .NET Standard Class Library (??MarshalerLib)
2. Link a new project reference 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?")

using ArgumentMarshalerLib;
using System;

namespace TestMarshalerLib
{
    public class TestArgumentMarshaler : ArgumentMarshaler
    {
        // Only Schemas allowed that are not used (string.Empty, *, # are already used from standard marshalers)
        public override string Schema => "?";

        public override void Set(Iterator<string> currentArgument)
        {
            try
            {
                // If Implementation should use an argument behind the command (e.g. -a "??")
                // it is necessary to move the Iterator to the next position
                Value = currentArgument.Next();
            }
            catch (ArgumentOutOfRangeException)
            {
                throw new TestArgumentMarshalerException(ErrorCode.MISSING);
            }

            // If no argument behind the command is used just add your value
            Value = "This is my personal number";
        }

        public class TestArgumentMarshalerException : ArgumentsException
        {
            public TestArgumentMarshalerException(ErrorCode errorCode) : base(errorCode) { }

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

References

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