public async Task <int> InvokeAsync(InvocationContext context)
{
var bindingContext = context.BindingContext;
var parameterBinders = _parameterDescriptors
.Select(p => bindingContext.GetModelBinder(p))
.ToList();
var invocationArguments =
parameterBinders
.Select(binder => binder.CreateInstance(bindingContext))
.ToArray();
var invocationTarget = _invocationTarget ??
_invocationTargetBinder?.CreateInstance(bindingContext);
object result;
if (_handlerDelegate == null)
{
result = _handlerMethodInfo.Invoke(
invocationTarget,
invocationArguments);
}
else
{
result = _handlerDelegate.DynamicInvoke(invocationArguments);
}
return(await CommandHandler.GetResultCodeAsync(result, context));
}
public async Task <int> InvokeAsync(InvocationContext context)
{
var bindingContext = context.BindingContext;
var(boundValues, _) = ModelBinder.GetBoundValues(
invokeArgumentBindingSources,
bindingContext,
_methodDescriptor.ParameterDescriptors,
_enforceExplicitBinding);
var invocationArguments = boundValues
.Select(x => x.Value)
.ToArray();
object result;
if (_handlerDelegate is null)
{
var invocationTarget = _invocationTarget ??
_invocationTargetBinder?.CreateInstance(bindingContext);
result = _handlerMethodInfo !.Invoke(invocationTarget, invocationArguments);
}
else
{
result = _handlerDelegate.DynamicInvoke(invocationArguments);
}
return(await CommandHandler.GetResultCodeAsync(result, context));
}
public async Task <int> InvokeAsync(InvocationContext context)
{
var bindingContext = context.BindingContext;
var invocationTarget =
_invocationTargetBinder?.CreateInstance(bindingContext);
var invocationArguments =
_parameterBinders.Select(p => p.CreateInstance(bindingContext))
.ToArray();
var result =
_handlerDelegate == null
? _handlerMethodInfo.Invoke(
invocationTarget,
invocationArguments)
: _handlerDelegate.DynamicInvoke(invocationArguments);
return(await CommandHandler.GetResultCodeAsync(result, context));
}
public void Values_from_parent_command_arguments_are_bound_by_name_by_default()
{
var parentCommand = new Command("parent-command")
{
new Argument <int>
{
Name = nameof(ClassWithMultiLetterSetters.IntOption)
},
new Command("child-command")
};
var binder = new ModelBinder <ClassWithMultiLetterSetters>();
var parseResult = parentCommand.Parse("parent-command 123 child-command");
var bindingContext = new BindingContext(parseResult);
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(123);
}
public void PropertyInfo_can_be_bound_to_command()
{
var command = new Command("the-command");
var argument = new Argument <int>();
command.Argument = argument;
var type = typeof(ClassWithMultiLetterSetters);
var binder = new ModelBinder(type);
var propertyInfo = type.GetProperties().First();
binder.BindMemberFromValue(
propertyInfo,
command);
var bindingContext = new BindingContext(command.Parse("the-command 42"));
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(42);
}
public void Explicitly_configured_default_values_can_be_bound_by_name_to_property_setters()
{
var argument = new Argument <string>(() => "the default");
var option = new Option("--value")
{
Argument = argument
};
var command = new Command("the-command");
command.AddOption(option);
var binder = new ModelBinder(typeof(ClassWithSetter <string>));
var parser = new Parser(command);
var bindingContext = new BindingContext(parser.Parse(""));
var instance = (ClassWithSetter <string>)binder.CreateInstance(bindingContext);
instance.Value.Should().Be("the default");
}
public void PropertyExpression_can_be_bound_to_argument()
{
var command = new Command("the-command");
var argument = new Argument <int> {
Arity = ArgumentArity.ExactlyOne
};
command.AddArgument(argument);
var binder = new ModelBinder <ClassWithMultiLetterSetters>();
binder.BindMemberFromValue(
i => i.IntOption,
argument);
var bindingContext = new BindingContext(command.Parse("the-command 42"));
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(42);
}
public void PropertyInfo_can_be_bound_to_argument()
{
var command = new Command("the-command");
var argument = new Argument <int> {
Arity = ArgumentArity.ExactlyOne
};
command.AddArgument(argument);
var type = typeof(ClassWithMultiLetterSetters);
var binder = new ModelBinder(type);
var propertyInfo = type.GetProperty(nameof(ClassWithMultiLetterSetters.IntOption));
binder.BindMemberFromValue(propertyInfo, argument);
var bindingContext = new BindingContext(command.Parse("the-command 42"));
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(42);
}
public void PropertyInfo_can_be_bound_to_option()
{
var command = new Command("the-command");
var option = new Option <int>("--fred");
command.Add(option);
var type = typeof(ClassWithMultiLetterSetters);
var binder = new ModelBinder(type);
var propertyInfo = type.GetProperties()[0];
binder.BindMemberFromValue(
propertyInfo,
option);
var bindingContext = new BindingContext(command.Parse("the-command --fred 42"));
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(42);
}
public void Option_arguments_are_bound_by_name_to_constructor_parameters(
Type type,
string commandLine,
object expectedValue)
{
var targetType = typeof(ClassWithCtorParameter <>).MakeGenericType(type);
var binder = new ModelBinder(targetType);
var command = new Command("the-command")
{
new Option("--value", argumentType: type)
};
var bindingContext = new BindingContext(command.Parse(commandLine));
var instance = binder.CreateInstance(bindingContext);
object valueReceivedValue = ((dynamic)instance).Value;
valueReceivedValue.Should().Be(expectedValue);
}
public void Explicit_model_binder_binds_only_to_configured_properties()
{
var intOption = new Option <int>("--int-property");
var stringOption = new Option <string>("--string-property");
var parser = new Parser(intOption, stringOption);
var bindingContext = new BindingContext(
parser.Parse("--int-property 42 --string-property Hello")
);
var binder = new ModelBinder <ClassWithMultiLetterSetters>
{
EnforceExplicitBinding = true
};
binder.BindMemberFromValue(obj => obj.IntOption, intOption);
var instance = binder.CreateInstance(bindingContext) as ClassWithMultiLetterSetters;
instance.Should().NotBeNull();
instance.IntOption.Should().Be(42);
instance.StringOption.Should().BeNull();
}
public void Values_from_options_on_parent_commands_can_be_bound_regardless_of_naming()
{
var childCommand = new Command("child-command");
var option = new Option <int>("-x");
var parentCommand = new Command("parent-command")
{
option, childCommand
};
var binder = new ModelBinder <ClassWithMultiLetterSetters>();
binder.BindMemberFromValue(c => c.IntOption, option);
var bindingContext = new BindingContext(
parentCommand.Parse("parent-command -x 123 child-command")
);
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(123);
}
public void Property_setters_with_no_default_value_and_no_matching_option_are_not_called()
{
var command = new Command("the-command")
{
new Option <string>("--string-option")
};
var binder = new ModelBinder(
typeof(ClassWithSettersAndCtorParametersWithDifferentNames)
);
var parser = new Parser(command);
var bindingContext = new BindingContext(parser.Parse(""));
var instance =
(ClassWithSettersAndCtorParametersWithDifferentNames)binder.CreateInstance(
bindingContext
);
instance.StringOption.Should().Be("the default");
}
public void Default_values_from_options_on_parent_commands_are_bound_by_name_by_default()
{
var parentCommand = new Command("parent-command")
{
new Option("--int-option")
{
Argument = new Argument <int>(() => 123)
},
new Command("child-command")
};
var binder = new ModelBinder <ClassWithMultiLetterSetters>();
var parseResult = parentCommand.Parse("parent-command child-command");
var bindingContext = new BindingContext(parseResult);
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(123);
}
public void Values_from_parent_command_arguments_can_be_bound()
{
var childCommand = new Command("child-command");
var parentCommand = new Command("parent-command", argument: new Argument <int>())
{
childCommand
};
var binder = new ModelBinder <ClassWithMultiLetterSetters>();
binder.BindMemberFromCommand(
c => c.IntOption,
parentCommand);
var bindingContext = new BindingContext(parentCommand.Parse("parent-command 123 child-command"));
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(123);
}
public void Explicit_model_binder_binds_only_to_configured_ctor_parameters()
{
var intOption = new Option <int>("-a");
var stringOption = new Option <string>("-b");
var parser = new Parser(intOption, stringOption);
var ctor = typeof(ClassWithMultiLetterCtorParameters)
.GetConstructors(BindingFlags.Public | BindingFlags.Instance)[0];
var paramInfo = ctor.GetParameters()[0];
var bindingContext = new BindingContext(parser.Parse("-a 42 -b Hello"));
var binder = new ModelBinder <ClassWithMultiLetterCtorParameters>
{
EnforceExplicitBinding = true
};
binder.BindConstructorArgumentFromValue(paramInfo, intOption);
var instance = binder.CreateInstance(bindingContext) as ClassWithMultiLetterCtorParameters;
instance.Should().NotBeNull();
instance.IntOption.Should().Be(42);
instance.StringOption.Should().Be("the default");
}
public void Command_arguments_are_bound_by_name_to_property_setters(
Type type,
string commandLine,
object expectedValue)
{
var targetType = typeof(ClassWithSetter <>).MakeGenericType(type);
var binder = new ModelBinder(targetType);
var command = new Command("the-command")
{
ArgumentBuilder.CreateArgument(type)
};
var parser = new Parser(command);
var bindingContext = new InvocationContext(parser.Parse(commandLine)).BindingContext;
var instance = binder.CreateInstance(bindingContext);
object valueReceivedValue = ((dynamic)instance).Value;
valueReceivedValue.Should().Be(expectedValue);
}
public void PropertyExpression_can_be_bound_to_option()
{
var command = new Command("the-command");
var option = new Option("--fred")
{
Argument = new Argument <int>()
};
command.AddOption(option);
var binder = new ModelBinder <ClassWithMultiLetterSetters>();
binder.BindMemberFromValue(
i => i.IntOption,
option);
var bindingContext = new BindingContext(command.Parse("the-command --fred 42"));
var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
instance.IntOption.Should().Be(42);
}
public void Command_arguments_are_bound_by_name_to_complex_constructor_parameters(
Type type,
string commandLine)
{
var targetType = typeof(ClassWithCtorParameter <>).MakeGenericType(type);
var binder = new ModelBinder(targetType);
var command = new Command("the-command")
{
ArgumentBuilder.CreateArgument(type)
};
var bindingContext = new InvocationContext(command.Parse(commandLine)).BindingContext;
var instance = binder.CreateInstance(bindingContext);
object valueReceivedValue = ((dynamic)instance).Value;
var expectedValue = new FileInfo(commandLine);
valueReceivedValue.Should().BeOfType <FileInfo>();
var fileInfoValue = valueReceivedValue as FileInfo;
fileInfoValue.FullName.Should().Be(expectedValue.FullName);
}
public static ValueDirectiveOptions Create(ParseResult parseResult) => _modelBinder.CreateInstance(new BindingContext(parseResult)) as ValueDirectiveOptions;
