Advanced iLogic Techniques Reference

You can write iLogic rules using only Inventor parameter assignment statements, predefined iLogic functions, and simple VB.NET code. You can also use the Inventor API directly.

However, you are not limited to these techniques. iLogic is based on VB.NET. You can use more advanced features of VB.NET and the .NET framework in a rule.

Important: At this time, only Visual Basic 2012 (VB 11.0) syntax is supported within rule code. Additions that were made in later versions of Visual Basic do not work.
Note: You can also use Visual Studio to create external DLL files that you can call from rules. These can be written in VB.NET, C#, or other languages.

Headers

Headers are statements that are required to be entered before the rule code in the Edit Rule dialog box. You can enter header statements directly in the header editor, or enter them in the main editor and iLogic will move them to the header editor.

Note: Most rules do not require a header.

To access the header editor, do one of the following:

The following statements are supported in the header editor:

Option Explicit On

Option Strict On

Option Infer Off

AddReference "filename.dll"

Imports ...

AddVbRule "Other Rule"

AddVbFile "filename.vb"

AddResources "filename.resources"

Option and Imports are standard VB.NET statements.

Option Explicit Off is the default. It allows you to use local variables without declaring them.

Option Strict Off is the default. Option Strict On also works for most rules.

Option Infer On is the default.

The main rule code is an "implicit" subroutine. To add more subroutines, functions, properties, or Classes, declare a Sub Main() as follows: 

Sub Main()
' your main rule code here
End Sub

Sub Main() can be used in any rule, regardless of whether the rule has additional code. For more detailed information about explicitly declaring your rule class, see “How is a rule processed?”

AddReference

Uses special iLogic syntax. Adding a DLL name to an AddReference statement is like using the AddReference command and browsing for a DLL in Visual Studio or Visual Basic Express.

Only .NET assemblies are supported. The DLL can be a standard Microsoft assembly, as in the Microsoft.NET\Framework folder.

For example, consider the following statement: 

AddReference "System.Drawing.dll"

In this statement, the .dll extension is optional.

You can also specify a user-created or third-party class library as a reference. User-created or third-party DLLs must all be in one folder. By default, these DLLs are located under the Inventor installation folder, in an iLogicAdd subfolder, such as:

C:\Program Files\Autodesk\Inventor [Version]\Bin\iLogicAdd

You can change this location using the iLogic Configuration command. You can also add references to DLLs in the main Inventor Bin folder (for example, C:\Program Files\Autodesk\Inventor [Version]\Bin).

The AddReference statement does not support a full path specification. You can only specify a filename. Add references to assemblies in the Global Assembly Cache (GAC), using a qualified name such as: 

AddReference "VsWebSite.Interop, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a”

You can also create or access registered COM objects in a rule using CreateObject or GetActiveObject. It is not necessary to use AddReference for a COM DLL.

AddVbRule

Includes the code from the specified rule as VB code, compiled with the main rule. The specified rule cannot be a standard rule. It must have the Straight VB code option enabled in the Options panel of the Edit Rule dialog box. iLogic does not pre-process the code in such a rule. The rule contains Classes or Modules that can be called from other rules. Use this statement to share code between rules, or to keep code modular.

Example 

AddVbRule "Other Rule"

AddVbFile

Operates similarly to AddVbRule, except that the VB code is stored in an external file instead of a rule. As with AddVbRule, the code must have the Straight VB code option enabled. This statement is useful for sharing common code between models. The file specification must be a relative path name. iLogic searches the folder of the current Inventor document, and in other folders, using the same search order employed for external rules.

Example 

AddVbFile "fileName.vb"

AddResources

Adds resources such as strings or bitmaps. The resources must be compiled with Visual Studio.

Example 

AddResources "fileName.resources"

Imports

Duplicate Imports statements are not allowed. The following default Imports statements are implicitly used in all rules:

If you use MessageBox in a rule, then iLogic automatically adds the following statement: 

Imports System.Windows.Forms

If you use ThisApplication or other Inventor objects, then iLogic automatically adds the following: 

Imports Inventor

Rule Arguments

iLogic provides advanced functionality that allows you to pass context information as rule arguments into the rules you run. This information can be used to modify the behavior of a rule without having to create a duplicate rule.

You pass rule arguments using functions available in the IiLogicAutomation interface (for external clients), and in iLogicVB (for other rule code and internal clients). These arguments are made available within a rule via the RuleArguments property.

For IiLogicAutomation, the functions available include:

Function RunRuleWithArguments(ByVal doc As Inventor.Document, ByVal ruleName As String, ByVal ruleArguments As Inventor.NameValueMap) As Integer

Function RunExternalRuleWithArguments(ByVal doc As Inventor.Document, ByVal ruleName As String, ByVal ruleArguments As Inventor.NameValueMap) As Integer

Function RunRuleDirectWithArguments(ByVal rule As iLogicRule, ByVal ruleArguments As Inventor.NameValueMap) As Integer

For iLogicVB, the functions available include:

Function RunRule(ByVal ruleName As String, ByVal ruleArguments As Inventor.NameValueMap) As Integer

Function RunRule(ByVal compoOrDocName As Object, ByVal ruleName As String, ByVal ruleArguments As Inventor.NameValueMap) As Integer

Function RunExternalRule(ByVal ruleName As String, ByVal ruleArguments As Inventor.NameValueMap) As Integer

Create rule arguments

To create rule arguments, use the Inventor API to create a new NameValueMap object. It is then passed to one of the functions when running the rule.

Access an argument passed to the rule 

x = RuleArguments(“myArg”)

Determine if an argument has been passed to the rule 

If RuleArguments.Exists(“myArg”) Then...

Pass the set of arguments to another rule using RunRule 

iLogicVB.RunRule(“someOtherRule”, RuleArguments.Arguments)

Additional Statements

If you use Sub Main(), the rule follows standard VB.NET format for a class, except that the Class... and End Class statements are not visible, and the statements before Sub Main() are outside the class. Therefore, place all assignment statements inside a Sub, Function, or Property. You can include declaration statements for class member variables such as Private temp As Double = 4.5 outside of a subroutine or function.

You can add Sub, Function, Property, and Class definitions after Sub Main()... End Sub. Any Class you add is nested in the main rule Class for that rule and cannot be used from another rule. To add an independent Class or Module, explicitly declare the rule Class using the following: 

Class ThisRule ' ...
Sub Main
End Sub
' ...
End Class

You can then add another Class or Module (or more than one) outside of this code. Class ThisRule becomes your main rule Class, and iLogic calls Sub Main (within it) to run your rule.

To include a Moduleor Class that is visible to multiple rules, put it in an external assembly (DLL). You can put more than one in the same DLL. You can also use AddVbRule to put them in a rule identified as "Straight VB code" within the Inventor document (). Or, use AddVbFile to put them in an external VB file.

When you develop advanced VB.NET code, use Visual Studio or Visual Basic Express rather than coding directly in a rule. You can then cut and paste relatively small snippets of code from Visual Studio into a rule. You can even paste in an entire dialog box Class (although resources are not easily supported). For larger units of code, or where required, create an assembly and use it as an external DLL from a rule.

You can store objects that are instances of a user-defined Class using the iLogic rule Shared Variable functions. To store these objects, serialize the Class, or it must be derived from MarshalByRefObject.

External DLLs

You can write your own external DLLs in .NET and call them from a rule. To debug a DLL, set the build output path under Project Properties Compile to iLogicAdd (under the Inventor Bin folder). Then, choose Inventor.exe for Start external program in your project properties in Visual Studio. This method allows you all the benefits of the debugging environment, including Edit and Continue.

External DLLs are useful when using a rule to display a dialog box for user input.

Inventor API

To access the Inventor API from a rule, use the ThisApplication property to access the Inventor application. Use ThisDoc.Document to access the document that contains the current rule.. You can create and modify features. Use Parameter.Param to get direct access to an Inventor.Parameter.

To use the Inventor API from your own DLL, add a reference to Autodesk.Inventor.Interop.dll in your Visual Basic project. It displays in the Add Reference dialog box on the .NET tab. For Inventor 2011, the version is 15.0.0.0.

Use iLogic Interfaces in External DLLs

All iLogic functions are grouped under interface objects such as Parameter, iProperties, iPart, and so on. You can pass iLogic interface objects as arguments to functions in external DLLs. To use these objects in your project, add a reference to Autodesk.iLogic.Interfaces.dll. Select the Browse tab in the Add Reference dialog box, and browse to the iLogicBin folder, under the Inventor bin folder (usually in C:\Program Files\Autodesk\Inventor [Version]\Bin\iLogicBin).

Documentation for the iLogic interfaces is provided in Autodesk.iLogic.Interfaces.xml. You can use the Object Browser in Visual Studio to read the interface descriptions. These descriptions include the names of the objects which implement the interfaces in rules. For example, the Feature object in a rule implements the ICadFeature interface.

Parent topic: About iLogic Expansion and Customization