Including Common Intermediate Language to your .Net designer toolbox – generating CIL

Article
02/20/2004

An interesting technique is called generative programming, “is a software engineering paradigm based on modeling software system families such that, given a particular requirements specification, a highly customized and optimized intermediate or end-product can be automatically manufactured on demand from elementary, reusable implementation components by means of configuration knowledge” as stated by Krzysztof Czarnecki and Ulrich Eisenecker in “Generative Programming: Methods, Tools, and Applications”

See more at:

Components and Generative Programming

https://www.prakinf.tu-ilmenau.de/~czarn/esec99/

Generative and Component-Based Software Engineering

https://www.prakinf.tu-ilmenau.de/~czarn/generate/engl.html

Generative Programming - Methods, Tools, and Applications

https://www.generative-programming.org/

Heavy use of analysis techniques like domain engineering, conceptual modeling, commonality and variability analysis, are applied to help with software designs and implementations that are better aligned to the application logic in context. Looks like a very compelling paradigm.

Current implementation mechanisms include among others, C++ templates, generic programming and also the generators technique (programs that create programs).

Works with C++ templates are:

Reflective Metaprogramming in C++ by Daveed Vandevoorde

https://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1471.pdf

Generative Matrix Computation Library

https://www.prakinf.tu-ilmenau.de/~czarn/gmcl/

Another mechanism for implementing generative programming concepts is using the .Net System.Reflection.Emit namespace that allow a compiler or tool to emit metadata and Microsoft Common Intermediate Language (CIL) at run time and optionally generate a portable executable file on disk.

Let’s programmatically generate the same simplistic program we created at:

Including Common Intermediate Language to your .Net designer toolbox - the beginning

https://blogs.msdn.com/marcod/archive/2004/02/20/76836.aspx

Let’s create a console application with C#, create a text file with extension .cs

A starting point is an assembly name:

AssemblyName assemblyName=new AssemblyName();

assemblyName.Name="unogen";

Then we need an AppDomain object:

AppDomain appdomain=Thread.GetDomain();

It helps us to create our dynamic assembly:

AssemblyBuilder assembler =appdomain.DefineDynamicAssembly(assemblyName,AssemblyBuilderAccess.RunAndSave);

A module is created next:

ModuleBuilder moduler=assembler.DefineDynamicModule("unogen.exe");

With a global method:

MethodBuilder functor

=moduler.DefineGlobalMethod("start",MethodAttributes.Static|MethodAttributes.Public,null,null);

The CIL instructions inside the method are create with a ILGenerator:

ILGenerator emitter=functor.GetILGenerator();

emitter.EmitWriteLine("here uno is executing");

emitter.Emit(OpCodes.Ret);

moduler.CreateGlobalFunctions();

Lastly, we define our entry point and save the assembly to disk:

assembler.SetEntryPoint(functor);

assembler.Save("unogen.exe");

That’s it, the complete listing is:

using System;

using System.Threading;

using System.Reflection;

using System.Reflection.Emit;

class exe

{

static void Main(string[] args)

{