Determine if Type is a pure "Data Type"

Question

Microsoft lists what I would consider "programming primitives" (I understand this is a misnomer) as "Data Types" in their documentation. The list of "Data Type" objects by their metric is thus:

Boolean Byte Char Date Decimal Double Integer Long Object SByte Short Single String UInteger ULong User-Defined UShort

Source

Currently, I am trying to create a function that generates a flat graph from a given object, because I am trying to serialize objects into JSON. The objects that I am working with have many, many circular references that always break the JSON serialize-r because it exceeds the recursion limit.

My Question:

How can I tell using introspection, reflection, what-have-you, intelligently, if an object is a "Pure" data type? As in: the object is a Boolean, Byte Char, etc, etc, not an object that simply inherits from Boolean Byte, or Char, etc.

My Reasoning:

What I hope to accomplish, is that as I recursively traverse through a given object, and am generating a flat structure from that, that I can hold onto object references in a list, and "skip" over objects that I have already hit, and just assign those Guids. The Guid will live in the JSON with the reference to the object, but for all intents and purposes (from the JSON serialize-r side of things), the circular references will be broken, allowing it to serialize.

However, things like strings, bools, nulls, those are easily describable in JSON. Is there a way as I'm checking if I have cataloged the object already, to also check if the object is a "pure Data Type"? To clarify, I still want to write strings, ints, bools, nulls, into the JSON even if I have already encountered a reference to those items.

I am also open to alternative solutions, or better ideas. I am trying to wrap my head around the problem better. Thanks in advance!

Answer 1

Not counting Object and User-Defined as "pure types", the .NET Framework Type class actually includes a property that will return True only for (most of) the built-in types: Type.IsPrimitive.

Primitive (meaning basic or simple) refers to standalone, basic types that represent a single value: They're either a single number (Integer, Long, Short, etc.), a single character (Char) or a single bit (Boolean). Thus you can check the Type.IsPrimitive property to quickly determine if the current object is any of the numerical types defined in the CLR (plus the Char).

If myObj.GetType().IsPrimitive Then

The good thing is that .NET Framework does not allow inheritance of structures, so you'll never bump into a type that inherits from, say, a Boolean.

Now you'll just need to check for the remaining non-primitive types (which too cannot be inherited) and you should have everything you need:

• Date
• Decimal
• String

All you need to do is:

Dim objType As Type = myObj.GetType()
If objType.IsPrimitive OrElse
    objType Is GetType(String) OrElse
     objType Is GetType(Date) OrElse
      objType Is GetType(Decimal) Then

And there you have it!

I would suggest turning this into an Extension Method for simple usage:

Imports System.Runtime.CompilerServices

Public Module Extensions

    <Extension()>
    Public Function IsPureType(ByVal Obj As Object) As Boolean
        If Obj Is Nothing Then Return False

        Dim objType As Type = Obj.GetType()
        Return objType.IsPrimitive OrElse
                objType Is GetType(String) OrElse
                 objType Is GetType(Date) OrElse
                  objType Is GetType(Decimal)
    End Function
End Module

Then you can use it like:

If myObj.IsPureType() Then

EDIT

Jimi pointed out that you can inherit TypeDelegator and override the IsPrimitiveImpl function which lets you (as a programmer) specify if your custom type is primitive or not.

However, in not a single one of my tests was I able to get Obj.GetType().IsPrimitive to return True for my custom classes. Presumably this is because Obj.GetType() returns the automatically generated RuntimeType for your custom class, and not a TypeDelegator, so there shouldn't be a need to worry.