public void MethodMissing(object source, MethodMissingParameters missingParameters) { if (PropertySpec == null) { return; } var methodName = missingParameters.MethodName; // Search for the getter var aliasMatches = (from alias in PropertySpec.Aliases let currentMethodName = string.Format("get_{0}", alias) where currentMethodName == methodName select alias).Count(); var getterName = string.Format("get_{0}", PropertySpec.PropertyName); if (methodName != getterName && aliasMatches == 0) { return; } if (!PropertySpec.CanRead) { throw new InvalidOperationException(string.Format("The property '{0}' does not allow reads", PropertySpec.PropertyName)); } var behavior = PropertySpec.Behavior; missingParameters.ReturnValue = behavior.GetValue(source, PropertySpec.PropertyName, PropertySpec.PropertyType); missingParameters.Handled = true; }
private void InvokeMethodImplementation(object source, MethodMissingParameters missingParameters, string currentMethodName) { missingParameters.Handled = true; var body = MethodSpec.MethodBody; if (body == null) { throw new NotImplementedException(string.Format("The method '{0}' does not have an implementation", currentMethodName)); } var signature = new MethodSignature(MethodSpec.ParameterTypes, MethodSpec.ReturnType); missingParameters.ReturnValue = body.Invoke(source, MethodSpec.MethodName, signature, missingParameters.Arguments); if (missingParameters.ReturnValue == null || MethodSpec.ReturnType == typeof(void)) { return; } // Verify that the return value is compatible with the return type var actualReturnType = missingParameters.ReturnValue.GetType(); if (!MethodSpec.ReturnType.IsAssignableFrom(actualReturnType)) { throw new InvalidReturnTypeException(MethodSpec.MethodName, MethodSpec.ReturnType, actualReturnType); } }
public void MethodMissing(object source, MethodMissingParameters missingParameters) { if (PropertySpec == null) return; var arguments = missingParameters.Arguments; if (arguments.Length != 1) return; var setterName = string.Format("set_{0}", PropertySpec.PropertyName); var aliasMatches = (from alias in PropertySpec.Aliases let currentMethodName = string.Format("set_{0}", alias) where currentMethodName == missingParameters.MethodName select alias).Count(); if (missingParameters.MethodName != setterName && aliasMatches == 0) return; // Match the runtime argument type var argumentType = arguments[0] == null ? typeof(void) : arguments[0].GetType(); if (argumentType != PropertySpec.PropertyType) return; if (!PropertySpec.CanWrite) throw new InvalidOperationException(string.Format("The property '{0}' does not allow writes", PropertySpec.PropertyName)); // Set the property value var behavior = PropertySpec.Behavior; behavior.SetValue(source, PropertySpec.PropertyName, PropertySpec.PropertyType, arguments[0]); missingParameters.Handled = true; }
public void MethodMissing(object source, MethodMissingParameters missingParameters) { if (MethodSpec == null) return; var currentMethodName = missingParameters.MethodName; // Make sure that the method name matches either the // actual method name or a name from the list of method aliases var names = new List<string>(); names.Add(MethodSpec.MethodName); names.AddRange(MethodSpec.Aliases); var isMatch = names.Contains(currentMethodName); if (!isMatch) return; // Match the parameter count var parameterCount = missingParameters.Arguments == null ? 0 : missingParameters.Arguments.Length; if (parameterCount != MethodSpec.ParameterTypes.Count) return; // Match the parameter types var isCompatible = true; var index = 0; foreach (var parameterType in MethodSpec.ParameterTypes) { Type argumentType = null; var currentArgument = missingParameters.Arguments[index++]; if (currentArgument != null) argumentType = currentArgument.GetType(); if (argumentType == null) continue; // Match the parameter type with the argument type // Note: Covariant typing is enabled by default if (parameterType.IsAssignableFrom(argumentType)) continue; isCompatible = false; break; } if (!isCompatible) return; InvokeMethodImplementation(source, missingParameters, currentMethodName); }
public void MethodMissing(object source, MethodMissingParameters missingParameters) { if (PropertySpec == null) { return; } var arguments = missingParameters.Arguments; if (arguments.Length != 1) { return; } var setterName = string.Format("set_{0}", PropertySpec.PropertyName); var aliasMatches = (from alias in PropertySpec.Aliases let currentMethodName = string.Format("set_{0}", alias) where currentMethodName == missingParameters.MethodName select alias).Count(); if (missingParameters.MethodName != setterName && aliasMatches == 0) { return; } // Match the runtime argument type var argumentType = arguments[0] == null ? typeof(void) : arguments[0].GetType(); if (argumentType != PropertySpec.PropertyType) { return; } if (!PropertySpec.CanWrite) { throw new InvalidOperationException(string.Format("The property '{0}' does not allow writes", PropertySpec.PropertyName)); } // Set the property value var behavior = PropertySpec.Behavior; behavior.SetValue(source, PropertySpec.PropertyName, PropertySpec.PropertyType, arguments[0]); missingParameters.Handled = true; }
public virtual void MethodMissing(object source, MethodMissingParameters missingParameters) { var callbacks = GetCallbacks(); if (callbacks == null) { return; } foreach (var callback in callbacks) { if (missingParameters.Handled) { return; } callback.MethodMissing(source, missingParameters); } }
public void MethodMissing(object source, MethodMissingParameters missingParameters) { if (PropertySpec == null) return; var methodName = missingParameters.MethodName; // Search for the getter var aliasMatches = (from alias in PropertySpec.Aliases let currentMethodName = string.Format("get_{0}", alias) where currentMethodName == methodName select alias).Count(); var getterName = string.Format("get_{0}", PropertySpec.PropertyName); if (methodName != getterName && aliasMatches == 0) return; if (!PropertySpec.CanRead) throw new InvalidOperationException(string.Format("The property '{0}' does not allow reads", PropertySpec.PropertyName)); var behavior = PropertySpec.Behavior; missingParameters.ReturnValue = behavior.GetValue(source, PropertySpec.PropertyName, PropertySpec.PropertyType); missingParameters.Handled = true; }
public void MethodMissing(object source, MethodMissingParameters missingParameters) { if (MethodSpec == null) { return; } var currentMethodName = missingParameters.MethodName; // Make sure that the method name matches either the // actual method name or a name from the list of method aliases var names = new List <string>(); names.Add(MethodSpec.MethodName); names.AddRange(MethodSpec.Aliases); var isMatch = names.Contains(currentMethodName); if (!isMatch) { return; } // Match the parameter count var parameterCount = missingParameters.Arguments == null ? 0 : missingParameters.Arguments.Length; if (parameterCount != MethodSpec.ParameterTypes.Count) { return; } // Match the parameter types var isCompatible = true; var index = 0; foreach (var parameterType in MethodSpec.ParameterTypes) { Type argumentType = null; var currentArgument = missingParameters.Arguments[index++]; if (currentArgument != null) { argumentType = currentArgument.GetType(); } if (argumentType == null) { continue; } // Match the parameter type with the argument type // Note: Covariant typing is enabled by default if (parameterType.IsAssignableFrom(argumentType)) { continue; } isCompatible = false; break; } if (!isCompatible) { return; } InvokeMethodImplementation(source, missingParameters, currentMethodName); }
private void InvokeMethodImplementation(object source, MethodMissingParameters missingParameters, string currentMethodName) { missingParameters.Handled = true; var body = MethodSpec.MethodBody; if (body == null) throw new NotImplementedException(string.Format("The method '{0}' does not have an implementation", currentMethodName)); var signature = new MethodSignature(MethodSpec.ParameterTypes, MethodSpec.ReturnType); missingParameters.ReturnValue = body.Invoke(source, MethodSpec.MethodName, signature, missingParameters.Arguments); if (missingParameters.ReturnValue == null || MethodSpec.ReturnType == typeof(void)) return; // Verify that the return value is compatible with the return type var actualReturnType = missingParameters.ReturnValue.GetType(); if (!MethodSpec.ReturnType.IsAssignableFrom(actualReturnType)) throw new InvalidReturnTypeException(MethodSpec.MethodName, MethodSpec.ReturnType, actualReturnType); }