即使条件为真，也可以解决条件的错误部分

Question

I lately have had to change a piece of code to allow compatibility with an older version DLL. The DLLs have the same name and are not signed. The difference also is in some additional methods added to the new DLL.

One way to go about this which doesn't seem right to me is to reference the new DLL in the project, build and run. If you want to use the other DLL, you just replace it in the bin folder. You can avoid errors by just checking the existence of a method in a constructor somewhere using Reflection, and set a flag so that later on you can avoid calling the new functions if you are using the older version.

The strange thing to me is that the following piece of code doesn't work when using the old version:

int[] someVariable = (DLLIsNewFormat) ? DLL.CallNewMethod() : new int[5];

Basically what is happening is that the DLLIsNewFormat is False but for some reason I get the error:

Method not found: 'Int32[] [NameSpace].[Class].CallNewMethod()'.

I understand that the best way to go about this is to probably check if each function exists and then calling them using reflection. But I just don't know why the code is behaving this way. Is this just undefined behavior?

Answer 1

What you want is to hide calls to non-existing methods from JIT.

To do so you need to make sure each of non-existent calls made in inside a function and call to such function is controlled by version condition:

private int[] WrappedNewMethod()
{
  return DLL.CallNewMethod();
}

...SomeOtherMethod()
{
   int[] someVariable = (DLLIsNewFormat) ? WrappedNewMethod(): new int[5];
}

Answer 2

This is happening at the time that the method containing your snippet is JIT-compiled. In order for JIT-compilation to happen, the method needs to be available at the time the method is invoked. Since the method is not available, the JIT-compiler throws this exception when the method containing this code is called, before the method is even executed.

One way around this would be to define a new method:

int[] HideCall()
{
    return DLL.CallNewMethod();
}

Then call this method instead of DLL.CallNewMethod() directly.

A better solution would be to define an interface in an assembly that is referenced by both your "conditional DLL" and the assembly you are conditionally using this DLL from. Have a default implementation of this interface available in the main assembly, and an alternate implementation in the conditionally-used DLL.

Then, at runtime, you can simply see if the DLL is available, use reflection to construct an instance of the class that implements this interface, and then substitute out a the reference to your default implementation with this one.

Example code:

// Interface, in an assembly visible to both of the other assemblies.
public interface IDLLInterface
{
    int[] CallNewMethod();
}

// Implementation in the main program.
class DefaultDLLImplementation : IDLLInterface
{
    public int[] CallNewMethod()
    {
        return new int[5];
    }
}

static class DLLImplementation
{
    public readonly IDLLInterface Instance;

    static DLLImplementation()
    {
        // Pseudo-code
        if (DllIsAvailable) {
            Instance = ConstructInstanceFromDllUsingReflection();
        } else {
            Instance = new DefaultDLLImplementation();
        }
    }
}

Then you can use DLLImplementation.Instance.CallNewMethod() instead, and the right method will be called automatically.

Of course, I would suggest naming your interface with a more descriptive name so that it's apparent what it means.