Is there a way in VB.NET to compare strings with an if statement without case sensitivity. like in MS-DOS batch with the /I switch?
strcomp function- or I believe there is a String.Compare() method as well.


Code: [Select]if StrComp(StringA,StringB,vbTextCompare)=0 then
'they are the same
end if

but of course .NET is moving away from such foolish notions as "functions". No, everything must now be methods and properties:

Code: [Select]If String.Compare(StringA,StringB,True)=0 then
'the same.

end if



Or, use the CompareTo() Method:

Code: [Select]if StringA.CompareTo(StringB,True)=0 then
'the same
end if


Note that you can even do this:

Code: [Select]If "ABCDEFG".CompareTo(StringA,True)=0 Then
'StringA is "ABCDEFG", or a lowercased equivalent
End If


Personally I NEVER use the equality operator to test strings- except for single-character strings or when I'm to lazy to write out a StrComp() call. StrComp is far better, especially in VB6, since the entire behaviour of the program could change- or the program could break- if the "Option Compare" is changed.or is there ucase function in vb.net??

Code: [Select]if ucase(str1)=ucase(str2) then
'equal
end ifNEVER use that.

performing two uppercase operations takes longer then the StrComp Function- the Ucase and Lcase functions are designed for changing the entire string to Upper or lower case; the strcomp() function is designed for comparing strings. For example if Strcomp finds the first two characters are different, it returns -1 or 1 and returns. using ucase or lcase means that the function will need to convert both strings, and the equality operator will invoke a comparison, and THEN it will return false. And given that this is .NET Ucase and Lcase have bugs and are slower then the .ToUpperCase and .ToLowerCase Methods.

Although using StrComp() obviously isn't an option with QuickBasic, since it's been offered in VB since I believe Version 3 or 4, there is no reason not to use it.


Additionally, using Lcase or Ucase has other performance complications as well. For example, this code:

Code: [Select]Select Case StrComp(A,b,vbtextCompare)
Case -1
Msgbox "A is smaller then B"
case 0
Msgbox "A and B are equal"
case 1
Msgbox "A is larger then B"
end Select

will execute faster then this:

Code: [Select]Au = Ucase$(A)
Bu = Ucase(B)
if Au < Bu Then
msgbox "A is larger then B
Elseif Au=Bu Then
Msgbox "A and B are equal"
Else
Msgbox A is Smaller then B"
end if

1. Ucase is performed on both strings, regardless of how far along the string they are the same. for example if we had strings of millions of characters, Ucase must go through every single character and perform the appropriate conversion. (realistically it likely calls the CharToLowerW API routine- or whatever the routine is called, but regardless a Loop is performed SOMEWHERE). The conversion of course is not a brainless addition of 32 or subtraction of 32, because it also involves special cases of Accent characters.

2. StrComp() iterates through each character in the string- the moment it finds a difference based on the given comparison, (also likely involving a UCase/Lcase or equivalent), it breaks out. THIS is important- the strcomp function is specially constructed to break out once it knows the answer to the function- (IE, characters differ). the Ucase=Ucase or Lcase-Lcase method converts both strings, and then performs a compare, which can be costly in tight loops, time-sensitive operations and can also be expensive in terms of memory if the strings are large- why?

in my example USAGE, two temporary variables are created to prevent more then one call of Ucase$. each one will be the same size as the corresponding value. calling functions and comparing their results directly wouldn't reduce the memory load since VB will generate temporary variables which is uses during evaluation.

ok, i got your point.

Quote from: BC_Programmer on March 30, 2009, 11:28:53 PM

2. StrComp() iterates through each character in the string- the moment it finds a difference based on the given comparison, (also likely involving a UCase/Lcase or equivalent), it breaks out. THIS is important- the strcomp function is specially constructed to break out once it knows the answer to the function- (IE, characters differ).

thus vb.net syntax reminds me of java.

Or model it like Batch's If statement with the /I switch, to not compare it by case.

It definitely speeds things up, thats for sure. I got lazy in a few comparisons in my Expression evaluator and used Ucase for a few comparisons; after replacing them the routine, although called over 10000 times to parse a complicated expression, decreased it's total time to almost half, even though I was using StrComp() in most places.