C# Version De SQL COMME

Est-il possible de trouver des modèles dans les chaînes de caractères en C#?

Quelque chose comme Sql COMME serait très utile.

  • double possible de Comment faire SQL Like % dans Linq?
  • pas un double, tout comme il y a plusieurs façons de faire de SQL Comme dans Linq qui ne s'appliquent pas pour le reste de C#
  • d'où le "possible" en double 😉
InformationsquelleAutor Ahmet Altun | 2011-03-24
  1. 53

    Les expressions régulières permettent de tout ce qui LIKE permet, et beaucoup plus, mais ont un tout autre syntaxe. Cependant, depuis les règles de LIKE sont tellement simples(où % signifie zéro ou plus caractères et _ signifie un caractère), et les deux LIKE arguments et les expressions régulières sont exprimés dans les chaînes de caractères, nous pouvons créer une expression régulière qui prend un LIKE argument (par exemple abc_ef% *usd) et de le transformer en l'équivalent de l'expression régulière (par exemple,\Aabc.ef.* \*usd\z): 

    @"\A" + new Regex(@"\.|$|\^|\{|\[|\(|\||\)|\*|\+|\?|\\").Replace(toFind, ch => @"\" + ch).Replace('_', '.').Replace("%", ".*") + @"\z"

    Cela, nous pouvons construire un Like() méthode:

    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);
  }
}

    Et donc:

    bool willBeTrue = "abcdefg".Like("abcd_fg");
bool willAlsoBeTrue = "abcdefg".Like("ab%f%");
bool willBeFalse = "abcdefghi".Like("abcd_fg");
    • Non, en SQL qui renvoie false (essayer dans de telles bases de données SQL d'Oracle ou PostgreSQL). En T-SQL il donne de vrai, pas parce que des caractères d'échappement (il n'en existe pas en cause ici), mais en raison de la gamme de caractères spécificateur de l'. Cette non-standard extension pourrait certainement être ajouté si vous le souhaitez.
    • J'ai trouvé le bug dans le MyStringExpessions.Comme fonction de (). Lors de la création de Regex, il ajoute une barre oblique inverse devant [...] qui le brise. J'ai supprimé "[|" d'en haut de la chaîne et tout semble fonctionner.
    • J'ai également eu à supprimer "\^|"
    • Unfortunly, n'est pas de travail, Like("abc", "[a-z]%") retourne false
    • précisément comme il se doit.
    • noter qu'une méthode qui a reproduit des T-SQL non-standard des ajouts à LIKE serait de retour true là, mais c'est une méthode de duplication SQL LIKE.
    • c'est teoretically correct, mais reste très limité d'utilisation. Par exemple, j'ai écrit une requête avec SqlMethods.Like mais n'a pas pu exécuter la requête qui l'utilise jusqu'à ce que j'ai trouvé votre post et correction de quelques problèmes (différence entre le T-SQL et SQL ANSI syntaxe). La plupart de C# les développeurs sont à l'aide de T-SQL donc je pense qu'il serait utile d'ajouter une alternative pour eux.
    • Au lieu d'essayer de correspondre à tous les caractères qui a besoin de s'échapper, ne serait-il pas préférable d'utiliser Regex.Escape à la place? la documentation pour \A et \z usages
    • Essayé d'utiliser des caractères génériques * au lieu de %. En remplaçant Replace("*", ".*") mais ça ne fonctionne pas..

    InformationsquelleAutor Jon Hanna
  2. 28

    Il y a plusieurs façons vous pouvez effectuer une recherche comme "comme" opérateur de SQL en C#.
    Si vous voulez simplement savoir si le modèle existe dans la variable de chaîne, vous pouvez utiliser 

    string value = "samplevalue";
        value.Contains("eva"); //like '%eva%'
         value.StartsWith("eva");  //like 'eva%'
        value.EndsWith("eva"); //like '%eva'

    si vous souhaitez rechercher le motif à partir d'une liste de chaîne, vous devez utiliser LINQ pour les Caractéristiques des Objets.

                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'
    InformationsquelleAutor Foyzul Karim
  3. 13

    Quand je suis tombé sur ce sur un contrat, je n'avais pas d'autre option que d'avoir un 100% compatible TransactSQL COMME une fonction. Ci-dessous est le résultat d'une fonction statique et une chaîne d'extension de la méthode. Je suis sûr qu'il peut être optimisé, mais il est assez rapide et passé ma longue liste de scénarios de test. Espérons que cela aide quelqu'un!

    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;
}
}
}
    • 20x plus rapide que la compilation d'un RegEx méthode que j'ai utilisé. Nice!
    • nice, fonctionne comme un charme
    • superbe, merci
    • C'est assez bon, mais les pauses inappropriée des modèles impliquant des crochets. c'est à dire un modèle de "[" va jeter IndexOutOfRangeException. La syntaxe de côté, il ne supporte pas la bonne extension de la gamme (cette fonction suppose que vous n'aurez qu'une seule gamme et pas d'autres personnages), le cas de LIKE '[a-cdf]' de la doc ne fonctionne pas correctement. Il semble que la - doit être le premier caractère d'être traités littéralement ou peut-être le dernier caractère - la documentation ne précise pas. La doc est également difficile de savoir comment il gère dingo plages, c'est à dire z -, Z-z, etc.
    • Je pense qu'il y a également une faible erreur de logique ici. Prendre en compte le profil "_" avec le texte "__". Avec la logique, il ignore le motif de la partie après le générique s'applique à la première de caractère car il n'y a plus de motif d'allouer (prévu). Normalement, un 2-l'entrée de caractères sera rejetée par un trait de soulignement modèle en définissant isMatch à false, mais le else if où il compare le dernier modèle de caractère à l'entrée de caractères se fait frapper ce qui signifie que le else pour la mise isMatch ne pas se faire frapper.
    InformationsquelleAutor komma8.komma1
  4. 9

    myString.Contain("someString"); //equal with myString LIKE '%someString%'
    myString.EndWith("someString"); //equal with myString LIKE '%someString'
    myString.StartWith("someString"); //equal with myString LIKE 'someString%'

    • Ajouter quelques explications avec la réponse à comment cette réponse aider les OP dans la fixation de l'émission en cours
    • Ce sujet d'une combinaison de tous les 3? Je suis à la recherche de ce modèle.. " pas comme '%/%/%/%' "
    • vous devez utiliser l'expression régulière.
    InformationsquelleAutor M.R.Sadeghi
  5. 5

    Simplement .Contains() serait de faire le travail pour vous.

    "Example String".Contains("amp");   //like '%amp%'

    Ce serait de retour vrai, et en faisant un select sur il serait de retour la sortie souhaitée.

    InformationsquelleAutor Ali Shah Ahmed
  6. 4

    Contient peut-être

    if ("bla bli blu".Contains("blu")){......}
    InformationsquelleAutor Guidhouse
  7. 3

    Opérateurs.LikeString

    https://msdn.microsoft.com/en-us/library/microsoft.visualbasic.compilerservices.operators.likestring(v=vs. 100).ASPX

    public static bool LikeString(
string Source,
string Pattern,
CompareMethod CompareOption
)
    • Cela a une syntaxe différente de SQL, mais je cherchais un C# équivalent à la VB comme opérateur.
    InformationsquelleAutor Fernando Diaz Toledano
  8. 2

    Découvrez cette question - Comment faire SQL Like % dans Linq?

    Aussi, pour les plus avancés, patron de la chaîne de la recherche, il y a beaucoup de tutoriels sur l'utilisation des Expressions Régulières - par exemple http://www.codeproject.com/KB/dotnet/regextutorial.aspx

    InformationsquelleAutor Stuart
  10. 2

    L'utiliser comme ceci:

    if (lbl.Text.StartWith("hr")==true ) {…}
    • Bon! StartWith("abc") est un simple équivalent de Like("abc%")
    InformationsquelleAutor chevhfghfghfgh
  11. 1

    Ont essayé votre

    "This is a string".Contains("string");
    • Contient() ne permet pas de répondre à tout. Par Exemple, @F1 COMME ('S%T') la requête ne peut pas être effectuée par Contains()
    InformationsquelleAutor Ash Burlaczenko
  12. 1

    Linq to SQL Comme Opérateur

    • SqlMethods.Comme peut être utilisé uniquement avec Linq to SQL, et non pas directement à partir de C#
    InformationsquelleAutor Sjoerd
  13. 1

    Je pense que vous pouvez utiliser "a string.Contains("str") pour cela.

    il recherche dans une chaîne de caractères à un patern, et le résultat vrai est fondée et false sinon.

    InformationsquelleAutor
  14. 1

    Comme une fin, mais la bonne réponse:

    La chose la plus proche il y a un type SQL fonction en C-Sharp est la mise en œuvre d'un type SQL fonction en C#.

    Vous pouvez déchirer de
    http://code.google.com/p/csharp-sqlite/source/checkout

    [racine]/csharp-sqlite/de la Communauté.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;
}
    InformationsquelleAutor Stefan Steiger
  15. 0
    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"));
}
}

    Le seul inconvénient est la suivante: "les caractères Génériques ne sont pas admis dans le milieu d'une corde. Par exemple, "te*xt" n'est pas autorisée."©

    • Comme prend deux opérandes de chaînes et retourne un résultat booléen. Ce n'est pas le cas.
    • les jeux de données sont beurk et complètement inutile à cet effet et le chargement de l'ensemble de données est au-dessus, vous ne voulez pas.
    InformationsquelleAutor QrystaL
  16. 0

    il y a plusieurs bonnes réponses ici. pour résumer ce qui est déjà là et correct: utilisation contient, startswith, endswith sont bonnes réponses pour la plupart des besoins. les expressions régulières sont ce que vous voulez pour les plus avancés besoins.

    quelque chose qui n'est pas mentionné dans la réponse à ces questions, cependant, est que, pour un ensemble de cordes, linq peut être utilisé pour appliquer ces filtres dans un appel à la méthode.

    InformationsquelleAutor Dave Rael
  17. 0

    Ajouter un VB.NET DLL encapsulation de l' VB.NET Comme Opérateur

    InformationsquelleAutor Peter Meinl
  18. 0

    Comme déjà proposé dans cette réponse et cette autre réponse Microsoft.VisualBasic.CompilerServices.Operators.LikeString pourrait être une bonne option pour les tâches simples, lorsqu'une RegExp est exagéré. La syntaxe est différente de RegExp et SQL COMME opérateur, mais il est vraiment simple à apprendre (principalement parce que c'est aussi très limité).

    Assemblée Microsoft.VisualBasic doit être ajouté comme une référence dans le projet d'utiliser cette méthode.

    Pour plus d'informations, voir Des opérateurs.LikeString Méthode et pour une description de la syntaxe de voir Comme Opérateur (Visual Basic).

    Il peut être utilisé comme une extension de la méthode de la classe 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);
    InformationsquelleAutor Jordi
  19. 0

    C'est ma mise en œuvre - il passe les tests et ne l'astuce - vous pouvez modifier le jeton de remplacement si vous êtes à l'aide de trois tildes dans vos déclarations:

    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);
}

    Exemple:

    //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
}
    InformationsquelleAutor DavidWainwright