Recherche de génériques pour LINQ

Je voudrais utiliser des Expressions Régulières, car vous pourriez ne pas toujours être à l'aide de Linq to SQL.

Comme cet exemple de Linq to Objects

List<string> list = new List<string>();
list.Add("This is a sentence.");
list.Add("This is another one.");
list.Add("C# is fun.");
list.Add("Linq is also fun.");

System.Text.RegularExpressions.Regex regEx = new System.Text.RegularExpressions.Regex("This");

var qry = list
    .Where<string>(item => regEx.IsMatch(item))
    .ToList<string>();

//Print results
foreach (var item in qry)
{
    Console.WriteLine(item);
}

ajouter un Système.Les données.Linq.SqlClient à votre utilisation ou l'importation de la liste puis essayez:

var results= from x in data
             where SqlMethods.Like(x.SearchField, “%something%like%this%”)
             select x;

À la recherche à la question

Ce que si je veux quelque chose comme %Test si%il travail%, comment dois-je faire?

alors je m'attends à quelque chose de

LIKE '%Test if%it work%'

ce qui signifie que la chaîne doit contenir 'Tester si' et de 'fonctionner', dans cet ordre.

Cela ne fonctionnera pas:

context.SomeTable.Where(s => s.Name.Contains("Test if%it work")).ToList();

Et si j'utilise:

context.SomeTable.Where(s => s.Name.Contains("Test if") && s.Name.Contains("it work")).ToList();

alors je vais trouver toutes les notices qui contiennent à la fois "Tester si" et "travail", mais pas spécialement dans cet ordre.

Donc, avec Contient ce n'est pas possible. Mais avec IndexOf il est.

IndexOf permettra de localiser l'searchstring ET retourne la position dans la chaîne. Permet de trouver les mots dans le bon ordre.

-- Update --

Avec ma réponse originale à cette question, il n'était pas mon but de fournir une solution générique, mais plutôt un exemple d'une autre approche qui n'est pas sql dependend. Donc, il est exact qu'à l'origine, par exemple, seulement les réponses à la question littérale. Mais depuis que la réponse peut être plus utile si elle est générique, j'ai écrit un IQuerable extension qui permet d'ajouter une déclaration à la requête simple comme un défaut de déclaration. L'extension fonctionne pour les deux Linq comme Linq-Sql.

Cela permettra de trouver tous les enregistrements avec "Test si" et "travail", dans cet ordre.

context.SomeTable.Like("test if%it work", "Name").ToList();

listOfString.Like("test if%it work").ToList();

Extension, permet à n'importe quel nombre de caractères de remplacement:

///<summary>
///Allow to search the string with wildcards.
///</summary>
///<typeparam name="T">String or an object with a string member.</typeparam>
///<param name="q">Original query</param>
///<param name="searchstring">The searchstring</param>
///<param name="memberName">The name of the field or null if not a field.</param>
///<returns>Query filtered by 'LIKE'.</returns>
public static IQueryable<T> Like<T>(this IQueryable<T> q, string searchstring, string memberName = null)
{
//%a%b%c% --> IndexOf(a) > -1 && IndexOf(b) > IndexOf(a) && IndexOf(c) > IndexOf(b)
var eParam = Expression.Parameter(typeof(T), "e");
MethodInfo methodInfo;
//Linq (C#) is case sensitive, but sql isn't. Use StringComparison ignorecase for Linq.
//Sql however doesn't know StringComparison, so try to determine the provider.
var isLinq = (q.Provider.GetType().IsGenericType && q.Provider.GetType().GetGenericTypeDefinition() == typeof(EnumerableQuery<>));
if (isLinq)
methodInfo = typeof(string).GetMethod("IndexOf", new[] { typeof(string), typeof(StringComparison) });
else
methodInfo = typeof(string).GetMethod("IndexOf", new[] { typeof(string) });
Expression expr;
if (string.IsNullOrEmpty(memberName))
expr = eParam;
else
expr = Expression.Property(eParam, memberName);
//Split the searchstring by the wildcard symbol:
var likeParts = searchstring.Split(new char[] { '%' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < likeParts.Length; i++)
{
MethodCallExpression e;
if (isLinq)
e = Expression.Call(expr, methodInfo, new Expression[] { Expression.Constant(likeParts[i], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) });
else
e = Expression.Call(expr, methodInfo, Expression.Constant(likeParts[i], typeof(string)));
if (i == 0)
{
//e.IndexOf("likePart") > -1
q = q.Where(Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(e, Expression.Constant(-1, typeof(int))), eParam));
}
else
{
//e.IndexOf("likePart_previous")
MethodCallExpression ePrevious;
if (isLinq)
ePrevious = Expression.Call(expr, methodInfo, new Expression[] { Expression.Constant(likeParts[i - 1], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) });
else
ePrevious = Expression.Call(expr, methodInfo, Expression.Constant(likeParts[i - 1], typeof(string)));
//e.IndexOf("likePart_previous") < e.IndexOf("likePart")
q = q.Where(Expression.Lambda<Func<T, bool>>(Expression.LessThan(ePrevious, e), eParam));
}
}
return q;
}

Car il n'a pas besoin de SqlMethods je suppose que vous pouvez l'utiliser pour toute base de données comme MySql ou Postgresql. Mais je ne sais pas pour sûr. J'ai fait le test avec Sql Server à l'aide de Entity Framework 6. La déclaration ci-dessus génère le code suivant dans Sql Server.

SELECT [Extent1].* FROM SomeTable AS [Extent1]
WHERE ((( CAST(CHARINDEX(N'test if', [Extent1].[Name]) AS int)) - 1) > -1)
AND ((( CAST(CHARINDEX(N'test if', [Extent1].[Name]) AS int)) - 1) < 
(( CAST(CHARINDEX(N'it work', [Extent1].[Name]) AS int)) - 1))

Sur la performance, il semble y avoir une discussion sur ce qui est "mieux": COMME ou CHARINDEX. Et à partir de ce que j'ai lu CHARINDEX semble être un favori.

var result = (from x in db.Members
where x.IDNumber.Contains(idnumber)
&& x.InstitutionIdentifier == institution.Identifier
select x).ToList();
return result;

De travail pour les deux Linq to SQL et Linq dans la mémoire.

ne sais pas si vous parlez LinqToSql ou tout simplement linq... mais vous pouvez les expressions régulières comme ceci:

.Where(dto => System.Text.RegularExpressions.Regex.IsMatch(dto.CustomerName, @"Ad"));

Vous pouvez également utiliser "contient"

var myresult = db.MyItems.Where(x=>x.MyField.Contains(mysearchstring));

- Je l'utiliser pour soutenir un filtre générique de "*" dans la recherche d'un utilisateur. (l'ordre n'a pas d'importance):

 if (!string.IsNullOrEmpty(SearchString))
{
List<String> containValues = new List<String>();
if (SearchString.Contains("*"))
{
String[] pieces = SearchString.Split("*");
foreach (String piece in pieces)
{
if (piece != "")
{
containValues.Add(piece);
}
}
}
if (containValues.Count > 0)
{
foreach(String thisValue in containValues)
{
Items = Items.Where(s => s.Description.Contains(thisValue));
}
}
else
{
Items = Items.Where(s => s.Description.Contains(SearchString));
}
}