This article will demonstrate one way to resolve the version conflict by using the 'Isolator.Fody' NuGet package to automatically isolate the add-in’s dependencies in a separate container using AssemblyLoadContext. All it takes is adding the [Isolator] attribute to the class.

A full Inventor and Vault sample application can be found on GitHub.

Previous articles have explained how to do this by directly modifying the add-in architecture and not referencing an external NuGet package.

What is AssemblyLoadContext?

• It's the runtime's provider for locating and loading dependencies. Whenever a dependency is loaded, an AssemblyLoadContext instance is invoked to locate it.
• AssemblyLoadContext provides a service of locating, loading, and caching managed assemblies and other dependencies.
• To support dynamic code loading and unloading, it creates an isolated context for loading code and its dependencies in their own AssemblyLoadContext instance.

How to update the add-in?

Update Project (.csproj) File

• Add the Isolator.Fody NuGet package reference.
• Add the WeaverConfiguration settings with the SkipIsolator set to false for an isolated AssemblyLoadContext or true for the default add-in behavior.

<ItemGroup>
    <PackageReference Include="Isolator.Fody" Version="1.0.0">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>build; compile</IncludeAssets>
    </PackageReference>
</ItemGroup>

<PropertyGroup>
    <WeaverConfiguration>
        <Weavers>
            <Isolator />
        </Weavers>
    </WeaverConfiguration>
</PropertyGroup>

Update Classes

• Add the [Isolator] attribute to classes that need to use the add-in's NuGet package versions instead of Autodesk's bundled versions.
• Do NOT add the [Isolator] attribute to classes that interact with Autodesk COM objects (ex. Inventor.Application, ButtonDefinition, ribbon UI code). COM interop requires the code to run in the default AssemblyLoadContext; isolating these classes will cause System.ArgumentException marshaling errors.
• If a class needs both COM interop and isolated dependencies, keep the COM code in a non-isolated class and delegate the isolated work to a separate [Isolator]-marked class.

// CANNOT isolate. Uses Inventor COM objects.
internal class MyButton : Button
{
    protected override void ButtonDefinition_OnExecute(NameValueMap context)
    {
        // Delegate to an isolated class for dependency-specific work.
        AssemblyInspector inspector = new();
        string result = inspector.DoIsolatedWork();
    }
}

// Safe to isolate. No COM interop.
[Isolator]
internal class AssemblyInspector
{
    public string DoIsolatedWork()
    {
        // Uses the add-in's version of Serilog, not Inventor's.
        Serilog.Log.Information("This runs in the isolated context");
        return typeof(Serilog.Log).Assembly.GetName().Version?.ToString() ?? "unknown";
    }
}

Notes

• <Isolator SkipIsolator='true' /> can replace <Isolator /> in the project file to temporarily disable isolation for debugging. Since false is the default, <Isolator /> and <Isolator SkipIsolator='false' /> are equivalent.
• Any typeof() calls for assemblies to be isolated must be placed inside the [Isolator]-marked class. If a Type is passed from a non-isolated class, it will resolve to the default context's version.
• When debugging, Visual Studio may prompt to find source files like ILTemplate.cs from a non-existent path (ex. D:\a\Isolator.Fody\...). This is the build server path embedded in the library's debug symbols and can be safely dismissed.
• This add-in format is compatible with Inventor versions using .NET Framework 4.8 or .NET 8. In .NET Framework, AppDomain is used instead of AssemblyLoadContext.
• This add-in format is compatible and works as an AppBundle with the Automation API.

References

• NuGet Package: Isolator.Fody
• GitHub Repo: Isolator.Fody
• Microsoft Learn - System.Runtime.Loader.AssemblyLoadContext
• GitHub - dotnet - AssemblyLoadContext.md

This article will demonstrate one way to resolve the version conflict by isolating the add-in’s dependencies in a separate container using AssemblyLoadContext.

A full sample application can be found on GitHub.

What is AssemblyLoadContext?

• It's the runtime's provider for locating and loading dependencies. Whenever a dependency is loaded, an AssemblyLoadContext instance is invoked to locate it.
• AssemblyLoadContext provides a service of locating, loading, and caching managed assemblies and other dependencies.
• To support dynamic code loading and unloading, it creates an isolated context for loading code and its dependencies in their own AssemblyLoadContext instance.

How to update the add-in?

Add IsolatedIExplorerExtension.cs

This is used as the new entry point into the add-in. It is a wrapper around the IExplorerExtension. It adds additional functionality behind the scenes but still exposes all methods called automatically by Vault.

• OnStartup(IApplication application) => Startup()
• OnLogOn(IApplication application) => LogOn()
• OnLogOff(IApplication application) => LogOff()
• OnShutdown(IApplication application) => Shutdown()
• CommandSites() => OnCommandSites()
• CustomEntityHandlers() => OnCustomEntityHandlers()
• DetailTabs() => OnDetailTabs()
• DockPanels() => OnDockPanels() (For Vault 2026+)
• HiddenCommands() => OnHiddenCommands()

using Autodesk.Connectivity.Explorer.Extensibility;
using System.ComponentModel;

namespace IsolatedVaultAddin.Isolation;

/// <summary>
///    <see cref="IExplorerExtension" /> is the entry point of the Vault addin.
///    This class is extended to have fully isolated addin dependency container.
///    Inherit this class and add custom logic to overrides of <see cref="Startup" />, <see cref="LogOn" />, <see cref="LogOff" />, <see cref="Shutdown" />, <see cref="OnCommandSites" />, <see cref="OnCustomEntityHandlers" />, <see cref="OnDetailTabs" />, <see cref="OnDockPanels" />, or <see cref="OnHiddenCommands" />.
/// </summary>
public abstract class IsolatedIExplorerExtension : IExplorerExtension
{
#if NETCOREAPP
    private object? _isolatedInstance;
#endif

    /// <summary>
    ///    Reference to the parameter in <see cref="IExplorerExtension.OnStartup" />, <see cref="IExplorerExtension.OnLogOn" />, <see cref="IExplorerExtension.OnLogOff" />, <see cref="IExplorerExtension.OnShutdown" />.
    /// </summary>
    public IApplication Application { get; private set; } = default!;

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnStartup(IApplication application)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnStartup), application);
            return;
        }
#endif

        Application = application;

#if NETCOREAPP
        Startup();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            Startup();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnLogOn(IApplication application)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnLogOn), application);
            return;
        }
#endif

        Application = application;

#if NETCOREAPP
        LogOn();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            LogOn();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnLogOff(IApplication application)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnLogOff), application);
            return;
        }
#endif

        Application = application;

#if NETCOREAPP
        LogOff();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            LogOff();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnShutdown(IApplication application)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnShutdown), application);
            return;
        }
#endif

        Application = application;

#if NETCOREAPP
        Shutdown();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            Shutdown();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public IEnumerable<CommandSite>? CommandSites()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke<CommandSite>(_isolatedInstance, nameof(CommandSites));
        }
#endif

#if NETCOREAPP
        return OnCommandSites();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnCommandSites();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public IEnumerable<CustomEntityHandler>? CustomEntityHandlers()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke<CustomEntityHandler>(_isolatedInstance, nameof(CustomEntityHandlers));
        }
#endif

#if NETCOREAPP
        return OnCustomEntityHandlers();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnCustomEntityHandlers();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public IEnumerable<DetailPaneTab>? DetailTabs()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke<DetailPaneTab>(_isolatedInstance, nameof(DetailTabs));
        }
#endif

#if NETCOREAPP
        return OnDetailTabs();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnDetailTabs();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

#if VAULT_HAS_DOCK_PANELS
    [EditorBrowsable(EditorBrowsableState.Never)]
    public IEnumerable<DockPanel>? DockPanels()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke<DockPanel>(_isolatedInstance, nameof(DockPanels));
        }
#endif

#if NETCOREAPP
        return OnDockPanels();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnDockPanels();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }
#endif

    [EditorBrowsable(EditorBrowsableState.Never)]
    public IEnumerable<string>? HiddenCommands()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke<string>(_isolatedInstance, nameof(HiddenCommands));
        }
#endif

#if NETCOREAPP
        return OnHiddenCommands();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnHiddenCommands();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin is loaded and <see cref="IExplorerExtension.OnStartup" /> method is executed.
    /// </summary>
    public abstract void Startup();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault is logged into and <see cref="IExplorerExtension.OnLogOn" /> method is executed.
    /// </summary>
    public abstract void LogOn();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault is logged out of and <see cref="IExplorerExtension.OnLogOff" /> method is executed.
    /// </summary>
    public abstract void LogOff();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin is unloaded and <see cref="IExplorerExtension.OnShutdown" /> method is executed.
    /// </summary>
    public abstract void Shutdown();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin ... and <see cref="IExplorerExtension.CommandSites" /> method is executed.
    /// </summary>
    public abstract IEnumerable<CommandSite>? OnCommandSites();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin ... and <see cref="IExplorerExtension.CustomEntityHandlers" /> method is executed.
    /// </summary>
    public abstract IEnumerable<CustomEntityHandler>? OnCustomEntityHandlers();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin ... and <see cref="IExplorerExtension.DetailTabs" /> method is executed.
    /// </summary>
    public abstract IEnumerable<DetailPaneTab>? OnDetailTabs();

#if VAULT_HAS_DOCK_PANELS
    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin ... and <see cref="IExplorerExtension.DockPanels" /> method is executed.
    /// </summary>
    public abstract IEnumerable<DockPanel>? OnDockPanels();
#endif    

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin ... and <see cref="IExplorerExtension.HiddenCommands" /> method is executed.
    /// </summary>
    public abstract IEnumerable<string>? OnHiddenCommands();
}

Add IsolatedIWebServiceExtension .cs

This is used as the new entry point into the add-in. It is a wrapper around the IWebServiceExtension. It adds additional functionality behind the scenes but still exposes all methods called automatically by Vault.

• OnLoad() => Load()

using Autodesk.Connectivity.WebServices;
using System.ComponentModel;

namespace IsolatedVaultAddin.Isolation;

/// <summary>
///    <see cref="IWebServiceExtension" /> is the entry point of the Vault addin.
///    This class is extended to have fully isolated addin dependency container.
///    Inherit this class and add custom logic to overrides of <see cref="Load" />.
/// </summary>
public abstract class IsolatedIWebServiceExtension : IWebServiceExtension
{
#if NETCOREAPP
    private object? _isolatedInstance;
#endif

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnLoad()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnLoad));
            return;
        }
#endif

#if NETCOREAPP
        Load();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            Load();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault addin is loaded and <see cref="IWebServiceExtension.OnLoad" /> method is executed.
    /// </summary>
    public abstract void Load();
}

Add IsolatedIJobHandler.cs

This is used as the new entry point into the add-in. It is a wrapper around the IJobHandler. It adds additional functionality behind the scenes but still exposes all methods called automatically by Vault.

• Execute(IJobProcessorServices context, IJob job) => OnExecute()
• CanProcess(string jobType) => OnCanProcess()
• OnJobProcessorStartup(IJobProcessorServices context) => JobProcessorStartup()
• OnJobProcessorShutdown(IJobProcessorServices context) => JobProcessorShutdown()
• OnJobProcessorWake(IJobProcessorServices context) => JobProcessorWake()
• OnJobProcessorSleep(IJobProcessorServices context) => JobProcessorSleep()

using Autodesk.Connectivity.Explorer.Extensibility;
using Autodesk.Connectivity.JobProcessor.Extensibility;
using System.ComponentModel;

namespace IsolatedVaultAddin.Isolation;

/// <summary>
///    <see cref="IJobHandler" /> is the entry point of the Vault job processor addin.
///    This class is extended to have fully isolated addin dependency container.
///    Inherit this class and add custom logic to overrides of <see cref="OnExecute" />, <see cref="OnCanProcess" />, <see cref="JobProcessorStartup" />, <see cref="JobProcessorShutdown" />, <see cref="JobProcessorWake" />, or <see cref="JobProcessorSleep" />.
/// </summary>
public abstract class IsolatedIJobHandler : IJobHandler
{
#if NETCOREAPP
    private object? _isolatedInstance;
#endif

    /// <summary>
    ///    Reference to the parameter in <see cref="IExplorerExtension.Execute" />, <see cref="IExplorerExtension.OnJobProcessorStartup" />, <see cref="IExplorerExtension.OnJobProcessorShutdown" />, <see cref="IExplorerExtension.OnJobProcessorWake" />, <see cref="IExplorerExtension.OnJobProcessorSleep" />.
    /// </summary>
    public IJobProcessorServices Context { get; private set; } = default!;

    /// <summary>
    ///    Reference to the parameter in <see cref="IExplorerExtension.Execute" />.
    /// </summary>
    public IJob Job { get; private set; } = default!;

    /// <summary>
    ///    Reference to the parameter in <see cref="IExplorerExtension.CanProcess" />.
    /// </summary>
    public string JobType { get; private set; } = default!;

    [EditorBrowsable(EditorBrowsableState.Never)]

    public JobOutcome Execute(IJobProcessorServices context, IJob job)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke(_isolatedInstance, nameof(Execute), context, job);
        }
#endif

        Context = context;
        Job = job;

#if NETCOREAPP
        return OnExecute();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnExecute();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public bool CanProcess(string jobType)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            return AddinLoadContext.Invoke(_isolatedInstance, nameof(CanProcess), jobType);
        }
#endif

        JobType = jobType;

#if NETCOREAPP
        return OnCanProcess();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            return OnCanProcess();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnJobProcessorStartup(IJobProcessorServices context)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnJobProcessorStartup), context);
            return;
        }
#endif

        Context = context;

#if NETCOREAPP
        JobProcessorStartup();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            JobProcessorStartup();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnJobProcessorShutdown(IJobProcessorServices context)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnJobProcessorShutdown), context);
            return;
        }
#endif

        Context = context;

#if NETCOREAPP
        JobProcessorShutdown();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            JobProcessorShutdown();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnJobProcessorWake(IJobProcessorServices context)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnJobProcessorWake), context);
            return;
        }
#endif

        Context = context;

#if NETCOREAPP
        JobProcessorWake();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            JobProcessorWake();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public void OnJobProcessorSleep(IJobProcessorServices context)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(OnJobProcessorSleep), context);
            return;
        }
#endif

        Context = context;

#if NETCOREAPP
        JobProcessorSleep();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            JobProcessorSleep();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault job processor is ... and <see cref="IJobHandler.ExecuteAsync" /> method is executed.
    /// </summary>
    public abstract JobOutcome OnExecute();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault job processor is ... and <see cref="IJobHandler.CanProcess" /> method is executed.
    /// </summary>
    public abstract bool OnCanProcess();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault job processor is ... and <see cref="IJobHandler.OnJobProcessorStartup" /> method is executed.
    /// </summary>
    public abstract void JobProcessorStartup();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault job processor is ... and <see cref="IJobHandler.OnJobProcessorShutdown" /> method is executed.
    /// </summary>
    public abstract void JobProcessorShutdown();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault job processor is ... and <see cref="IJobHandler.OnJobProcessorWake" /> method is executed.
    /// </summary>
    public abstract void JobProcessorWake();

    /// <summary>
    ///    Overload this method to execute custom logic when the Vault job processor is ... and <see cref="IJobHandler.OnJobProcessorSleep" /> method is executed.
    /// </summary>
    public abstract void JobProcessorSleep();
}

Add AddinLoadContext.cs

This is a custom implementation of the AssemblyLoadContext specifically for the format of a Vault add-in.

#if NETCOREAPP
using Autodesk.Connectivity.Explorer.Extensibility;
using Autodesk.Connectivity.JobProcessor.Extensibility;
using Autodesk.Connectivity.WebServices;
using System.Reflection;
using System.Runtime.Loader;

namespace IsolatedVaultAddin.Isolation;

/// <summary>
///    Isolated addin dependency container.
/// </summary>
/// <remarks>
///    References:
///    <a href="https://learn.microsoft.com/en-us/dotnet/core/tutorials/creating-app-with-plugin-support">
///    Microsoft/Tutorials/Plugins
///    </a>
///    <a href="https://github.com/dotnet/coreclr/blob/v2.1.0/Documentation/design-docs/assemblyloadcontext.md">
///    GitHub/DotNet/CoreCLR
///    </a>
/// </remarks>
internal sealed class AddinLoadContext : AssemblyLoadContext
{
    /// <summary>
    ///   Add-ins contexts storage.
    /// </summary>
    private static readonly Dictionary<string, AddinLoadContext> _dependenciesProviders = new(1);

    private readonly AssemblyDependencyResolver _resolver;

    private const BindingFlags MethodSearchFlags = BindingFlags.Public | BindingFlags.Instance;

    private AddinLoadContext(Type type, string addinName) : base(addinName)
    {
        string addinLocation = type.Assembly.Location;

        _resolver = new AssemblyDependencyResolver(addinLocation);
    }

    /// <summary>
    ///   Resolve and load dependency any time one is loaded if it exists in the isolated addin dependency container.
    /// </summary>
    protected override Assembly? Load(AssemblyName assemblyName)
    {
        string? assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);

        return assemblyPath is not null
             ? LoadFromAssemblyPath(assemblyPath)
             : null;
    }

    /// <summary>
    ///   Resolve and load unmanaged native dependency any time one is loaded if it exists in the isolated addin dependency container.
    /// </summary>
    protected override nint LoadUnmanagedDll(string assemblyName)
    {
        string? assemblyPath = _resolver.ResolveUnmanagedDllToPath(assemblyName);

        return assemblyPath is not null
             ? LoadUnmanagedDllFromPath(assemblyPath)
             : nint.Zero;
    }

    /// <summary>
    ///   Determine if the <see cref="AssemblyLoadContext" /> is custom or still the default context.
    /// </summary>
    public static bool CheckIfCustomContext(Type type)
    {
        AssemblyLoadContext? currentContext = GetLoadContext(type.Assembly);

        return currentContext != Default;
    }

    /// <summary>
    ///     Get or create a new isolated context for the type.
    /// </summary>
    public static AddinLoadContext GetDependenciesProvider(Type type)
    {
        // Assembly location used as context name and the unique provider key.
        string addinRoot = System.IO.Path.GetDirectoryName(type.Assembly.Location)!;
        if (_dependenciesProviders.TryGetValue(addinRoot, out var provider))
        {
            return provider;
        }

        string addinName = System.IO.Path.GetFileName(addinRoot);
        provider = new AddinLoadContext(type, addinName);
        _dependenciesProviders.Add(addinRoot, provider);

        return provider;
    }

    /// <summary>
    ///   Create new instance in the separated context.
    /// </summary>
    public object CreateAssemblyInstance(Type type)
    {
        string assemblyLocation = type.Assembly.Location;
        Assembly assembly = LoadFromAssemblyPath(assemblyLocation);

        return assembly.CreateInstance(type.FullName!)!;
    }

    /// <summary>
    ///   Execute <see cref="IExplorerExtension.OnStartup" />, <see cref="IExplorerExtension.OnLogOn" />, <see cref="IExplorerExtension.OnLogOff" />, <see cref="IExplorerExtension.OnShutdown" /> methods in the isolated context.
    /// </summary>
    /// <remarks>
    ///   Matches parameter format of <see cref="IExplorerExtension.OnStartup" />, <see cref="IExplorerExtension.OnLogOn" />, <see cref="IExplorerExtension.OnLogOff" />, <see cref="IExplorerExtension.OnShutdown" /> methods.
    /// </remarks>
    public static void Invoke(object instance, string methodName, IApplication application)
    {
        Type instanceType = instance.GetType();

        Type[] methodParameterTypes =
        [
             typeof(IApplication)
        ];

        object[] methodParameters =
        [
             application
        ];

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, methodParameterTypes, null)!;

        _ = method.Invoke(instance, methodParameters)!;
    }

    /// <summary>
    ///   Execute <see cref="IJobHandler.OnJobProcessorStartup" />, <see cref="IJobHandler.OnJobProcessorShutdown" />, <see cref="IJobHandler.OnJobProcessorWake" />, <see cref="IJobHandler.OnJobProcessorSleep" /> methods in the isolated context.
    /// </summary>
    /// <remarks>
    ///   Matches parameter format of <see cref="IJobHandler.OnJobProcessorStartup" />, <see cref="IJobHandler.OnJobProcessorShutdown" />, <see cref="IJobHandler.OnJobProcessorWake" />, <see cref="IJobHandler.OnJobProcessorSleep" /> methods.
    /// </remarks>
    public static void Invoke(object instance, string methodName, IJobProcessorServices context)
    {
        Type instanceType = instance.GetType();

        Type[] methodParameterTypes =
        [
             typeof(IJobProcessorServices)
        ];

        object[] methodParameters =
        [
             context!
        ];

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, methodParameterTypes, null)!;

        _ = method.Invoke(instance, methodParameters)!;
    }

    /// <summary>
    ///   Execute <see cref="IJobHandler.Execute" /> method in the isolated context.
    /// </summary>
    /// <remarks>
    ///   Matches parameter format of <see cref="IJobHandler.Execute" /> method.
    /// </remarks>
    public static JobOutcome Invoke(object instance, string methodName, IJobProcessorServices context, IJob job)
    {
        Type instanceType = instance.GetType();

        Type[] methodParameterTypes =
        [
             typeof(IJobProcessorServices),
             typeof(IJob)
        ];

        object[] methodParameters =
        [
             context!,
             job!
        ];

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, methodParameterTypes, null)!;

        return (JobOutcome)method.Invoke(instance, methodParameters)!;
    }

    /// <summary>
    ///   Execute <see cref="IJobHandler.CanProcess" /> method in the isolated context.
    /// </summary>
    /// <remarks>
    ///   Matches parameter format of <see cref="IJobHandler.CanProcess" /> method.
    /// </remarks>
    public static bool Invoke(object instance, string methodName, string jobType)
    {
        Type instanceType = instance.GetType();

        Type[] methodParameterTypes =
        [
             typeof(string)
        ];

        object[] methodParameters =
        [
             jobType
        ];

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, methodParameterTypes, null)!;

        return (bool)method.Invoke(instance, methodParameters)!;
    }

    /// <summary>
    ///   Execute <see cref="IWebServiceExtension.OnLoad" /> method in the isolated context.
    /// </summary>
    /// <remarks>
    ///   Matches parameter format of <see cref="IWebServiceExtension.OnLoad" /> method.
    /// </remarks>
    public static void Invoke(object instance, string methodName)
    {
        Type instanceType = instance.GetType();

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, [], null)!;

        _ = method.Invoke(instance, [])!;
    }

    /// <summary>
    ///   Execute <see cref="IExplorerExtension.CommandSites" /> method in the isolated context.
    /// </summary>
    /// <remarks>
    ///   Matches parameter format of <see cref="IExplorerExtension.CommandSites" /> method.
    /// </remarks>
    public static IEnumerable<T>? Invoke<T>(object instance, string methodName)
    {
        Type instanceType = instance.GetType();

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, [], null)!;

        return (IEnumerable<T>?)method.Invoke(instance, [])!;
    }
}
#endif

Add ResolveHelper.cs

This is a helper class used to resolve conflicting versions of a dependency.

using System.Reflection;
#if NETCOREAPP
using System.Runtime.Loader;
#endif

namespace IsolatedVaultAddin.Isolation;

/// <summary>
///    Used to resolve conflicting versions of a dependency.
/// </summary>
public static class ResolveHelper
{
    private static string? _moduleDirectory;
    private static object? _domainResolvers;

    /// <summary>
    ///    Subscribes the current domain to resolve dependencies for the type.
    /// </summary>
    /// <typeparam name="T">
    ///    Type, to search for dependencies in the directory where this type is defined.
    /// </typeparam>
    /// <remarks>
    ///    Dependencies are searched in a directory of the specified type.
    ///    At the time of dependency resolution, all other dependency resolution methods for the domain are disabled,
    ///    this requires calling <see cref="EndAssemblyResolve" /> immediately after executing user code where dependency failures occur.
    /// </remarks>
    public static void BeginAssemblyResolve<T>()
    {
        BeginAssemblyResolve(typeof(T));
    }

    /// <summary>
    ///    Subscribes the current domain to resolve dependencies for the type.
    /// </summary>
    /// <param name="type">
    ///    Type, to search for dependencies in the directory where this type is defined.
    /// </param>
    /// <remarks>
    ///    Dependencies are searched in a directory of the specified type.
    ///    At the time of dependency resolution, all other dependency resolution methods for the domain are disabled,
    ///    this requires calling <see cref="EndAssemblyResolve" /> immediately after executing user code where dependency failures occur.
    /// </remarks>
    public static void BeginAssemblyResolve(Type type)
    {
        if (_domainResolvers is not null)
            return;
        if (type.Module.FullyQualifiedName == "<Unknown>")
            return;

#if NETCOREAPP
        var loadContextType = typeof(AssemblyLoadContext);
        var resolversField = loadContextType.GetField("AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)!;
        var resolvers = resolversField.GetValue(null);
        resolversField.SetValue(null, null);
#else
        var domainType = AppDomain.CurrentDomain.GetType();
        var resolversField = domainType.GetField("_AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)!;
        var resolvers = resolversField.GetValue(AppDomain.CurrentDomain);
        resolversField.SetValue(AppDomain.CurrentDomain, null);
#endif

        _domainResolvers = resolvers;
        _moduleDirectory = System.IO.Path.GetDirectoryName(type.Module.FullyQualifiedName);

        AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
    }

    /// <summary>
    ///    Unsubscribes the current domain to resolve dependencies for the type.
    /// </summary>
    public static void EndAssemblyResolve()
    {
        if (_domainResolvers is null)
            return;

#if NETCOREAPP
        var loadContextType = typeof(AssemblyLoadContext);
        var resolversField = loadContextType.GetField("AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)!;
        resolversField.SetValue(null, _domainResolvers);
#else
        var domainType = AppDomain.CurrentDomain.GetType();
        var resolversField = domainType.GetField("_AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)!;
        resolversField.SetValue(AppDomain.CurrentDomain, _domainResolvers);
#endif

        _domainResolvers = null;
        _moduleDirectory = null;

        AppDomain.CurrentDomain.AssemblyResolve -= OnAssemblyResolve;
    }

    private static Assembly? OnAssemblyResolve(object? sender, ResolveEventArgs args)
    {
        string? assemblyName = new AssemblyName(args.Name).Name;

        string assemblyPath = System.IO.Path.Combine(_moduleDirectory!, $"{assemblyName}.dll");
        if (System.IO.File.Exists(assemblyPath) is false)
            return null;

        return Assembly.LoadFrom(assemblyPath);
    }
}

Update Project (.csproj) File

• Must set Private to False on Vault-related assembly file reference.
• Replace VaultVersion value of 2026 with the version of Vault being referenced.

<!-- Custom Variable -->
<PropertyGroup>
    <VaultVersion>2026</VaultVersion>
</PropertyGroup>

<PropertyGroup Condition="$(VaultVersion) >= 2026">
    <DefineConstants>$(DefineConstants);VAULT_HAS_DOCK_PANELS</DefineConstants>
</PropertyGroup>

<ItemGroup>
    <Reference Include="Autodesk.Connectivity.Explorer.Extensibility">
        <HintPath>$(ProgramFiles)\Autodesk\Vault Client $(VaultVersion)\Explorer\Autodesk.Connectivity.Explorer.Extensibility.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
    <Reference Include="Autodesk.Connectivity.Extensibility.Framework">
        <HintPath>$(ProgramFiles)\Autodesk\Vault Client $(VaultVersion)\Explorer\Autodesk.Connectivity.Extensibility.Framework.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
    <Reference Include="Autodesk.Connectivity.JobProcessor.Extensibility">
        <HintPath>$(ProgramFiles)\Autodesk\Vault Client $(VaultVersion)\Explorer\Autodesk.Connectivity.JobProcessor.Extensibility.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
    <Reference Include="Autodesk.Connectivity.WebServices">
        <HintPath>$(ProgramFiles)\Autodesk\Vault Client $(VaultVersion)\Explorer\Autodesk.Connectivity.WebServices.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
    <Reference Include="Autodesk.DataManagement.Client.Framework">
        <HintPath>$(ProgramFiles)\Autodesk\Vault Client $(VaultVersion)\Explorer\Autodesk.DataManagement.Client.Framework.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
    <Reference Include="Autodesk.DataManagement.Client.Framework.Vault">
        <HintPath>$(ProgramFiles)\Autodesk\Vault Client $(VaultVersion)\Explorer\Autodesk.DataManagement.Client.Framework.Vault.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
</ItemGroup>

Notes

• This add-in format is compatible with Vault versions using .NET Framework 4.8 or .NET 8.

References

• Microsoft Learn - System.Runtime.Loader.AssemblyLoadContext
• GitHub - dotnet - AssemblyLoadContext.md

Core Concepts

• iLogic rules execute inside the Inventor process.
• Visual Studio must attach to Inventor after it is already running.
• Breakpoints are triggered programmatically from within the rule, not pre-set in source files.
• Visual Studio opens a read-only temporary, runtime-generated file for debugging.

Attaching Visual Studio to Inventor

Step-By-Step

• Launch Autodesk Inventor.
• Open Visual Studio, with or without code.
• In Visual Studio:
  • Navigate to Debug => Attach To Process
  • Set:
    • Connection Type: Local
    • Process: Inventor.exe
  • Click Attach

Expected Result

• Visual Studio is now listening to the Inventor process.
• No source code opens yet.
• Visual Studio will activate only when a breakpoint or exception is hit.

For Autodesk's official walkthrough, see: Using Visual Studio to Debug iLogic Rules

Debugging iLogic Rules

How It Works

• Inventor signals the debugger when execution reaches the breakpoint call.
• Visual Studio opens a temporary runtime version of the rule.
• Execution pauses on the break line.
• All local variables, objects, and the call stack are inspectable.

Internal iLogic Rules

Internal iLogic rules have a built-in keyword that acts as a breakpoint and triggers a pause in the execution.

Add the following line anywhere in the rule:

Break()

External iLogic Rules

External rules can have a similar method for the same functionality as the internal rules. These rules are compiled at runtime, allowing changes to take effect immediately without restarting Inventor.

Add the following method to the external rule class and call it anywhere in the rule:

''' <summary>
''' Allow external debugger to attach like a breakpoint.
''' </summary>
''' <remarks>
''' <see cref="System.Diagnostics.DebuggerStepThroughAttribute"/> attribute prevents stepping into the helper method itself.
''' </remarks>
<System.Diagnostics.DebuggerStepThrough>
Public Shared Sub Break()
    If System.Diagnostics.Debugger.IsAttached Then
        System.Diagnostics.Debugger.Break()
    End If
End Sub

Resetting The iLogic Cache

iLogic can cache rules and store runtime state. The following command, which can be added to a separate rule, will force iLogic to release memory and reset its execution context.

Usage (When to Consider Resetting)

• Inconsistent internal rule behavior.
• Long debugging sessions.

  ThisApplication.CommandManager.ControlDefinitions.OfType(Of ControlDefinition)() _
    .FirstOrDefault(Function(c) c.InternalName = "iLogic.FreeILogicMemory") _
    ?.Execute()
  

Common Pitfalls

• Forgetting to attach before executing the rules.
• Expecting breakpoints to persist between runs.
• Editing the temporary files opened by Visual Studio.

Summary

With a simple attach-to-process setup and deliberate breakpoint triggers, Visual Studio becomes a powerful debugging environment for iLogic development. This approach scales from quick rule inspection to larger external rule workflows and provides a consistent debugging experience for Inventor automation.

This article will demonstrate one way to resolve the version conflict by isolating the add-in’s dependencies in a separate container using AssemblyLoadContext.

A full sample application can be found on GitHub.

What is AssemblyLoadContext?

• It's the runtime's provider for locating and loading dependencies. Whenever a dependency is loaded, an AssemblyLoadContext instance is invoked to locate it.
• AssemblyLoadContext provides a service of locating, loading, and caching managed assemblies and other dependencies.
• To support dynamic code loading and unloading, it creates an isolated context for loading code and its dependencies in their own AssemblyLoadContext instance.

How to update the add-in?

Add IsolatedApplicationAddInServer.cs

This is used as the new entry point into the add-in. It is a wrapper around the ApplicationAddInServer. It adds additional functionality behind the scenes but still exposes the startup and shutdown methods called automatically by Inventor.

• Activate(ApplicationAddInSite application, bool firstTime) => OnActivate()
• Deactivate() => OnDeactivate()

using Inventor;

namespace IsolatedInventorAddin;

/// <summary>
///    <see cref="ApplicationAddInServer" /> is the standard entry point of the Inventor addin.
///    This class is extended to have fully isolated addin dependency container.
///    Inherit this class and add custom logic to overrides of <see cref="OnActivate" /> or <see cref="OnDeactivate" />.
/// </summary>
public abstract class IsolatedApplicationAddInServer : ApplicationAddInServer
{
#if NETCOREAPP
    private object? _isolatedInstance;
#endif

    public object? Automation { get; set; } = null;

    /// <summary>
    ///    Reference to the parameter in <see cref="ApplicationAddInServer.Activate" />.
    /// </summary>
    public ApplicationAddInSite ApplicationAddInSite { get; private set; } = default!;

    /// <summary>
    ///    Reference to the parameter in <see cref="ApplicationAddInServer.Activate" />.
    /// </summary>
    public bool FirstTime { get; private set; } = default!;

    public void Activate(ApplicationAddInSite applicationAddInSite, bool firstTime)
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext dependenciesProvider = AddinLoadContext.GetDependenciesProvider(currentType);
            _isolatedInstance = dependenciesProvider.CreateAssemblyInstance(currentType);

            AddinLoadContext.Invoke(_isolatedInstance, nameof(Activate), applicationAddInSite, firstTime);
            return;
        }
#endif

        ApplicationAddInSite = applicationAddInSite;
        FirstTime = firstTime;

#if NETCOREAPP
        OnActivate();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            OnActivate();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    public void Deactivate()
    {
        Type currentType = GetType();

#if NETCOREAPP
        if (AddinLoadContext.CheckIfCustomContext(currentType) is false)
        {
            AddinLoadContext.Invoke(_isolatedInstance!, nameof(Deactivate));
            return;
        }

        OnDeactivate();
#else
        try
        {
            ResolveHelper.BeginAssemblyResolve(currentType);
            OnDeactivate();
        }
        finally
        {
            ResolveHelper.EndAssemblyResolve();
        }
#endif
    }

    [Obsolete("Deprecated in the Inventor API. Required for legacy compatibility.")]
    public void ExecuteCommand(int CommandID) { }

    /// <summary>
    ///    Overload this method to execute custom logic when the Inventor addin is loaded and <see cref="ApplicationAddInServer.Activate" /> method is executed.
    /// </summary>
    public abstract void OnActivate();

    /// <summary>
    ///    Overload this method to execute custom logic when the Inventor addin is unloaded and <see cref="ApplicationAddInServer.Deactivate" /> method is executed.
    /// </summary>
    public abstract void OnDeactivate();
}

Add AddinLoadContext.cs

This is a custom implementation of the AssemblyLoadContext specifically for the format of an Inventor add-in.

#if NETCOREAPP
using Inventor;
using System.Reflection;
using System.Runtime.Loader;

namespace IsolatedInventorAddin;

/// <summary>
///     Isolated add-in dependency container.
/// </summary>
internal sealed class AddinLoadContext : AssemblyLoadContext
{
    /// <summary>
    ///     Add-ins contexts storage.
    /// </summary>
    private static readonly Dictionary<string, AddinLoadContext> _dependenciesProviders = new(1);
    private readonly AssemblyDependencyResolver _resolver;
    private const BindingFlags MethodSearchFlags = BindingFlags.Public | BindingFlags.Instance;

    private AddinLoadContext(Type type, string addinName) : base(addinName)
    {
        string addinLocation = type.Assembly.Location;
        _resolver = new AssemblyDependencyResolver(addinLocation);
    }

    /// <summary>
    ///     Resolve dependency any time one is loaded if it exists in the isolated add-in dependency container.
    /// </summary>
    protected override Assembly? Load(AssemblyName assemblyName)
    {
        string? assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
        return assemblyPath is not null ? LoadFromAssemblyPath(assemblyPath) : null;
    }

    /// <summary>
    ///     Determine whether the type is the type not associated with the default context.
    /// </summary>
    public static bool CheckAccess(Type type)
    {
        AssemblyLoadContext? currentContext = GetLoadContext(type.Assembly);
        return currentContext != Default;
    }

    /// <summary>
    ///     Get or create a new isolated context for the type.
    /// </summary>
    public static AddinLoadContext GetDependenciesProvider(Type type)
    {
        // Assembly location used as context name and the unique provider key.
        string addinRoot = System.IO.Path.GetDirectoryName(type.Assembly.Location)!;
        if (_dependenciesProviders.TryGetValue(addinRoot, out var provider))
        {
            return provider;
        }

        string addinName = System.IO.Path.GetFileName(addinRoot);
        provider = new AddinLoadContext(type, addinName);
        _dependenciesProviders.Add(addinRoot, provider);
        return provider;
    }

    /// <summary>
    ///     Create new instance in the separated context.
    /// </summary>
    public object CreateInstance(Type type)
    {
        string assemblyLocation = type.Assembly.Location;
        Assembly assembly = LoadFromAssemblyPath(assemblyLocation);
        return assembly.CreateInstance(type.FullName!)!;
    }

    /// <summary>
    ///     Execute <see cref="ApplicationAddInSite" /> in the separated context.
    /// </summary>
    /// <remarks>
    ///     Matches parameter format of <see cref="ApplicationAddInServer.Activate" /> method.
    /// </remarks>
    public static void Invoke(object instance, string methodName, ApplicationAddInSite application, bool firstTime)
    {
        Type instanceType = instance.GetType();
        Type[] methodParameterTypes =
        [
            typeof(ApplicationAddInSite),
            typeof(bool)
        ];
        object[] methodParameters =
        [
            application,
            firstTime
        ];

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, methodParameterTypes, null)!;
        // Call the inheriting method which may contain custom logic if it exists.
        _ = method.Invoke(instance, methodParameters)!;
    }

    /// <remarks>
    ///     Matches parameter format of <see cref="ApplicationAddInServer.Deactivate" /> method.
    /// </remarks>
    public static void Invoke(object instance, string methodName)
    {
        Type instanceType = instance.GetType();

        MethodInfo method = instanceType.GetMethod(methodName, MethodSearchFlags, null, [], null)!;
        // Call the inheriting method which may contain custom logic if it exists.
        _ = method.Invoke(instance, [])!;
    }
}
#endif

Add ResolveHelper.cs

This is a helper class used to resolve conflicting versions of a dependency.

#if NETCOREAPP
using System.Runtime.Loader;
#endif

namespace IsolatedInventorAddin;

/// <summary>
///    Used to resolve conflicting versions of a dependency.
/// </summary>
public static class ResolveHelper
{
    private static string? _moduleDirectory;
    private static object? _domainResolvers;

    /// <summary>
    ///   Subscribes the current domain to resolve dependencies for the type.
    /// </summary>
    /// <typeparam name="T">Type, to search for dependencies in the directory where this type is defined.</typeparam>
    /// <remarks>
    ///    Dependencies are searched in a directory of the specified type.
    ///    At the time of dependency resolution, all other dependency resolution methods for the domain are disabled,
    ///    this requires calling <see cref="EndAssemblyResolve" /> immediately after executing user code where dependency failures occur.
    /// </remarks>
    public static void BeginAssemblyResolve<T>()
    {
        BeginAssemblyResolve(typeof(T));
    }

    /// <summary>
    ///    Subscribes the current domain to resolve dependencies for the type.
    /// </summary>
    /// <param name="type">Type, to search for dependencies in the directory where this type is defined.</param>
    /// <remarks>
    ///    Dependencies are searched in a directory of the specified type.
    ///    At the time of dependency resolution, all other dependency resolution methods for the domain are disabled,
    ///    this requires calling <see cref="EndAssemblyResolve" /> immediately after executing user code where dependency failures occur.
    /// </remarks>
    public static void BeginAssemblyResolve(Type type)
    {
        if (_domainResolvers is not null)
            return;
        if (type.Module.FullyQualifiedName == "<Unknown>")
            return;

#if NETCOREAPP
        var loadContextType = typeof(AssemblyLoadContext);
        var resolversField = loadContextType.GetField("AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)!;
        var resolvers = resolversField.GetValue(null);
        resolversField.SetValue(null, null);
#else
        var domainType = AppDomain.CurrentDomain.GetType();
        var resolversField = domainType.GetField("_AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)!;
        var resolvers = resolversField.GetValue(AppDomain.CurrentDomain);
        resolversField.SetValue(AppDomain.CurrentDomain, null);
#endif

        _domainResolvers = resolvers;
        _moduleDirectory = System.IO.Path.GetDirectoryName(type.Module.FullyQualifiedName);

        AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
    }

    /// <summary>
    ///    Unsubscribes the current domain to resolve dependencies for the type.
    /// </summary>
    public static void EndAssemblyResolve()
    {
        if (_domainResolvers is null)
            return;

#if NETCOREAPP
        var loadContextType = typeof(AssemblyLoadContext);
        var resolversField = loadContextType.GetField("AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)!;
        resolversField.SetValue(null, _domainResolvers);
#else
        var domainType = AppDomain.CurrentDomain.GetType();
        var resolversField = domainType.GetField("_AssemblyResolve", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)!;
        resolversField.SetValue(AppDomain.CurrentDomain, _domainResolvers);
#endif

        _domainResolvers = null;
        _moduleDirectory = null;

        AppDomain.CurrentDomain.AssemblyResolve -= OnAssemblyResolve;
    }

    private static Assembly? OnAssemblyResolve(object? sender, ResolveEventArgs args)
    {
        string assemblyName = new AssemblyName(args.Name).Name;

        var assemblyPath = System.IO.Path.Combine(_moduleDirectory!, $"{assemblyName}.dll");
        if (System.IO.File.Exists(assemblyPath) is false)
            return null;

        return Assembly.LoadFrom(assemblyPath);
    }
}

Update Project (.csproj) File

• Must set Private to False on Autodesk.Inventor.Interop assembly file reference.
• Replace 2026 with the version of Inventor being referenced.

<!-- Custom Variable -->
<PropertyGroup>
    <InventorVersion>2026</InventorVersion>
</PropertyGroup>

<ItemGroup>
    <Reference Include="Autodesk.Inventor.Interop">
        <HintPath>$(ProgramFiles)\Autodesk\Inventor $(InventorVersion)\Bin\Public Assemblies\Autodesk.Inventor.Interop.dll</HintPath>
        <!-- Required For Isolated Addin -->
        <Private>False</Private>
    </Reference>
</ItemGroup>

Notes

• This add-in format is compatible with Inventor versions using .NET Framework 4.8 or .NET 8.
• This add-in format is compatible and works as an AppBundle with the Automation API.

References

• Microsoft Learn - System.Runtime.Loader.AssemblyLoadContext
• GitHub - dotnet - AssemblyLoadContext.md