/// <summary> /// Invokes the static method. /// </summary> /// <param name="typeName">Name of the type.</param> /// <param name="methodName">Name of the method.</param> /// <param name="methodParameters">The method parameters.</param> /// <returns>RemoteInvokeResult.</returns> /// <exception cref="InvalidObjectException"></exception> public SandboxMarshalInvokeResult InvokeStaticMethod(string typeName, string methodName, params object[] methodParameters) { SandboxMarshalInvokeResult result = new SandboxMarshalInvokeResult(); try { typeName.CheckEmptyString(nameof(typeName)); methodName.CheckEmptyString(nameof(methodName)); var type = ReflectionExtension.SmartGetType(typeName); type.CheckNullObject(nameof(type)); var methodInfo = type.GetMethod(methodName); methodInfo.CheckNullObject(nameof(methodInfo)); if (!methodInfo.IsStatic) { throw new InvalidObjectException(nameof(methodName), data: methodName, reason: "Method is not static"); } result.SetValue(methodInfo.Invoke(null, methodParameters)); } catch (Exception ex) { result.SetException(ex.Handle(new { typeName, methodName, methodParameters })); } return(result); }
/// <summary> /// Creates the instance and invoke method. /// </summary> /// <param name="typeFullName">Name of the type.</param> /// <param name="constructorParameters">The constructor parameters.</param> /// <param name="methodName">Name of the method.</param> /// <param name="methodParameters">The method parameters.</param> /// <returns>RemoteInvokeResult.</returns> /// <exception cref="InvalidObjectException"></exception> public SandboxMarshalInvokeResult CreateInstanceAndInvokeMethod(string typeFullName, object[] constructorParameters, string methodName, params object[] methodParameters) { SandboxMarshalInvokeResult result = new SandboxMarshalInvokeResult(); try { typeFullName.CheckEmptyString(nameof(typeFullName)); methodName.CheckEmptyString(nameof(methodName)); var type = ReflectionExtension.SmartGetType(typeFullName); type.CheckNullObject(nameof(type)); var instance = Activator.CreateInstance(type, (object[])constructorParameters); var methodInfo = type.GetMethod(methodName); methodInfo.CheckNullObject(nameof(methodInfo)); if (methodInfo.IsStatic) { throw new InvalidObjectException(nameof(methodName), data: methodName, reason: "Method is static"); } result.SetValue(methodInfo.Invoke(instance, methodParameters)); } catch (Exception ex) { result.SetException(ex.Handle(new { typeFullName, constructorParameters, methodName, methodParameters })); } return(result); }
/// <summary> /// Creates the instance. /// </summary> /// <param name="typeName">Name of the type.</param> /// <param name="parameters">The parameters.</param> /// <returns>System.Object.</returns> public object CreateInstance(string typeName, params object[] parameters) { typeName.CheckEmptyString(nameof(typeName)); if (!typeName.StartsWith(Namespace)) { typeName = string.Format("{0}.{1}", Namespace, typeName); } return(Activator.CreateInstance(ReflectionExtension.SmartGetType(typeName, false), parameters)); }
/// <summary> /// Gets the object. /// </summary> /// <returns>System.Object.</returns> public object GetObject() { try { if (string.IsNullOrWhiteSpace(Value) || string.IsNullOrWhiteSpace(Type)) { return(null); } Type type = ReflectionExtension.SmartGetType(Type, true); return(JToken.Parse(Value).ToObject(type)); } catch (Exception ex) { throw ex.Handle(new { Value, Type }); } }
/// <summary> /// Initializes the specified options. /// </summary> /// <param name="options">The options.</param> private void Initialize(DynamicStaticMethodOptions options) { try { options.CheckNullObject(nameof(options)); options.DynamicCode.CheckEmptyString(nameof(options.DynamicCode)); Type type = null; if (!string.IsNullOrWhiteSpace(options.ClassName) && !string.IsNullOrWhiteSpace(options.MethodName)) { if (options.ClassName == options.MethodName) { throw new InvalidObjectException(nameof(options), data: new { options }, reason: "Conflict name for compile closure."); } type = ReflectionExtension.SmartGetType(string.Format("{0}.{1}", _namespace, options.ClassName)); if (type != null) { _methodInfo = type.GetMethod(options.MethodName); if (_methodInfo != null && _methodInfo.IsStatic) { return; } } } var tmpId = Guid.NewGuid().ToString("N"); var generatedCode = BuildMethodCodeAsClass(options, tmpId); TempAssemblyProvider provider = new TempAssemblyProvider(); var tempAssembly = provider.CreateTempAssembly(generatedCode.AsArray()); type = ReflectionExtension.SmartGetType(string.Format("{0}.DynamicStatiClass{1}", _namespace, tmpId)); type.CheckNullObjectAsInvalid(nameof(options), data: new { options, generatedCode, tmpId }); _methodInfo = type.GetMethod(string.Format("DynamicStaticMethod{0}", tmpId)); } catch (Exception ex) { throw ex.Handle(new { options }); } }
/// <summary> /// Creates the method invoker. /// </summary> /// <param name="methodCodeFullName">Full name of the method code.</param> /// <returns></returns> public static MethodInvoker CreateMethodInvoker(string methodCodeFullName) { try { methodCodeFullName.CheckEmptyString(nameof(methodCodeFullName)); //TODO. Consider simple case in this stage. // No generic, no instance. Only static method. {namespace}+.{class}.{method} var lastDot = methodCodeFullName.LastIndexOf('.'); if (lastDot > -1) { string method = methodCodeFullName.Substring(lastDot); var typeFullName = methodCodeFullName.Substring(0, lastDot); var type = ReflectionExtension.SmartGetType(typeFullName, false); type.CheckNullObjectAsInvalid(nameof(methodCodeFullName), data: new { method, typeFullName }); var methodInfo = type.GetMethod(method); methodInfo.CheckNullObjectAsInvalid(nameof(methodCodeFullName), data: new { method, typeFullName }); return(new MethodInvoker(methodInfo)); } else { throw ExceptionFactory.CreateInvalidObjectException(nameof(methodCodeFullName), data: new { methodCodeFullName }); } } catch (BaseException bex) { throw bex; } catch (Exception ex) { throw ex.Handle(new { methodCodeFullName }); } }
/// <summary> /// Froms the raw. /// </summary> /// <param name="sourceAssembly">The source assembly.</param> /// <param name="readerType">Type of the reader.</param> /// <param name="coreComponentVersion">The core component version.</param> /// <param name="configurationItem">The configuration item.</param> /// <returns></returns> public static RuntimeConfigurationItem FromRaw(string sourceAssembly, string readerType, Version coreComponentVersion, ConfigurationRawItem configurationItem) { try { configurationItem.CheckNullObject(nameof(configurationItem)); configurationItem.Type.CheckEmptyString(nameof(configurationItem.Type)); var result = new RuntimeConfigurationItem(configurationItem) { Assembly = sourceAssembly, ReaderType = readerType, RuntimeType = ReflectionExtension.SmartGetType(configurationItem.Type, false) ?? ReflectionExtension.SmartGetType(configurationItem.Type, true) }; result.IsActive = JudgeActive(coreComponentVersion, result.MinComponentVersionRequired, result.MaxComponentVersionLimited); result.Value = RawStringToObject(configurationItem.Value, result.RuntimeType); return(result); } catch (Exception ex) { throw ex.Handle(); } }