Equivalent of “Dim As String * 1” VB6 to VB.NET

Question

I have some VB6 code that needs to be migrated to VB.NET, and I wanted to inquire about this line of code, and see if there is a way to implement it in .NET

Dim strChar1 As String * 1

Intellisense keeps telling me that an end of statement is expected.

Answer 1

The fixed length strings has been deprecated in VB.NET because there are several better options.

Since your fixed length string is just one character long, you can use the Char type in this case, as Mark suggested.

Dim strChar1 As Char

Answer 2

Seeing as you're doing a VB6 migration, I'd definitely consider VBFixedStringAttribute as well as the other options listed by Mike Spross, but, in this case, because it is a single character, a Char may be an option in this case too.

As mentioned elsewhere VBFixedString is only acknowledged by the Get and Put VB I/O API. So the best solution (other than rewriting your code that references the "fixed length string") is to write your own equivalent of Microsoft.VisualBasic.Compatibility.VB6.FixedLengthString. See this answer for more details.

Answer 3

That's known as a "fixed-length" string. There isn't an exact equivalent in VB.NET.

Edit: Well, OK, there's VBFixedStringAttribute, but I'm pretty sure that exists solely so that automated migration tools can more easily convert VB6 code to VB.NET for you, and it's not really the ".NET way" to do things. Also see the warnings in the article for details on why this still isn't exactly the same thing as a fixed-length string in VB6.

Generally, fixed-length strings are only used in VB6 if you are reading fixed-size records from a file or over the network (i.e. parsing headers in a protocol frame).

For example, you might have a file that contains a set of fixed-length records that all have the format (integer, 1-character-string, double), which you could represent in VB6 as a user-defined type:

Public Type Record
   anInteger As Integer
   aSingleCharacter As String * 1
   aDouble As Double
End Type

This way, VB6 code that reads from the file containing records in this format can read each fixed-sized record stored in the file, and in particular, it will only read 1 byte for aSingleCharacter. Without the * 1, VB6 would have no idea how many characters to read from the file, since a String can normally have any number of characters.

In VB.NET, you can do one of the following, depending on your needs:

• If the length matters (i.e. you need to read exactly one byte from some data source, for example) consider using an array instead, such as

  Dim aSingleByteArray(1) As Byte

• Alternatively, you could use one of the Stream classes. In particular, if you are reading data from a network socket or a file, consider using NetworkStream or FileStream, respectively. A Stream is meant for byte-for-byte access (i.e. raw binary access). StreamReader is a related class that simplifies reading data when it is text-based, so that might be good if you are reading a text file, for example. Otherwise (if dealing with binary data), stick with one of the Stream classes.

• If the length doesn't matter, you could just use a "normal" String. That is to say:

  Dim aNormalString As String

Which answer is "correct" really depends on why it was declared that way in the original VB6 code.