LIKE operator fails with multiple occurance of string in pattern?

[Ed Brown]

I'm working on a VB.Net application that needs to do quite a bit of string
pattern matching, and am having problems using the "LIKE" operator to match
the same string twice in the pattern. For example, in the following code:

Private Sub Button1_Click(B yVal sender As System.Object, ByVal e As
System.EventArg s) Handles Button1.Click
Dim theString As String
theString = "1234 TEST 5432 TEST ABCD"
If theString Like "*TEST*TEST *" Then
MessageBox.Show ("Matches!")
Else
MessageBox.Show ("No Match!")
End If
End Sub

I would expect the LIKE operator in this test to return true, since
theString matches the pattern "*TEST*TEST *", specifying zero-or-more
characters followed by "TEST" followed by zero-or-more characters followed
by "TEST" followed by zero-or-more characters. However, when I run the above
code, the LIKE operator returns false. If I change the pattern to
"*TEST*ABC* ", the LIKE operator returns true. If I alter the pattern to
something like "*TEST*TEST A*", it again returns false. It seems that LIKE
won't match a pattern that contains the same string of characters twice. Can
anyone explain why the operator behaves this way?

Thanks in advance for any replies.

[Jay B. Harlow [MVP - Outlook]]

Ed,
I cannot explain the Like operator as I don't use it very much, I use the
System.Test.Reg ularExpressions .RegEx class instead. As the patterns
supported by RegEx far exceeds the patterns allowed in the Like operator.

Something like:

Dim theRegex As New
System.Text.Reg ularExpressions .Regex(".*TEST. *TEST.*")
Dim theString As String
theString = "1234 TEST 5432 TEST ABCD"
If theRegex.IsMatc h(theString) Then
MessageBox.Show ("Matches!")
Else
MessageBox.Show ("No Match!")
End If

I will normally define my Regex variables as Shared within a class, or
Static within a routine, with the RegExOptions.Co mpiled option if the regex
is used a lot within my program.

Something like:

Imports System.Text.Reg ularExpressions

Static theRegex As New Regex(".*TEST.* TEST.*",
RegexOptions.Co mpiled)
The following site provides a good overview of regular expressions:

http://www.regular-expressions.info/

While this site provides the syntax specifically supported by .NET:

http://msdn.microsoft.com/library/de...geElements.asp

Hope this helps
Jay
"Ed Brown" <eb****@compute r-systems.com> wrote in message
news:e7******** *****@TK2MSFTNG P09.phx.gbl...

I'm working on a VB.Net application that needs to do quite a bit of string
pattern matching, and am having problems using the "LIKE" operator to
match the same string twice in the pattern. For example, in the following
code:

Private Sub Button1_Click(B yVal sender As System.Object, ByVal e As
System.EventArg s) Handles Button1.Click
Dim theString As String
theString = "1234 TEST 5432 TEST ABCD"
If theString Like "*TEST*TEST *" Then
MessageBox.Show ("Matches!")
Else
MessageBox.Show ("No Match!")
End If
End Sub

I would expect the LIKE operator in this test to return true, since
theString matches the pattern "*TEST*TEST *", specifying zero-or-more
characters followed by "TEST" followed by zero-or-more characters followed
by "TEST" followed by zero-or-more characters. However, when I run the
above code, the LIKE operator returns false. If I change the pattern to
"*TEST*ABC* ", the LIKE operator returns true. If I alter the pattern to
something like "*TEST*TEST A*", it again returns false. It seems that LIKE
won't match a pattern that contains the same string of characters twice.
Can anyone explain why the operator behaves this way?

Thanks in advance for any replies.

[Ed Brown]

Thanks Jay, using the RegEx class did the trick.

"Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> wrote in message
news:up******** ******@TK2MSFTN GP15.phx.gbl...

Ed,
I cannot explain the Like operator as I don't use it very much, I use the
System.Test.Reg ularExpressions .RegEx class instead. As the patterns
supported by RegEx far exceeds the patterns allowed in the Like operator.

Something like:

Dim theRegex As New
System.Text.Reg ularExpressions .Regex(".*TEST. *TEST.*")
Dim theString As String
theString = "1234 TEST 5432 TEST ABCD"
If theRegex.IsMatc h(theString) Then
MessageBox.Show ("Matches!")
Else
MessageBox.Show ("No Match!")
End If

I will normally define my Regex variables as Shared within a class, or
Static within a routine, with the RegExOptions.Co mpiled option if the
regex is used a lot within my program.

Something like:

Imports System.Text.Reg ularExpressions

Static theRegex As New Regex(".*TEST.* TEST.*",
RegexOptions.Co mpiled)
The following site provides a good overview of regular expressions:

http://www.regular-expressions.info/

While this site provides the syntax specifically supported by .NET:

http://msdn.microsoft.com/library/de...geElements.asp

Hope this helps
Jay
"Ed Brown" <eb****@compute r-systems.com> wrote in message
news:e7******** *****@TK2MSFTNG P09.phx.gbl...

I'm working on a VB.Net application that needs to do quite a bit of
string pattern matching, and am having problems using the "LIKE" operator
to match the same string twice in the pattern. For example, in the
following code:

Private Sub Button1_Click(B yVal sender As System.Object, ByVal e As
System.EventArg s) Handles Button1.Click
Dim theString As String
theString = "1234 TEST 5432 TEST ABCD"
If theString Like "*TEST*TEST *" Then
MessageBox.Show ("Matches!")
Else
MessageBox.Show ("No Match!")
End If
End Sub

I would expect the LIKE operator in this test to return true, since
theString matches the pattern "*TEST*TEST *", specifying zero-or-more
characters followed by "TEST" followed by zero-or-more characters
followed by "TEST" followed by zero-or-more characters. However, when I
run the above code, the LIKE operator returns false. If I change the
pattern to "*TEST*ABC* ", the LIKE operator returns true. If I alter the
pattern to something like "*TEST*TEST A*", it again returns false. It
seems that LIKE won't match a pattern that contains the same string of
characters twice. Can anyone explain why the operator behaves this way?

Thanks in advance for any replies.