{"id":61,"date":"2010-05-19T19:18:00","date_gmt":"2010-05-19T17:18:00","guid":{"rendered":"http:\/\/dev.bratched.fr\/en\/?p=61"},"modified":"2010-05-19T19:18:00","modified_gmt":"2010-05-19T17:18:00","slug":"dynamic-methods-in-net","status":"publish","type":"post","link":"https:\/\/bratched.com\/en\/2010\/05\/19\/dynamic-methods-in-net\/","title":{"rendered":"Dynamic methods in .NET"},"content":{"rendered":"

Using reflection<\/a> to invoke methods which are not known at compile time might be problematic in performance critical applications. It is roughly 2.5-3.0 times slower than direct method calls. Here\u2019s a sample test I\u2019ve conducted:<\/p>\n

\n
class Program\n    {\n        [DllImport(\"kernel32.dll\")]\n        static extern void QueryPerformanceCounter(ref long ticks);\n\n        static PropertyInfo _intProp = typeof(Foo).GetProperty(\"IntProp\", BindingFlags.Public | BindingFlags.Instance);\n\n        static void Main(string[] args)\n        {\n            Foo foo = new Foo { IntProp = 10 };\n            const int COUNT = 1;\n            Console.WriteLine(Measure(() => ReadPropertyWithReflection(foo), COUNT));\n            Console.WriteLine(Measure(() => ReadPropertyDirectly(foo), COUNT));\n        }\n\n        static void ReadPropertyWithReflection(Foo foo)\n        {\n            int intProp = (int)_intProp.GetValue(foo, null);\n        }\n\n        static void ReadPropertyDirectly(Foo foo)\n        {\n            int intProp = foo.IntProp;\n        }\n\n        static long Measure(Action action, int count)\n        {\n            long startTicks = 0;\n            QueryPerformanceCounter(ref startTicks);\n            for (int i = 0; i < count; i++)\n            {\n                action();\n            }\n            long endTicks = 0;\n            QueryPerformanceCounter(ref endTicks);\n            return endTicks - startTicks;\n        }\n\n        class Foo\n        {\n            public int IntProp { get; set; }\n        }\n    }<\/pre>\n<\/div>\n
Here are the results:<\/p>\n\n\n\n\n\n
Method<\/strong><\/td>\nCPU units<\/strong><\/td>\n<\/tr>\n
Direct method invocation<\/td>\n796<\/td>\n<\/tr>\n
Reflection method invocation<\/td>\n1986<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
So using reflection to perform a single property read is 2.5 slower than direct property access.<\/p>\n
Dynamic methods can be used to generate and execute a method at run time, without having to declare a dynamic assembly and a dynamic type to contain the method. They are the most efficient way to generate and execute small amounts of code. Here\u2019s an example of using DynamicMethod<\/a> class to generate a getter for a given property:<\/p>\n
\n
static Func<Arg0, TReturn> EmitGetter<Arg0, TReturn>(PropertyInfo propertyInfo)\n    {\n        MethodInfo mi = propertyInfo.GetGetMethod();\n        DynamicMethod dm = new DynamicMethod(\n            \"_get\",\n            typeof(TReturn),\n            new Type[] { typeof(Arg0) },\n            propertyInfo.DeclaringType);\n\n        ILGenerator il = dm.GetILGenerator();\n        il.Emit(OpCodes.Ldarg_0);\n        il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);\n        il.EmitCall(OpCodes.Callvirt, mi, null);\n        il.Emit(OpCodes.Ret);\n\n        return (Func<Arg0, TReturn>)dm.CreateDelegate(typeof(Func<Arg0, TReturn>));\n    }<\/pre>\n<\/div>\n
Now using this method we can emit a getter method from a PropertyInfo<\/a> at run time and execute the returned delegate:<\/p>\n
\n
Func<Foo, int> getter = EmitGetter<Foo, int>(_intProp);\n    Console.WriteLine(Measure(() => getter(foo), COUNT));<\/pre>\n<\/div>\n
And here are the final results I\u2019ve obtained using three different methods to read a property value:<\/p>\n\n\n\n\n\n\n
Method<\/strong><\/td>\nCPU units<\/strong><\/td>\n<\/tr>\n
Direct method invocation<\/td>\n796<\/td>\n<\/tr>\n
Dynamic method invocation<\/td>\n1190<\/td>\n<\/tr>\n
Reflection method invocation<\/td>\n1986<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n","protected":false},"excerpt":{"rendered":"
Using reflection to invoke methods which are not known at compile time might be problematic in performance critical applications. It is roughly 2.5-3.0 times slower than direct method calls. Here\u2019s a sample test I\u2019ve conducted: class Program { [DllImport(“kernel32.dll”)] static extern void QueryPerformanceCounter(ref long ticks); static PropertyInfo _intProp = typeof(Foo).GetProperty(“IntProp”, BindingFlags.Public | BindingFlags.Instance); static void […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[263,266],"tags":[284,312],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t