À l'aide de “Correspondance” dans une déclaration de Linq

J'ai une table qui contient deux enregistrements (il y aura beaucoup à l'exécution). Le deviceId de la dossiers sont, “DEVICE1” et “USB2”. Je veux utiliser une expression régulière pour extraire des enregistrements.

Le code ci-dessous compile mais ne parvient pas à renvoyer un résultat. Quand j'ai passez le curseur sur le “les appareils.ToList()” déclaration j'obtiens l'erreur suivante:

base {System.SystemException} = {"LINQ to Entities does not recognize the method 'System.Text.RegularExpressions.MatchCollection Matches(System.String)' method, and this method cannot be translated into a store expression."}”

Quelqu'un peut me montrer comment je peux modifier ma requête, de sorte que ce serait de retour des dossiers en fonction de l'expression?

filterText = @"DEVICE.";
Regex searchTerm = new Regex(filterText);

using (var ctx = new MyEntities())
{
 var devices = from d in ctx.Devices
                let matches = searchTerm.Matches(d.DeviceId)
                where matches.Count > 0
                select ((Device)d);
return devices.ToList();
}

Essayez d.DeviceId.StartsWith(searchTerm) au lieu de searchTerm.Les matchs.

OriginalL'auteur Retrocoder | 2010-08-16

c#linq-to-entities regex

16

Je ne crois pas que vous pouvez utiliser des expressions régulières avec LINQ to entities. Cependant, il semble que vous êtes juste essayer de trouver des appareils qui commencent par "APPAREIL", de sorte que la requête serait:
```
return ctx.Devices.Where(d => d.DeviceId.StartsWith("DEVICE"))
                  .ToList();
```
EDIT: Si vous avez réellement besoin de la flexibilité d'une expression régulière, vous devriez probablement d'abord récupérer l'Id de périphérique (et seulement l'Id de périphérique) vers le client, puis effectuez l'une expression régulière sur ceux-ci, et enfin récupérer le reste des données qui correspond à ces requêtes:
```
Regex regex = new Regex(...);

var deviceIds = ctx.Devices.Select(d => DeviceId).AsEnumerable();

var matchingIds = deviceIds.Where(id => regex.IsMatch(id))
                           .ToList();

var devices = ctx.Devices.Where(d => matchingIds.Contains(d.DeviceId));
```
C'est en supposant qu'il serait coûteux pour récupérer toutes les données de tous les appareils pour commencer. Si c'est pas trop mal, ce serait une option plus simple. À force de traitement à effectuer dans le processus, l'utilisation AsEnumerable():
```
var devices = ctx.Devices.AsEnumerable()
                         .Where(d => regex.IsMatch(d.DeviceId))
                         .ToList();
```
L'exemple ne montrer que je suis à la recherche de "Périphérique" au début, mais le regexpr pourrait être quelque chose d'autre, par exemple ".*De l'appareil.2" etc. J'ai besoin d'être en mesure de donner à l'utilisateur quelque chose flexable.
Si vous avez besoin de plus de flexibilité, vous devriez l'avons dit dans la question.
L'envoi d'une très grande collection de matchingIds à la base de données peut entraîner des erreurs. Je pense que je ne voudrais pas prendre ce cours parce que le bon fonctionnement de votre application peut dépendre de la sélectivité de l'expression régulière, qui est fourni par l'utilisateur.
Si c'est le cas, l'OP peut toujours fournir par lots. Pour le moment nous n'en savons pas beaucoup sur le scénario de la façon dont de nombreux appareils, il y aura, combien d'autres données, il est, si la regex est vraiment de l'utilisateur ou le seront dans le code à partir de différents endroits, etc.

OriginalL'auteur Jon Skeet
4

Vous devez toujours vous rappeler que votre LinqToEntities requêtes doivent être traduits pour les requêtes SQL. Depuis SQL Server n'a pas de support pour les expressions régulières, cela peut ne pas fonctionner.

Comme le suggère le commentaire par Paul Ruane, StartsWith fonctionne. Cela peut se traduire par LinqToEntities en WHERE DeviceId LIKE 'DEVICE%'.

Si StartsWith n'est pas assez parce que vous pouvez avoir besoin de rechercher des chaînes dans le milieu des colonnes de base de données, Contains travaillera également:
```
var devices = from d in ctx.Devices
              where d.DeviceId.Contains("DEVICE")
              select d;
```
Le résultat sera le suivant: WHERE DeviceId LIKE '%DEVICE%'.

Pourrais-je avoir tous les périphériques d'abord et ensuite appliquer la regEx choses à l'aide de linq to objects ?
Ce serait possible, mais cela ne fonctionnera que si vous obtenez d'abord tous les objets en mémoire. Il est généralement une meilleure idée de faire autant que possible dans la base de données. Je voudrais des conseils que vous utilisez Contient.
Pourquoi avez-vous besoin pour obtenir chacun d'eux? Comme pas de travail ?
Vous pouvez, voir ma réponse. Oui, il est inefficace, mais si vous devez utiliser une expression régulière soit ça, ou l'utilisation d'une procédure Stockée.
C'est l'un ou l'autre. Soit vous essayez de laisser la base de données de limiter le nombre de résultats via une requête (à l'aide de la chaîne.Contient) ou vous obtenez tous les enregistrements de la mémoire et de l'utilisation d'une expression régulière. Mais supposons que vous disposez d'un million d'enregistrements et seulement mille satisfaire votre contrainte, je donnerais la flexibilité de regex pour (bien) meilleure performance.

OriginalL'auteur Ronald Wildenberg
1

Rappelez-vous lors de l'utilisation d'Entity Framework ou Linq to Sql que votre requête finit par être convertis en SQL. SQL ne comprends pas votre expression régulière de l'objet, et ne peut pas utiliser ses matches sur le côté serveur. Pour utiliser votre RegEx facilement vous pouvez récupérer tous les périphériques à partir du serveur en premier, et ensuite utiliser votre logique. par exemple,
```
using (var ctx = new MyEntities()) 
{ 
    var devices = from Device d in ctx.Devices select d;

    //Retrieve all the devices:
    devices = devices.ToList();

    devices = from d in devices
                  let matches = searchTerm.Matches(d.DeviceId) 
                  where matches.Count > 0 
                  select ((Device)d); 

    return devices.ToList(); 
}
```
Cela ne veut porter le coût de la récupération de plus de données que vous avez besoin, peut-être même beaucoup plus. Pour une logique complexe, vous souhaitez mai à envisager une Procédure Stockée, ce qui pourrait potentiellement utiliser la même expression régulière via des fonctions CLR.

Me battre pour elle, sauf que je l'avais écrit comme return ctx.Devices.ToList().Where(d => searchTerm.Matches(d.DeviceId)).ToList().
Ouais, je l'aurais été encore plus rapide était pas pour le fait que IE tombé deux fois sur cette page!

OriginalL'auteur Simon Steele

LinqToEntities ne prend pas en charge poussant Regex est à la base de données. Juste ne Contient (qui est converti en sql... où DeviceId Like '%PÉRIPHÉRIQUE%').

    filterText = @"DEVICE.";


    using (var ctx = new MyEntities())
    {
            var devices = from d in ctx.Devices
                          d.DeviceId.Contains(filterText)

                          select d;
            return devices.ToList();
        }

OriginalL'auteur Nix

Vous devez vous connecter pour publier un commentaire.