Convertir les exemples VBA de la documentation Inventor en règles iLogic

lundi 8 juin 2026
iLogicInventorVBACAO

Quand on automatise Inventor avec iLogic, la meilleure source d'exemples n'est pas un forum lointain : elle est déjà installée sur votre poste. La documentation locale d'Inventor contient des centaines d'extraits de code couvrant presque toutes les méthodes de l'API.

Sur une installation standard, ces exemples se trouvent dans :

C:\Users\Public\Documents\Autodesk\Inventor 202x\Local Help

(remplacez 202x par votre millésime). Vous y retrouvez l'aide de programmation, dans laquelle chaque objet de l'API est accompagné d'un exemple complet.

Il y a cependant un piège : ces exemples sont écrits en VBA, l'ancien langage de macros d'Inventor. Or iLogic, lui, fonctionne en VB.NET. Les deux langages se ressemblent énormément, mais quelques différences de syntaxe empêchent de copier-coller directement. La bonne nouvelle, c'est que la conversion est mécanique : une fois les quelques règles ci-dessous assimilées, l'adaptation prend quelques secondes.

Conversion d'un exemple VBA de la documentation Inventor en règle iLogic VB.NET

Les règles de conversion

1. Supprimer la déclaration de procédure

En VBA, le code est encapsulé dans une procédure Sub ... End Sub (ou Function ... End Function). Dans une règle iLogic, le code s'exécute directement : il n'y a pas d'enveloppe à conserver.

On supprime donc la première ligne (Public Sub ...) et la dernière (End Sub).

2. Supprimer le mot-clé Set

En VBA, l'affectation d'une référence d'objet doit être précédée du mot-clé Set. En VB.NET, cette distinction n'existe plus : l'affectation est identique qu'il s'agisse d'un objet ou d'une valeur.

' VBA
Set oPartDoc = ThisApplication.Documents.Add(...)

' VB.NET (iLogic)
oPartDoc = ThisApplication.Documents.Add(...)

3. Supprimer le mot-clé Call

En VBA, Call sert à appeler une procédure de façon explicite. En VB.NET il est inutile : on appelle directement la méthode.

' VBA
Call oExtrudeDef.SetDistanceExtent(0.25, kNegativeExtentDirection)

' VB.NET (iLogic)
oExtrudeDef.SetDistanceExtent(0.25, PartFeatureExtentDirectionEnum.kNegativeExtentDirection)

4. Ajouter les parenthèses aux appels de méthode

C'est le piège le plus discret. En VBA, on peut appeler une méthode avec des arguments sans parenthèses lorsqu'on n'utilise pas sa valeur de retour. En VB.NET, les parenthèses sont obligatoires.

' VBA
oPaths.Add oTextBox

' VB.NET (iLogic)
oPaths.Add(oTextBox)

La règle vaut aussi pour les méthodes appelées sans aucun argument (y compris celles dont tous les arguments sont optionnels), que VBA accepte sous leur seul nom : il faut leur ajouter une paire de parenthèses vides.

' VBA
oProfile = oSketch.Profiles.AddForSolid
oSketch.Edit

' VB.NET (iLogic)
oProfile = oSketch.Profiles.AddForSolid()
oSketch.Edit()

5. Qualifier les constantes d'énumération

En VBA, les constantes comme kPartDocumentObject ou kJoinOperation sont exposées globalement : on les écrit telles quelles. En VB.NET, chaque constante appartient à une énumération et doit être préfixée par le nom de son type.

C'est d'autant plus important qu'en iLogic, Option Explicit est désactivé : une constante écrite sans son type n'est pas signalée comme une erreur de compilation. Elle est silencieusement interprétée comme une nouvelle variable vide, et la règle produit alors un résultat erroné — sans aucun message. Mieux vaut donc toujours qualifier.

  • kPartDocumentObject → DocumentTypeEnum.kPartDocumentObject
  • kJoinOperation → PartFeatureOperationEnum.kJoinOperation
  • kNegativeExtentDirection → PartFeatureExtentDirectionEnum.kNegativeExtentDirection

Pour retrouver le type d'une constante, il suffit de rechercher son nom dans l'aide de l'API : la page de l'énumération liste toutes ses valeurs.

À noter : l'objet ThisApplication est disponible aussi bien en VBA qu'en iLogic. Inutile donc de le récupérer autrement : la plupart des exemples de la documentation s'appuient dessus et restent valables.

6. Remplacer Debug.Print par une écriture dans le journal

En VBA, Debug.Print envoie du texte vers la fenêtre Exécution (Immediate) de l'éditeur VBA. En iLogic, cette fenêtre n'existe pas : on écrit dans le journal iLogic via l'objet Logger, dont la sortie s'affiche dans la fenêtre Journal iLogic.

' VBA
Debug.Print "Area: " & oMassProps.Area

' VB.NET (iLogic)
Logger.Info("Area: " & oMassProps.Area)

Logger propose plusieurs niveaux : Logger.Info() pour une information, Logger.Warn() pour un avertissement et Logger.Error() pour une erreur. Pour du simple affichage de résultats, Logger.Info() convient. Notez au passage que Logger.Info est une méthode : ses parenthèses sont obligatoires, comme le veut la règle 4.

7. Adapter les déclarations de tableaux

VBA autorise la déclaration explicite de la borne inférieure d'un tableau (Dim arr(1 To 3)). VB.NET ne le permet pas : tous les tableaux commencent à l'indice 0 et l'on ne déclare que la borne supérieure. Pour conserver les indices 1 à 3 utilisés par le reste du code, on déclare donc un tableau de borne supérieure 3 — l'indice 0 reste simplement inutilisé.

' VBA
Dim adPrincipalMoments(1 To 3) As Double

' VB.NET (iLogic)
Dim adPrincipalMoments(3) As Double

À l'inverse, une déclaration qui ne précise que la borne supérieure (Dim oNames(1) As String) se convertit sans aucune modification : dans les deux langages, elle crée un tableau d'indices 0 à 1. Seule la forme explicite x To y doit être adaptée.

8. Méfiez-vous des déclarations multiples sur une ligne

VBA et VB.NET n'interprètent pas de la même façon une ligne comme Dim a, b As Type. En VBA, seul b est du type indiqué ; a est un Variant. En VB.NET, les deux variables sont du type indiqué.

' VBA  → oEdge1 est un Variant, oEdge2 est un Edge
Dim oEdge1, oEdge2 As Edge

' VB.NET → oEdge1 ET oEdge2 sont des Edge
Dim oEdge1, oEdge2 As Edge

Le code ne change pas, mais le sens si. Dans la plupart des exemples de la documentation, cette différence est sans conséquence (on voulait de toute façon deux objets typés) — il faut simplement en avoir conscience.

Premier exemple : extruder un texte

Prenons l'exemple fourni par la documentation pour créer une extrusion à partir d'un texte d'esquisse. Voici le code VBA d'origine :

Public Sub ExtrudeSketchText()
    ' Create a new part document, using the default part template.
    Dim oPartDoc As PartDocument
    Set oPartDoc = ThisApplication.Documents.Add(kPartDocumentObject, _
                ThisApplication.FileManager.GetTemplateFile(kPartDocumentObject))

    ' Set a reference to the component definition.
    Dim oCompDef As PartComponentDefinition
    Set oCompDef = oPartDoc.ComponentDefinition

    ' Create a new sketch on the X-Y work plane.
    Dim oSketch As PlanarSketch
    Set oSketch = oCompDef.Sketches.Add(oCompDef.WorkPlanes.Item(3))

    ' Set a reference to the transient geometry object.
    Dim oTransGeom As TransientGeometry
    Set oTransGeom = ThisApplication.TransientGeometry

    ' Create a text box at (0,0)
    Dim oTextBox As TextBox
    Set oTextBox = oSketch.TextBoxes.AddFitted(oTransGeom.CreatePoint2d(0, 0), "Inventor")

    ' Add the text box to an object collection
    Dim oPaths As ObjectCollection
    Set oPaths = ThisApplication.TransientObjects.CreateObjectCollection
    oPaths.Add oTextBox

    ' Create a profile.
    Dim oProfile As Profile
    Set oProfile = oSketch.Profiles.AddForSolid(False, oPaths)

    ' Extrude the text.
    Dim oExtrudeDef As ExtrudeDefinition
    Set oExtrudeDef = oCompDef.Features.ExtrudeFeatures.CreateExtrudeDefinition(oProfile, kJoinOperation)
    Call oExtrudeDef.SetDistanceExtent(0.25, kNegativeExtentDirection)
    Dim oExtrude As ExtrudeFeature
    Set oExtrude = oCompDef.Features.ExtrudeFeatures.Add(oExtrudeDef)
End Sub

Et voici le même code converti pour iLogic, après application des cinq règles :

' Create a new part document, using the default part template.
Dim oPartDoc As PartDocument
oPartDoc = ThisApplication.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _
            ThisApplication.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject))

' Set a reference to the component definition.
Dim oCompDef As PartComponentDefinition
oCompDef = oPartDoc.ComponentDefinition

' Create a new sketch on the X-Y work plane.
Dim oSketch As PlanarSketch
oSketch = oCompDef.Sketches.Add(oCompDef.WorkPlanes.Item(3))

' Set a reference to the transient geometry object.
Dim oTransGeom As TransientGeometry
oTransGeom = ThisApplication.TransientGeometry

' Create a text box at (0,0)
Dim oTextBox As TextBox
oTextBox = oSketch.TextBoxes.AddFitted(oTransGeom.CreatePoint2d(0, 0), "Inventor")

' Add the text box to an object collection
Dim oPaths As ObjectCollection
oPaths = ThisApplication.TransientObjects.CreateObjectCollection
oPaths.Add(oTextBox)

' Create a profile.
Dim oProfile As Profile
oProfile = oSketch.Profiles.AddForSolid(False, oPaths)

' Extrude the text.
Dim oExtrudeDef As ExtrudeDefinition
oExtrudeDef = oCompDef.Features.ExtrudeFeatures.CreateExtrudeDefinition( _
    oProfile, PartFeatureOperationEnum.kJoinOperation)
oExtrudeDef.SetDistanceExtent(0.25, PartFeatureExtentDirectionEnum.kNegativeExtentDirection)
Dim oExtrude As ExtrudeFeature
oExtrude = oCompDef.Features.ExtrudeFeatures.Add(oExtrudeDef)

Les modifications se résument à : suppression de l'enveloppe Sub/End Sub, retrait de tous les Set, retrait du Call, ajout des parenthèses sur oPaths.Add(...) et qualification des trois constantes d'énumération. Le reste — déclarations Dim, continuations de ligne _, appels de méthode — est identique entre les deux langages.

Deuxième exemple : récupérer les propriétés de masse

Ce second exemple récupère les propriétés de masse d'une pièce sans « salir » le document, c'est-à-dire sans mettre en cache les résultats calculés dans le fichier. Il est ici spécifique à une pièce, mais l'objet MassProperties peut tout aussi bien être obtenu depuis un assemblage ou depuis une occurrence de composant.

Il illustre deux règles supplémentaires : les nombreux Debug.Print et les déclarations de tableaux à borne inférieure. Voici le code VBA d'origine :

Public Sub GetPartMassPropsWithoutDirtying()
    ' Set a reference to the part document.
    ' This assumes a part document is active.
    Dim oPartDoc As PartDocument
    Set oPartDoc = ThisApplication.ActiveDocument

    ' Set a reference to the mass properties object.
    Dim oMassProps As MassProperties
    Set oMassProps = oPartDoc.ComponentDefinition.MassProperties

    'Check if mass property results are already available
    'at a high accuracy level or better. If so, simply
    'print out the results, else, set a flag to not cache
    'the results in the document.
    If oMassProps.AvailableAccuracy <> k_High And _
      oMassProps.AvailableAccuracy <> k_VeryHigh Then
      ' Set the accuracy to high.
      oMassProps.Accuracy = k_High

      'Set CacheResultsOnCompute property to False
      'so that results are not saved with the document
      'and hence the document is not 'dirtied'.
      oMassProps.CacheResultsOnCompute = False
    End If

    ' Display the mass properties of the part.
    Debug.Print "Area: " & oMassProps.Area

    Debug.Print "Center of Mass: " & _
    oMassProps.CenterOfMass.X & ", " & _
    oMassProps.CenterOfMass.Y & ", " & _
    oMassProps.CenterOfMass.Z

    Debug.Print "Mass: " & oMassProps.Mass
    Dim adPrincipalMoments(1 To 3) As Double
    Call oMassProps.PrincipalMomentsOfInertia(adPrincipalMoments(1), _
    adPrincipalMoments(2), _
    adPrincipalMoments(3))
    Debug.Print "Principal Moments of Inertia: " & _
    adPrincipalMoments(1) & ", " & _
    adPrincipalMoments(2) & ", " & _
    adPrincipalMoments(3)

    Dim adRadiusOfGyration(1 To 3) As Double
    Call oMassProps.RadiusOfGyration(adRadiusOfGyration(1), _
    adRadiusOfGyration(2), _
    adRadiusOfGyration(3))
    Debug.Print "Radius of Gyration: " & _
    adRadiusOfGyration(1) & ", " & _
    adRadiusOfGyration(2) & ", " & _
    adRadiusOfGyration(3)

    Debug.Print "Volume: " & oMassProps.Volume

    Dim Ixx As Double
    Dim Iyy As Double
    Dim Izz As Double
    Dim Ixy As Double
    Dim Iyz As Double
    Dim Ixz As Double
    Call oMassProps.XYZMomentsOfInertia(Ixx, Iyy, Izz, Ixy, Iyz, Ixz)
    Debug.Print "Moments: "
    Debug.Print " Ixx: " & Ixx
    Debug.Print " Iyy: " & Iyy
    Debug.Print " Izz: " & Izz
    Debug.Print " Ixy: " & Ixy
    Debug.Print " Iyz: " & Iyz
    Debug.Print " Ixz: " & Ixz
End Sub

Et le même code converti pour iLogic :

' Set a reference to the part document.
' This assumes a part document is active.
Dim oPartDoc As PartDocument
oPartDoc = ThisApplication.ActiveDocument

' Set a reference to the mass properties object.
Dim oMassProps As MassProperties
oMassProps = oPartDoc.ComponentDefinition.MassProperties

' Check if mass property results are already available
' at a high accuracy level or better. If so, simply
' print out the results, else, set a flag to not cache
' the results in the document.
If oMassProps.AvailableAccuracy <> MassPropertiesAccuracyEnum.k_High And _
  oMassProps.AvailableAccuracy <> MassPropertiesAccuracyEnum.k_VeryHigh Then
  ' Set the accuracy to high.
  oMassProps.Accuracy = MassPropertiesAccuracyEnum.k_High

  ' Set CacheResultsOnCompute property to False
  ' so that results are not saved with the document
  ' and hence the document is not 'dirtied'.
  oMassProps.CacheResultsOnCompute = False
End If

' Display the mass properties of the part.
Logger.Info("Area: " & oMassProps.Area)

Logger.Info("Center of Mass: " & _
  oMassProps.CenterOfMass.X & ", " & _
  oMassProps.CenterOfMass.Y & ", " & _
  oMassProps.CenterOfMass.Z)

Logger.Info("Mass: " & oMassProps.Mass)

Dim adPrincipalMoments(3) As Double
oMassProps.PrincipalMomentsOfInertia(adPrincipalMoments(1), _
  adPrincipalMoments(2), _
  adPrincipalMoments(3))
Logger.Info("Principal Moments of Inertia: " & _
  adPrincipalMoments(1) & ", " & _
  adPrincipalMoments(2) & ", " & _
  adPrincipalMoments(3))

Dim adRadiusOfGyration(3) As Double
oMassProps.RadiusOfGyration(adRadiusOfGyration(1), _
  adRadiusOfGyration(2), _
  adRadiusOfGyration(3))
Logger.Info("Radius of Gyration: " & _
  adRadiusOfGyration(1) & ", " & _
  adRadiusOfGyration(2) & ", " & _
  adRadiusOfGyration(3))

Logger.Info("Volume: " & oMassProps.Volume)

Dim Ixx As Double
Dim Iyy As Double
Dim Izz As Double
Dim Ixy As Double
Dim Iyz As Double
Dim Ixz As Double
oMassProps.XYZMomentsOfInertia(Ixx, Iyy, Izz, Ixy, Iyz, Ixz)
Logger.Info("Moments: ")
Logger.Info(" Ixx: " & Ixx)
Logger.Info(" Iyy: " & Iyy)
Logger.Info(" Izz: " & Izz)
Logger.Info(" Ixy: " & Ixy)
Logger.Info(" Iyz: " & Iyz)
Logger.Info(" Ixz: " & Ixz)

Ici, les constantes k_High et k_VeryHigh sont qualifiées par MassPropertiesAccuracyEnum, les Debug.Print deviennent des Logger.Info(...), les tableaux (1 To 3) deviennent (3), et les Call devant PrincipalMomentsOfInertia, RadiusOfGyration et XYZMomentsOfInertia disparaissent — ces méthodes renseignant leurs résultats par arguments ByRef, on les appelle directement.

En résumé

La documentation locale d'Inventor est une mine d'exemples souvent ignorée parce qu'ils sont en VBA. En gardant ces quelques règles en tête, vous pouvez les transformer en règles iLogic opérationnelles en quelques secondes :

  1. Supprimer la déclaration Sub / End Sub.
  2. Supprimer les Set.
  3. Supprimer les Call.
  4. Ajouter les parenthèses manquantes aux appels de méthode (y compris les appels sans argument : AddForSolid()).
  5. Qualifier les constantes d'énumération par leur type.
  6. Remplacer les Debug.Print par des écritures dans le journal (Logger.Info).
  7. Adapter les déclarations de tableaux à borne inférieure (1 To n → borne supérieure seule).
  8. Vérifier les déclarations multiples (Dim a, b As Type) dont le sens diffère entre les deux langages.

Coup de pouce Besoin d'un développement Inventor (iLogic, .NET, VBA, C++) ou Fusion 360 (Python, C++) ? Contactez-moi pour un devis gratuit.

Sur le même sujet

WIIP Enveloppecontact@wiip.fr
Téléphone(+33) 6 46 40 75 66
Localisation8 rue du bocage, 62910 SERQUES (France)
Mentions légales