# Visual Basic > Visual Basic FAQs >  Classic VB - What is an Enum, and how can I use it?

## si_the_geek

An Enumeration is basically a new data type (like String or Integer) that you design yourself, which has an associated list of possible values (known as elements).

You might think it would be better to use a String to hold the current value instead, but there are several reasons why an Enum is better, such as:
The list of valid options will be shown in a pop-up list when you are writing code (see the picture below, after the first Code snippet), so you don't need to remember them or even type them - instead you can just select them with your mouse or keyboard.It is harder to make a typo that causes bugs, as not only are the values shown in the list for you to pick from, but also valid entries you type will be changed to the case you declared them - so you can see when the case is not automatically corrected for you.If you use Option Explicit (which is highly recommended anyway), any typo's will cause a message warning you about them.They take less memory than Strings, and code that uses them runs faster than the String equivalent.

*The basics*
To set up an Enumeration, use code like this in the "General" - "Declarations" section of a code file (at the very top):


```
Private Enum MyValues  ' this is the name of our Enumeration
  First       '} 
  Second      '} these are the elements/values that will be allowed
  Third       '}  (add as many as you like, there must be at least one!)
End Enum
```

To use it, declare a variable (or parameter, etc) using the Enum as the data type, and then when you are typing you will see a list of possible elements that you can select from (or type if you prefer):

To work with them, you can use the element names just as you would usually use a variable/const, eg:


```
Dim MyVariable As MyValues
  MyVariable = First
  
  If MyVariable = Second Then
    MsgBox "This message will not be shown!"
  End If
```

*How it works*
The Enum itself is just a way to group the elements (like _First_ and _Second_ above), each of which is basically created as a Const with a data type of Long.

Each of them is automatically assigned a unique number, which you never actually need to know, because you can just use the name instead (as shown in the previous Code snippet).  

Using the names is the best thing to do, as it makes your code more readable (you don't need to remember which element the number 37 refers to!), and it also means that if the numbers ever change (like when you add an extra element to the list) the code that uses them doesn't need to change.

If you really want to, you can actually specify the number that will be associated with each element  - but unless you have a good reason it is just a waste of time (as the values will automatically be unique anyway).  For example, it _could_ have been declared like this:


```
Private Enum MyValues  
  First = -23
  Second = 4 
  Third = 8723
End Enum
```

(even if you do this, you should still use the names in the rest of your code)

*Common problems*
No matter what order you declared the elements in, they are always listed alphabetically (so "Two" would be listed _after_ "Three").  If you want them to be listed in a certain order, change the element names (perhaps by adding a prefix) so that the alphabetical order is the same as the order you want.
The values are not strictly limited to the list of elements you provided - just to the Long data type (so _MyVariable = 527934_ is allowed!).  It is therefore a good idea to do some validation to ensure one of the elements you want has been selected, eg:


```
Select Case MyVariable 
Case First
  'code for when the value is First
Case Second
  'code for when the value is Second
Case Third 
  'code for when the value is Third
Case Else
  'value is not apt - warn the user
  MsgBox "That value is not allowed!"
End Select
```

Just like with variables, you can declare an Enum with the keywords Private or Public, and so use them from different code files in your project... however, unlike variables you cannot specify which code file the Enum was declared in, so it is not a good idea to create two or more Enum's with the same name (depending on the circumstances you could get the wrong one).

*Advanced - Multiple values at the same time*
In some cases you might want to allow multiple values at the same time, just like can be done with MsgBox, which allows things like this:


```
MsgBox "OK?", vbOKCancel + vbQuestion
```

To be able to do that, specifying the values is needed - as you will want to ensure that the values do not accidentally overlap an existing value when they are combined (for example you wouldn't want _vbOKCancel + vbQuestion_ to be the same as _vbOKOnly_ !). The best way to do this is with powers of 2, as it ensures uniqueness without making the numbers growing quicker than needed, eg:


```
Private Enum MyMultiValues
  Option1 = 1  '2^0
  Option2 = 2  '2^1
  Option3 = 4  '2^2
  Option4 = 8  '2^3
  Option5 = 16 '2^4
End Enum
```

You can then _set_ multiple values without any problems, eg:


```
Dim MyOptions as MyMultiValues
  MyOptions = Option1 + Option2  'will contain 3, which can only mean Option1 + Option2
```

Reading the values out of it is slightly harder, as you only want to get _part_ of the overall value (and don't want to write lots of extra code to check all the possible permutations!).

The way to read just one part of it is with bit masking, which you can do like this:


```
If (MyOptions And Option1) = Option1 Then
  MsgBox "Option1 was selected!"
End If
If (MyOptions And Option2) = Option2 Then
  MsgBox "Option2 was selected!"
End If
```

(note that the _And_ used here is not the logical And you normally use, but a bitwise operator instead - see the help on And for more details)

If you want to validate the value, just check if it is _at least_ the lowest single value (in this case, Option1), and _less than_ double the highest single value (Option5).  This is because the maximum is all elements added together, which is one less than double the highest value (in this case, _1+2+4+8+16= 31_, which is the same as _(16*2)-1_ ), eg:


```
If (MyOptions >= Option1) And (MyOptions < Option5 * 2) Then
  MsgBox "Value is valid"
Else
  MsgBox "Value is not valid"
End If
```

----------


## Merri

You may also name the Enum values with spaces:

```
Public Enum MyEnum
    [My Default]
    [My Special Value]
    [My Extra Super Special Value]
    [My Extreme]
End Enum
```

Try to use values that are unlikely to be used by anything else, because you really want these values to be unique and not to be confused with anything else.


I'd highly recommend always using the Or operator instead of the + operator when doing bit level manipulation  :Smilie:

----------

