à l'aide de statique Regex.IsMatch vs la création d'une instance de Regex

En C# si vous avez un code comme:

public static string importantRegex = "magic!";

public void F1(){
  //code
  if(Regex.IsMatch(importantRegex)){
    //codez in here.
  }
  //more code
}
public void main(){
  F1();
/*
  some stuff happens......
*/
  F1();
}

ou si vous persister une instance d'une Regex contenant le modèle important? Quel est le coût de l'utilisation de Regex.IsMatch? J'imagine que c'est une NFA créé dans chaque Regex intance. Ce que je comprends de cette NFA la création est non trivial.

InformationsquelleAutor Ben McNiel | 2009-01-05
  1. 48

    Dans une rare départ de mon typiques de l'égoïsme, je suis une sorte de renversement de moi-même sur cette réponse.

    Ma réponse originale à cette question, conservée au-dessous, était fondée sur un examen de la version 1.1 de la .NET framework. C'est assez honteux, depuis .NET 2.0 a été pendant plus de trois ans au moment de ma réponse, et il contenait des modifications à la Regex classe qui affectent de façon significative la différence entre le statique et les méthodes d'instance.

    Dans .NET 2.0 (et 4.0), la statique IsMatch fonction est définie comme suit:

    public static bool IsMatch(string input, string pattern){
    return new Regex(pattern, RegexOptions.None, true).IsMatch(input);
}

    La différence importante ici est que peu true comme troisième argument. Qui correspond à un paramètre nommé "useCache". Si c'est le cas, alors l'analyse de l'arbre est récupéré à partir de la mise en cache sur le deuxième et l'utilisation ultérieure.

    Cette mise en cache mange la plupart—mais pas tous—de la différence de performances entre le statique et les méthodes d'instance. Dans mes tests, la statique IsMatch méthode était encore d'environ 20% plus lente que la méthode d'instance, mais qui ne représentait qu'environ une demi-seconde augmentation lors de l'exécution à 100 fois sur un ensemble de 10 000 chaînes d'entrée (pour un total de 1 million d'opérations).

    De 20% ralentissement peut encore être important dans certains scénarios. Si vous vous trouvez regexing des centaines de millions de chaînes, vous aurez probablement envie de prendre chaque étape, vous pouvez la rendre plus efficace. Mais je serais prêt à parier que 99% du temps, vous êtes à l'aide d'une Regex pas plus d'une poignée de fois, et l'ordre de la milliseconde vous perdez à la méthode statique ne sera pas même à proximité de notable.

    Accessoires pour devgeezer, qui a souligné près d'un an, bien que personne ne semblait remarquer.

    Mon ancienne réponse suivante:

    La statique IsMatch fonction est définie comme suit:

    public static bool IsMatch(string input, string pattern){
    return new Regex(pattern).IsMatch(input);
}

    Et, oui, l'initialisation d'une Regex objet n'est pas anodin. Vous devez utiliser la statique IsMatch (ou l'une de l'autre statique Regex fonctions) comme un raccourci rapide uniquement pour les modèles que vous utilisez seulement une fois. Si vous réutiliserez le modèle, c'est la peine de réutiliser un Regex objet, trop.

    Quant à savoir si ou non vous devez spécifier RegexOptions.Compiled, comme suggéré par Jon Skeet, c'est une autre histoire. La réponse est: ça dépend. Pour de simples motifs ou pour des modèles utilisés seulement une poignée de fois, il peut être plus rapide d'utiliser un non-compilé instance. Vous devriez certainement profil avant de se décider. Le coût de la compilation d'une expression régulière objet est assez grande, en effet, et peut-être pas la peine.

    Prenons, comme exemple, l'exemple suivant:

    const int count = 10000;

string pattern = "^[a-z]+[0-9]+$";
string input   = "abc123";

Stopwatch sw = Stopwatch.StartNew();
for(int i = 0; i < count; i++)
    Regex.IsMatch(input, pattern);
Console.WriteLine("static took {0} seconds.", sw.Elapsed.TotalSeconds);

sw.Reset();
sw.Start();
Regex rx = new Regex(pattern);
for(int i = 0; i < count; i++)
    rx.IsMatch(input);
Console.WriteLine("instance took {0} seconds.", sw.Elapsed.TotalSeconds);

sw.Reset();
sw.Start();
rx = new Regex(pattern, RegexOptions.Compiled);
for(int i = 0; i < count; i++)
    rx.IsMatch(input);
Console.WriteLine("compiled took {0} seconds.", sw.Elapsed.TotalSeconds);

    À count = 10000, comme indiqué, la deuxième sortie est plus rapide. Augmentation count à 100000, et la version compilée gagne.

    • Si la regex sera réutilisée pas le coût de compilation être largement compensé par le coût de la ré-analyse de l'expression rationnelle sur l'utilisation répétée?
    • La regex n'est pas réanalysé sur chaque utilisation si une instance unique est utilisé. Il ne serait d'être réanalysée si vous utilisez une nouvelle instance à chaque fois (comme ce serait le cas si vous utilisez la fonction statique).
    • Vous rangez votre objet regex dans un static readonly variable dans une longue durée de vie de l'application. Si nous ignorons temps de démarrage (par déplacement de sw.Start() après la regex constructeur), la compilation des regex exécute un ordre de grandeur plus rapide dans votre code de test
    • De ne pas être facile, mais vous pourriez aussi bien il suffit de déplacer la totalité de la boucle avant de sw.Start(), et de l'appeler tous les temps de démarrage. Au moment de l'exécution de coût est temps d'exécution de coût. Rendant l'utilisateur à attendre que quelque chose initialise est le même que l'utilisateur attendre que quelque chose d'autre s'exécute.
    • Et en passant, avec le deux constructeur appels en dehors de la minuterie de démarrage, j'obtiens beaucoup moins qu'un ordre de grandeur de différence entre compilé et non pas compilé à 10000 itérations sur ma machine. Pas compilé prend environ 0,011 et compilé prend environ 0,01. Au count=1000, compilé est encore plus lent.
    InformationsquelleAutor P Daddy
  2. 31

    Si vous allez réutiliser l'expression régulière à plusieurs reprises, j'avais créer avec RegexOptions.Compiled et de les mettre en cache. Il n'y a pas de point d'en faire le cadre d'analyser l'expression régulière pattern chaque fois que vous le souhaitez.

    InformationsquelleAutor Jon Skeet
  3. 11

    Cette réponse n'est plus approprié en ce qui concerne les versions de .NET que j'ai sur ma machine.
    4.0.30319 & 2.0.50727 les deux sont les suivantes pour IsMatch:

    public static bool IsMatch(string input, string pattern)
{
  return new Regex(pattern, RegexOptions.None, true).IsMatch(input);
}

    La "vraie" valeur pour un paramètre dans le constructeur appelé "useCache". Tous les Regex constructeurs en fin de compte de la chaîne par le biais de celui-ci, la statique appeler celui-ci directement - passer en "vrai".

    Vous en savoir plus sur la BCL blog sur l'optimisation des Regex performance mettant en évidence les méthodes statiques " cache utiliser ici. Ce blog posts cite également des mesures de performance. La lecture de la série de billets de blog sur l'optimisation de la Regex de la performance est un excellent endroit pour commencer.

    InformationsquelleAutor devgeezer
  4. 8

    Je suis d'accord avec Jon et juste pour clarifier, il ressemblerait à quelque chose comme ceci:

    static Regex regex = new Regex("regex", RegexOptions.Compiled);

    Son mériteraient également à regarder la RegexOptions enum pour d'autres indicateurs qui peuvent être utile à certains moments.

    InformationsquelleAutor Andrew Hare
  5. 6

    Il y a beaucoup de choses qui influent sur les performances de l'aide d'une expression régulière. En fin de compte, la seule façon de le savoir le plus performant dans votre situation est de mesurer, à l'aide d'réaliste d'une situation que possible.

    La page sur la compilation et la réutilisation de l'expression régulière objets sur MSDN couvre ce. En résumé, il est dit

    1. Compilé des expressions régulières prendre le temps de compiler, et une fois compilé n'ont que leurs la mémoire publié sur AppDomain décharge. Si vous devez utiliser la compilation ou non dépendra du nombre de modèles que vous utilisez et la façon dont ils sont souvent utilisés.

    2. Statique Regex méthodes cache l'analyse de l'expression régulière pour la représentation des 15 dernières (par défaut) les modèles. Donc, si vous n'êtes pas en utilisant de nombreux modèles différents dans votre application, ou de votre utilisation est suffisamment cluster, il n'y aura pas beaucoup de différence entre vous mise en cache de l'instance ou le cadre de la mise en cache il.

    • Je ne m'inquiète pas si le thread est l'âge de sept mois, c'est la seule réponse qu'il obtient droit.
    InformationsquelleAutor Ben Lings
  6. 3

    Je vous suggère de lire Jeff post sur la compilation de Regex.

    Comme pour la question, si vous posant cette question, il signifie que vous allez utiliser qu'une seule fois. Donc, il n'a pas vraiment d'importance, comme le Réflecteur du démontage de Regex.IsMatch est:

    public static bool IsMatch(string input, string pattern, RegexOptions options)
{
    return new Regex(pattern, options, true).IsMatch(input);
}
    • +1 pour le lien vers le post sur le sujet
    InformationsquelleAutor Recep
  7. 2

    Pour une application WinForm j'ai été travailler sur, nous pourrions définir une expression régulière sur les caractères valides qui irait sur chaque frappe de touche et une validation du texte pour toutes les zones de texte (application de saisie de données), j'ai donc utilisé un cache ou compilé les regexes comme 

      private static Dictionary<string, Regex> regexCache = new Dictionary<string, Regex>(20);

    Où l'expression regex a été la clé.

    Ensuite, j'ai eu une fonction statique je pouvais l'appeler lors de la validation de données:

    public static bool RegExValidate(string text, string regex)
{
  if (!regexCache.ContainsKey(regex))
  {
    Regex compiledRegex = new Regex(regex,RegexOptions.Compiled);
    regexCache.Add(regex, compiledRegex);
  }
  return regexCache[regex].IsMatch(text);
}
    InformationsquelleAutor benPearce