Metaprogramming in .NET

Editor's Notes

• #6: It’s all magic….but not really 
• #7: This is a pretty typical definition of metaprogramming.
• #8: So I co-authored a book… 
• #9: This is the definition I used in my book, but what does it mean? Let’s look at a couple of simple examples.
• #10: With C# 4, you can use the dynamic keyword to manipulate members at runtime.
• #11: In JavaScript, you can write code as a string, and have the JS environment evaluate the code for you (though eval is considered ‘evil’)
• #12: Metaprogramming can be viewed as taking complex code, and reducing its visibility. There’s still complex things to be done, but metaprogramming techniques can reduce it and lead you to a design where it’s relatively easy to manage
• #13: You’re going to acquire a new set of tools. Used wisely, it can make your programming life easier.
• #14: Doing metaprogramming in .NET requires some dedication to learn new ideas, use frameworks that may be unfamiliar, etc. However, keep at it. The further you go, the easier it becomes, and you’ll start to see your programs in a whole new way.
• #15: Reflection provides you to find out information about your code, and execute it if you want.
• #16: A testing framework uses reflection to find all of the test classes and test methods.
• #17: Here’s a simple piece of code, let’s look at how it would be represented in a Reflection graph
• #18: You have an assembly, types, methods, parameters, as well as events, properties, etc.
• #19: Here’s what that code sample looks like with its names.
• #20: If you’d want to get the type of the 2nd argument, here’s the code.
• #21: If you wanted to invoke a method on an object, here’s the code
• #22: While Reflection is a powerful tool for metaprogramming, it can be slow. Always consider performance when using Reflection.
• #24: You can generate code based on a template in Visual Studio. These are called Code Snippets
• #25: Once you create the snippet, you can import it via the Code Snippets Manager
• #26: And then use it in your code
• #27: How do I make a code snippet for ArgumentNullException?
• #28: There’s a tool called ILDasm that’s been in the .NET installation since 1.0. It lets you see the guts of an assembly at its metadata level…
• #29: ….and at the IL level.
• #30: With IL knowledge, you can do all sorts of tricks that C# or VB don’t support. For example, you can create generic attributes that can be consumed by C# and VB.
• #31: Knowing IL is required if you want to run new code at runtime. If you wanted to create a new type, SRE was the way to do it. If you just needed a new method, use DynamicMethod (added in 2.0)
• #32: With SRE, you can create dynamic proxies, which are used extensively by mocking engines.
• #33: So what the issue with IL? It’s harder to understand, and it’s pretty easy to mess up. Take this simple function.
• #34: Here’s the same function in IL.
• #35: If the ldstr op code is gone, it’ll probably compile in ilasm, but running it will create all sorts of issues (e.g. InvalidProgramException)
• #36: Expressions allow you to view your code as a data structure – a tree. Basing an API on that can make it safer to generate code.
• #37: Here’s what that function looks like as a dynamic method
• #38: Here’s what it looks like using the LINQ expressions API.
• #39: We’ve all seen the property name trick, which uses LINQ expressions. It’s a little slower, but it’s “safe”. But there’s some really cool things you can do with expressions, like genetic programming.
• #41: While C# doesn’t support AOP out-of-box, it’s possible through assembly parsing frameworks like Cecil or CCI to add aspects via the presence of attributes.
• #42: But you need good debugging experience
• #44: Traditionally, compilers are black boxes. You don’t get access to what’s going on, and there’s lot of valuable information within.
• #45: Roslyn opens up the compiler, providing APIs to different parts of the pipeline.
• #46: There’s lot of crazy things you can do if you can compile code on the fly. Let’s create a dynamic class that is a mock of another class (useful for testing)
• #47: Makes total sense, right? 
• #48: But I can take the generated proxy class, save it to disk, and step into the code
• #50: Knowing IL is required if you want to run new code at runtime. If you wanted to create a new type, SRE was the way to do it. If you just needed a new method, use DynamicMethod (added in 2.0)
• #51: Don’t fear metaprogramming. The tools may be a little more advanced than unusual, and you may need to invest some time, but it’s worth it.
• #52: Embrace metaprogramming. It’ll make your coding peaceful 
• #53: GitHub repos Csla.AutoAddBusinessRules CodeSnippets ExpressionEvolver Injectors Rocks References Code Snippets (C#) - https://msdn.microsoft.com/en-us/library/f7d3wz0k(v=vs.90).aspx Creating and Using IntelliSense Code Snippets - https://msdn.microsoft.com/en-us/library/vstudio/ms165392(v=vs.100).aspx Comparison of code generation tools - http://en.wikipedia.org/wiki/Comparison_of_code_generation_tools Sigil: Adding Some (More) Magic To IL - http://kevinmontrose.com/2013/02/14/sigil-adding-some-more-magic-to-il/ Visual Studio Code Snippets - http://visualstudiocodesnippets.com/ Visual Studio code snippets - http://www.codeproject.com/Articles/737354/Visual-Studio-code-snippets