CommandParameterParser

Sealed, type-based parser registry that converts string inputs into typed objects. Provides built-in parsers for int, float, and string, with an internal API for registering custom parsers.

Definition

Namespace: Paragon.Core.Command Assembly: Paragon.dll

public sealed class CommandParameterParser

Remarks

CommandParameterParser maintains a static Dictionary<Type, CommandParameterParser> mapping each supported type to its parser instance. Built-in parsers are registered in the static constructor:

Type	Parser Behavior
int	Standard int.TryParse()
float	Strips trailing 'f', replaces ',' with '.', then float.TryParse()
string	Requires wrapping double quotes ("value"); returns the inner content

Custom parsers can be added via the internal RegisterParser<T>() method, which accepts a ParserDelegate<T> with the signature bool TryParse(string input, out T value).

Quick Lookup

Goal	How
Parse a string to typed value	CommandParameterParser.Parse(typeof(int), "42")
Try-parse with success check	CommandParameterParser.TryParse(typeof(float), "3.14", out var val)
Register custom parser	CommandParameterParser.RegisterParser<T>(tryParseFunc) (internal)

Methods

Parse

Parses a string input into the specified type.

public static object Parse(Type type, string input)

Parameter	Type	Description
type	Type	Target type to parse into
input	string	String representation of the value

Returns: The parsed value as object, or null/default if parsing fails.

TryParse

Attempts to parse a string input into the specified type.

public static bool TryParse(Type type, string input, out object value)

Parameter	Type	Description
type	Type	Target type to parse into
input	string	String representation of the value
value	out object	The parsed value if successful

Returns: true if parsing succeeded.

Throws KeyNotFoundException for unregistered types. If no parser is registered for the given type, this method throws rather than returning false.

Built-in Parsers

int

Standard int.TryParse():

// Valid inputs:
"42"    → 42
"-1"    → -1
"abc"   → 0 (parse fails, returns default)

float

Strips trailing 'f' suffix and replaces commas with dots before parsing:

// Valid inputs:
"3.14"   → 3.14f
"3.14f"  → 3.14f  (trailing 'f' stripped)
"3,14"   → 3.14f  (comma replaced with dot)
"abc"    → 0f     (parse fails, returns default)

string

Requires wrapping double quotes. Returns the inner content:

// Valid inputs:
"\"hello\""     → "hello"
"\"foo bar\""   → "foo bar"

// Invalid inputs:
"hello"         → ""  (no quotes, returns empty string)

Common Pitfalls

String values must be double-quoted Unlike other parsers, the string parser requires the input to be wrapped in double quotes: "\"value\"". Unquoted strings return an empty string.

Unregistered types cause exceptions If Parse() or TryParse() is called with a type that has no registered parser, a KeyNotFoundException is thrown. There is no fallback or generic conversion.

Parse failures are silent When TryParse returns false, the output value is null. The caller (Command.Execute) still proceeds with this null value, which may cause unexpected behavior in the invoked command.

Float parser is locale-aware The float parser replaces commas with dots before parsing, handling European-style decimal separators (3,14 → 3.14).

Examples

Using Parse

object intVal = CommandParameterParser.Parse(typeof(int), "42");
// intVal = 42

object floatVal = CommandParameterParser.Parse(typeof(float), "3,14f");
// floatVal = 3.14f

object strVal = CommandParameterParser.Parse(typeof(string), "\"hello\"");
// strVal = "hello"

Custom Parser Registration (internal)

// To support a custom type, register a parser:
CommandParameterParser.RegisterParser<Vector2>((string input, out Vector2 value) =>
{
    string[] parts = input.Split(',');
    if (parts.Length == 2 &&
        float.TryParse(parts[0], out float x) &&
        float.TryParse(parts[1], out float y))
    {
        value = new Vector2(x, y);
        return true;
    }
    value = default;
    return false;
});

// Now commands can use Vector2 parameters:
// [Command("set-position")]
// public static void SetPosition(Vector2 pos) { ... }
// Command.Execute("set-position", "1.5,2.0");

See Also

• CommandParameter — Delegates parsing to this class via SetValueFromString()

• Command — Orchestrates parameter parsing during execution

• CommandMethod — Contains the CommandParameter[] array that uses this parser