[RESOLVED] Option Strict Problems

[Ritzky]

Good day everyone.

I have:

Debug.DebugTextBox.Text = ("Current Guest: " + e.Params("user"))

And

Debug.DebugTextBox.Text = (("Guest Error: (" + e.Params("errorCode") & "): ") + e.Params("errorMessage"))

Error BC30038 Option Strict On prohibits operands of type Object for operator '+'.

Also, I'm trying to write the logged in user to another form (debug.debugtextbox.text), but I want to put it in new lines. As of now, for each output, it just erases what's currently in the textbox and then updates with the new log. Something like Environtment.NewLine(), but that doesn't seem to work for a separate form.

[Inferrd]

Error BC30038 Option Strict On prohibits operands of type Object for operator '+'.

In VB,always use the & Operator to concatenate strings, never "+".

Also, I'm trying to write the logged in user to another form (debug.debugtextbox.text), but I want to put it in new lines. As of now, for each output, it just erases what's currently in the textbox and then updates with the new log. Something like Environtment.NewLine(), but that doesn't seem to work for a separate form.

Does your TextBox have its MultiLine Property set? If so, the following is one way to do what you require:

Debug.DebugTextBox.AppendText("Your String" & Environment.NewLine)

[Ritzky]

Replacing it with a "&" sign leaves it with the same error. (Still Option Strict Conversion Problem).

The AppendText worked or my textbox, though.

[techgnome]

e.Params returns an object of type Object... what you want is the string representation of that... interesting thing about the Object type, it comes with a .ToString method that will return the string representation of that object.

-tg

[JuggaloBrotha]

Good day everyone.

I have:

Debug.DebugTextBox.Text = ("Current Guest: " + e.Params("user"))

And

Debug.DebugTextBox.Text = (("Guest Error: (" + e.Params("errorCode") & "): ") + e.Params("errorMessage"))

Error BC30038 Option Strict On prohibits operands of type Object for operator '+'.

Also, I'm trying to write the logged in user to another form (debug.debugtextbox.text), but I want to put it in new lines. As of now, for each output, it just erases what's currently in the textbox and then updates with the new log. Something like Environtment.NewLine(), but that doesn't seem to work for a separate form.

Debug.DebugTextBox.Text = String.Format("Current Guest: {0}", e.Params("user"))

Debug.DebugTextBox.Text = String.Format("Guest Error: ({0}): {1}", e.Params("errorCode"), e.Params("errorMessage"))

[Inferrd]

Replacing it with a "&" sign leaves it with the same error. (Still Option Strict Conversion Problem)

My apologies. I had always assumed & worked with Objects that boxed String types, or types that could be converted to Strings. Apparently it disallows any operand that is an Object Type, full stop. I presumably haven't noticed this behaviour before as I normally always cast the Object back to its underlying Type before working with it.

Live and learn

[Sitten Spynne]

My apologies. I had always assumed & worked with Objects that boxed String types, or types that could be converted to Strings. Apparently it disallows any operand that is an Object Type, full stop. I presumably haven't noticed this behaviour before as I normally always cast the Object back to its underlying Type before working with it.

Live and learn

Technically, the answer is "it only allows widening implicit conversions or explicit conversions". That's something we have to unravel, but it's useful to know because if you're just getting used to Option Strict it can seem like it chooses randomly.

An "implicit conversion" is when you try to convert a type without using any casts like CType() or CDbl(), or a conversion method like ToString(). These are implicit conversions:

Dim value As Integer = 14.7 ' Converts from Double to Integer
Dim otherWay As Double = 10 ' Integer to Double
Dim another As Byte = 8 ' This is actually Integer to Byte and sometimes frustrating!
Dim badIdea As Double = 12 - "14" ' Implicitly converts String to Integer, then performs subtraction
                                  ' returning an Integer, then implicitly converts to Double

You probably don't consider the first few to be "type conversions" at all! That's why implicit conversions are supported, if you had to express all of those as casts you'd waste a lot of time on code clutter. But not all of those conversions are legal with Option Strict. Why?

That's where "narrowing" conversions appear. It's useful to think of data types as having a "size", which is just "How many values can they represent?" Integers can represent 4 billion values, Bytes can hold 255. So Integer is "bigger" than Byte. More importantly, every Byte is also a value that Integer can represent, but Integer has many values such as -145 that Byte cannot.

So in terms of conversions, we say Integer is "wider" than Byte. Byte to Integer is a "widening" conversion, because we are converting to a type that can not only represent all Byte values, but has more. But Integer to Byte is a "narrowing" conversion, because there are Integers that cannot be represented as Byte.

So if Option Strict is on, we are forced to use explicit casts when we want to make narrowing conversions:

Dim value As Integer = CInt(14.7) ' Double is narrowed explicitly
Dim otherWay As Double = 10 ' But Integer is widened implicitly
Dim another As Byte = 8 ' This is a PITA in C# but VB seems to recognize it.
Dim badIdea As Double = 12 - Integer.Parse("14") ' We had to parse String to Integer before the subtraction

I'm sort of confused by that Byte conversion. Technically '8' is an Integer literal, and Intellisense confirms. Technically it's not safe to narrow Integer to Byte. It looks like the compiler's smart enough to do range checking and allow it. Feel blessed, C# makes this a pain.

So, the reason Object needed a string conversion is Object is technically the widest type of all: it can be anything! That means converting from Object to anything else is always considered "narrowing", even when you can prove that the only thing the Object could be is one particular type. Option Strict makes you be explicit with your dangerous casts, in the hopes that you think harder about them.

Now you know!