Dynamic methods are useful to compiler writers when the type of an object is not known at compile time. Calls to the object's members must be resolved at run time, frequently with the additional overhead of manipulating argument lists. The following Visual Basic code provides an example of this.

Sub Example(ByVal obj as Object)
    ' ...
    obj.SomeMethod(x, y, z)
    ' ...
End Sub

The compiler must generate code to look up SomeMethod, prepare the arguments as an array of objects, and invoke the method. Executing such calls with reflection, using the InvokeMember method, does not provide good performance. Performance can be improved by using members of the System.Reflection.Emit namespace to create a dynamic assembly, module, type, and method, but this can result in a larger working set and greater code complexity. Dynamic methods allow a more efficient implementation strategy in cases where the dynamic method signature matches an existing delegate type, because there is no need to create a dynamic assembly, module, or type. This approach performs much better than using the InvokeMember method. It does not perform as well as a virtual call, but it requires a much smaller working set because no new types are created. Furthermore, the generated MSIL and associated native code can be reclaimed when no longer needed.

Dynamic methods can eliminate the need to write custom serialization and deserialization code. You can mark a serializable type according to simple rules and then use a serialization engine to examine the metadata for the type, generate an appropriate serializer and deserializer as needed, and run the generated code on instances of the type.

Given sufficient security permissions, a serialization engine implemented using dynamic methods can access private and protected data to enable serialization of objects not authored by the engine creator.

Generated methods can be cached if used frequently, or they can simply be released.

Partial evaluation, also known as program specialization, is a technique for optimizing algorithms where one or more of the input variables vary more slowly than the other inputs. Partial evaluation generates specialized method calls that treat the values of the slowly varying inputs as if they were constant, allowing additional optimizations to be applied to the algorithm as a whole.

Using this technique, it is often possible to transform a low-performance general-purpose algorithm into a high-performance specialized algorithm. The following are some examples:

• Compiling a Regex object to generate a program that is specialized to match on a particular pattern.

• Compiling a metadata-driven serialization engine into a program that is specialized to serialize and deserialize a specific type or set of types.

• Compiling an XML schema to generate a program that is specialized to validate a particular schema.

• Compiling an XSLT transformation into a program that is specialized to transform an XML document in a specific way.

• Compiling a generic encryption program that encrypts data using any specified key into a program that is optimized for a particular key.

Dynamic methods can be used to implement partial evaluation by generating specialized methods at run time. In addition to performance improvements, dynamic methods allow reclamation of the MSIL method bodies and the related machine code produced by the JIT compiler. This can be critical in long-running programs.

For a description of some of these scenarios in more detail, see Reflection Emit Application Scenarios.

Many applications or platforms have extensibility mechanisms that give users the ability to write and execute custom code while the application is running, frequently through the use of predefined functions. By using dynamic methods to generate this code, the application or platform designer can reduce the number of functions required (and hence the memory footprint) and provide more flexibility for the user without sacrificing performance.

Tasks

Concepts

Reference

Other Resources