cil

Let's say I have a buggy application like this: using System; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Console.WriteLine("2 + 1 = {0}", Add(2, 1)); } static int Add(int x, int y) { return x + x; // <-- oops! } } } The application is already compiled and deployed into the wild. Someone has found the bug, and now they are requesting a fix for it. While I could re-deploy this application with the fix, its an extreme hassle for reasons outside of my control -- I just want to write a patch for the bug instead. Specifically, I want to insert my own MSIL into

As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance. Does anybody know any good resources for learning how to program CIL with in-depth descriptions of commands, etc.? I have looked around but not found anything particularly good. Curt Hagenlocher The only CIL book on my shelf is Expert .NET 2.0 IL Assembler

I am currently serializing SQL table rows into a binary format for efficient storage. I serialize/deserialize the binary data into a List<object> per row. I'm trying to upgrade this to use POCOs, that will be dynamically generated (emitted) with one Field per column. I've been searching online for hours and have stumbled upon ORMs/frameworks like EF, T4, ExpandoObject, but all of these either use a dynamic object (properties can be added/removed on the fly) or simply generate a POCO before compiling. I cannot use templating because the schema of the tables is unknown at compile time, and using

I would want to compile existing software into presentation that can later be run on different architectures (and OS). For that I need a (byte)code that can be easily run/emulated on another arch/OS ( LLVM IR? Some RISC assemby?) Some random ideas: Compiling into JVM bytecode and running with java. Too restricting? C-compilers available? MS CIL. C-Compilers available? LLVM? Can Intermediate representation be run later? Compiling into RISC arch such as MMIX. What about system calls? Then there is the system call mapping thing, but e.g. BSD have system call translation layers. Are there any

If I define a struct in C# using automatic properties like this: public struct Address { public Address(string line1, string line2, string city, string state, string zip) { Line1 = line1; Line2 = line2; City = city; State = state; Zip = zip; } public string Line1 { get; protected set; } public string Line2 { get; protected set; } public string City { get; protected set; } public string State { get; protected set; } public string Zip { get; protected set; } } When I attempt to build the file, I get a compilation error saying The 'this' object cannot be used before all of its fields are assigned

Why is it so easy to decompile .NET IL-code into source code, compared to decompiling native x86 binaries? (Reflector produces quite good source code most of the time, while decompiling the output of a C++ compiler is almost impossible.) Is it because IL contains a lot of meta data? Or is it because IL is a higher abstraction than x86 instructions? I did some research and found the following two usefull articles, but neither of them answers my question. MSIL Decompiler Theory C Decompiler - Quick primer I think you've got the most important bits already. As you say, there's more metadata

Is it possible to insert IL code to C# method? I just posted a utility which allows entire C# function bodies to be automatically replaced with inline IL, using a custom attribute. Like similar utilities, this works via the ILDASM/ILASM round-trip which can be set up as a post-build step. The tool also adjusts the PDB in order to preserve single-stepping and setting breakpoints on individual IL instructions in the debugger. It's different from some of the other round-trip IL inliners in that it (only) substitutes for entire function bodies, like this: class MyClass { [ILFunc(@" .locals init (

A few days back, while writing an answer for this question here on overflow I got a bit surprised by the C# compiler, who wasn’t doing what I expected it to do. Look at the following to code snippets: First: object[] array = new object[1]; for (int i = 0; i < 100000; i++) { ICollection<object> col = (ICollection<object>)array; col.Contains(null); } Second: object[] array = new object[1]; for (int i = 0; i < 100000; i++) { ICollection<object> col = array; col.Contains(null); } The only difference in code between the two snippets is the cast to ICollection<object>. Because object[] implements