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

Below is a summary of approaches you can take to avoid the issue of Visual Studio “pulling in” the version-specific DLLs via direct references:

---

The Problem: Direct Assembly References

When you reference the Tekla DLLs directly in your project, Visual Studio treats them as “primary” references and automatically resolves them from the GAC (or local bin) even if you remove the files from your bin folder. This prevents your AssemblyResolve handler or App.config binding redirects from taking effect because the runtime has already bound to the “primary” assembly.

---

Recommended Approaches

1. Late-Binding via Reflection

Remove the direct references from your project and instead load the assemblies dynamically at runtime. For instance, you can determine the running Tekla version (perhaps by inspecting the running process or other means) and then load the appropriate DLL using Assembly.LoadFrom. Once loaded, use reflection to create instances and call their methods.

A simplified example:

CSHARPCopied
string teklaVersion = GetTeklaVersion(); // Implement logic to determine current Tekla version.
string assemblyFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, teklaVersion);
string assemblyPath = Path.Combine(assemblyFolder, "Tekla.Structures.Model.dll");

Assembly teklaAssembly = Assembly.LoadFrom(assemblyPath);

// Use reflection to create instance & invoke method.
Type modelType = teklaAssembly.GetType("Tekla.Structures.Model.TeklaModel"); 
object teklaModel = Activator.CreateInstance(modelType);
MethodInfo method = modelType.GetMethod("SomeMethod");
method.Invoke(teklaModel, null);

This technique avoids having “primary” dependency–all calls use reflection or dynamically discovered interfaces.

---

2. Create a Plugin or Proxy Layer

Another common solution is to create an abstraction layer. Build a separate assembly that defines interfaces for the functionality you need from Tekla. Then, for each supported Tekla version, create a plugin (or adapter) that implements the interface. At runtime, load the correct plugin assembly based on the Tekla version and cast the dynamically created object to your interface.

A simplified workflow:

• Define an interface:

  CSHARPCopied
  public interface ITeklaModel
  {
      void SomeMethod();
  }

• Implement a plugin for Tekla 2023:

  CSHARPCopied
  // In Tekla2023Plugin.dll
  public class Tekla2023Model : ITeklaModel
  {
      public void SomeMethod()
      {
          // Use Tekla.Structures.Model.TeklaModel from Tekla 2023
      }
  }

• Load dynamically:

  CSHARPCopied
  string teklaVersion = GetTeklaVersion();
  string pluginPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, teklaVersion, "Tekla2023Plugin.dll");
  Assembly pluginAssembly = Assembly.LoadFrom(pluginPath);
  Type pluginType = pluginAssembly.GetTypes().First(x => typeof(ITeklaModel).IsAssignableFrom(x));
  ITeklaModel tekla = (ITeklaModel)Activator.CreateInstance(pluginType);
  tekla.SomeMethod();

This way, your core application depends only on your abstraction layer. Each Tekla-specific implementation is isolated so that changes in one version’s DLLs won’t affect your entire code base.

---

3. Using Application Domains (Advanced)

If you need even more isolation, you might consider creating separate AppDomains configured with their own probing paths for the correct Tekla version assemblies. This is more advanced and may not be necessary unless you have strict version isolation requirements.

---

Summary

• Avoid Direct References: Remove direct Tekla DLL references from your project to stop Visual Studio from forcing the GAC resolution.
• Dynamic Loading: Use Reflection (or a plugin pattern) to load assemblies from version-specific folders.
• Abstraction: Consider defining interfaces so your application core is decoupled from Tekla version details.

By using these techniques, you can dynamically load the appropriate version of the Tekla assemblies at runtime without having Visual Studio override your AssemblyResolve handler or binding redirect settings.

---

This approach allows you to support multiple Tekla Structures versions within a single application without needing to recompile for each version.