public virtual object Execute(ModelParameters parameters) { object output = null; this.Accessed++; try { //Arguments object[] args = parameters.Values.ToArray(); //Invoke the method (with arguments) output = _method.Invoke(this.Model, args); } catch (Exception e) { this.Model.OnException(this, parameters, e); return(output); } //Should it have thrown, and it didn't? if (this.Throws) { throw new ModelException(this, "Requirements were not met, and was expected to throw Exception: '" + this.Exception + "'" + " ID: '" + this.ExceptionId + "''"); } return(output); }
protected ModelParameters DetermineParameters(ModelAction action) { try { ModelParameters allparameters = action.Parameters; ModelParameters choosen = new ModelParameters(); //Loop through the method parameters foreach (ParameterInfo info in action.Method.GetParameters()) { //Find the all parameters assoicated with this param ModelParameters parameters = allparameters.Find(info.Name); //Exclude invalid parameters (if not requested) if (!this.InvalidParameters) { parameters = (ModelParameters)parameters.FindFlag((int)ModelItemFlags.Throws, false); } if (parameters.Count <= 0) { throw new ModelException(this, "Unable to find a ModelParameter for method parameter: '" + info.Name + "'"); } //Choose one of the parameters, based upon weight ModelParameter parameter = parameters.Choose(this); parameter.Accessed++; //Note: We cloning the param, since were choosing only one of the values to use this time. parameter = (ModelParameter)parameter.Clone(); //Choose (or generate) one of the values ModelValue value = DetermineParameterValue(parameter); value.Accessed++; //Add it to the array parameter.Value = value; choosen.Add(parameter); } return(choosen); } catch (Exception e) { //Make this easier to debug throw new ModelException(this, "DetermineParameters", e); } }
public virtual void OnException(ModelAction action, ModelParameters parameters, Exception e) { //Since were using reflection, if an error occurs within the method //make this easier to debug (for the method writer) so they see their exception //instead of the reflection based one. while (e.InnerException != null && e is TargetInvocationException) { e = e.InnerException; } //Find what should have thrown the exception, action or parameters Type exception = action.Exception; string exceptionid = action.ExceptionId; if (exception == null && exceptionid == null) { //Otherwise maybe one of the parameters was supposed to throw //Find the parameter that expects an error ModelParameters found = (ModelParameters)parameters.FindFlag((int)ModelItemFlags.Throws); if (found.Count > 0) { //Note: We find the 'highest' weighted parameter (ie: order of errors processed) found.SortByWeightDesc(); exception = found.First.Exception; exceptionid = found.First.ExceptionId; } } //Exception not expected if (exception == null && exceptionid == null) { throw new ModelException(action, "Threw an exception: " + e.Message, e); } //Expected: Simple verification, type based if (exception != null && (exception != e.GetType())) { throw new ModelException(action, "Threw the wrong exception: " + e.Message, e); } //Expected: Advanced verification, user implemented function if (exceptionid != null) { this.OnException(action, parameters, e, exceptionid); //Throws if not verified } }
//Constructor public ModelActionInfo(ModelAction action, ModelParameters parameters, object retval) { _action = action; _parameters = parameters; _retval = retval; }
public override void Reload() { //Clear, so they will be dynamically setup by reflection again _requirements = null; _parameters = null; }
private void ExecuteActionInfo(ModelActionInfo actioninfo) { ModelAction action = actioninfo.Action; ModelParameters parameters = actioninfo.Parameters; Model model = action.Model; //Pre-Execute, events //Note: If CallBefore returns false, we simply don't execute the method if (model.OnCallBefore(action, parameters)) { //Adding the selected action (and its param values) to the trace. if (this.Options.Tracing) { _actionstrace.Add(actioninfo); } //Execute the method (delegate) actioninfo.RetVal = action.Execute(parameters); _actionscalled++; //Add the returned model to the system Model output = actioninfo.RetVal as Model; if (output != null) { //If it doesn't already exist, and the model type is part of the set if (this.Models.FindInstance(output) == null) { actioninfo.Created = true; //Add returned models, if requested if (this.Options.AddReturnedModels) { //Note: We always obey the maxinstance count Models found = (Models)this.Models.FindType(output.GetType()).FindFlag((int)ModelItemFlags.Disabled, false); if (found.Count < output.MaxInstances) { output.Enabled = true; //Enabled by default if (output.ParentModel == null) //Hook up the creator, if not already specified { output.ParentModel = action.Model; } this.Models.Add(output); } } } } //Trace if (this.Options.Tracing) { ModelTrace.WriteLine(ModelTrace.FormatMethod(actioninfo)); } //Post-Execute, events model.OnCallAfter(action, parameters, actioninfo.RetVal); } //Reset cached variables foreach (ModelVariable variable in this.Models.Variables) { variable.CachedValue = null; } }
public virtual void OnException(ModelAction action, ModelParameters parameters, Exception e, string id) { //Override this method, and verify the ExceptionId specified in the model throw new ModelException(this, "ExceptionId was specified and not verified. Override Model.VerifyException, and verify the ExceptionId as was specified in the model", e); }
public virtual void OnCallAfter(ModelAction action, ModelParameters parameters, object result) { //Note: Override if you want to do after if (CallAfter != null) { CallAfter(action, parameters, result); } }
public virtual bool OnCallBefore(ModelAction action, ModelParameters parameters) { //Note: Override if you want to do something, or call other methods BEFORE execution of the action bool result = true; //true, indicates continue to call the action if (_callbefore != null) { foreach (CallBeforeHandler handler in _callbefore) { result &= handler(action, parameters); } } return(result); }