Fast and Easy Enum to text

80x faster

I've been thinking about this issue with text associated with enums since way back in 2003, but I never got around to writing and testing any code to make it easier.  Since I also have a gazillion (and counting) enums in DART, I thought I would finally try to do something about it.  There are about four different methods used in our code to convert from an enum to some kind of text to be displayed:

1. Enum.ToString, when the desired text is a valid VB identifier (simple, but slow)
2. An associated array of strings indexed by the enum, fast when the enum can be used to index but extra work to make an array of strings and keep it in sync, etc.
3. A select case type of statement where the enum is tested and a string is returned; again, extra work.
4. Encoded enum names (e.g., AlertResponseType.INVEST_2F_7CINTEROG) where valid identifiers are created and then the ToString name is converted to readable text.

I had two ideas on how to do this: 1. Create the array (lookup table) automatically and 2. add readable text to the enum value as an attribute.  He is an example:

Private Enum sample4 'verbose
    <Description("Not Declared")> _
    none
    <Description("The First of Two")> _
    One
    <Description("The Second of Two")> _
    Two
End Enum

or (I added the descriptions for the speedup text)

Public Enum AlertResponseType As Integer 'encoded
    <Description("OK")>             OK = -1
    <Description("ABORT|SHUTDWN")>  ABORT_7CSHUTDWN = 0
    <Description("ACCEPT")>         ACCEPT
    <Description("ACCEPT|CONTROL")> ACCEPT_7CCONTROL
    <Description("ACCEPT|ORDER")>   ACCEPT_7CORDER

The EnumText class below will automatically create an array of text associated with the enum values the first time it is used -- and then just use the existing array thereafter.

Speed is not always the most important thing, but I also did some simple loop tests to see how much faster this technique is:

Enum kind	Speedup (x faster)
simple	54.2x
sparse	28.0x
flags	17.7x
encoded	82.6x

I've tried the lookup using array search versus dictionaries, dictionaries win out if you have long enums so it probably depends on your project.  There are other considerations that can complicate this if you allow things like Enum.ToString for a byte or integer that isn't defined.  (You can google several solutions to this enum issue, for general and specific cases -- I didn't see our encoded identifier, though)

The speedup is pretty impressive (2000 to 9000 percent), although I actually expected EnumText v. IdentifierToString to be in the 1000Xs.

Here's the code:
You use it like this:
EnumText(Of verbose4).ToText(verbose4.Two))
 EnumText(Of AlertResponseType).ToText(AlertResponseType.ACCEPT_7CCONTROL))
 

It basically does a quick assessment of what kind of enum it is and then creates a converter for it.

Public Class EnumText(Of T)

   Shared Sub New()
      Dim t As Type = GetType(T)
      If Not t.IsEnum Then
         Throw New ArgumentException("This is only for enums!")
      End If
      Dim needsLookup As Boolean 'i.e. a dictionary
      Dim names As String() = System.Enum.GetNames(t)
      Dim valuesT As T() = DirectCast(System.Enum.GetValues(t), T()) 'for byte, etc.
      Dim values(valuesT.Length - 1) As Integer 

      For n As Integer = 0 To names.GetUpperBound(0)
         Dim name As String = names(n)
         Dim fi As Reflection.FieldInfo = t.GetField(name)
         Dim attrs As System.ComponentModel.DescriptionAttribute() = _
            DirectCast(fi.GetCustomAttributes(GetType(System.ComponentModel.DescriptionAttribute), False), _
            System.ComponentModel.DescriptionAttribute())
         If attrs.Length > 0 Then
            names(n) = attrs(0).Description
         End If
         values(n) = System.Convert.ToInt32(valuesT(n))
         If Not needsLookup _
            AndAlso values(n) <> n Then
            needsLookup = True
         End If
      Next
      If t.GetCustomAttributes(GetType(FlagsAttribute), False).Length > 0 Then 'is flags
         'also assumes needsLookup
         _converter = New FlagsConverter(names, values)
      ElseIf needsLookup Then
         _converter = New LookupConverter(names, values)
      Else
         _converter = New Converter(names)
      End If
   End Sub

   Private Class Converter '(Of V)
      Protected names As String()
      Public Sub New(ByVal names As String())
         Me.names = names
      End Sub
      Public Overridable Function ToText(ByVal value As Integer) As String
         Return names(value)
      End Function
   End Class

   Private Class LookupConverter : Inherits Converter
      Private table As New Dictionary(Of Integer, String)
      Protected values As Integer()
      Public Sub New(ByVal names As String(), ByVal values As Integer())
         MyBase.new(names)
         Me.values = values
         ''overkill: table? what about just iterate through the array?
         ''enum lists are usually short, right?
         For n As Integer = 0 To names.GetUpperBound(0)
            table(values(n)) = names(n)
         Next
      End Sub
      Public Overrides Function ToText(ByVal value As Integer) As String
         Dim text As String = Nothing
         If table.TryGetValue(value, text) Then
            Return text
         Else
            Return value.ToString 'fallback
         End If
      End Function
   End Class

   Private Class FlagsConverter : Inherits LookupConverter
      Public Sub New(ByVal names As String(), ByVal values As Integer())
         MyBase.new(names, values)
      End Sub
      Public Overrides Function ToText(ByVal value As Integer) As String
         If value = 0 Then
            Return MyBase.ToText(0)
         End If
         Dim sb As New System.Text.StringBuilder
         Dim index As Integer = Me.values.GetUpperBound(0)
         Do While index > 0
            If (value And values(index)) = values(index) Then
               value -= values(index)
               If sb.Length > 0 Then
                  sb.Append(","c)
               End If
               sb.Append(names(index))
            End If
            index -= 1
         Loop
         Return sb.ToString
      End Function
   End Class

   Private Shared _converter As Converter
   Public Shared Function ToText(ByVal value As Integer) As String
      Return _converter.ToText(value)
   End Function

TESTING

   Private Enum simple1 'simple
      none
      One
      Two
   End Enum
   Private Enum sparse2 'sparse
      none
      One = 1
      Two = 2
      Four = 4
   End Enum
   <Flags()> _
   Private Enum flags3 'flags
      none
      One = 1
      Two = 2
      Four = 4
   End Enum
   Private Enum verbose4 'verbose
      <Description("Not Declared")> _
      none
      <Description("The First of Two")> _
      One
      <Description("The Second of Two")> _
      Two
   End Enum
   Public Enum AlertResponseType As Integer 'encoded
      <Description("OK")> OK = -1
      <Description("ABORT|SHUTDWN")> ABORT_7CSHUTDWN = 0
      <Description("ACCEPT")> ACCEPT
      <Description("ACCEPT|CONTROL")> ACCEPT_7CCONTROL
      <Description("ACCEPT|ORDER")> ACCEPT_7CORDER
      <Description("ACKNOWL|SHUTDWN")> ACKNOWL_7CSHUTDWN
      <Description("ASSIGN")> ASSIGN
      <Description("BREAK")> BREAK
      <Description("BREAK|ENGAGE")> BREAK_7CENGAGE
      <Description("CANTCO")> CANTCO
      <Description("CDO")> CDO
      <Description("CEASE|MISSION")> CEASE_7CMISSION
      <Description("CONFIRM|SHUTDOWN")> CONFIRM_7CSHUTDOWN
      <Description("COVER")> COVER
      <Description("DCORLTE")> DCORLTE
      <Description("DEFER")> DEFER
      <Description("ENGAGE")> ENGAGE
      <Description("HNDOVER|TO")> HNDOVER_7CTO
      <Description("IGNORE")> IGNORE
      <Description("INTER­|CONSOLE|HNDOVER")> INTER_AD_7CCONSOLE_7CHNDOVER
      <Description("INVEST/|INTEROG")> INVEST_2F_7CINTEROG
      <Description("KILL")> KILL
      <Description("NEVER")> NEVER
      <Description("REJECT")> REJECT
      <Description("REQ|CONTROL")> REQ_7CCONTROL
      <Description("SCRAM")> SCRAM
      <Description("SURVIVE")> SURVIVE
      <Description("WILCO")> WILCO
      <Description("OVERRIDE")> OVERRIDE
   End Enum

   

Public Shared Sub Test()
    Dim s3 As flags3 = CType(5, EnumText(Of T).flags3)
    Debug.Print("--Samples--")
    Debug.Print("simple1.One  =" & EnumText(Of simple1).ToText(simple1.One))
    Debug.Print("sparse2.Four  =" & EnumText(Of sparse2).ToText(sparse2.Four))
    Debug.Print("flags3.One Or flags3.Four  =" & EnumText(Of flags3).ToText(flags3.One Or flags3.Four)) 'flags
    Debug.Print("verbose4.Two  =" & EnumText(Of verbose4).ToText(verbose4.Two))
    Debug.Print("spares(5)  =" & EnumText(Of sparse2).ToText(5)) 'not defined
    Debug.Print("flags(5).ToString  =" & s3.ToString)
    Debug.Print("flags3(5).ToText  =" & EnumText(Of flags3).ToText(s3)) 'flag using integer
    Debug.Print("ACCEPT_7CCONTROL  =" & EnumText(Of AlertResponseType).ToText(AlertResponseType.ACCEPT_7CCONTROL))
    Debug.Print("--Speedup (simple)--")
    Dim sw As Stopwatch = Stopwatch.StartNew
    For i As Integer = 1 To 1000000
       Dim s As String = simple1.Two.ToString
    Next
    Dim sw1 As Long = sw.ElapsedTicks
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = EnumText(Of simple1).ToText(simple1.Two)
    Next
    Dim sw2 As Long = sw.ElapsedTicks
    Debug.Print("{0} {1} {2:0.0}", sw1, sw2, sw1 / sw2)
    Debug.Print("--Speedup (sparse)--")
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = sample2.Four.ToString
    Next
    sw1 = sw.ElapsedTicks
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = EnumText(Of sample2).ToText(sample2.Four)
    Next
    sw2 = sw.ElapsedTicks
    Debug.Print("{0} {1} {2:0.0}", sw1, sw2, sw1 / sw2)
    Debug.Print("--Speedup (flags)--")
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = s3.ToString
    Next
    sw1 = sw.ElapsedTicks
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = EnumText(Of sample3).ToText(s3)
    Next
    sw2 = sw.ElapsedTicks
    Debug.Print("{0} {1} {2:0.0}", sw1, sw2, sw1 / sw2)

    Debug.Print("--Speedup (encoded)--")
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = IdentifierToString(AlertResponseType.INTER_AD_7CCONSOLE_7CHNDOVER.ToString)
    Next
    sw1 = sw.ElapsedTicks
    sw.Reset() : sw.Start()
    For i As Integer = 1 To 1000000
       Dim s As String = EnumText(Of AlertResponseType).ToText(AlertResponseType.INTER_AD_7CCONSOLE_7CHNDOVER)
    Next
    sw2 = sw.ElapsedTicks
    Debug.Print("{0} {1} {2:0.0}", sw1, sw2, sw1 / sw2)

   End Sub
   Shared Function IdentifierToString(ByVal sIdentifier As String) As String
      'NAME: Devon Terminello
      'DATE: March 2004
      'PURPOSE: This function replaces _[hex digit][hex digit] with the asc character that
      '         corresponds with the 2 hex digits. NOTE: This gives me a way to encode
      '         characters into an identifier, which would not otherwise be visible
      Dim sRet As String = ""
      Dim iIndexId As Integer, iChr As Integer
      If Not sIdentifier Is Nothing Then
         Do While iIndexId < sIdentifier.Length
            If sIdentifier.Chars(iIndexId) = "_"c Then
               iChr = Integer.Parse(sIdentifier.Substring(iIndexId + 1, 2), Globalization.NumberStyles.HexNumber)
               sRet &= Chr(iChr)
               iIndexId += 3
            Else
               sRet &= sIdentifier.Chars(iIndexId)
               iIndexId += 1
            End If
         Loop
      End If
      Return sRet
   End Function

End Class

 

It prints out:

--Samples--
simple1.One  =One
sparse2.Four  =Four
flags3.One Or flags3.Four  =Four,One
verbose4.Two  =The Second of Two
spares(5)  =5
flags(5).ToString  =One, Four
flags3(5).ToText  =Four,One  <-- I do my flags backwards compared to MS, but it matches how I assign bits better I think
ACCEPT_7CCONTROL  =ACCEPT|CONTROL

Other things of note:
Negative valued enums, MS uses unsigned sort, so GetNames will have the negative numbered enums at the end.
Since I set and think of flag bits going right to left, that's how I print out my text, too,