How to construct single character constants

Question

How do I define a constant Char value, similar to vbCr? This does not work...

Public Const ctrM As Char = "\m"C

This says the constant must have exactly one character. Well, ok, isn't that what "\m" is?, what about the following

Public Const ctrM as Char = Convert.ToChar(9)

That's not allowed because it's a function. Huh. Luckily this does work:

Public Dim ctrM as Char = Convert.ToChar(9)

But this seems sub-optimal. Am I missing something here?

Answer 1

Replace:

Public Const ctrM as Char = "\m"C

for this:

Public Const ctrM As Char = "m"c

Answer 2

Credits goes to Plutonix for giving a working/workable solution in a comment.
Used the following approach when I made large use of Modules long ago.

Add a Public Module to your Project :

    Public Module MyConsts

        ' Define your constant Char

        Public Const vbTabC As Char = Microsoft.VisualBasic.Chr(9) ' For Tabulation
        Public Const vbEMC As Char = Microsoft.VisualBasic.Chr(25) ' For EM (End of Medium)
        ' ^^ if you know the ASCII Char Code.
        ' Use Microsoft.VisualBasic.ChrW() for Unicode (unsure of that)

        Public Const vbCharQM As Char = "?"c
        Public Const vbComma As Char = ","c
        Public Const vbDot As Char = "."c
        ' or
        Public Const vbCharQM2 As Char = CChar("?")
        ' ^^ if you can actually write the char as String in the Compiler IDE

    End Module

Then use the constants identifier anywhere in your project like any VB constant string, but, they are of type Char of course (To combine them with String, you'll have to use .ToString())

    Public Sub TestConstChar()
        MessageBox.Show("[" + vbEMC.ToString() + "]")
        ' But hey ! What's the purpose of using End of Medium Char ?
    End sub

---

Note that you have Environment.NewLine that automatically returns the valid Line Feed, or Carriage Return/Line Feed, or only Carriage Return, or even another control Char/String/Stream that is on use on your Operating System.

Based on the Environment.NewLine example, you can also define a (wandering) Class

Public Class MyConstChars

    Public Shared ReadOnly Property Tab() As Char
        Get
            Return Microsoft.VisualBasic.ControlChars.Tab
        End Get
    End Property

    ' ...

End Class

' And use it anywhere like myString = "1" + MyConstChars.Tab.ToString() + "One"

This approach allows you to have more control over the actual value of the static/shared Property, like with Environment.NewLine, and allows your Class to propose much more options (Members) than a simple Constant. However, writing the LambdaClassName.LambdaClassProperty isn't very intuitive I reckon.

---

One another way to ease coding by using constant tags/identifiers in the IDE is to define Code Templates. A code template (piece of code) can be defined in the options of your IDE. You may already know what it is about : you type a keyword, then the IDE replace that keyword with one block of code (that you use often enough to require that shortcut) That's what is happening when you redefines (Overrides) a .ToString() Function in classes.

    ' I have for example one code template keyword...
    PlaceholderChecker

    ' ...that generates the following Code :

    #If IsDebugMode Then
    ''' <summary>
    ''' Placeholder Routine to check wether ALL Class Components are included in Solution.
    ''' </summary>
    Private Shared Sub PlaceholderChecker()
        p_ClassVariableName_ClassPartialSuffix = True
    End Sub
    #End If

In some cases, you don't have to define constants - or have to write more complex code - to get where you want.

Answer 3

The answer by fsintegral is fine, but can be slightly simpler. And you can use the Framework functions if you prefer them to the VB Functions.

Class method:

Public Class AppConsts

    Public Shared ReadOnly CtrlEM As Char = Convert.ToChar(25)
    Public Shared ReadOnly CtrlT As Char = Convert.ToChar(9)
    Public Shared ReadOnly CtrlN As Char = Convert.ToChar(10)
    Public Shared ReadOnly CtrlM As Char = Convert.ToChar(13)
    Public Shared ReadOnly CrLf As String = CtrlN & CtrlM
    ...
End Class

'Usage:
Dim s as string = "..." & AppConts.CtrlEM

They will even show up in intellisense. If you dont like the Type/Class name intruding, you can import the class (I kind of like the Type portion included because it narrows the IntelliSense list rapidly to the relevant values):

Imports AppConsts
....
Dim s As String = CtrlEM

Alternatively, you can use the module method:

Module Program

    Friend ReadOnly CtrlM As Char = Convert.ToChar(25)

End Module

' usage:
Dim s2 As String = "xxxx..." & CtrlM

They are not really constants as far as how the compiler treats them at compile time because they aren't -- they are just ReadOnly fields. But as far as your code is concerned in the IDE, they will act, feel and taste like constants.

It is the use of Const statement which limits how you can define them and require you to use (some) the VB functions rather than .NET ones.