How can I dynamically load the correct version-specific Tekla Structures DLLs at runtime in .NET?

Below is an explanation of why your current approach isn’t working along with some alternatives to achieve dynamic version binding for Tekla Structures DLLs.

---

Why Binding Redirects and AssemblyResolve Don't Work as Expected

When you reference an assembly directly in your project, Visual Studio (and the compiler) embeds a reference to that assembly’s specific version. At runtime, even if you add binding redirects in your application configuration file, the reference is treated as the “primary” binding. This means the CLR will always attempt to load the version that was used at compile time. In your case, even though you try to load a version‑specific DLL from a folder based on the running Tekla Structures version, Visual Studio (and the runtime) falls back to the version found in the Global Assembly Cache (GAC).

Binding redirects work best when:

• The new assembly is backward‑compatible.
• The reference version is not “hardwired” as the primary dependency (for example, via direct project references).

Because your application directly references the Tekla DLLs (or your “dummy” example) at compile time, the runtime binding rules force it to use the primary reference, regardless of your assembly resolver’s logic.

---

Alternatives for Dynamically Loading Version‑Specific Assemblies

To create an application that works dynamically with multiple Tekla Structures versions without recompiling for each version, consider one of these strategies:

1. Use Late Binding / Reflection

• Remove direct references
Instead of referencing the Tekla assemblies (or type libraries) in your main project, define interfaces or abstract classes in a separate, version‑independent assembly.

• Load at runtime
Use Assembly.LoadFrom or Assembly.LoadFile to load the correct version from a folder based on the Tekla Structures version. Then, use reflection or a dependency injection/factory pattern to create instances of the required types.

Example Idea:

CSHARPCopied
// Define an interface that your Tekla–based functionality should implement.
public interface ITeklaOperations
{
    void Execute();
}

Then in each version–specific plugin assembly (which you do build against the version of Tekla Structures of that year), implement the interface. At runtime, select and load the appropriate plugin assembly dynamically and cast the created object to ITeklaOperations.

2. Use a Plugin Architecture with Separate AppDomains

Another approach is to create a plugin mechanism where each Tekla Structures version is isolated in its own AppDomain. You load the correct version’s assembly in that separate application domain. This prevents version conflicts because the binding context is isolated from your main application.

High-level steps:

• Detect the running Tekla Structures version.
• Set up a new AppDomain with a private probe path (using the AppDomainSetup.PrivateBinPath or PrivateBinPathProbe).
• Load the version‑specific assembly into that AppDomain.
• Communicate with the loaded assembly using remoting or by abstracting its functionality via interfaces.

3. Utilize a Custom Assembly Loader

If possible, avoid static references to the Tekla DLLs. Instead, implement a custom assembly resolver that completely controls the loading mechanism. In this case, you prepare a “launcher” or bootstrapper that is version‑agnostic and then performs all necessary dynamic loads. Your main logic only deals with the factories or interfaces that are abstracted away from the actual Tekla assembly versions.

---

Summary

Because direct references cause your application to resolve the referenced DLL from the GAC or from the location it was originally loaded, binding redirects or the AssemblyResolve event cannot override this behavior. To load different Tekla Structures versions at runtime, you should remove direct references and utilize late binding (reflection), a plugin architecture (possibly with multiple AppDomains), or a custom assembly loader method. This design lets you select the right version’s assemblies dynamically at runtime based on the version of Tekla Structures that is running.