private void LateBind() { Type staticType = Type.GetType("Microsoft.Practices.Unity.UnityContainerExtensions, " + _containerInterface.Assembly.FullName, true); _unityContainerExtensions = new ImpromptuLateLibraryType(staticType); _staticContext = InvokeContext.CreateStatic(staticType); }
public void CacheableGetStaticTimed() { var tStaticType = typeof(DateTime); var tContext = InvokeContext.CreateStatic(tStaticType); var tCachedInvoke = new CacheableInvocation(InvocationKind.Get, "Today", context: tContext); Timer.Action1 = (() => { var tOut = tCachedInvoke.Invoke(tStaticType); }); var tMethodInfo = typeof(DateTime).GetProperty("Today").GetGetMethod(); Timer.Action2 = (() => { var tOut = tMethodInfo.Invoke(tStaticType, new object[] { }); }); var elapsed = Timer.Go(3 * TimeIt.Million); Console.WriteLine("Impromptu: " + elapsed.Item1); Console.WriteLine("Refelection: " + elapsed.Item2); Console.WriteLine("Impromptu VS Reflection: {0}", TimeIt.RelativeSpeed(elapsed)); Assert.Less(elapsed.Item1, elapsed.Item2); }
private void LateBind() { Type type = _kernelInterface; Type staticType = Type.GetType("Ninject.ResolutionExtensions, " + type.Assembly.FullName, true); _staticContext = InvokeContext.CreateStatic(staticType); _resolutionExtensions = new ImpromptuLateLibraryType(staticType); }
private static bool TryHandleSingleton(Type type, out object instance) { var properties = type.GetProperties(); var desiredProperty = properties.FirstOrDefault(x => x.Name == "Instance" && x.PropertyType == type); if (desiredProperty == null) { instance = null; return(false); } instance = Dynamic.InvokeGet(InvokeContext.CreateStatic(type), desiredProperty.Name); // instance = desiredProperty.GetGetMethod().Invoke(null, Type.EmptyTypes); return(true); }
public void MethodStaticMethodValueTimed() { #if DEBUG Assert.Ignore("Visual Studio slows down dynamic too much in debug mode"); #endif var tStaticType = typeof(DateTime); var tTarget = InvokeContext.CreateStatic(tStaticType); string tDate = "01/20/2009"; Timer.Action1 = (() => { var tOut = Dynamic.InvokeMember(tTarget, "Parse", tDate); }); var tMethodInfo = typeof(DateTime).GetMethod("Parse", new[] { typeof(string) }); Timer.Action2 = (() => { var tOut = tMethodInfo.Invoke(tStaticType, new object[] { tDate }); }); var elapsed = Timer.Go(); Console.WriteLine("Impromptu: " + elapsed.Item1); Console.WriteLine("Refelection: " + elapsed.Item2); Console.WriteLine("Impromptu VS Reflection: {0}", TimeIt.RelativeSpeed(elapsed)); Assert.Less(elapsed.Item1, elapsed.Item2); }
public void GetStaticTimed() { #if DEBUG Assert.Ignore("Visual Studio slows down dynamic too much in debug mode"); #endif var tStaticType = typeof(DateTime); var tTarget = InvokeContext.CreateStatic(tStaticType); Timer.Action1 = (() => { var tOut = Dynamic.InvokeGet(tTarget, "Today"); }); var tMethodInfo = typeof(DateTime).GetProperty("Today").GetGetMethod(); Timer.Action2 = (() => { var tOut = tMethodInfo.Invoke(tStaticType, new object[] { }); }); var elapsed = Timer.Go(3 * TimeIt.Million); Console.WriteLine("Impromptu: " + elapsed.Item1); Console.WriteLine("Refelection: " + elapsed.Item2); Console.WriteLine("Impromptu VS Reflection: {0}", TimeIt.RelativeSpeed(elapsed)); Assert.Less(elapsed.Item1, elapsed.Item2); }
public void CacheableMethodStaticMethodValueTimed() { var tStaticType = typeof(DateTime); var tContext = InvokeContext.CreateStatic(tStaticType); string tDate = "01/20/2009"; var tCachedInvoke = new CacheableInvocation(InvocationKind.InvokeMember, "Parse", argCount: 1, context: tContext); Timer.Action1 = (() => { var tOut = tCachedInvoke.Invoke(tStaticType, tDate); }); var tMethodInfo = typeof(DateTime).GetMethod("Parse", new[] { typeof(string) }); Timer.Action2 = (() => { var tOut = tMethodInfo.Invoke(tStaticType, new object[] { tDate }); }); var elapsed = Timer.Go(); Console.WriteLine("Impromptu: " + elapsed.Item1); Console.WriteLine("Refelection: " + elapsed.Item2); Console.WriteLine("Impromptu VS Reflection: {0}", TimeIt.RelativeSpeed(elapsed)); Assert.Less(elapsed.Item1, elapsed.Item2); }
public StaticDynamicWrapper(Type target) : base(InvokeContext.CreateStatic(target)) { }
/// <summary> /// Visit a method call expression /// </summary> /// <param name="expCall"></param> /// <returns></returns> protected EToken VisitMethodCallExpression(MethodCallExpression expCall) { List <EToken> args = (from p in expCall.Arguments select this.VisitExpression(p, expCall)).ToList(); EToken expCallTargetExpression; if (expCall.Object == null) { // Here we should use FullName of declaring type, but a bug in Dynamic.Linq.Core prevents // usage of full namespaces and uses shortcut aliases only. // TODO: El tipo ExpressionType.Unbox aquí es incorrecto, debería ser null expCallTargetExpression = new EToken(expCall.Method?.DeclaringType?.Name, ExpressionType.Unbox, null); } else { // Métodos en objetos expCallTargetExpression = this.VisitExpression(expCall.Object, expCall); } bool canMaterializeMethodCall = args.All((i) => i.Type == ExpressionType.Constant) && (expCallTargetExpression.Type == ExpressionType.Constant || expCallTargetExpression.Type == ExpressionType.Unbox); if (canMaterializeMethodCall) { List <object> methodCallUnboxedArgs = new List <object>(); // Grab all arguments and remove them from the dictionary foreach (var arg in args) { methodCallUnboxedArgs.Add(this.PopArgument(arg.Text)); } object expCallResult; if (expCall.Object == null) { expCallResult = Dynamic.InvokeMember( InvokeContext.CreateStatic(expCall.Method?.DeclaringType), expCall.Method.Name, methodCallUnboxedArgs.ToArray()); } else { expCallResult = Dynamic.InvokeMember( this.PopArgument(expCallTargetExpression.Text), expCall.Method.Name, methodCallUnboxedArgs.ToArray()); } return(this.CheckMaterializationResult(expCallResult, expCall.Method.ReturnType)); } // If this method is LinqKit's Invoke() then we can do this ASAP because Dynamic.Linq.Core won't swallow complex method calls // We asume that the coder is looking for lazy evaluation if (expCall.Method.Name == "Invoke" && expCall.Method?.DeclaringType?.FullName.Contains("LinqKit") == true) { var targetOfInvoke = expCall.Arguments.First() as MethodCallExpression; var argumentsOfTargetInvoke = new List <object>(); foreach (var arg in targetOfInvoke.Arguments) { if (arg is ConstantExpression constant) { argumentsOfTargetInvoke.Add(constant.Value); } } // Materialize it! Currently only works with static calls var materializedTargetOfInvoke = Dynamic.InvokeMember( InvokeContext.CreateStatic(targetOfInvoke.Method?.DeclaringType), targetOfInvoke.Method.Name, argumentsOfTargetInvoke.ToArray()) as LambdaExpression; var result = this.VisitLambdaExpression(materializedTargetOfInvoke); // Replace the target source arguments for (int x = 0; x < materializedTargetOfInvoke.Parameters.Count; x++) { var expArg = materializedTargetOfInvoke.Parameters[x]; var externalArg = args[x + 1]; this.Parameters.Remove(expArg.Name); this.TempParameters.Remove(expArg.Name); result.Text = result.Text.Replace($"[{expArg.Name}]", externalArg.Text); } return(result); } return(new EToken($"{expCallTargetExpression}.{expCall.Method.Name}({args.StringJoinObject(", ")})", expCall.NodeType, expCall.Method.ReturnType)); }