Identical resources in 64-bit and 32-bit target
instruction-set platforms? Yes, very unpleasant situation. Main problem here is: you can never mix different instruction-set architectures in the same process. It can even compile bit will crash during run-time.
First of all, I don' understand the situation when you need them at the same time.
So first, let me explain it on a more usual case. You task is to identify if you can work in compliance with it. Let's see. Why do we need different target platform. Normally, we can have just one project. Suppose it is developed for the target "Any CPU", with all assemblies of the application using this target. In this case, you simply deploy the product to the system with any of the architectures (currently .NET supports three of them: x86, I64 (Itanium) and x86-64). Even though they are incompatible, the "Any CPU" assemblies will run on any platform, and the run-time instruction set will be defined by the host system. This is because the assemblies are JIT-compiled. In this schema, the problem of resources will never appear. It will work this way if all your code is pure .NET, without unmanaged components.
I hope the above schema can work for you, because below it goes
really advanced stuff. If you are still interested, keep reading.
There are situations where you have some unmanaged component which defines the instruction-set architecture of the whole application. This is the opposite situation: you can use only one instruction-set architecture. Again, the problem of different resource will not appear.
Finally, there are some more difficult situations when you need to change the structure of the projects depending on the target instruction-set architecture. For this purpose, you can create a sophisticated project or master project file using the features of MSBuild and common project format.
You can even automate switching the instruction-set architecture during build. You don't need two or more different solution, this is not supportable, please see:
http://en.wikipedia.org/wiki/Don%27t_repeat_yourself[
^].
Instead, you need only one solution which dynamically changes the target instruction-set architecture. To achieve that, you will need to learn project development for MSBuild. Please start here:
http://msdn.microsoft.com/en-us/library/dd637714.aspx[
^].
With this approach, you can have only one solution used for development and testing. The build will be automatic. You will need to have a master project written manually in the format used by MSBuild. It will take your development solution(s) or separate projects on input and will modify their properties (such as instruction-set architecture, optional modules, etc.) and will build two or more compilations of the solution and put them in different directories per target platform. It will take considerable learning and debugging of the development process. I've done this successfully in a reasonably short period of time and got a very stable one-click-builds-all process.
See also:
http://en.wikipedia.org/wiki/Instruction_set[
^].
—SA
Submit an article or tip