.Net Are there potential problems when two versions of the same assembly are loaded in one AppDomain?

Question

Hi,

We've come up with a strategy to handle backward compatibility when there is a breaking change between two versions. We load the previous version assemblies in the current AppDomain, deserialize some data with the old version types and then convert these into their equivalent in the new version.

1. Are there any pitfalls with this approach that I should be aware of?
2. What would happen if I try to load a type by reflection when its assembly version is omitted, will it always load the latest version of the type if two version of it exists in the current AppDomain?

Edit:

Here is an scenario of question #2,

These two assemblies are loaded in the same AppDomain:

• MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089
• MyAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089

Both assembly define the type MyAssembly.MyType.

Then if some code use this kind of reflection:

Type t = Type.GetType("MyAssembly.MyType, MyAssembly, Culture=neutral, PublicKeyToken=b17a5c561934e089");

Will this call deterministically return MyAssembly.MyType, MyAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089?

I guess the same scenario would occur if I use BinaryFormatter.AssemblyFormat = FormatterAssemblyStyle.Simple when deserializing types that exists in two loaded version of the same assembly.

Answer 1

I'll work from the assumption that you use Assembly.LoadFile(). Reflection cannot really get you into trouble, it needs an Assembly reference to get the ball rolling. Your code is in control when it decides what Assembly reference to use. Clearly, you'll need the one you got from a previous call to LoadFile() if you'd want to load a type from the old version.

The LoadFile() call cannot otherwise mess up any other assembly resolves, the assembly is loaded without a loading context.