Autodesk Inventor API met C#: je eigen ribbon-knop toevoegen

Waarom een ribbon-knop?

Standaard commando's in Inventor kun je via iLogic of macro's aanroepen. Maar als je een tool wilt die professioneel geïntegreerd is in de Inventor-interface — met een eigen knop in het lint, een icoon, en een tooltip — dan heb je een C# add-in nodig.

In deze tutorial bouw je stap voor stap een Inventor add-in die een knop toevoegt aan een eigen tabblad in het ribbon.

Vereisten

• Visual Studio 2022
• Autodesk Inventor 2025 (+ SDK)
• Basiskennis C# en COM-interop

Stap 1: Project aanmaken en references toevoegen

Maak een nieuw Class Library (.NET Framework 4.8) project aan in Visual Studio.

Voeg de volgende referentie toe via Project ? Add Reference ? Browse:

C:\Program Files\Autodesk\Inventor 2025\Bin  Autodesk.Inventor.Interop.dll

Stel ook hier Copy Local = False in.

Voeg ook een referentie toe aan stdole (zit standaard in het .NET Framework) — dit is nodig voor pictogrammen.

Stap 2: IAutodesk.Inventor.ApplicationAddInServer implementeren

Elke Inventor add-in implementeert de interface ApplicationAddInServer. Inventor roept Activate() aan bij het laden en Deactivate() bij het sluiten.

using System;
using System.Runtime.InteropServices;
using Inventor;

namespace MijnInventorAddin
{
    /// <summary>
    /// Entry point van de Inventor add-in.
    /// De GUID hieronder moet uniek zijn — genereer er een via
    /// Visual Studio ? Tools ? Create GUID.
    ///
    /// Deze GUID moet ook in het .addin-bestand staan zodat
    /// Inventor weet welke klasse te laden.
    /// </summary>
    [GuidAttribute("JOUW-UNIEKE-GUID-HIER")]
    public class MijnInventorAddin : ApplicationAddInServer
    {
        // Referentie naar de Inventor Application — bewaar deze
        // voor gebruik in andere methoden
        private Inventor.Application _inventorApp;

        // De knopknop die we aanmaken — bewaar deze zodat hij
        // niet door de garbage collector wordt opgeruimd
        private ButtonDefinition _mijnKnop;

        public void Activate(ApplicationAddInSite addInSiteObject, bool firstTime)
        {
            // Sla de applicatie-referentie op voor later gebruik
            _inventorApp = addInSiteObject.Application;

            // Voeg de ribbon-knop toe wanneer de add-in voor het
            // eerst geladen wordt (firstTime = true bij installatie)
            if (firstTime)
                VoegRibbonKnopToe();
        }

        public void Deactivate()
        {
            // Ruim referenties op zodat COM-objecten vrijgegeven worden
            _mijnKnop    = null;
            _inventorApp = null;
        }

        public object Automation => null;

        public void ExecuteCommand(int commandID) { }
    }
}

Stap 3: De ribbon-knop aanmaken

Nu voegen we de methode toe die de knop in het lint plaatst:

private void VoegRibbonKnopToe()
{
    // Haal de gebruikersinterface op
    UserInterfaceManager uiMgr = _inventorApp.UserInterfaceManager;

    // Haal het Ribbon-object op voor Part-documenten
    // Andere opties: "ZeroDoc", "Assembly", "Drawing"
    Ribbon partRibbon = uiMgr.Ribbons["Part"];

    // Maak een nieuw tabblad aan (of gebruik een bestaand)
    // "KleverCAD" is de interne naam; "KleverCAD Tools" is wat de gebruiker ziet
    RibbonTab mijnTab;
    try
    {
        mijnTab = partRibbon.RibbonTabs["KleverCAD"];
    }
    catch
    {
        mijnTab = partRibbon.RibbonTabs.Add(
            "KleverCAD Tools",   // Zichtbare naam
            "KleverCAD",         // Interne naam (uniek)
            "{" + "JOUW-UNIEKE-TAB-GUID" + "}");
    }

    // Maak een paneel aan in het tabblad
    RibbonPanel mijnPanel = mijnTab.RibbonPanels.Add(
        "Automatisering",        // Zichtbare naam
        "KleverCAD.Automatisering", // Interne naam
        "{" + "JOUW-UNIEKE-PANEL-GUID" + "}");

    // Maak een ButtonDefinition aan
    // Dit is de eigenlijke knop-definitie in Inventor
    _mijnKnop = _inventorApp.CommandManager.ControlDefinitions
        .AddButtonDefinition(
            "Hallo KleverCAD",       // Naam op de knop
            "KleverCAD.Hello",       // Interne unieke naam
            CommandTypesEnum.kNonShapeEditCmdType,
            "{" + "JOUW-UNIEKE-KNOP-GUID" + "}",
            "Mijn eerste knop",      // Beschrijving (tooltip)
            "Klik hier voor een demo van KleverCAD"); // Uitgebreide tooltip

    // Voeg de knop toe aan het paneel
    mijnPanel.CommandControls.AddButton(_mijnKnop, true);

    // Koppel een event handler aan de knop
    _mijnKnop.OnExecute += MijnKnop_OnExecute;
}

/// <summary>
/// Wordt uitgevoerd wanneer de gebruiker op de knop klikt.
/// </summary>
private void MijnKnop_OnExecute(NameValueMap context)
{
    System.Windows.Forms.MessageBox.Show(
        "Hallo vanuit KleverCAD!\n\nDit is je eigen Inventor-knop.",
        "KleverCAD Add-in",
        System.Windows.Forms.MessageBoxButtons.OK,
        System.Windows.Forms.MessageBoxIcon.Information);
}

Stap 4: Het .addin-bestand aanmaken

Inventor laadt add-ins op basis van een .addin-bestand. Maak het bestand MijnInventorAddin.addin aan en plaats het in:

C:\ProgramData\Autodesk\Inventor 2025\Addins\

Inhoud van het .addin-bestand:

<?xml version="1.0" encoding="utf-16" ?>
<Addin Type="Standard">
  <ClassId>{JOUW-UNIEKE-GUID-HIER}</ClassId>
  <ClientId>{JOUW-UNIEKE-GUID-HIER}</ClientId>
  <DisplayName>KleverCAD Tools</DisplayName>
  <Description>Aangepaste tools van KleverCAD</Description>
  <Assembly>C:\pad\naar\MijnInventorAddin.dll</Assembly>
  <LoadOnStartUp>1</LoadOnStartUp>
  <SupportedSoftwareVersionGreaterThan>24..</SupportedSoftwareVersionGreaterThan>
</Addin>

Belangrijk: De GUID in het .addin-bestand moet exact overeenkomen met de [GuidAttribute] op je klasse. Genereer één keer een GUID via Visual Studio ? Tools ? Create GUID en gebruik die overal.

Stap 5: Testen

1. Compileer het project.
2. Kopieer de DLL naar het pad in het .addin-bestand.
3. Start Inventor opnieuw op.
4. Open een Part-document — je ziet nu het tabblad "KleverCAD Tools" in het lint.
5. Klik op de knop "Hallo KleverCAD".

Conclusie

Met een C# add-in heb je volledige controle over de Inventor-interface. Je kunt knoppen, tabbladen en panelen toevoegen, iconen instellen, en complexe logica koppelen aan gebruikersacties. Dit is de professionele manier om tools te bouwen die naadloos in Inventor geïntegreerd zijn.

Volgende stap: leer hoe je een eigen icoon toevoegt aan de knop, en hoe je de add-in correct debugt vanuit Visual Studio.

Why add a ribbon button?

A ribbon button turns your C# code into a first-class citizen inside Inventor's user interface. Instead of typing a command name or loading scripts manually, your users can click a professional-looking button in the ribbon, just like any built-in Inventor tool.

What you need

• Visual Studio 2022 (Community is free)
• Autodesk Inventor 2024 or later
• The Inventor API (installed with Inventor; SDK available from the Autodesk Developer Network)
• Basic C# knowledge

Step 1: Create the add-in project

Inventor add-ins are COM components wrapped as Class Libraries. Use the Autodesk Inventor Add-in template if available, or create a Class Library manually and add the following references from the Inventor installation folder:

• Autodesk.Inventor.Interop.dll

Set Embed Interop Types = False and Copy Local = False for this reference.

Step 2: Implement the StandardAddInServer interface

Every Inventor add-in implements Inventor.ApplicationAddInServer. The Activate method is where you create your ribbon button.

using Inventor;
using System.Runtime.InteropServices;

namespace MyInventorAddin
{
    [GuidAttribute("YOUR-GUID-HERE")]  // Generate a unique GUID in Visual Studio: Tools ? Create GUID
    public class AddInServer : ApplicationAddInServer
    {
        // Keep a reference to the Inventor application
        private Inventor.Application _inventorApp;
        private ButtonDefinition _myButton;

        public void Activate(ApplicationAddInSite addInSiteObject, bool firstTime)
        {
            // Store the application reference
            _inventorApp = addInSiteObject.Application;

            // Create the ribbon button on first load
            if (firstTime)
                AddRibbonButton();
        }

        public void Deactivate()
        {
            // Release COM references when the add-in is unloaded
            _myButton = null;
            _inventorApp = null;
        }

        public object Automation => null;
        public void ExecuteCommand(int commandID) { }
    }
}

Step 3: Create the button and add it to the ribbon

private void AddRibbonButton()
{
    // Load an icon from the project resources
    // Use a 32x32 PNG for the large icon and 16x16 for the small icon
    stdole.IPictureDisp largeIcon = PictureDispConverter.ToIPictureDisp(
        Properties.Resources.MyButtonIcon32);
    stdole.IPictureDisp smallIcon = PictureDispConverter.ToIPictureDisp(
        Properties.Resources.MyButtonIcon16);

    // Create a ButtonDefinition (the command behind the button)
    _myButton = _inventorApp.CommandManager.ControlDefinitions.AddButtonDefinition(
        DisplayName:    "My Button",
        InternalName:   "MyInventorAddin_MyButton",
        Classification: CommandTypesEnum.kQueryOnlyCmdType,
        ClientId:       AddInClientID,        // GUID of this add-in
        DescriptionText: "Runs my custom command",
        ToolTipText:    "My custom Inventor command",
        StandardIcon:   smallIcon,
        LargeIcon:      largeIcon);

    // Wire up the click event
    _myButton.OnExecute += MyButton_OnExecute;

    // Find the Part ribbon (shown when a part document is open)
    Ribbon partRibbon = _inventorApp.UserInterfaceManager.Ribbons["Part"];

    // Add a new tab called "KleverCAD"
    RibbonTab myTab = partRibbon.RibbonTabs.Add(
        DisplayName:  "KleverCAD",
        InternalName: "MyInventorAddin_Tab",
        ClientId:     AddInClientID);

    // Add a panel inside that tab
    RibbonPanel myPanel = myTab.RibbonPanels.Add(
        DisplayName:  "Tools",
        InternalName: "MyInventorAddin_Panel",
        ClientId:     AddInClientID);

    // Add the button to the panel
    myPanel.CommandControls.AddButton(_myButton, UseLargeIcon: true);
}

private void MyButton_OnExecute(NameValueMap context)
{
    // This code runs when the user clicks the button
    System.Windows.Forms.MessageBox.Show("Hello from MyInventorAddin!", "My Add-in");
}

Step 4: Register the add-in

Inventor discovers add-ins via a .addin file placed in the user add-ins folder:

%APPDATA%\Autodesk\Inventor 2024\Addins\MyInventorAddin.addin

The file is a simple XML document:

<?xml version="1.0" encoding="utf-8" ?>
<Addin Type="Standard">
  <ClassId>{YOUR-GUID-HERE}</ClassId>
  <ClientId>{YOUR-GUID-HERE}</ClientId>
  <DisplayName>My Inventor Add-in</DisplayName>
  <Description>A sample Inventor add-in</Description>
  <Assembly>C:\Path\To\MyInventorAddin.dll</Assembly>
  <LoadOnStartUp>1</LoadOnStartUp>
  <UserUnloadable>1</UserUnloadable>
</Addin>

Restart Inventor and your button will appear in the Part ribbon under the KleverCAD tab.

Next steps

From this foundation you can expand the button's functionality to interact with the open document, iterate over components in an assembly, or generate geometry — all through the Inventor API.