System.BadImageFormatException: Could not load file or assembly

This bitness conflict often leads to exceptions like System.BadImageFormatException or System.IO.FileLoadException.

If your project references another assembly and their bitness does not match, you'll typically encounter the following exception:

System.BadImageFormatException: 'Could not load file or assembly <Name>. An attempt was made to load a program with an incorrect format.'

This exception occurs when the CLR (Common Language Runtime) attempts to load an assembly, but the architecture (x86 or x64) of the assembly does not match the current process or platform target.

If you are dynamically loading assemblies, for instance using Assembly.LoadFrom(), you'll likely see this exception:

System.IO.FileLoadException: 'Could not load file or assembly <Name>.'

This exception typically occurs if the assembly file cannot be loaded due to mismatched bitness or other platform-related issues.

Assemblies in .NET can be compiled for different platform targets: Any CPU, x86, or x64. When the bitness (32-bit vs 64-bit) of the assembly doesn’t match the process it's being loaded into, the .NET runtime cannot load the assembly correctly, and you end up with one of these exceptions.

• x86 (32-bit): The assembly is compiled to run on 32-bit processes.
• x64 (64-bit): The assembly is compiled to run on 64-bit processes.
• Any CPU: The assembly can run on either platform (32-bit or 64-bit), but it will load with the bitness of the process that is loading it.

This may involve changing the platform target of your project to ensure compatibility between all referenced assemblies.

• Right-click on your project, then select Properties.

• Go to the Build tab.

• Under Configuration, select All Configurations (or your specific build configuration like Debug or Release).

• Under Platform target, choose the appropriate platform:

  • Any CPU: The application can run on either 32-bit or 64-bit systems, depending on the architecture of the machine it’s running on.
  • x86: Forces the application to run as a 32-bit process.
  • x64: Forces the application to run as a 64-bit process.

When you set your project’s platform target to Any CPU, the application will run in 64-bit mode if the host machine is 64-bit, and in 32-bit mode if the host machine is 32-bit. For example, if you deploy an application compiled with Any CPU on a 64-bit system, the application and any referenced assemblies that also use Any CPU will run as 64-bit processes.

If you are using Any CPU, assemblies compiled with this setting will adapt to the architecture of the machine, meaning that on a 64-bit machine, everything will run in 64-bit mode. However, if there’s a referenced assembly that is specifically compiled for x86 or x64, you could still run into bitness issues.

Often, third-party assemblies are compiled for a specific architecture (x86 or x64). You cannot change their bitness, but you can change your own assembly's bitness to match the third-party assembly.