正規表現では、LIKEが許可するすべてのこと、およびそれ以上のことが可能ですが、構文はまったく異なります。ただし、LIKEのルールは非常に単純であるため（_%_はゼロ以上の文字を意味し、___は1文字を意味します）、およびLIKE引数と正規表現は文字列で表現されます。LIKE引数（_abc_ef% *usd_など）を受け取る正規表現を作成し、同等の正規表現（_\Aabc.ef.* \*usd\z_など）に変換できます。
_@"\A" + new Regex(@"\.|\$|\^|\{|\[|\(|\||\)|\*|\+|\?|\\").Replace(toFind, ch => @"\" + ch).Replace('_', '.').Replace("%", ".*") + @"\z"
_それからLike()メソッドを構築できます：
_public static class MyStringExtensions
{
public static bool Like(this string toSearch, string toFind)
{
return new Regex(@"\A" + new Regex(@"\.|\$|\^|\{|\[|\(|\||\)|\*|\+|\?|\\").Replace(toFind, ch => @"\" + ch).Replace('_', '.').Replace("%", ".*") + @"\z", RegexOptions.Singleline).IsMatch(toSearch);
}
}
_それゆえ：
_bool willBeTrue = "abcdefg".Like("abcd_fg");
bool willAlsoBeTrue = "abcdefg".Like("ab%f%");
bool willBeFalse = "abcdefghi".Like("abcd_fg");
_C＃でSQLの「LIKE」演算子として検索できる方法はいくつかあります。パターンが文字列変数に存在するかどうかだけを知りたい場合は、使用できます
string value = "samplevalue";
value.Contains("eva"); // like '%eva%'
value.StartsWith("eva"); // like 'eva%'
value.EndsWith("eva"); // like '%eva'
文字列のリストからパターンを検索する場合は、LINQ to Object Featuresを使用する必要があります。
List<string> valuee = new List<string> { "samplevalue1", "samplevalue2", "samplevalue3" };
List<string> contains = (List<string>) (from val in valuee
where val.Contains("pattern")
select val); // like '%pattern%'
List<string> starts = (List<string>) (from val in valuee
where val.StartsWith("pattern")
select val);// like 'pattern%'
List<string> ends = (List<string>) (from val in valuee
where val.EndsWith ("pattern")
select val);// like '%pattern'
契約でこれに遭遇したとき、100％準拠のTransactSQL LIKE関数を持つ以外に選択肢はありませんでした。結果は以下のとおりです-静的関数と文字列拡張メソッド。さらに最適化できると確信していますが、非常に高速で、テストシナリオの長いリストに合格しました。それが誰かを助けることを願っています！
using System;
using System.Collections.Generic;
namespace SqlLikeSample
{
public class TestSqlLikeFunction
{
static void Main(string[] args)
{
TestSqlLikePattern(true, "%", "");
TestSqlLikePattern(true, "%", " ");
TestSqlLikePattern(true, "%", "asdfa asdf asdf");
TestSqlLikePattern(true, "%", "%");
TestSqlLikePattern(false, "_", "");
TestSqlLikePattern(true, "_", " ");
TestSqlLikePattern(true, "_", "4");
TestSqlLikePattern(true, "_", "C");
TestSqlLikePattern(false, "_", "CX");
TestSqlLikePattern(false, "[ABCD]", "");
TestSqlLikePattern(true, "[ABCD]", "A");
TestSqlLikePattern(true, "[ABCD]", "b");
TestSqlLikePattern(false, "[ABCD]", "X");
TestSqlLikePattern(false, "[ABCD]", "AB");
TestSqlLikePattern(true, "[B-D]", "C");
TestSqlLikePattern(true, "[B-D]", "D");
TestSqlLikePattern(false, "[B-D]", "A");
TestSqlLikePattern(false, "[^B-D]", "C");
TestSqlLikePattern(false, "[^B-D]", "D");
TestSqlLikePattern(true, "[^B-D]", "A");
TestSqlLikePattern(true, "%TEST[ABCD]XXX", "lolTESTBXXX");
TestSqlLikePattern(false, "%TEST[ABCD]XXX", "lolTESTZXXX");
TestSqlLikePattern(false, "%TEST[^ABCD]XXX", "lolTESTBXXX");
TestSqlLikePattern(true, "%TEST[^ABCD]XXX", "lolTESTZXXX");
TestSqlLikePattern(true, "%TEST[B-D]XXX", "lolTESTBXXX");
TestSqlLikePattern(true, "%TEST[^B-D]XXX", "lolTESTZXXX");
TestSqlLikePattern(true, "%Stuff.txt", "Stuff.txt");
TestSqlLikePattern(true, "%Stuff.txt", "MagicStuff.txt");
TestSqlLikePattern(false, "%Stuff.txt", "MagicStuff.txt.img");
TestSqlLikePattern(false, "%Stuff.txt", "Stuff.txt.img");
TestSqlLikePattern(false, "%Stuff.txt", "MagicStuff001.txt.img");
TestSqlLikePattern(true, "Stuff.txt%", "Stuff.txt");
TestSqlLikePattern(false, "Stuff.txt%", "MagicStuff.txt");
TestSqlLikePattern(false, "Stuff.txt%", "MagicStuff.txt.img");
TestSqlLikePattern(true, "Stuff.txt%", "Stuff.txt.img");
TestSqlLikePattern(false, "Stuff.txt%", "MagicStuff001.txt.img");
TestSqlLikePattern(true, "%Stuff.txt%", "Stuff.txt");
TestSqlLikePattern(true, "%Stuff.txt%", "MagicStuff.txt");
TestSqlLikePattern(true, "%Stuff.txt%", "MagicStuff.txt.img");
TestSqlLikePattern(true, "%Stuff.txt%", "Stuff.txt.img");
TestSqlLikePattern(false, "%Stuff.txt%", "MagicStuff001.txt.img");
TestSqlLikePattern(true, "%Stuff%.txt", "Stuff.txt");
TestSqlLikePattern(true, "%Stuff%.txt", "MagicStuff.txt");
TestSqlLikePattern(false, "%Stuff%.txt", "MagicStuff.txt.img");
TestSqlLikePattern(false, "%Stuff%.txt", "Stuff.txt.img");
TestSqlLikePattern(false, "%Stuff%.txt", "MagicStuff001.txt.img");
TestSqlLikePattern(true, "%Stuff%.txt", "MagicStuff001.txt");
TestSqlLikePattern(true, "Stuff%.txt%", "Stuff.txt");
TestSqlLikePattern(false, "Stuff%.txt%", "MagicStuff.txt");
TestSqlLikePattern(false, "Stuff%.txt%", "MagicStuff.txt.img");
TestSqlLikePattern(true, "Stuff%.txt%", "Stuff.txt.img");
TestSqlLikePattern(false, "Stuff%.txt%", "MagicStuff001.txt.img");
TestSqlLikePattern(false, "Stuff%.txt%", "MagicStuff001.txt");
TestSqlLikePattern(true, "%Stuff%.txt%", "Stuff.txt");
TestSqlLikePattern(true, "%Stuff%.txt%", "MagicStuff.txt");
TestSqlLikePattern(true, "%Stuff%.txt%", "MagicStuff.txt.img");
TestSqlLikePattern(true, "%Stuff%.txt%", "Stuff.txt.img");
TestSqlLikePattern(true, "%Stuff%.txt%", "MagicStuff001.txt.img");
TestSqlLikePattern(true, "%Stuff%.txt%", "MagicStuff001.txt");
TestSqlLikePattern(true, "_Stuff_.txt_", "1Stuff3.txt4");
TestSqlLikePattern(false, "_Stuff_.txt_", "1Stuff.txt4");
TestSqlLikePattern(false, "_Stuff_.txt_", "1Stuff3.txt");
TestSqlLikePattern(false, "_Stuff_.txt_", "Stuff3.txt4");
Console.ReadKey();
}
public static void TestSqlLikePattern(bool expectedResult, string pattern, string testString)
{
bool result = testString.SqlLike(pattern);
if (expectedResult != result)
{
Console.ForegroundColor = ConsoleColor.Red; System.Console.Out.Write("[SqlLike] FAIL");
}
else
{
Console.ForegroundColor = ConsoleColor.Green; Console.Write("[SqlLike] PASS");
}
Console.ForegroundColor = ConsoleColor.White; Console.WriteLine(": \"" + testString + "\" LIKE \"" + pattern + "\" == " + expectedResult);
}
}
public static class SqlLikeStringExtensions
{
public static bool SqlLike(this string s, string pattern)
{
return SqlLikeStringUtilities.SqlLike(pattern, s);
}
}
public static class SqlLikeStringUtilities
{
public static bool SqlLike(string pattern, string str)
{
bool isMatch = true,
isWildCardOn = false,
isCharWildCardOn = false,
isCharSetOn = false,
isNotCharSetOn = false,
endOfPattern = false;
int lastWildCard = -1;
int patternIndex = 0;
List<char> set = new List<char>();
char p = '\0';
for (int i = 0; i < str.Length; i++)
{
char c = str[i];
endOfPattern = (patternIndex >= pattern.Length);
if (!endOfPattern)
{
p = pattern[patternIndex];
if (!isWildCardOn && p == '%')
{
lastWildCard = patternIndex;
isWildCardOn = true;
while (patternIndex < pattern.Length &&
pattern[patternIndex] == '%')
{
patternIndex++;
}
if (patternIndex >= pattern.Length) p = '\0';
else p = pattern[patternIndex];
}
else if (p == '_')
{
isCharWildCardOn = true;
patternIndex++;
}
else if (p == '[')
{
if (pattern[++patternIndex] == '^')
{
isNotCharSetOn = true;
patternIndex++;
}
else isCharSetOn = true;
set.Clear();
if (pattern[patternIndex + 1] == '-' && pattern[patternIndex + 3] == ']')
{
char start = char.ToUpper(pattern[patternIndex]);
patternIndex += 2;
char end = char.ToUpper(pattern[patternIndex]);
if (start <= end)
{
for (char ci = start; ci <= end; ci++)
{
set.Add(ci);
}
}
patternIndex++;
}
while (patternIndex < pattern.Length &&
pattern[patternIndex] != ']')
{
set.Add(pattern[patternIndex]);
patternIndex++;
}
patternIndex++;
}
}
if (isWildCardOn)
{
if (char.ToUpper(c) == char.ToUpper(p))
{
isWildCardOn = false;
patternIndex++;
}
}
else if (isCharWildCardOn)
{
isCharWildCardOn = false;
}
else if (isCharSetOn || isNotCharSetOn)
{
bool charMatch = (set.Contains(char.ToUpper(c)));
if ((isNotCharSetOn && charMatch) || (isCharSetOn && !charMatch))
{
if (lastWildCard >= 0) patternIndex = lastWildCard;
else
{
isMatch = false;
break;
}
}
isNotCharSetOn = isCharSetOn = false;
}
else
{
if (char.ToUpper(c) == char.ToUpper(p))
{
patternIndex++;
}
else
{
if (lastWildCard >= 0) patternIndex = lastWildCard;
else
{
isMatch = false;
break;
}
}
}
}
endOfPattern = (patternIndex >= pattern.Length);
if (isMatch && !endOfPattern)
{
bool isOnlyWildCards = true;
for (int i = patternIndex; i < pattern.Length; i++)
{
if (pattern[i] != '%')
{
isOnlyWildCards = false;
break;
}
}
if (isOnlyWildCards) endOfPattern = true;
}
return isMatch && endOfPattern;
}
}
}
myString.Contain("someString"); // equal with myString LIKE '%someString%'myString.EndWith("someString"); // equal with myString LIKE '%someString'myString.StartWith("someString"); // equal with myString LIKE 'someString%'
単に.Contains（）が作業を行います。
"Example String".Contains("amp"); //like '%amp%'
これはtrueを返し、それに対して選択を実行すると、目的の出力が返されます。
多分含まれています
if ("bla bli blu".Contains("blu")){......}
Operators.LikeString
public static bool LikeString(
string Source,
string Pattern,
CompareMethod CompareOption
)
次のように使用します。
if (lbl.Text.StartWith("hr")==true ) {…}
この質問を確認してください- LinqでSQL Like％を実行するには？
また、より高度な文字列パターン検索については、正規表現の使用に関する多くのチュートリアルがあります。 http://www.codeproject.com/KB/dotnet/regextutorial.aspx
正規表現 を確認してください。
試しましたか
"This is a string".Contains("string");
遅くても適切な答えとして：
C-SharpのSQL-Like関数に最も近いのは、C＃でのSQL-Like関数の実装です。
http://code.google.com/p/csharp-sqlite/source/checkout からリッピングできます
[root] /csharp-sqlite/Community.CsharpSqlite/src/func_c.cs
/*
** Implementation of the like() SQL function. This function implements
** the build-in LIKE operator. The first argument to the function is the
** pattern and the second argument is the string. So, the SQL statements:
**
** A LIKE B
**
** is implemented as like(B,A).
**
** This same function (with a different compareInfo structure) computes
** the GLOB operator.
*/
static void likeFunc(
sqlite3_context context,
int argc,
sqlite3_value[] argv
)
{
string zA, zB;
u32 escape = 0;
int nPat;
sqlite3 db = sqlite3_context_db_handle( context );
zB = sqlite3_value_text( argv[0] );
zA = sqlite3_value_text( argv[1] );
/* Limit the length of the LIKE or GLOB pattern to avoid problems
** of deep recursion and N*N behavior in patternCompare().
*/
nPat = sqlite3_value_bytes( argv[0] );
testcase( nPat == db.aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
testcase( nPat == db.aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] + 1 );
if ( nPat > db.aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] )
{
sqlite3_result_error( context, "LIKE or GLOB pattern too complex", -1 );
return;
}
//Debug.Assert( zB == sqlite3_value_text( argv[0] ) ); /* Encoding did not change */
if ( argc == 3 )
{
/* The escape character string must consist of a single UTF-8 character.
** Otherwise, return an error.
*/
string zEsc = sqlite3_value_text( argv[2] );
if ( zEsc == null )
return;
if ( sqlite3Utf8CharLen( zEsc, -1 ) != 1 )
{
sqlite3_result_error( context,
"ESCAPE expression must be a single character", -1 );
return;
}
escape = sqlite3Utf8Read( zEsc, ref zEsc );
}
if ( zA != null && zB != null )
{
compareInfo pInfo = (compareInfo)sqlite3_user_data( context );
#if SQLITE_TEST
#if !TCLSH
sqlite3_like_count++;
#else
sqlite3_like_count.iValue++;
#endif
#endif
sqlite3_result_int( context, patternCompare( zB, zA, pInfo, escape ) ? 1 : 0 );
}
}
/*
** Compare two UTF-8 strings for equality where the first string can
** potentially be a "glob" expression. Return true (1) if they
** are the same and false (0) if they are different.
**
** Globbing rules:
**
** '*' Matches any sequence of zero or more characters.
**
** '?' Matches exactly one character.
**
** [...] Matches one character from the enclosed list of
** characters.
**
** [^...] Matches one character not in the enclosed list.
**
** With the [...] and [^...] matching, a ']' character can be included
** in the list by making it the first character after '[' or '^'. A
** range of characters can be specified using '-'. Example:
** "[a-z]" matches any single lower-case letter. To match a '-', make
** it the last character in the list.
**
** This routine is usually quick, but can be N**2 in the worst case.
**
** Hints: to match '*' or '?', put them in "[]". Like this:
**
** abc[*]xyz Matches "abc*xyz" only
*/
static bool patternCompare(
string zPattern, /* The glob pattern */
string zString, /* The string to compare against the glob */
compareInfo pInfo, /* Information about how to do the compare */
u32 esc /* The escape character */
)
{
u32 c, c2;
int invert;
int seen;
int matchOne = (int)pInfo.matchOne;
int matchAll = (int)pInfo.matchAll;
int matchSet = (int)pInfo.matchSet;
bool noCase = pInfo.noCase;
bool prevEscape = false; /* True if the previous character was 'escape' */
string inPattern = zPattern; //Entered Pattern
while ( ( c = sqlite3Utf8Read( zPattern, ref zPattern ) ) != 0 )
{
if ( !prevEscape && c == matchAll )
{
while ( ( c = sqlite3Utf8Read( zPattern, ref zPattern ) ) == matchAll
|| c == matchOne )
{
if ( c == matchOne && sqlite3Utf8Read( zString, ref zString ) == 0 )
{
return false;
}
}
if ( c == 0 )
{
return true;
}
else if ( c == esc )
{
c = sqlite3Utf8Read( zPattern, ref zPattern );
if ( c == 0 )
{
return false;
}
}
else if ( c == matchSet )
{
Debug.Assert( esc == 0 ); /* This is GLOB, not LIKE */
Debug.Assert( matchSet < 0x80 ); /* '[' is a single-byte character */
int len = 0;
while ( len < zString.Length && patternCompare( inPattern.Substring( inPattern.Length - zPattern.Length - 1 ), zString.Substring( len ), pInfo, esc ) == false )
{
SQLITE_SKIP_UTF8( zString, ref len );
}
return len < zString.Length;
}
while ( ( c2 = sqlite3Utf8Read( zString, ref zString ) ) != 0 )
{
if ( noCase )
{
if( 0==((c2)&~0x7f) )
c2 = (u32)sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
if ( 0 == ( ( c ) & ~0x7f ) )
c = (u32)sqlite3UpperToLower[c]; //GlogUpperToLower(c);
while ( c2 != 0 && c2 != c )
{
c2 = sqlite3Utf8Read( zString, ref zString );
if ( 0 == ( ( c2 ) & ~0x7f ) )
c2 = (u32)sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
}
}
else
{
while ( c2 != 0 && c2 != c )
{
c2 = sqlite3Utf8Read( zString, ref zString );
}
}
if ( c2 == 0 )
return false;
if ( patternCompare( zPattern, zString, pInfo, esc ) )
return true;
}
return false;
}
else if ( !prevEscape && c == matchOne )
{
if ( sqlite3Utf8Read( zString, ref zString ) == 0 )
{
return false;
}
}
else if ( c == matchSet )
{
u32 prior_c = 0;
Debug.Assert( esc == 0 ); /* This only occurs for GLOB, not LIKE */
seen = 0;
invert = 0;
c = sqlite3Utf8Read( zString, ref zString );
if ( c == 0 )
return false;
c2 = sqlite3Utf8Read( zPattern, ref zPattern );
if ( c2 == '^' )
{
invert = 1;
c2 = sqlite3Utf8Read( zPattern, ref zPattern );
}
if ( c2 == ']' )
{
if ( c == ']' )
seen = 1;
c2 = sqlite3Utf8Read( zPattern, ref zPattern );
}
while ( c2 != 0 && c2 != ']' )
{
if ( c2 == '-' && zPattern[0] != ']' && zPattern[0] != 0 && prior_c > 0 )
{
c2 = sqlite3Utf8Read( zPattern, ref zPattern );
if ( c >= prior_c && c <= c2 )
seen = 1;
prior_c = 0;
}
else
{
if ( c == c2 )
{
seen = 1;
}
prior_c = c2;
}
c2 = sqlite3Utf8Read( zPattern, ref zPattern );
}
if ( c2 == 0 || ( seen ^ invert ) == 0 )
{
return false;
}
}
else if ( esc == c && !prevEscape )
{
prevEscape = true;
}
else
{
c2 = sqlite3Utf8Read( zString, ref zString );
if ( noCase )
{
if ( c < 0x80 )
c = (u32)sqlite3UpperToLower[c]; //GlogUpperToLower(c);
if ( c2 < 0x80 )
c2 = (u32)sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
}
if ( c != c2 )
{
return false;
}
prevEscape = false;
}
}
return zString.Length == 0;
}
これには"a string.Contains("str")を使用できると思います。
文字列でパターンを検索し、結果がtrueである場合はfalseを検索します。
ここにはいくつかの良い答えがあります。すでにここにあるものを要約すると、正しい：contains、startswith、endswithを使用することは、ほとんどのニーズに適した答えです。正規表現は、より高度なニーズに必要なものです。
ただし、これらの回答で言及されていないのは、文字列のコレクションに対して、linqを使用してwhereメソッドの呼び出しでこれらのフィルターを適用できることです。
Areadyが this answer および this other answer で提案したように、Microsoft.VisualBasic.CompilerServices.Operators.LikeStringはRegExpが過剰である場合の単純なタスクに適したオプションです。構文はRegExpやSQL LIKE演算子とは異なりますが、学ぶのは本当に簡単です（主に非常に制限されているため）。
このメソッドを使用するには、プロジェクトへの参照としてアセンブリMicrosoft.VisualBasicを追加する必要があります。
詳細については Operators.LikeStringメソッド を、構文の説明については Like Operator（Visual Basic） を参照してください。
Stringクラスの拡張メソッドとして使用できます。
/// <summary>
/// Visual Basic like operator. Performs simple, case insensitive, string pattern matching.
/// </summary>
/// <param name="thisString"></param>
/// <param name="pattern"> ? = Any single character. * = Zero or more characters. # = Any single digit (0–9)</param>
/// <returns>true if the string matches the pattern</returns>
public static bool Like(this string thisString, string pattern)
=> Microsoft.VisualBasic.CompilerServices.Operators
.LikeString(thisString, pattern, Microsoft.VisualBasic.CompareMethod.Text);
public static class StringsEx
{
public static IEnumerable<String> Like(this IEnumerable<String> input, String pattern)
{
var dt = new DataTable();
dt.Columns.Add("Search");
foreach (String str in input)
{
dt.Rows.Add(str);
}
dt.DefaultView.RowFilter = String.Format("Search LIKE '{0}'", pattern);
return dt.DefaultView.ToTable()
.AsEnumerable()
.Select(r => r.Field<String>("Search"));
}
}
唯一の欠点は次のとおりです。「文字列の途中でワイルドカード文字を使用することはできません。たとえば、「te * xt」は使用できません。」©
VB.NETを追加DLL VB.NET Like Operator をカプセル化
これは私の実装です-テストに合格し、トリックを行います-ステートメントで3つのチルダを使用している場合、置換トークンを変更することができます。
private Regex LikeExpressionToRegexPattern(String likePattern)
{
var replacementToken = "~~~";
String result = likePattern.Replace("_", replacementToken)
.Replace("%", ".*");
result = Regex.Replace(result, @"\[.*" + replacementToken + @".*\]", "_");
result = result.Replace(replacementToken, ".");
return new Regex("^" + result + "$", RegexOptions.IgnoreCase);
}
例：
// Define a test string.
string text = "Hello stackoverflow world";
string like = "%flow%";
// Define a regular expression and Find matches.
MatchCollection matches = LikeExpressionToRegexPattern(like).Matches(text);
//Result.
if (matches.Count > 0) {
//Yes
} else {
//No
}