public void TestRefOutMethods() { IDynamicMethod refMethod = DynamicMethod.Create(typeof(MethodTarget).GetMethod("MethodWithRefParameter")); MethodTarget target = new MethodTarget(); object[] args = new object[] { "aleks", 5 }; refMethod.Invoke(target, args); Assert.AreEqual("ALEKS", args[0]); Assert.AreEqual(25, args[1]); IDynamicMethod outMethod = DynamicMethod.Create(typeof(MethodTarget).GetMethod("MethodWithOutParameter")); args = new object[] { "aleks", null }; outMethod.Invoke(target, args); Assert.AreEqual("ALEKS", args[1]); IDynamicMethod refOutMethod = DynamicMethod.Create(typeof(RefOutTestObject).GetMethod("DoIt")); RefOutTestObject refOutTarget = new RefOutTestObject(); args = new object[] { 0, 1, null }; refOutMethod.Invoke(refOutTarget, args); Assert.AreEqual(2, args[1]); Assert.AreEqual("done", args[2]); refOutMethod.Invoke(refOutTarget, args); Assert.AreEqual(3, args[1]); Assert.AreEqual("done", args[2]); int count = 0; string done; target.DoItCaller(0, ref count, out done); Assert.AreEqual(1, count); Assert.AreEqual("done", done); }
public void PassNullableArguments() { IDynamicMethod dm = DynamicMethod.Create(typeof(TestMethods).GetMethod("PassNullableArgumentStatic")); DateTime dt = DateTime.Now; Assert.AreEqual(dt, dm.Invoke(null, dt)); }
public ClassDecl CreateClass(JSValue nsValue, string typename, Type type, IDynamicMethod dynamicMethod) { var nameAtom = GetAtom(typename); JSContext ctx = _context; var protoVal = JSApi.JS_NewObject(ctx); var type_id = RegisterType(type, protoVal); var ctorVal = _db.NewDynamicConstructor(nameAtom, dynamicMethod); var decl = new ClassDecl(this, ctorVal, protoVal, type); JSApi.JS_SetConstructor(ctx, ctorVal, protoVal); JSApi.JSB_SetBridgeType(ctx, ctorVal, GetAtom(Values.KeyForCSharpTypeID), type_id); JSApi.JSB_SetBridgeType(ctx, protoVal, GetAtom(Values.KeyForCSharpTypeID), type_id); if (!nsValue.IsNullish()) { JSApi.JS_DefinePropertyValue(ctx, nsValue, nameAtom, ctorVal, JSPropFlags.JS_PROP_ENUMERABLE | JSPropFlags.JS_PROP_CONFIGURABLE); } else { JSApi.JS_FreeValue(ctx, ctorVal); } // Debug.LogFormat("define class {0}: {1}", type, protoVal); JSApi.JS_FreeValue(ctx, protoVal); _pendingClasses.Add(decl); return(decl); }
/// <summary> /// /// </summary> /// <param name="objectType"></param> /// <param name="types"></param> /// <returns></returns> public static IDynamicMethod GetDynamicMethod(Type objectType, string methodName, params object[] parameters) { MethodCacheKey key = MethodCacheKey.Create(objectType, methodName, parameters); IDynamicMethod dynamicMethod = null; if (!_dynamicMethods.TryGetValue(key, out dynamicMethod)) { lock (_dynamicMethods) { if (!_dynamicMethods.TryGetValue(key, out dynamicMethod)) { MethodInfo methodInfo = GetMethod(objectType, methodName, parameters); if (methodInfo != null) { dynamicMethod = DynamicMethod.Create(methodInfo); if (dynamicMethod != null) { _dynamicMethods.Add(key, dynamicMethod); } } } } } return(dynamicMethod); }
private void CanCreateWithRestrictedPermissionsImpl() { MethodInfo method = this.GetType().GetMethod("RespectsPermissionsPublicMethod"); IDynamicMethod m = DynamicMethod.Create(method); m.Invoke(this, null); }
/// <summary> /// Uses reflection to dynamically invoke a method, /// throwing an exception if it is not /// implemented on the target object. /// </summary> /// <param name="obj"> /// Object containing method. /// </param> /// <param name="method"> /// Name of the method. /// </param> /// <param name="parameters"> /// Parameters to pass to method. /// </param> public static object CallMethod(object obj, string method, params object[] parameters) { Guard.ArgumentNotNull(obj, "obj"); Guard.ArgumentNotNullOrEmpty(method, "method"); IDynamicMethod dynamicMethod = DynamicMethodCache.GetDynamicMethod(obj.GetType(), method, parameters); if (dynamicMethod == null) { ThrowHelper.ThrowNotImplementedException( ReflectionSR.MethodNotImplemented, obj.GetType().FullName, method, TypeHelper.GetTypesString(parameters)); } object result = null; try { result = dynamicMethod.Invoke(obj, parameters); } catch (Exception ex) { throw new CallMethodException( string.Format(ReflectionSR.Culture, ReflectionSR.MethodCallFailed, obj.GetType().FullName, method), ex); } return(result); }
public void TestStaticMethods() { IDynamicMethod isNullOrEmpty = DynamicMethod.Create(typeof(StringUtils).GetMethod("IsNullOrEmpty")); Assert.IsTrue((bool)isNullOrEmpty.Invoke(null, new object[] { null })); Assert.IsTrue((bool)isNullOrEmpty.Invoke(null, new object[] { String.Empty })); Assert.IsFalse((bool)isNullOrEmpty.Invoke(null, new object[] { "Ana Maria" })); }
public void CanAcceptImplicitlyConvertedTypesAsSubstitutesForArguments() { IDynamicMethod method = DynamicMethod.Create(typeof(TheClassWithMethod).GetMethod("TheMethod")); bool ret = (bool)(method.Invoke(new TheClassWithMethod(), new object[] { new TheClassDerivedFromTheArgumentClass() })); Assert.IsTrue(ret); }
public MethodCaller(IDynamicMethod dynamicMethod, IDeployPath deployPath, IOperationRetryIgnore operationRetryIgnore, IMethodOverrides methodOverrides, ResourceReference method) { _method = method; _dynamicMethod = dynamicMethod; _operationRetryIgnore = operationRetryIgnore; _deployPath = (method.RootType == ReferenceRoot.SR) ? deployPath.GetDeployPath(methodOverrides.GetOverride(method)) : deployPath.GetDeployPath(method); }
public void AddMethod(bool bStatic, string name, IDynamicMethod method) { var nameAtom = _register.GetAtom(name); var db = _register.GetTypeDB(); var funcVal = db.NewDynamicMethod(nameAtom, method); JSApi.JS_DefinePropertyValue(_context, bStatic ? _ctor : _proto, nameAtom, funcVal, JSPropFlags.DEFAULT); }
/// <summary> /// Creates a new instance of the safe method wrapper. /// </summary> /// <param name="method">Method to wrap.</param> public SafeMethod(MethodInfo method) { this.methodInfo = method; if (method.IsPublic && ReflectionUtils.IsTypeVisible(method.DeclaringType, DynamicReflectionManager.ASSEMBLY_NAME)) { this.dynamicMethod = DynamicMethod.Create(method); this.isOptimized = true; } }
/// <summary> /// Returns dynamic method if one exists. /// </summary> /// <param name="method">Method to look up.</param> /// <param name="createCallback">callback function that will be called to create the dynamic method</param> /// <returns>An <see cref="IDynamicMethod"/> for the given method.</returns> internal static IDynamicMethod GetDynamicMethod(MethodInfo method, CreateMethodCallback createCallback) { lock (methodCache.SyncRoot) { IDynamicMethod dynamicMethod = (IDynamicMethod)methodCache[method]; if (dynamicMethod == null) { dynamicMethod = createCallback(method); methodCache[method] = dynamicMethod; } return(dynamicMethod); } }
public JSValue NewDynamicConstructor(JSAtom name, IDynamicMethod method) { if (method == null) { var funValue = JSApi.JSB_NewCFunctionMagic(_context, JSApi.class_private_ctor, name, 0, JSCFunctionEnum.JS_CFUNC_constructor_magic, 0); return(funValue); } else { var magic = _dynamicMethods.Count; var funValue = JSApi.JSB_NewCFunctionMagic(_context, JSApi._DynamicMethodInvoke, name, 0, JSCFunctionEnum.JS_CFUNC_constructor_magic, magic); _dynamicMethods.Add(method); return(funValue); } }
public void TestInstanceMethods() { IDynamicMethod getAge = DynamicMethod.Create(typeof(Inventor).GetMethod("GetAge")); Assert.AreEqual(tesla.GetAge(DateTime.Today), getAge.Invoke(tesla, new object[] { DateTime.Today })); MethodTarget target = new MethodTarget(); IDynamicMethod test = DynamicMethod.Create(typeof(MethodTarget).GetMethod("MethodReturningString")); Assert.AreEqual(tesla.Name, test.Invoke(target, new object[] { 5, DateTime.Today, new String[] { "xyz", "abc" }, tesla })); ArrayList list = new ArrayList(new string[] { "one", "two", "three" }); IDynamicMethod removeAt = DynamicMethod.Create(typeof(ArrayList).GetMethod("RemoveAt")); removeAt.Invoke(list, new object[] { 1 }); Assert.AreEqual(2, list.Count); Assert.AreEqual("three", list[1]); }
public void PassInvalidNumberOfArguments() { IDynamicMethod dm = DynamicMethod.Create(typeof(TestMethods).GetMethod("PassReferenceArgumentStatic")); DateTime dt = DateTime.Now; Assert.IsNull(dm.Invoke(null, null)); // this is ok try { dm.Invoke(null); // this is not ok Assert.Fail(); } catch (ArgumentException) { } try { dm.Invoke(null, null, null); // this is not ok Assert.Fail(); } catch (ArgumentException) { } }
private void CanCreatePrivateMethodButThrowsOnInvokeImpl() { MethodInfo privateMethod = this.GetType().GetMethod("RespectsPermissionsPrivateMethod", BindingFlags.NonPublic | BindingFlags.Instance); IDynamicMethod m = DynamicMethod.Create(privateMethod); try { object result = m.Invoke(this, null); if (SystemUtils.MonoRuntime) { Assert.AreEqual("Result", result); } else { Assert.Fail("shoud throw a security exception"); } } catch (MethodAccessException) { } }
//[Test] public void PerformanceTests() { int n = 10000000; object x = null; // tesla.GetAge start = DateTime.Now; for (int i = 0; i < n; i++) { x = tesla.GetAge(DateTime.Today); } stop = DateTime.Now; PrintTest("tesla.GetAge (direct)", n, Elapsed); start = DateTime.Now; IDynamicMethod getAge = DynamicMethod.Create(typeof(Inventor).GetMethod("GetAge")); for (int i = 0; i < n; i++) { object[] args = new object[] { DateTime.Today }; x = getAge.Invoke(tesla, args); } stop = DateTime.Now; PrintTest("tesla.GetAge (dynamic reflection)", n, Elapsed); start = DateTime.Now; MethodInfo getAgeMi = typeof(Inventor).GetMethod("GetAge"); for (int i = 0; i < n; i++) { object[] args = new object[] { DateTime.Today }; x = getAgeMi.Invoke(tesla, args); } stop = DateTime.Now; PrintTest("tesla.GetAge (standard reflection)", n, Elapsed); }
public void TestArgumentTypeCasts() { IDynamicMethod sqrt = DynamicMethod.Create(typeof(Math).GetMethod("Sqrt")); object result = sqrt.Invoke(null, new object[] { 4 }); Assert.AreEqual(Math.Sqrt(4), result); try { sqrt.Invoke(null, new object[] { null }); Assert.Fail(); } catch (InvalidCastException) { } try { sqrt.Invoke(null, new object[] { "4" }); Assert.Fail(); } catch (InvalidCastException) { } }
static void Main(string[] args) { IExecutorService executorService = Executors.NewFixedThreadPool(THREAD_POOL_SIZE); IFuture <int> f1 = executorService.Submit <int>(GenerateNumbers); IFuture <string> f2 = executorService.Submit <string>(PrintCharacters); IFuture <int> f3 = executorService.Submit <int>(PrintArray); Console.WriteLine("Numbers generated till {0}", f1.GetResult()); Console.WriteLine("Original String {0}", f2.GetResult()); Console.WriteLine("Array Count {0}", f3.GetResult()); Console.WriteLine("---------"); Console.WriteLine("Calculating sums..."); var futures = new List <IFuture <long> >(); // Call without method arguments for (int i = 0; i < 20000; i++) { SumNumbers sumNumbers = new SumNumbers(100 + i); IFuture <long> submit = executorService.Submit <long>(sumNumbers.CalculateSum); futures.Add(submit); } long sum = 0; foreach (var future in futures) { sum += future.GetResult(); } Console.WriteLine("Sum = " + sum); futures.Clear(); Console.WriteLine("---------"); Console.WriteLine("Calculating sums..."); // Call with method arguments for (int i = 0; i < 20000; i++) { SumNumbers2 sumNumbers2 = new SumNumbers2(); int i1 = i; // copy to local variable for closure. IFuture <long> submit = executorService.Submit(() => sumNumbers2.CalculateSumWithArgsAndReturnValue(100 + i1)); futures.Add(submit); } sum = 0; foreach (var future in futures) { sum += future.GetResult(); } Console.WriteLine("Sum = " + sum); //Say this was created at runtime and we don't know the type or parameter values at compile time. object obj = new SumNumbers2(); object[] parameters = new object[] { 100 }; //Find the method we want to invoke MethodInfo methodInfo = ReflectionUtils.GetMethod(obj.GetType(), "CalculateSumWithArgsAndReturnValue", ReflectionUtils.GetTypes(parameters)); //Use expression trees to generate code to invoke method and assign to a delegate. LateBoundMethod methodCallback = DelegateFactory.Create(methodInfo); IFuture <object> futureLong = executorService.Submit(() => methodCallback(obj, parameters)); var result = futureLong.GetResult(); Console.WriteLine("LateBoundMethod Style : Result = " + result); ///Use Spring's IL generation to invoke method dynamically. IDynamicMethod method = DynamicMethod.Create(methodInfo); IFuture <object> futureLongViaDM = executorService.Submit(() => method.Invoke(obj, parameters)); var resultViaDM = futureLongViaDM.GetResult(); Console.WriteLine("Spring's IDynamicMethod Style: Result = " + resultViaDM); // This will make the executor accept no new threads // and finish all existing threads in the queue executorService.Shutdown(); Console.WriteLine("Hit return to exit"); Console.ReadLine(); }
public void RegisterOperator(Type type, string op, IDynamicMethod func) { RegisterOperator(type, op, _db.NewDynamicMethod(GetAtom(op), func)); }
public void RegisterOperator(Type type, string op, IDynamicMethod func, bool left, Type sideType) { RegisterOperator(type, op, _db.NewDynamicMethod(GetAtom(op), func), left, sideType); }
public void AddLeftOperator(string op, IDynamicMethod func, Type type) { _register.RegisterOperator(_type, op, func, true, type); }
public ClassDecl CreateClass(string typename, Type type, IDynamicMethod dynamicMethod) { return(CreateClass(JSApi.JS_UNDEFINED, typename, type, dynamicMethod)); }
public DynamicMethodImpl(MethodInfo methodInfo, IDynamicMethod generatedMethod) { this.nullArguments = new object[methodInfo.GetParameters().Length]; this.methodInfo = methodInfo; this.method = generatedMethod; }
/// <summary> /// Creates a new instance of the safe method wrapper. /// </summary> /// <param name="method">Method to wrap.</param> public SafeMethod(MethodInfo method) { this.methodInfo = method; if (method.IsPublic && ReflectionUtils.IsTypeVisible(method.DeclaringType, DynamicReflectionManager.ASSEMBLY_NAME)) { this.dynamicMethod = DynamicMethod.Create(method); this.isOptimized = true; } }
public void AddRightOperator(string op, IDynamicMethod func, Type type) { _register.RegisterOperator(_type, op, func, false, type); }
public DynamicMethodImpl(MethodInfo methodInfo, IDynamicMethod generatedMethod) { this.nullArguments = new object[methodInfo.GetParameters().Length]; this.methodInfo = methodInfo; this.method = generatedMethod; }
public DynamicMethodWrapper(IDynamicMethod method) { _method = method; }
public void AddSelfOperator(string op, IDynamicMethod func) { _register.RegisterOperator(_type, op, func); }