Parameters lezen en aanpassen met C# in Inventor

Parameters zijn de basis van parametrisch ontwerp in Inventor. Ze bepalen afmetingen, hoeken en relaties tussen onderdelen. Via de Inventor COM API kun je parameters lezen, aanpassen, aanmaken en zelfs koppelen tussen bestanden. Dit is de kern van automatische maatvoering, configuratietools en parametrische bibliotheken.

Hoe parameters werken in Inventor

Inventor kent drie soorten parameters: Model Parameters (aangemaakt door schetsafmetingen of features), Reference Parameters (berekende waarden, alleen-lezen) en User Parameters (handmatig aangemaakt, volledig bewerkbaar). Je benadert ze allemaal via Document.ComponentDefinition.Parameters.

Verbinding met Inventor maken

using Inventor;
using System.Runtime.InteropServices;

// Haal de actieve Inventor-instantie op (of start er één)
Application inventorApp;
try
{
    inventorApp = (Application)Marshal.GetActiveObject("Inventor.Application");
}
catch
{
    var type = Type.GetTypeFromProgID("Inventor.Application");
    inventorApp = (Application)Activator.CreateInstance(type);
    inventorApp.Visible = true;
}

Parameters lezen

public void LeesParameters(PartDocument doc)
{
    var parameters = doc.ComponentDefinition.Parameters;

    // Alle parameters overlopen
    foreach (Parameter param in parameters)
    {
        string naam   = param.Name;
        string eenheid = param.Units;
        double waarde  = (double)param.Value; // interne eenheid (cm voor lengte!)
        string uitdr   = param.Expression;    // bv. "100 mm" of "Breedte / 2"
        bool   isRead  = param.IsReadOnly;

        Console.WriteLine($"{naam} = {uitdr}  [{eenheid}]  readonly={isRead}");
    }
}

Let op: Inventor slaat lengtes intern op in centimeters. Een parameter van 100 mm heeft Value = 10.0. Gebruik altijd Expression voor leesbare weergave met eenheid.

Een parameter aanpassen

public void StelParameterIn(PartDocument doc, string naam, string expressie)
{
    var parameters = doc.ComponentDefinition.Parameters;

    try
    {
        var param = parameters[naam];
        if (param.IsReadOnly)
        {
            Console.WriteLine($"Parameter '{naam}' is alleen-lezen.");
            return;
        }
        param.Expression = expressie; // bv. "150 mm" of "Hoogte * 2"
        doc.Update();                 // herbereken het model
        Console.WriteLine($"Parameter '{naam}' ingesteld op {expressie}.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Fout bij aanpassen '{naam}': {ex.Message}");
    }
}

Een User Parameter aanmaken

public void MaakUserParameter(PartDocument doc, string naam, string expressie, string eenheid)
{
    var userParams = doc.ComponentDefinition.Parameters.UserParameters;

    // Controleer of de parameter al bestaat
    foreach (UserParameter up in userParams)
        if (up.Name == naam) { Console.WriteLine("Al aanwezig."); return; }

    // Eenheid als UnitsTypeEnum-string of directe string
    userParams.AddByExpression(naam, expressie, eenheid);
    doc.Update();
    Console.WriteLine($"User parameter '{naam}' aangemaakt met waarde {expressie}.");
}

Parameters met expressies (formules)

Parameters kunnen naar andere parameters verwijzen via expressies. Dit is de basis van parametrisch ontwerp:

// "Dikte = Breedte / 4"
StelParameterIn(doc, "Dikte", "Breedte / 4");

// "Hoogte = Breedte * 1.618" (Gulden snede)
StelParameterIn(doc, "Hoogte", "Breedte * 1.618 mm");

// Constante waarde
StelParameterIn(doc, "Breedte", "200 mm");

Parametertabel importeren vanuit Excel

In productie lees je parameters vaak uit een Excel-bestand of database en pas je meerdere parameters in één keer aan:

public void ImporteerParametersTabel(PartDocument doc, Dictionary tabel)
{
    var parameters = doc.ComponentDefinition.Parameters;
    var fouten = new List();

    foreach (var kv in tabel)
    {
        try
        {
            var p = parameters[kv.Key];
            if (!p.IsReadOnly)
                p.Expression = kv.Value;
        }
        catch (Exception ex)
        {
            fouten.Add($"{kv.Key}: {ex.Message}");
        }
    }

    doc.Update(); // één keer herbereken na alle wijzigingen

    if (fouten.Any())
        Console.WriteLine("Fouten:\n" + string.Join("\n", fouten));
    else
        Console.WriteLine("Alle parameters bijgewerkt.");
}

Parameters koppelen tussen onderdelen

In een assembly kun je parameters van één onderdeel laten verwijzen naar parameters van een ander onderdeel. Dat doe je via de Derived Parameters-functie of via een gedeelde parameterbestand (ipt/iam). In code kun je de parameter-expressie direct verwijzen naar een extern bestand:

// Verwijzing naar externe parameterbestand (iPart)
param.Expression = "[@Parameters.xlsx]!Breedte";

Parameters vergelijken en valideren

public bool ValideerParameters(PartDocument doc, Dictionary grenzen)
{
    var parameters = doc.ComponentDefinition.Parameters;
    bool geldig = true;

    foreach (var kv in grenzen)
    {
        var param  = parameters[kv.Key];
        double val = (double)param.Value * 10; // cm naar mm
        if (val < kv.Value.min || val > kv.Value.max)
        {
            Console.WriteLine($"⚠ {kv.Key} = {val} mm buiten bereik [{kv.Value.min}, {kv.Value.max}] mm");
            geldig = false;
        }
    }
    return geldig;
}

Veelgemaakte fouten

Interne eenheid vergeten (cm vs mm) — Parameter.Value geeft de interne waarde in centimeters. Vermenigvuldig altijd met 10 voor mm, of gebruik Expression voor een leesbare waarde met eenheid.

Parameter niet gevonden (IndexOutOfRange) — gebruik een try-catch of controleer vooraf of de naam bestaat via parameters.Count en een loop.

Update vergeten na aanpassing — na het aanpassen van parameters moet je doc.Update() aanroepen om het model opnieuw te berekenen.

Reference Parameters aanpassen — reference parameters zijn het resultaat van berekeningen en kunnen niet direct ingesteld worden. Pas de bron-parameter aan.

Samenvatting

Parameters zijn de sleutel tot flexibele, herbruikbare Inventor-modellen. Via C# kun je parameters lezen, aanpassen, aanmaken en valideren — ideaal voor configuratietools waarbij de gebruiker afmetingen ingeeft en jouw code het model automatisch aanpast. Vergeet nooit de eenheidsconversie (intern = cm) en roep doc.Update() aan na elke aanpassing.

Parameters are the foundation of parametric design in Inventor. They drive dimensions, angles and relationships between parts. Via the Inventor COM API you can read, modify, create and even link parameters between files — the core of automatic sizing, configuration tools and parametric libraries.

How Parameters Work in Inventor

Inventor has three parameter types: Model Parameters (created by sketch dimensions or features), Reference Parameters (calculated values, read-only) and User Parameters (manually created, fully editable). Access them all via Document.ComponentDefinition.Parameters.

Important: Inventor stores lengths internally in centimeters. A 100 mm parameter has Value = 10.0. Always use Expression for human-readable display with units.

Reading Parameters

foreach (Parameter param in doc.ComponentDefinition.Parameters)
{
    Console.WriteLine($"{param.Name} = {param.Expression}  [{param.Units}]  readonly={param.IsReadOnly}");
}

Modifying a Parameter

public void SetParameter(PartDocument doc, string name, string expression)
{
    var p = doc.ComponentDefinition.Parameters[name];
    if (p.IsReadOnly) { Console.WriteLine("Read-only."); return; }
    p.Expression = expression; // e.g. "150 mm" or "Height * 2"
    doc.Update();
}

Creating a User Parameter

var userParams = doc.ComponentDefinition.Parameters.UserParameters;
userParams.AddByExpression("MyParam", "50 mm", "mm");
doc.Update();

Batch Import from a Table

public void ImportParameterTable(PartDocument doc, Dictionary table)
{
    var parameters = doc.ComponentDefinition.Parameters;
    foreach (var kv in table)
    {
        var p = parameters[kv.Key];
        if (!p.IsReadOnly) p.Expression = kv.Value;
    }
    doc.Update(); // recalculate once after all changes
}

Validating Parameter Ranges

public bool ValidateParameters(PartDocument doc, Dictionary limits)
{
    bool valid = true;
    foreach (var kv in limits)
    {
        double val = (double)doc.ComponentDefinition.Parameters[kv.Key].Value * 10; // cm → mm
        if (val < kv.Value.min || val > kv.Value.max)
        {
            Console.WriteLine($"⚠ {kv.Key} = {val} mm out of range [{kv.Value.min}, {kv.Value.max}]");
            valid = false;
        }
    }
    return valid;
}

Common Pitfalls

Internal unit (cm vs mm) — Parameter.Value returns centimeters. Multiply by 10 for mm or use Expression for a readable value with unit.

Parameter not found — use a try-catch or loop to verify the name exists before indexing.

Forgetting doc.Update() — after modifying parameters, call doc.Update() to recalculate the model.

Summary

Parameters are the key to flexible, reusable Inventor models. Via C# you can read, modify, create and validate them — ideal for configuration tools where the user enters dimensions and your code automatically adjusts the model. Never forget unit conversion (internal = cm) and always call doc.Update() after every change.