#Define meta key code
The book also covers the alternative technologies of IL rewriting, using Cecil and PostSharp to produce and/or modify an existing assembly at the byte code level to add or augment classes and methods, and there is also information on the DLR, a technology associated with the implementation of the dynamic type in C#, which also acted as a compilation target for Ruby and Python when such languages were ported to the. The System.Core assembly contains a compiler for such expression trees that you can access via the type with its Compile method which can build a delegate from an Expression tree. Expression trees, originally added to support LINQ, offer an easier way for defining dynamic methods, using a tree structure of language agnostic object instances to express the desired functionality. This can be a little limiting, though it is also powerful as you have access to IL constructs that cannot be expressed in C#, such as fault handlers. The book moves on to Reflection.Emit for generating new assemblies, though this involves working at the IL level when defining new methods.
T4 templates, which you might use to define a data access layer and which are supported at compile time inside Visual Studio, and the CodeDom are studied in some detail. NET technologies for generating classes and methods, starting with techniques for generating and then compiling source code. The rest of the book looks at the various other. Reflection itself doesn’t allow you to add methods to existing classes or even define new classes and methods though so it is a little limited. Reflection only goes so far in this dimension – it certainly allows you to choose methods at runtime and even find methods that didn’t exist when your component was built. NET platform.Ĭhapter one discusses the need for metaprogramming and this is followed by chapter two which looks at the relationship between metaprogramming and Reflection. This book has a great discussion of what metaprogramming is, and describes how you might do it on the. Looking back at the many years I spent as a programmer using Common Lisp, I now realise that one thing I loved about that language was the ability to easily do metaprogramming, It was a fairly trivial exercise to write code that generated other code, whether the need was an embedded domain specific language (implemented via macros) or the generation of a test suite from a grammar definition (for an SQL interpreter that I wrote to enable external parties to query our object model).
0 kommentar(er)
