How to construct single character constants - vb.net

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

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.

Answer 2

Replace:
Public Const ctrM as Char = "\m"C
for this:
Public Const ctrM As Char = "m"c

Answer 3

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.