public object?Resolve(Type?type) { if (type == null) { throw new CommandRuntimeException("Cannot resolve null type."); } try { if (_resolver != null) { var obj = _resolver.Resolve(type); if (obj == null) { throw CommandRuntimeException.CouldNotResolveType(type); } return(obj); } // Fall back to use the activator. return(Activator.CreateInstance(type)); } catch (CommandAppException) { throw; } catch (Exception ex) { throw CommandRuntimeException.CouldNotResolveType(type, ex); } }
public static ConfiguredCommand FromType <TCommand>(string name, bool isDefaultCommand = false) where TCommand : class, ICommand { var settingsType = ConfigurationHelper.GetSettingsType(typeof(TCommand)); if (settingsType == null) { throw CommandRuntimeException.CouldNotGetSettingsType(typeof(TCommand)); } return(new ConfiguredCommand(name, typeof(TCommand), settingsType, null, isDefaultCommand)); }
public static CommandSettings CreateSettings(CommandValueLookup lookup, ConstructorInfo constructor, ITypeResolver resolver) { if (constructor.DeclaringType == null) { throw new InvalidOperationException("Cannot create settings since constructor have no declaring type."); } var parameters = new List <object?>(); var mapped = new HashSet <Guid>(); foreach (var parameter in constructor.GetParameters()) { if (lookup.TryGetParameterWithName(parameter.Name, out var result)) { parameters.Add(result.Value); mapped.Add(result.Parameter.Id); } else { var value = resolver.Resolve(parameter.ParameterType); if (value == null) { throw CommandRuntimeException.CouldNotResolveType(parameter.ParameterType); } parameters.Add(value); } } // Create the settings. if (!(Activator.CreateInstance(constructor.DeclaringType, parameters.ToArray()) is CommandSettings settings)) { throw new InvalidOperationException("Could not create settings"); } // Try to do property injection for parameters that wasn't injected. foreach (var(parameter, value) in lookup) { if (!mapped.Contains(parameter.Id) && parameter.Property.SetMethod != null) { parameter.Property.SetValue(settings, value); } } return(settings); }
public static CommandSettings CreateSettings(CommandValueLookup lookup, Type settingsType, ITypeResolver resolver) { var settings = CreateSettings(resolver, settingsType); foreach (var (parameter, value) in lookup) { parameter.Property.SetValue(settings, value); } // Validate the settings. var validationResult = settings.Validate(); if (!validationResult.Successful) { throw CommandRuntimeException.ValidationFailed(validationResult); } return settings; }
private static Task <int> Execute( CommandTree leaf, CommandTree tree, CommandContext context, ITypeResolver resolver, IConfiguration configuration) { // Bind the command tree against the settings. var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver); configuration.Settings.Interceptor?.Intercept(context, settings); // Create and validate the command. var command = leaf.CreateCommand(resolver); var validationResult = command.Validate(context, settings); if (!validationResult.Successful) { throw CommandRuntimeException.ValidationFailed(validationResult); } // Execute the command. return(command.Execute(context, settings)); }
public static CommandValueLookup GetParameterValues(CommandTree?tree, ITypeResolver resolver) { var lookup = new CommandValueLookup(); var binder = new CommandValueBinder(lookup); CommandValidator.ValidateRequiredParameters(tree); while (tree != null) { // Process unmapped parameters. foreach (var parameter in tree.Unmapped) { if (parameter.IsFlagValue()) { // Set the flag value to an empty, not set instance. var instance = Activator.CreateInstance(parameter.ParameterType); lookup.SetValue(parameter, instance); } else { // Is this an option with a default value? if (parameter.DefaultValue != null) { var value = parameter.DefaultValue?.Value; // Need to convert the default value? if (value != null && value.GetType() != parameter.ParameterType) { var converter = GetConverter(lookup, binder, resolver, parameter); if (converter != null) { value = converter.ConvertFrom(value); } } binder.Bind(parameter, resolver, value); CommandValidator.ValidateParameter(parameter, lookup); } else if (Nullable.GetUnderlyingType(parameter.ParameterType) != null || !parameter.ParameterType.IsValueType) { lookup.SetValue(parameter, null); } } } // Process mapped parameters. foreach (var mapped in tree.Mapped) { if (mapped.Parameter.WantRawValue) { // Just try to assign the raw value. binder.Bind(mapped.Parameter, resolver, mapped.Value); } else { var converter = GetConverter(lookup, binder, resolver, mapped.Parameter); if (converter == null) { throw CommandRuntimeException.NoConverterFound(mapped.Parameter); } if (mapped.Parameter.IsFlagValue() && mapped.Value == null) { if (mapped.Parameter is CommandOption option && option.DefaultValue != null) { // Set the default value. binder.Bind(mapped.Parameter, resolver, option.DefaultValue?.Value); } else { // Set the flag but not the value. binder.Bind(mapped.Parameter, resolver, null); } }