When can the System.Reflection.Emit namespace come in handy?

It seems that in .NET classes are provided that allow you to generate dynamically assemblies in a high-level language.

Why dive low?

2 answers 2

Reflection.Emit is for those who want to create dynamic assemblies (and not add something to existing ones) on pure IL (hardcore is shorter). More details below.

Or maybe you need something else and preferably simpler?

  • If you just need a dynamic type, maybe you just need dynamic or ExpandoObject ? And no code generation, the truth about the verification at the compilation stage can be forgotten.

  • Do you need a method (can also their group) that will accept and analyze lambda expressions? Then use Expression Trees. For simple cases it will be good, but if you decided to write your ORM, then this occupation is not at all simple. Remember that for Expression Trees, only single-line lambda expressions are supported.

  • If you need dynamically generated HTML (suddenly), and this is not a web application, then use RazorEngine . Also by simulating a web application, you can add support for Intellisense.

Code generation

In short: if you still need full code generation, use Roslyn. Because it is powerful and platform independent. T4 may also be useful (especially if you need non-C # and non-VB code).

Advantages and disadvantages of Reflection.Emit

Benefits

  • creating a dynamic assembly on pure IL: you have complete control of the code and can write highly optimized code. The advantage is that if there is any possibility not available in C #, but available in the CLR, you can also use it.
  • good code generation performance. The code you created is immediately compiled into an assembly (unlike Microsoft.CodeDom , but Roslyn is fine, because it pulls the compiler as a service).
  • platform-independent approach (unlike Microsoft.CodeDom , which is specific only to the Microsoft implementation, but Roslyn is also platform-independent)

disadvantages

  • you have to prescribe simple things like cycles (just a series of transitions). You have to think low. Therefore, it is difficult to create non-trivial programs.
  • You are required to generate a new build. If this suits you, then this is not a disadvantage. But if you want to add something to the existing one, then this is impossible with Reflection.Emit .

Based on this, decide whether you want to use Reflection.Emit or not. But I suppose it's quite hardcore.

Alternatives

  • Microsoft.CodeDom
  • Roslyn
  • T4

Microsoft.CodeDom vs Reflection.Emit

Ways of programming

The generated code using Microsoft.CodeDom can be part of the solution (LINQ to SQL, WSDL, XSD classes are generated in this way). You can also use partial classes to tweak generated code. When using Reflection.Emit you are required to create a new assembly.

When you use Reflecion.Emit you program with IL commands. When you program with Microsoft.CodeDom you create C # commands.

Therefore Microsoft.CodeDom will be easier to create Microsoft.CodeDom code, as you program with higher level commands. The code created on Reflecion.Emit will be more difficult to create on IL (for example, cycles will have to be created using transitions), especially when you program complex logic.

From this it follows that there are more opportunities on Reflection.Emit (so IL has more opportunities than C #). However, for every familiar thing in C #, you will have to write a lot more code.

Performance

The Microsoft.CodeDom code will be slower than Reflection.Emit , since it is compiled, then the C # code is generated, then this generated code is compiled. Reflection.Emit immediately compiled into an assembly.

Platform (non) dependency

As @Grundy correctly noted, this is platform independence for Reflecion.Emit . And Microsoft.CodeDom is available only on Microsoft platforms.

Roslyn (based on the question )

However, I would not use Microsoft.CodeDom . For Roslyn is more powerful and expressive.

  • Roslyn is on Mono (platform independent).
  • Roslyn, unlike Microsoft.CodeDom not just a wrapper on csc.exe, but can also analyze the code semantically, dynamically compile and parse the code. This is a way to create any tool for C # and VB. Therefore, there are possibilities from formatting the code to finding all the references in the solution for a given symbol.

T4

But what if you do not need a dynamically generated assembly, but need to supplement part of an existing solution?

Or if you need dynamically generated files, but not C # or VB? For example, say JavaScript or CSS. (For HTML, I recommend RazorEngine if that, but using T4 is also possible). Or some kind of exotic expansion. And yet, having aggravated the task, there are several of these files, but the number is known only at the time the code is executed.

Then you can use T4. This is a tool in Visual Studio (or just a console utility ) that is used to generate code for any language. Also available in MonoDevelop.

At once I will say that the Entity Framework (not. NET Core) uses T4.

Conceptually similar to ASPX, only code between C # -insert <# #> not necessarily HTML / CSS / JavaScript, but in the programming language of the target file. Manuals .

Of the minuses

  • There is no built-in support for syntax highlighting and Intellisense in Visual Studio, so you have to either get used or install third-party plug-ins for Visual Studio.
  • one
    Generating Files with the TextTransform Utility - Grundy
  • @Grundy added manual, true link, closer to the root. - Vadim Ovchinnikov
  • In my link, we are talking about a separate utility that can be run and get the result from a template. That is, it is not only in Visual Studio - Grundy
  • I would have taken Expression Trees to the very beginning, because, firstly, they cover most of the needs for dynamic code generation - and secondly, they conveniently decompose this code generation. - Pavel Mayorov
  • @Grundy Well, this is absolutely hardcore to create projects not in Visual Studio. - Vadim Ovchinnikov

As already mentioned in the previous answer, there are several ways of code generation. Some of them allow you to generate code in design time, i.e. in IDE (T4). The other is to generate C # code at runtime (CodeDom), and the third is to generate executable code (ie, IL) at runtime (Reflection.Emit).

And although it may seem that the latter case is quite rare, it is not. Without even thinking, you use this business all the time.

Compiled regular expressions

Yes, if you create a regular expression as follows: var regex = new Regex("abc", RegexOptions.Compiled); , the runtime will generate a class with a specialized state machine using Reflection.Emit, and will not interpret the regular expression each time.

Serializers

Yes, most serializers use reflection, but this is a very slow thing. Therefore, the same XmlSerializer will generate a special class of the serializer during execution and save it in a special folder for later use. The same approach is also used by the binary serializer, and Newtonsoft.Json, beloved by everyone, does not shy away from code generation.

PostSharp and other AOP

For example, we want to make a run-time decorator for logging. If we have a virtual method marked with the [LogMethod] attribute, then we can generate a class of an heir that will override this virtual method and log all method arguments, and then call the base implementation.

PostSharp and other AOP frameworks are built directly on the technology of code generation during execution.

Expression trees

Yes, Expression Trees in C # is a high-level construct, but the Expression.Compile method actually uses Reflection.Emit to generate code at runtime.

Object-to-object mappers

Any Automappers use Reflection.Emit to generate a match between the display of instances of one type to another.

ORM

This is a special case of mappers and they use code generation in full. NHibernate, LINQ 2 SQL, Entity Fraework, all generate classes at runtime to map objects to each other or to intercept calls to the repository method.

Mock frameworks

Rhyno Mocks, Moq and others, all of them are based either on Expression Trees or directly on Reflection.Emit (yes, many mock frameworks use DynamicProxy, which already uses Reflection.Emit) to generate stubs for testing.

WCF and other communication stuff

Yes, and they also generate various proxy classes for call inspection and other instrumentation during execution.

Application Insights and other loggers / analyzers

And again, in order to make the logging process as simple as possible, code generation is used in such tools.

DLR - Dynamic Languagage Runtime

The CLR has special functionality for interacting with dynamically typed languages, such as Python, Ruby etc. There, DLR is used to its fullest to increase productivity.

You will not believe it, but you can use Reflection.Emit (albeit indirectly) even to bypass the standard problems of the C # language.

Perhaps you know that the new T() restriction for generics is fear and horror. It uses reflection, which seriously affects performance, and it also wraps up exceptions that occurred when creating an instance in TargetInvocationException . I have already encountered in several projects that this method essentially spoils the end-to-end execution time. Therefore, these projects use a specialized CustomActivactor :

 public static class CustomActivator { public static T CreateInstance<T>() where T : new() { return ActivatorImpl<T>.Factory(); } private class ActivatorImpl<T> where T : new() { // Под колпаком используем Reflection.Emit! private static readonly System.Linq.Expressions.Expression<Func<T>> _expr = () => new T(); public static readonly Func<T> Factory = _expr.Compile(); } }

Now our activator does not suffer from performance problems and does not wrap exceptions from constructors into a boring TargetInvocationExpression .

ZY Actually, I touched only part of the scripts, the same ASP.NET uses code generation to the fullest. To understand the full picture, you can try to search for yourself. For example, you can search for the ILGenerator type or something else from the System.Reflection.Emit namespace:

  • On github : 40K links to ILGenerator (there is no semantic search there, so many links will not be valid, but will make it clear the scale of the tragedy).
  • in MS-a sorts : dozens of links and examples of use, most of which I cited earlier.

UPDATE: this topic has resulted in a rather long post on the subtleties of the work of the activator, generalizations and code generation - Dissecting the new () constraint in C #: a perfect example of a leaky abstraction .

  • why doesn't CustomActivator suffer from performance problems? If you add these same static fields to the generic class - will they fix the performance problem? - Grundy
  • Because it generates an IL to create an instance and this IL is cached. Therefore, there is no twitching reflection every time. - Sergey Teplyakov
  • that is, if you just add a static field in which you can immediately call expression.Compie() , then the inner class can be omitted? - Grundy
  • By the way. and why in that case simply not to collect the constructor's call in the expression? then the new() constraint is not necessary, is it? - Grundy
  • one
    @SergeyTeplyakov, let's solve the problem of only the default constructor, because you can pick up a call for anyone - Grundy