Get TypeName from DocumentType
Hi @PolemEngineering. When it comes to checking document type in my codes, I have mostly switched over from using the Document.DocumentType property, and the DocumentTypeEnum Enum, to using the TypeOf Operator. It seems to process faster, looks easier to read, and often takes a little less code, so typing it that way is also a bit faster. Since you are already using TryCast Operator, which requires the a 'type name' (not a String), using the 'TypeOf' operator would be a very natural and logical adaptation to go along with it. There are obviously more variations within the DocumentTypeEnum than there are 'type names' to check against with the 'TypeOf' operator, but 99% of the time I'm only checking for those 3 main types (drawing, part, assembly) anyways. Sometimes, depending on the situation, I also like to just create my own set of Boolean type variables, which have their values set from those checks, as seen in my examples below.
I actually did some local testing using the System.Diagnostics.StopWatch, and found that the 'TypeOf' checks processed 2 to 3 times faster than the DocumentTypeEnum checks. Below are two extremely basic iLogic rules you can test this theory with, as I did.
TypeOf checks test
Dim oDoc As Inventor.Document = ThisDoc.Document
Dim bIsDrawing, bIsPart, bIsAssembly As Boolean
Dim oSW As New System.Diagnostics.Stopwatch()
oSW.Start()
bIsDrawing = (TypeOf oDoc Is DrawingDocument)
bIsPart = (TypeOf oDoc Is PartDocument)
bIsAssembly = (TypeOf oDoc Is AssemblyDocument)
oSW.Stop()
Logger.Info("TypeOf Test Elapsed Ticks = " & oSW.ElapsedTicks.ToString)
oSW.Reset()DocumentTypeEnum checks test
Dim oDoc As Inventor.Document = ThisDoc.Document
Dim bIsDrawing, bIsPart, bIsAssembly As Boolean
Dim oSW As New System.Diagnostics.Stopwatch()
oSW.Start()
bIsDrawing = (oDoc.DocumentType = DocumentTypeEnum.kDrawingDocumentObject)
bIsPart = (oDoc.DocumentType = DocumentTypeEnum.kPartDocumentObject)
bIsAssembly = (oDoc.DocumentType = DocumentTypeEnum.kAssemblyDocumentObject)
oSW.Stop()
Logger.Info("DocumentTypeEnum Test Elapsed Ticks = " & oSW.ElapsedTicks.ToString)
oSW.Reset()If this solved your problem, or answered your question, please click ACCEPT SOLUTION .
Or, if this helped you, please click (LIKE or KUDOS) 👍.
Wesley Crihfield
(Not an Autodesk Employee)
If taking the next logical step, and checking DocumentSubType, there are a couple other tips that you may find useful.
Most of us who have been writing code to automate Inventor for a while have come across the following common properties of the Document object, and attempted to use them.
That first one 'DocumentSubType' appears to now be 'retired', because we can no longer find any further information about how to check its value within the online help documentation, and the links to the value type it returns are now broken. However, it seems as though Autodesk has chosen to continue supporting its functionality in the background, to keep from 'breaking' the functionality of 'legacy' solutions, for now. It claims to return a value that is DocumentSubType Type (not a String or Enum), and when we look older code examples using it, they use it like this [Document.DocumentSubType.DocumentSubTypeID = ], which indicates that value Type was an object that had a property named 'DocumentSubTypeID, which had a String type value, which was one of those long GUID type, unreadable pattern of letters, numbers, & symbols.
The second one 'Document.SubType' actually returns the same value as 'Document.DocumentSubType.DocumentSubTypeID' did, and does so with far less code or complication.
However, both of them leave us with a value we can not directly read, or understand clearly.
And, there is yet another way to get that same value from a Document, through its standard iProperties, in its third PropertySet named 'Design Tracking Properties' (aka 'Project'), and its property at index 16, named 'Document SubType'.
However, if you want a value that you can actually read, and understand, we can use the very next iProperty in that same set, named 'Document SubType Name' (index 17). If it is a regular part, it will return "Modeling" (for some reason), if a sheet metal part, it will contain "Sheet Metal" text, if regular assembly, it will contain "Assembly" text, if a weldment type assembly, it will contain "Weldment" text, and so on. This same exact value can be seen within the standard iProperties dialog, on the Project tab, beside the label "File Subtype:" in every document.
The last year or two, I have mostly switched from checking SubType using any of the above mentioned ways, to using the 'TypeOf' operator on the ComponentDefinition object directly, instead. It seems to require less code, and is equally easy to read and understand (at least for me). This is because pretty much every SubType has a unique type of ComponentDefinition to match it, and then some. ComponentDefinition is a base type, which has several other, more specific types derived from it, for special purposes/uses. And some of those sub types even have other more specific sub types derived from them also. At this point in my codes, I am usually about to declare a variable for the ComponentDefinition anyways, which usually requires me typing that TypeName anyways, so this is another relatively efficient and logical way to check it.
Below is a simple iLogic rule which extracts that same SubTypeID value from the Document object in all 3 ways that I know of, plus shows the 'readable' way I mentioned, but does not show the 'TypeOf' check on the ComponentDefinition, because it does not fit this situation very well.
Dim oDoc As Inventor.Document = ThisDoc.Document
Dim sSubType_ID_1 As String = oDoc.DocumentSubType.DocumentSubTypeID
Dim sSubType_ID_2 As String = oDoc.SubType
Dim sSubType_ID_3 As String = oDoc.PropertySets.Item(3).Item(16).Value
Dim sSubTypeName As String = oDoc.PropertySets.Item(3).Item(17).Value
MessageBox.Show("Document SubType Info:" & vbCrLf & _
"Document.DocumentSubType.DocumentSubTypeID = " & sSubType_ID_1 & vbCrLf & _
"Document.SubType = " & sSubType_ID_2 & vbCrLf & _
"'Document SubType' iProperty Value = " & sSubType_ID_3 & vbCrLf & _
"'Document SubType Name' iProperty Value = " & sSubTypeName, _
"This Document's SubType Info", MessageBoxButtons.OK, MessageBoxIcon.Information)
Wesley Crihfield
(Not an Autodesk Employee)
That's not a bad idea. I also had the thought to create my own DocumentSubTypeEnum within an external rule, so I could reference it with 'AddVbFile' from other rules, but I don't recall if I ever finished that thought / idea, to be honest, because I am certainly not using it right now.
Below is a link to my Inventor Ideas post where I am asking Autodesk to add a DocumentSubTypeEnum, or something similar, to make that step easier.
Checking TypeOf ComponentDefinition is not universal way of checking document sub type, but just another tool to keep in the tool belt. I have found it very useful in some situations, but it might not be ideal for 100% of situations. For instance drawings do not have one, and there are some types of ComponentDefinition that do not have a Document associated with them, even if they do have that Property named Document. Below is just a generic sample code I just threw together, because I usually just use a single line in various rules and methods, in various places.
Dim oDoc As Inventor.Document = ThisDoc.Document
Dim oCD As ComponentDefinition = Nothing
Try : oCD = oDoc.ComponentDefinition : Catch : End Try
Dim bIsDrawing, bIsPart, bIsSheetMetal, bIsFlatPattern, bIsAssembly, bIsWeldment, bIsWelds, bIsVirtual As Boolean
'I do not know of any sub types of drawings, plus they do not have a ComponentDefinition
bIsDrawing = (TypeOf oDoc Is DrawingDocument)
'next one may be true for both regular parts and sheet metal, since sheet metal is derived from part
bIsPart = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is PartComponentDefinition)
'this one is more specific
bIsSheetMetal = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is SheetMetalComponentDefinition)
'this is similar, but not derived from sheet metal definition type
bIsFlatPattern = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is FlatPattern)
'this one may be true for regular assembly and weldment, because weldment derived from assembly
bIsAssembly = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is AssemblyComponentDefinition)
'this one is more specific
bIsWeldment = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is WeldmentComponentDefinition)
'this is not derived from weldment type, and is just the welds in a weldment
bIsWelds = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is WeldsComponentDefinition)
'no actual document, just for adding useful rows into BOM
bIsVirtual = (oCD IsNot Nothing) AndAlso (TypeOf oCD Is VirtualComponentDefinition)
MsgBox( _
"IsDrawing = " & bIsDrawing & vbCrLf & _
"IsPart = " & bIsPart & vbCrLf & _
"IsSheetMetal = " & bIsSheetMetal & vbCrLf & _
"IsFlatPattern = " & bIsFlatPattern & vbCrLf & _
"IsDrawing = " & bIsDrawing & vbCrLf & _
"IsAssembly = " & bIsAssembly & vbCrLf & _
"IsWeldment = " & bIsWeldment & vbCrLf & _
"IsWelds = " & bIsWelds & vbCrLf & _
"IsVirtual = " & bIsVirtual)
Wesley Crihfield
(Not an Autodesk Employee)
