• line 3 subscribes to the AssemblyResolve event with &＃39;CurrentDomainAssemblyResolve&＃39; as a handler. This handler will be called whenever the AssemblyResolve event is invoked.
• lines 5 and 6 just suggest myClass does something to trigger the resolve event.
• line 11 gets the filename inside the ResolveEventArgs parameter.
• line 12 combines the filename with a custom assembly location (AssemblyVault constant) which would make up the full file path of the assembly that&＃39;s being resolved.
• line 13 checks whether this assembly file actually exists and line 14 attempts to load it before returning it.
• if the resolve handler was not able to locate the assembly, return null in line 17.

So far so good, now the embedded part.

3. Resolving an embedded assembly

As described in the previous chapter, in order to get the resolving of embedded assemblies working, we need to subscribe to the AssemblyResolve event that is invoked by the appdomain of the current thread (System.AppDomain.CurrentDomain).

The mechanism for resolving an embedded resource differs only in the way the Assembly is loaded. Consider the extended version of the CurrentDomainAssemblyResolve method from the previous chapter:

private static Assembly CurrentDomainAssemblyResolve(object sender, ResolveEventArgs args) { var assembly &＃61; System.AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a &＃61;> a.FullName &＃61;&＃61; args.Name); if (assembly !&＃61; null) return assembly; using (var stream &＃61; Assembly.GetExecutingAssembly().GetManifestResourceStream(GetResourceName(args.Name))) { if (stream !&＃61; null) { // Read the raw assembly from the resource var buffer &＃61; new byte[stream.Length]; stream.Read(buffer, 0, buffer.Length); // Load the assembly return Assembly.Load(buffer); } } return null; } private static string GetResourceName(string assemblyName) { var name &＃61; new AssemblyName(assemblyName).Name; return $"{EmbeddedResourceNamespace}.{name}.dll"; }

• lines 3-6 prevent the assembly from being loaded twice.
• line 8 creates the stream of the resource of which the name is calculated in the method starting in line 23. In other words, this is the stream containing our embedded resource.
• line 13-14 read the entire resource stream into a buffer.
• line 17 loads the assembly from a buffer and returns it.
• line 25-26 construct the name of the resource. Which consists of the &＃39;root&＃39; namespace for embedded resources (like &＃39;Coen.Utilities.Embedded&＃39;) and the name of the resource (like &＃39;ICSharpCode.SharpZipLib&＃39;) and the .dll extension.

Note again that this code snippet is simplified for explanation purposes. If you make your own AssemblyResolve handler, make sure to do proper exception handling.

The best time to subscribe to this event, is as soon as possible, before any other calls are made. Doing this manually by forcing the user to call an &＃39;Initialize&＃39;-method before he can use the assembly or a specific class, is not so user-friendly. It is better to subscribe to the AssemblyResolve event as soon as the assembly containing the embedded resource is loaded; using the module initializer described in the next chapter.

4. Adding a module initializer

A module initializer can be seen as a constructor for an assembly (technically it is a constructor for a module; each .NET assembly is comprised of one or more modules, typically just one). It is run when a module is loaded for the first time, and is guaranteed to run before any other code in the module runs, before any type initializers, static constructors or any other initialization code.

Why can&＃39;t I just use C# to do this?

Module initializers are a feature of the CLR that is not available in C#. C# cannot do this because it puts everything in a class/struct and module initializers need to be globally defined. This is why we will be injecting this module initializer into the MSIL (or as it is called: IL weaving) after the C# code is compiled.

Which library to use?

So, there are a few ways to create a module initializer. One way is to use Fody, the IL weaving library by Simon Cropp. This is a great library and definitely worth checking out.
However, for fun and to learn more about this technique, we&＃39;re going a little deeper and do it ourselves. For this we use the Mono.Cecil library, which is actually used by Fody as well.

Mono.Cecil

Cecil is an awesome project written by Jb Evain to generate and inspect programs and libraries in the ECMA CIL format. With Cecil, it is possible to load existing managed assemblies, browse all the contained types, modify them on the fly and save the modified assembly back to the disk ... Which is exactly what we need.

The trick

For the assembly containing the embedded resource we are going to create an internal class called ModuleInitializer, which will contain a public method called Initialize(). This Initialize-method subscribes to the AssemblyResolve event:

internal class ModuleInitializer
{ public static void Initialize() { System.AppDomain.CurrentDomain.AssemblyResolve &＃43;&＃61; CurrentDomainAssemblyResolve; } private static Assembly CurrentDomainAssemblyResolve(object sender, ResolveEventArgs args) { // Embedded resolve magic here } }

Nothing fancy here. Note that in this code snippet, the ModuleInitializer class is internal, so it cannot be called from outside the assembly. We don&＃39;t want any other calls made to this class other than our module initializer. Another important thing to note is that the public Initialize()-method is static and has no parameters. This is a requirement for using this technique and will be explained further on.

The trick comprises of a few steps:

• Read the compiled assembly.
• Find the Initialize() method in the compiled assembly.
• Create an assembly constructor using Mono.Cecil and make it call the Initialize() method
• Inject the constructor into the assembly
• Save the assembly and rewrite the program database (.pdb) to match the new assembly structure.

Notes:
We need to take into account that we may want the assembly to be strong named, which is why the final save-step will also take into account the key to sign the assembly.

Since injecting the module initializer into the assembly must be done in the MSIL, obviously this process needs to be a post-build step. I created a console application for this, so I can easily add it as a post-build event for any assembly I want to use this technique for.

The implementation

Let&＃39;s check out the code that makes this all happen. It consists of a public main Inject()-method calling other private methods that will be described further on.

When explaining the code, I will leave out any boiler-plate code required for this console application to work. If you want to check it out in its full glory, check out my GitHub project.

Inject()

Consider the following code of the method that will be the main entry for the console application after command line arguments have been parsed:

private AssemblyDefinition InjectionTargetAssembly { get; set; } public void Inject(string injectionTargetAssemblyPath, string keyfile &＃61; null) { // Validate the preconditions // - Does the injectionTargetAssemblyPath exist? // - If the keyfile is provided, does the file exist? try { // Read the injectionTarget ReadInjectionTargetAssembly(injectionTargetAssemblyPath); // Get a reference to the initializerMethod var initializerMethod &＃61; GetModuleInitializerMethod(); // Inject the Initializermethod into the assembly as a constructormethod InjectInitializer(initializerMethod); // Rewrite the assembly WriteAssembly(injectionTargetAssemblyPath, keyfile); } catch (Exception ex) { throw new InjectionException(ex.Message, ex); } }

• line 1 defines a private property in which the AssemblyDefinition is stored after the assembly has been read from file. AssemblyDefinition is a type defined in the Cecil library.
• ReadInjectiontargetAssembly() in line 12 reads the AssemblyDefinition from disk and stores in the InjectionTargetAssembly property.
• GetModuleInitializerMethod() in line 15 locates the Initialize() method in the assembly and returns it.
• line 18 calls the InjectInitializer() method, which creates the constructor and makes it call the Initialize() method.
• WriteAssembly() in line 21 rewrites the assembly.

This is the main structure of the Inject method. In the following paragraphs, each of the important calls will be further explained:

• ReadInjectionTargetAssembly()
• GetModuleInitializerMethod()
• InjectInitializer()
• WriteAssembly()

ReadInjectionTargetAssembly()

The ReadInjectionTargetAssembly-method reads the assembly in which the constructor should be injected. It also reads the Program Database (.pdb) file, if it could be located, in order to restructure its contents with respect to the changes made to the assembly after injecting the constructor.

private void ReadInjectionTargetAssembly(string assemblyFile) { var readParams &＃61; new ReaderParameters(ReadingMode.Immediate); if (GetPdbFilePath(assemblyFile) !&＃61; null) { readParams.ReadSymbols &＃61; true; readParams.SymbolReaderProvider &＃61; new PdbReaderProvider(); } InjectionTargetAssembly &＃61; AssemblyDefinition.ReadAssembly(assemblyFile, readParams); }

• line 3 defines the parameters for the read action. We want don&＃39;t want to defer reading to a later time, so set it to Immediate ReadingMode.
• line 5 determines whether a .pdb file is present
• line 7-8 configure the reader parameters to enable reading the symbols.
• line 11 reads the assembly using the configured reader parameters and stores the AssemblyDefinition into a private property &＃39;InjectionTargetAssembly&＃39; so it can be accessed in later stages.

GetModuleInitializerMethod()

After the target assembly was read, the GetModuleInitializerMethod is called, which locates the &＃39;Initialize&＃39; method that should be called by the injected constructor. After it has been located, some validation is done to ensure the call to this method can actually be made.

Note that in the following snippet the className and methodName are provided as parameters. In my proof of concept, I retrieved these via command line parameters of the injector program. They correspond with the classname/methodname of the target assembly&＃39;s module initializer class and method as defined in the previous subchapter The Trick.

private MethodReference GetModuleInitializerMethod(string className, string methodName) { if (InjectionTargetAssembly &＃61;&＃61; null) { throw new InjectionException("Unable to determine ModuleInitializer: InjectionTargetAssembly is null"); } // Retrieve the ModuleInitializer Class var moduleInitializerClass &＃61; InjectionTargetAssembly.MainModule.Types.FirstOrDefault(t &＃61;> t.Name &＃61;&＃61; className); if (moduleInitializerClass &＃61;&＃61; null) { throw new InjectionException($"No type found named &＃39;{className}&＃39;"); } // Retrieve the ModuleInitializer method var resultMethod &＃61; moduleInitializerClass.Methods.FirstOrDefault(m &＃61;> m.Name &＃61;&＃61; methodName); if (resultMethod &＃61;&＃61; null) { throw new InjectionException($"No method named &＃39;{methodName}&＃39; exists in the type &＃39;{moduleInitializerClass.FullName}&＃39;"); } // Validate the found method if (resultMethod.Parameters.Count > 0) { throw new InjectionException("Module initializer method must not have any parameters"); } // Initialize method cannot be private or protected if (resultMethod.IsPrivate || resultMethod.IsFamily) { throw new InjectionException("Module initializer method may not be private or protected, use public or internal instead"); } //Return type must be void if (!resultMethod.ReturnType.FullName.Equals(typeof(void).FullName)) { throw new InjectionException("Module initializer method must have &＃39;void&＃39; as return type"); } // Method must be static if (!resultMethod.IsStatic) { throw new InjectionException("Module initializer method must be static"); } return resultMethod; }

• line 1 is the method definition. Note that it returns a MethodReference type which references the details of the Module Initialize method inside the assembly.
• line 9 attempts to find the initializer class in the assembly&＃39;s main module.
• line 16 attempts to find the initialize method in the initializer class found in line 9.
• lines 23 and further make sure the initialize method has the required features:
• It should be parameterless
• It must be public or internal (preferably internal)
• Its return type should be void
• It must be static
• Special note for line 35. The reason this void-type comparison is made using the full names, is that we don&＃39;t want to compare types themselves. The void type in the current CLR, may differ from the one for which the target assembly is created. This would result in a false negative.

Now the assembly is read and the method is located that should be called by the constructor, we&＃39;re ready to modify the assembly.

InjectInitializer()

This method is where the magic happens.

private void InjectInitializer(MethodReference initializer) { if (initializer &＃61;&＃61; null) { throw new ArgumentNullException(nameof(initializer)); } const MethodAttributes Attributes &＃61; MethodAttributes.Static | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName; var initializerReturnType &＃61; InjectionTargetAssembly.MainModule.Import(initializer.ReturnType); // Create a new method .cctor (a static constructor) inside the Assembly var cctor &＃61; new MethodDefinition(".cctor", Attributes, initializerReturnType); var il &＃61; cctor.Body.GetILProcessor(); il.Append(il.Create(OpCodes.Call, initializer)); il.Append(il.Create(OpCodes.Ret)); var moduleClass &＃61; InjectionTargetAssembly.MainModule.Types.FirstOrDefault(t &＃61;> t.Name &＃61;&＃61; ""); if (moduleClass &＃61;&＃61; null) { throw new InjectionException("No module class found"); } moduleClass.Methods.Add(cctor); }

• line 8 defines a constant which will be important later. This constant defines the attribute of the static constructor method that we inject into the assembly. Module initializers should have the following attributes:
• Static - Indicates that the method is defined on the type; otherwise, it is defined per instance, which is something we don&＃39;t want in this case.
• SpecialName - Indicates that the method is special. The name describes how this method is special.
• RTSpecialName - Indicates that the common language runtime checks the name encoding.
• line 10 determines the return type of the static constructor by hijacking it from the initializer-method&＃39;s return type. This will always be void (we validated it before). The reason why we don&＃39;t want to use typeof(void) here, is the same why we didn&＃39;t compare void types before (line 35 in the GetModuleInitializerMethod()-method): The void type of the target assembly maybe different from the one in the current CLR.
• line 13 creates the method definition for the static constructor (or .cctor) with the given attributes and proper return type.
• line 14 gets an ILProcessor object which can be used to further modify the method body and inject whatever IL code we want to add.
• line 15 adds a call to the inject-method to the ILProcessor object
• line 16 adds a &＃39;return&＃39; to the ILProcessor object. This will exit the static constructor (in technical terms: pushing a return value from the callee&＃39;s evaluation stack onto the caller&＃39;s evaluation stack).
• line 18 gets the main module itself. This is the module to which we want to add our new static constructor method.
• line 25 adds the new static constructor to the module.

All this above is still done in memory; nothing has been changed to the assembly yet. This is what the last method in this sequence is for.

WriteAssembly()

The WriteAssembly method saves the changes to the assembly and modifies the .pdb file with respect to these changes. It is quite similar to the ReadInjectionTargetAssembly method we defined before.

private void WriteAssembly(string assemblyFile, string keyfile) { if (InjectionTargetAssembly &＃61;&＃61; null) { throw new InjectionException("Unable to write the Injection TargetAssembly: InjectionTargetAssembly is null"); } var writeParams &＃61; new WriterParameters(); if (GetPdbFilePath(assemblyFile) !&＃61; null) { writeParams.WriteSymbols &＃61; true; writeParams.SymbolWriterProvider &＃61; new PdbWriterProvider(); } if (keyfile !&＃61; null) { writeParams.StrongNameKeyPair &＃61; new StrongNameKeyPair(File.ReadAllBytes(keyfile)); } InjectionTargetAssembly.Write(assemblyFile, writeParams); }