Question

I can build my C# project for x86 and for x64. Why? I thought it generates a special code which is not platform specific at all.

Answer 1

First, let me be blunt and say that I don’t know the whole story here, I’m going to answer with what I think I know. I’ll happily delete or change my answer if someone can tell me where I’m wrong.

The way I understand it, this setting is a flag that says “the assembly is supposed to be run in this type of architecture”. That’s for the x86 and x64 setting. The MSIL/.NET setting is just saying “I don’t care, I can run on either, so pick the one that is optimal or available.”

For instance, you might be making calls to Win32 API functions through P/Invoke, in which case the assembly won’t work on x64 and you should flag it as x86.

So if my understanding is correct, here’s how the three flags make the assembly run (note, it’s the main assembly, the program assembly, that dictates this, not each individual assembly for themselves) on different platforms:

Setting        x86      x64  <-- Platform (CPU/OS)
MSIL/.NET     32-bit   64-bit
x86           32-bit   32-bit
x64           N/A (*)  64-bit

The N/A for x64 assembly on x86 means that the assembly won’t load, and you’ll get an exception if you try.

Also note that conflicting settings involving x86 and x64 will make your program crash at one point or another. If the main assembly is set to x86, it will run as a 32-bit process on both a 32-bit and 64-bit operating system, and any attempts at loading assemblies flagged as x64 will fail. Likewise, if the main assembly is set to x64, it will only run on 64-bit operating system, and any attempt at loading an assembly set to x86 will fail.

A MSIL main executable assembly will run as 32-bit on a 32-bit operating system (like if it was set to x86, with the above failure point,) and as 64-bit on a 64-bit operating system (like if it was set to x64, with the above failure point.)

Obviously Typically, you want to go with the MSIL setting if you’re not calling assemblies that are flagged as something specific, and as long as you’re not doing P/Invoke that isn’t portable across 32-bit and 64-bit (I have no idea if this works, if P/Invoke to win-api functions will map to a correctly bitsized dll or not.)

Since references are pointers, and pointers are stored as a native x-bit address on the two platforms, depending on the amount of references you have, you might have a case against just going with MSIL. You should, however, verify that this is a problem before you make a change to your settings.