Real world uses of Reflection.Emit

Question

In all the books I've read on reflection they often say that there aren't many cases where you want to generate IL on the fly, but they don't give any examples of where it does make sense.

After seeing Reflection.Emit as a job requirement for a gaming company I was curious where else it's being used.

I'm now wondering if there are any situations you've seen in the real world were it was the best solution to the problem. Perhaps it is used as an implementation to a design pattern?

Note I imagine PostSharp / AOP uses it.

PostSharp performs a post compile step but does not emit code at runtime. — Daniel Brückner, Feb 22 '10 at 17:20
I know it's a bit late in the game but - the very website we are using now (stackoverflow.com) is making heavy use of dapper, which makes (heavy) use of Reflection.Emit. — YS., Apr 27 '12 at 00:00
I thought Dapper used CodeDOM to generate the model classes. — Water Cooler v2, Jan 26 '14 at 16:49

score 15 · Answer 1 · edited May 23 '17 at 12:25

Expression.Compile essentially does this - that is key to some of LINQ.

I am currently using reflection emit to re-write a serialization API - because sometimes reflection just isn't good enough. As it happens this will also allow it to generate dlls (much like how sgen works), allowing fully static code (I'm hopeful this will make it iPhone friendly).

I also use a similar approach in HyperDescriptor to provide very fast name-based property-lookup.

I've also used emit to do things like:

all related to SO questions.

Finally, this IL approach is the core of protobuf-net "v2"; the reason here is that it allows me both to have a fast model at runtime (compiling it via IL on the fly), and to write the same directly to a static-compiled dll, so that it works on things like iPhone, Phone 7, etc (which lack the necessary meta-programming APIs).

could you please provide the links to those questions you mention? — Jordão, Jun 18 '10 at 00:19

score 13 · Answer 2 · answered Feb 22 '10 at 17:24

13

Dynamically generating a mock object which implements some interface. Example frameworks which do this: moq, rhino mocks.

answered Feb 22 '10 at 17:24

Wim Coenen

66,094
13
157
251

score 8 · Answer 3 · answered Feb 22 '10 at 17:11

8

I'm using it as a way to create dynamic proxies on the fly to wrap a class. NHibernate uses this same pattern to proxy calls to POCO objects to instead query a database.

Any time you want to be able to "write code" (i.e. create a new function, etc.) dynamically, you'll need Emit.

answered Feb 22 '10 at 17:11

David Pfeffer

38,869
30
127
202

3

That used to be more true before the System.Linq.Expressions namespace came into play with the `Compile()` method. – Sam Harwell Feb 22 '10 at 17:14
I should add that some phantom bugs silently resolved themselves when I switched some Emit code to Expressions code. It's cleaner and more maintainable for basically every place it applies to. – Sam Harwell Feb 22 '10 at 17:53
Expression Compile method has a huge limitation of working only on lambda without statement body – Eli Dagan Nov 16 '15 at 18:15

score 7 · Answer 4 · answered Feb 22 '10 at 17:18

7

Castle DynamicProxy uses it for, you guess, dynamic proxies. DynamicProxy is then used by the Castle's IoC container Windsor and OR mapper ActiveRecord.

answered Feb 22 '10 at 17:18

Daniel Brückner

59,031
16
99
143

1

...and Rhino Mocks and Moq and NHibernate and whole set of other frameworks and applications ;) – Krzysztof Kozmic Feb 23 '10 at 09:23

score 6 · Answer 5 · answered Feb 22 '10 at 17:17

6

The DLR and DLR related languages heavily rely on Reflection.Emit

answered Feb 22 '10 at 17:17

JaredPar

733,204
149
1,241
1,454

score 3 · Answer 6 · answered Feb 22 '10 at 17:40

I remember seeing Relection.Emit used in chapter 8: "On-the-Fly Code Generation for Image Processing" of Beautiful Code. Basicly the author specializes a function for doing a certain set of image processing operations on a given image, which in turn leads to greatly reduced execution time.

score 3 · Answer 7 · answered Jun 18 '10 at 11:33

3

I've used it in an application where a property had to be accessed repeatedly via reflection (because the property name was not known at compile time).

By creating a helper class at runtime that generates code to access the property, the resulting code was an order of magnitude faster than the original reflection-only code.

answered Jun 18 '10 at 11:33

Philippe Leybaert

168,566
31
210
223

I just wrote a library to do this, but it use `Expression` trees instead of `Reflection.Emit`. – Gabe Aug 23 '10 at 20:40

score 2 · Answer 8 · answered Feb 22 '10 at 17:16

2

The XMLSerializer actually generates code and compiles it on first run. You can read this great blog post on Scott Hanselman's site regarding how to debug XML Serialization if you know this is happening.

answered Feb 22 '10 at 17:16

Nick

5,875
1
27
38

1

The post suggest that XMLSerializer actually generates C# code and compiles it instead of emitting IL directly. – Daniel Brückner Feb 22 '10 at 17:25

score 2 · Answer 9 · answered Feb 22 '10 at 17:24

2

Mocking libraries also use Reflection.Emit to generate proxies used in Unit Testing.

answered Feb 22 '10 at 17:24

Nick

5,875
1
27
38

score 2 · Answer 10 · answered Jun 17 '10 at 23:58

I have recently used it to create a proof of concept for compiling a set of operations that's very expensive to do at runtime, and achieved a 200% improvement in speed. The operations were to use RegEx to parse a large string, and loop over the matches, use Reflection to find and instantiate types, and a bunch of other things that aren't exactly fast. By using IL emit, I created dynamic functions that matched a delegate type (using DynamicMethod) and cached them. I did the normal RegEx/Reflection dance once per input value to figure out what it should do, then used StringBuilder to concatenate the strings as literals, and instead of Reflection/Activator I now could use the actual types themselves in the emitted IL. Here's a helpful tip: don't try to write IL yourself unless you're a sado-masochist. Write a sample function or type in C# that does what you want, compile it, and use Reflector or ILDASM to see the generated IL. Then use Emit to do similar logic. Another tip is you can create locals and store them to variables, then use Emit(OpCodes.Ldloc, myLocalVar) and it'll get the local address for you, instead of having to keep track of the local index (i.e. ldloc_1).

score 2 · Answer 11 · answered Jul 03 '18 at 18:05

Generate declarative code, such as using interface to declare underlying HTTP REST service. https://github.com/neurospeech/retro-core-fit
Performance booster, most of the time I use Expression.Compile to create a fragment of code to retrieve information quickly by compiling giving expression to compiled delegate which can be executed in future. If you use PropertyInfo.GetValue, it is very slow, but if you create an expression to access property and compile it to a delegate (which internally uses Reflection.Emit), it is huge savings on CPU time.

score 1 · Answer 12 · answered Feb 22 '10 at 17:12

1

Duck Typing

answered Feb 22 '10 at 17:12

Yuriy Faktorovich

67,283
14
105
142

2

Interesting.. where would it make sense to use Duck Typing? – Ryu Feb 22 '10 at 17:21
For mocking, you might want IProcess proxies that use Process as an underlying implementation. – Warty Nov 21 '15 at 22:36
2

The link is dead. – Sinatr Aug 01 '17 at 11:26

user1575914 · Answer 13 · 2012-11-05T10:25:01.940

0

Reflection.Emit namespace is used to develop LinqPad.It helps to create typed Datacontexts dynamically. Check out this link http://www.linqpad.net/HowLINQPadWorks.aspx.

edited Nov 05 '12 at 10:25

answered Nov 05 '12 at 07:23

user1575914

5
1
3

score 0 · Answer 14 · answered Nov 24 '17 at 02:08

0

I like to explore more for AI-Inspired for self-learning. It allows us to create a class or module at run-time

answered Nov 24 '17 at 02:08

ronIT

1,035
1
9
6

score 0 · Answer 15 · answered Dec 25 '17 at 14:22

0

For instance Entity Framework uses Reflection.Emit to build proxy classes at run-time which inherit from your model classes to provide lazy loading and change tracking.

answered Dec 25 '17 at 14:22

Kamran

782
10
35

score 0 · Answer 16 · answered Jul 03 '18 at 17:44

Generating enums from external data:

Dynamic enum in C#

In that example the data comes from a lookup database and the enum is created at compile-time by reading out of the database. This maintains type-safety without having to manually maintain duplicate sources of information.

Davide Cannizzo · Answer 17 · 2019-06-02T13:30:46.057

I'm actually developing my own language and I'm building its compiler using .NET Framework's Reflection.Emit.
Someone could think that building a compiler using C# is not good, but things are actually working fine and compile-time performances are good enough. Also, this is obviously not related at all to the runtime performances, which will depend upon CLR, not my compiler (except for minimal optimization like operator precedence). I'll publish it on GitHub as soon as I'll have completed it.

Real world uses of Reflection.Emit

17 Answers17