|
All you have to do is
1. Get the MethodInfo using reflection
2. Point a delegate to the methodInfo
3. invoke the delegate.
For faster performance just cache the delegate. That's it. Generating code has it's usage just not here!
Relativity
|
|
|
|
|
Great Tips!
I tried a test according to FatCatProgrammer mentioned, invoke by caching delegate gives very fast performance. (However using Emit is also a good idea)
delegate void SayDelegate(ref string a, out Person p, int avi);
...
MethodInfo methodInfo = t.GetMethod("Say");
SayDelegate s = (SayDelegate)Delegate.CreateDelegate(typeof(SayDelegate), p, methodInfo);
for (int i = 0; i < 1000000; i++)
{
s(ref word, out p, 3);
}
Result:
1000000 times invoked by Reflection: 123ms
1000000 times invoked by FastInvoke: 144ms
1000000 times invoked by DirectCall: 121ms
|
|
|
|
|
It is necessary if you don't know the method's signature until runtime
|
|
|
|
|
However if you don't know the method's signature then you'll never be able to correct call the FastInvokeHandler properly.
FastInvokeHandler(object target,
object[] paramters
Relativity
|
|
|
|
|
could you use your code with bsd license?
|
|
|
|
|
hi, can you please tell which license you use?
There's no license information attached?
|
|
|
|
|
I need something just like a fast method invoker, but instead of method invocation, i need to create instances of a runtimetype really fast.
Any ideas how to implement this?
public delegate object FastConstructorHandler(object[] paramters);
FastConstructorHandler GetConstructorInvoker(ConstructorInfo constructorInfo)
{
....
}
|
|
|
|
|
I tried to do it myself. Could some1 validate this, please?
The code uses some methods already defined in the FastMethodInvoker solution.
---------------------------
public static FastConstructorHandler CreateCtor(ConstructorInfo ctorInfo)
{
DynamicMethod dynamicMethod = new DynamicMethod(string.Empty,
typeof(object), new Type[] { typeof(object[]) }, ctorInfo.DeclaringType.Module, false);
ILGenerator il = dynamicMethod.GetILGenerator();
ParameterInfo[] ps = ctorInfo.GetParameters();
Type[] paramTypes = new Type[ps.Length];
LocalBuilder[] locals = new LocalBuilder[ps.Length];
for (int i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = ps[i].ParameterType;
locals[i] = il.DeclareLocal(paramTypes[i], true);
}
for (int i = 0; i < paramTypes.Length; i++)
{
il.Emit(OpCodes.Ldarg_0);
EmitFastInt(il, i);
il.Emit(OpCodes.Ldelem_Ref);
EmitCastToReference(il, paramTypes[i]);
il.Emit(OpCodes.Stloc, locals[i]);
}
for (int i = 0; i < paramTypes.Length; i++)
{
il.Emit(OpCodes.Ldloc, locals[i]);
}
il.Emit(OpCodes.Newobj, ctorInfo);
il.Emit(OpCodes.Ret);
return (FastConstructorHandler)dynamicMethod.CreateDelegate(typeof(FastConstructorHandler));
}
|
|
|
|
|
Sorry, my English is poor. I'm a Chinese.
But if the target type is "struct", the result is incorrect.
Code:
<br />
class Program<br />
{<br />
static void Main(string[] args)<br />
{<br />
Type t = typeof(Person);<br />
MethodInfo methodInfo = t.GetMethod("Say");<br />
Person person = new Person(30);<br />
methodInfo.Invoke(person, null);<br />
FastInvokeHandler fastInvoker = GetMethodInvoker(methodInfo);<br />
fastInvoker(person, null);<br />
Console.ReadLine();<br />
}<br />
}<br />
<br />
public struct Person<br />
{<br />
private readonly int _age;<br />
<br />
public Person(int age)<br />
{<br />
_age = age;<br />
}<br />
<br />
public void Say()<br />
{<br />
Console.WriteLine("My age is {0}.", _age);<br />
}<br />
}<br />
<br />
Result Is:
My age is 30.
My age is 1854584.
|
|
|
|
|
Excellent, I am now using this in my project, and it smoothly replaced the default dynamic invocation. Great work.
One thing to note - there is way to bring this one step closer to the "default dynamic invocation", by disabling the accessibility checks (public, private etc.), since the methodInfo.Invoke does not consider them as well.
To disable them, add one more "bool" parameter to the constructor of the DynamicMethod, with value "true" (skipVisibility parameter).
|
|
|
|
|
Thanks for your article.
Do you know how to make it work in Partial Trust environment?
DynamicMethod dynamicMethod = new DynamicMethod(string.Empty, typeof(object),
new Type[] { typeof(object), typeof(object[]) },
methodInfo.DeclaringType.Module);
...needs "Reflection.Emit" permission
, if I do this:
DynamicMethod dynamicMethod = new DynamicMethod(string.Empty, typeof(object),
new Type[] { typeof(object), typeof(object[]) } );
...the permission is not required, however the Invoke throws System.Security.VerificationException {"Operation could destabilize the runtime."}.
I would appreciate any ideas.
Thanks again for the great article.
|
|
|
|
|
// T is delegate, methodInfo can be private
static T GetDelegate<t>(object instance, MethodInfo methodInfo) where T : class
{
return Delegate.CreateDelegate(typeof(T), instance, methodInfo) as T;
}
call it like this:
delegate void SayDelegate(ref string word, out Person p, int avi);
...
Person person = new Person();
MethodInfo methodInfo = t.GetMethod("Say");
...
SayDelegate sayDelegate = GetDelegate<saydelegate>(person, methodInfo);
Stopwatch watch3 = new Stopwatch();
watch3.Start();
for (int i = 0; i < 1000000; i++)
{
sayDelegate(ref word, out p, 3);
}
watch3.Stop();
Console.WriteLine("1000000 times invoked: " + watch3.ElapsedMilliseconds + "ms");
|
|
|
|
|
Congratulations on finding a way to obfuscate standard calling conventions, and defeating the point of delegates all together.
Sure that would be an effective means to obtain it were the method private, and that's what you'd do if you -knew the signature-. That's the difference here.
The FastMethodInvoke is goal oriented at solving the problem of what you do when you -don't- know the signature of the method. You'd basically use it for a dynamic application that binds to methods indiscriminately. I use it for creating a fast constructor invoking system. Sure it only allows public members, but you rarely need a case where you invoke private members, if it's not your member you're invoking, that's fine, but if it's your own architecture you should be able to design it in a way where such methods aren't needed.
The same thing you have as above can be done like so, if Say is public:
SayDelegate sd = new SayDelegate(new Person().Say);
Stopwatch sw = new Stopwatch();
sw.Start();
Person p = null;
string s = "Test";
for (int i = 0; i < 1000000; i++)
sd(ref s, out p, 0);
sw.Stop();
Console.WriteLine(sw.Elapsed);
|
|
|
|
|
You are right, the signature is required to know.
But, there is small different, the method "say" can be assigned at runtime, not compile-time.
And this way has a fatal weakness, if the method is instance method and require to change the instance many times, this way will take much time.
(
the following Delegate method takes long time.
[MethodImpl(MethodImplOptions.InternalCall)]
private extern bool BindToMethodInfo(object target, RuntimeMethodHandle method, RuntimeTypeHandle methodType, DelegateBindingFlags flags);
)
|
|
|
|
|
You're using methods I don't really use. I never bound the method directly to a specific instance, which is why it required two arguments: one for the instance to refer to on the call, and two, for the parameters to make the call.
The FastMethodInvoker basically emits the object instance (Ldarg_0) and then the series of parameters (Ldarg_1 and then the members of the array are cast into new local values of the proper type, which are then pushed onto the stack.)
After the object and members are pushed to the stack you just call the method with the information provided (Callvirt). You can access private members if, rather than using the module of the type, you use the -DeclaringType- in creating the dynamic method. This associates the dynamic method to the scope of the type in general. So basically both methods have private method access (I stumbled on that by random chance.)
The FastMethodInvoker, by design, literally creates a new object-parameter list method on the fly. Which, as I'm sure you know by looking, there will be a slight hit in speed due to the copying of the parameters into local copies, but that's necessary since you're calling a method using an object array, you have to ensure the values are properly cast/unboxed before making the call.
I use a variant of this system on an inheritance constructor validation system. That is, because constructors, unlike all other (visible) members, do not inherit normally, ensuring derivations of a known design have the constructors needed to instantiate the inherited type(s) is indeed a chore (at a minimum using ugly reflection and checks specific to the individual case.) After verifying the constructor(s) exist(s) I can use this system to create a dynamic method that will instantiate the specific type(s) quickly. The reason I don't just use a simpler system like yours that doesn't emit the duplicate parameter:local listing is the specific signatures are defined through the root-type's constructor attributes. So the signatures would change case-by-case, depending on the specific needs of whoever uses it.
But I guess everyone has their own personal uses for things like this. It's select code that very few people would need.
Edit:
And on top of it all, I added parameter-count checks, primitive up-casting checks (if it requires a double for the parameter, a byte is fine since it's in the range of values, it now casts properly). Something this example lacked.
|
|
|
|
|
Excellent article = thank you. And, also thanks to Manuel Abadia[^] for his extensions to it.
I have extendend the work a little further, implementing a complete generic late-bound wrapper for a utilising these techniques. It allows for late binding of the default constructor, parameterised constructors, and both static and instance methods and properties. It automatically caches the generated IL (in static dictionaries, so it is avalable for all instances) when it is first called. Usage is like this:
<br />
Latebound<MyType> myType = new Latebound<MyType>(optional parameters);<br />
myType["MyProperty"] = value;<br />
value = myType["MyOtherProperty"];<br />
myType.Call("MyMethod", optional parameters);<br />
<br />
Latebound<MyType>.SetStatic("MyStaticProperty", value);<br />
value = Latebound<MyType>.GetStatic("MyStaticProperty");<br />
<br />
value = Latebound<MyType>.CallStatic("MyStaticMethod", optional parameters);<br />
<br />
The source for this class is available Here[^]
Regards
Mick
http://midimick.com/magicknet/magickDoc.html[^]
|
|
|
|
|
The link to the code doesnt seem to work.... Probably im doing something wrong!
|
|
|
|
|
I'm no huge freak over comments or structure, but there's practically no definition of what's happening in the method that does everything...
If you're interested, I've rewritten it into my preferred method, and it can be found here:
Optimized Method Call
Later,
-Allen Copeland Jr.
PS: I'm no IL guru, so the comments could be complete nonsense, let me know?
|
|
|
|
|
|
Hi Luyan,
Thanks much for your project. It was extremely helpful in some development work that I have recently done. I decided that I would send you a little wrapper class, and a test project that I did using your code. I couldn't quite find an email address for you, so I posted it on code project (FastInvokeWrapper.asp).
Of course, I botched up the links, so it's going to take a few days before it get's properly posted. Anyway, thanks again for your project.
Billy p.
|
|
|
|
|
I think the result is not exact. Before we invoke the target method,we should do preparetion to create the instance of target class,and get the MethodInfo of the target method. So, I think we should add them to the test.
I think we should test the following three method:
private static void Reflection()
{
string word = "hello";
Person p = null;
object[] param = new object[] { word, p, 3 };
Type tp = typeof(Person);
object person = new Person();
MethodInfo methodInfo = tp.GetMethod("Say");
methodInfo.Invoke(person, param);
}
private static void FastInvoke()
{
string word = "hello";
Person p = null;
Type t = typeof(Person);
object[] param = new object[] { word, p, 3 };
MethodInfo methodInfo = t.GetMethod("Say");
FastInvokeHandler fastInvoker = GetMethodInvoker(methodInfo);
Person person = new Person();
fastInvoker(person, param);
}
private static void DirectCall()
{
string word = "hello";
Person p = null;
Person person = new Person();
person.Say(ref word,out p, 3);
}
|
|
|
|
|
I'm agree with it.
When I modify the test as follows
<br />
Stopwatch watch = new Stopwatch();<br />
watch.Start();<br />
for (int i = 0; i < 1000; i++)<br />
{<br />
Type t = typeof(Person);<br />
MethodInfo methodInfo = t.GetMethod("Say");<br />
Person person = new Person();<br />
string word = "hello";<br />
Person p = null;<br />
object[] param = new object[] { word, p, 3 };<br />
methodInfo.Invoke(person, param);<br />
}<br />
watch.Stop();<br />
Console.WriteLine("1000 times invoked by Reflection: " + watch.ElapsedMilliseconds + "ms");<br />
<br />
Stopwatch watch1 = new Stopwatch();<br />
watch1.Start();<br />
for (int i = 0; i < 1000; i++)<br />
{<br />
Type t = typeof(Person);<br />
MethodInfo methodInfo = t.GetMethod("Say");<br />
Person person = new Person();<br />
string word = "hello";<br />
Person p = null;<br />
object[] param = new object[] { word, p, 3 };<br />
FastInvokeHandler fastInvoker = GetMethodInvoker(methodInfo);<br />
fastInvoker(person, param);<br />
}<br />
watch1.Stop();<br />
Console.WriteLine("1000 times invoked by FastInvoke: " + watch1.ElapsedMilliseconds + "ms");<br />
<br />
Stopwatch watch2 = new Stopwatch();<br />
watch2.Start();<br />
for (int i = 0; i < 1000; i++)<br />
{<br />
Person person = new Person();<br />
string word = "hello";<br />
Person p = null;<br />
person.Say(ref word, out p, 3);<br />
}<br />
watch2.Stop();<br />
Console.WriteLine("1000 times invoked by DirectCall: " + watch2.ElapsedMilliseconds + "ms");<br />
The result is
18ms
542ms
0ms
We can see before we can fast call the method,we already lose much more time to generate the instance.
Any suggestion about it?
|
|
|
|
|
That's true. If you call the method just ONE time, fastMethodInvoker is indeed slower than reflection. But if the method is called many times, you can buffer the FastInvokeHandler in a collection(Dictionary, etc.) at the first call for a better performance later.
|
|
|
|
|
I get MethodAccessException while using get properties on reference type generics. I works succesfully with value type generics however i couldn't find a solution for this. I also checked ildasm utility and the code generated looks like the same.
Do you have any solution for this ?
Generated IL Code :
IL_0000: ldarg.0
IL_0001: callvirt System.String get_Value2()/FastMethodInvoker.aField`1[System.String]
IL_0006: ret
Code:
<br />
public class aField<T><br />
{<br />
private T m_Value;<br />
public T Value2<br />
{<br />
get<br />
{<br />
return m_Value;<br />
}<br />
set<br />
{<br />
m_Value = value;<br />
}<br />
}<br />
}<br />
static void Main(string[] args)<br />
{<br />
aField<string> s = new aField<string>();<br />
s.Value2 = "test";<br />
<br />
aField<int> p = new aField<int>();<br />
p.Value2 = 5;<br />
<br />
Type t = s.GetType();<br />
<br />
MethodInfo methodInfo = t.GetProperty("Value2").GetGetMethod();<br />
}<br />
Can Erten
|
|
|
|
|
I found the solution from a previous post. On the dynamic method constructor we need to set skipVisibility to true.
<br />
DynamicMethod dm = new DynamicMethod("GetPropertyorField_" + methodName, typeof(object), new Type[] { typeof(object) },mod,true);<br />
However I didn't understand the cause of that since the property is public.
Also it works on aField<int> and is not working with aField<string> without modifying the dynamicmethod contructor. Any idea about the cause ?
Can Erten
|
|
|
|
|