Quand ne pas utiliser RegexOptions.Compilé

Deux choses à penser sont que RegexOptions.Compiled prend le temps CPU et de la mémoire.

Avec cela à l'esprit, il est fondamentalement juste un exemple, lorsque vous devez pas utilisation RegexOptions.Compilé :

• Votre expression régulière exécute seulement une poignée de fois, et la nette accélération au moment de l'exécution n'est pas justifier le coût de la compilation.

Il y a trop de variables à prédire et de tracer une ligne dans le sable, pour ainsi dire. Il avait vraiment besoin de tests afin de déterminer la meilleure approche à adopter. Ou, si vous n'avez pas envie de tester, puis ne pas utiliser Compiled jusqu'à ce que vous faites.

Maintenant, si vous ne choisissez RegexOptions.Compiled il est important que vous n'êtes pas de gaspillage avec elle.

Souvent la meilleure façon de le faire est de définir votre objet, comme une variable statique qui peut être réutilisé à plusieurs reprises. Par exemple...

public static Regex NameRegex = new Regex(@"[^a-zA-Z&-]+", RegexOptions.Compiled);

Le seul problème avec cette approche est que si vous êtes à la déclaration à l'échelle mondiale, alors il peut être un gaspillage si votre application n'est pas toujours l'utiliser, ou ne pas l'utiliser lors du démarrage. Ainsi, une approche légèrement différente serait d'utiliser chargement différé comme je le décris dans l'article que j'ai écrit hier.

Donc dans ce cas ce serait quelque chose comme ceci...

public static Lazy<Regex> NameRegex = 
    new Lazy<Regex>(() => new Regex("[^a-zA-Z&-]+", RegexOptions.Compiled));

Ensuite, il vous suffit de référence NameRegex.Value chaque fois que vous souhaitez utiliser cette expression régulière et il est instancié quand il est d'abord accessible.

RegexOptions.Compilé dans le Monde Réel

Sur un couple de mes sites, je suis en utilisant les Regex routes pour ASP.NET MVC. Et ce scénario est parfait pour RegexOptions.Compiled. Les itinéraires sont définis lors de l'application web démarre, et sont ensuite réutilisés pour toutes les demandes ultérieures tant que l'application continue de fonctionner. De sorte que ces expressions régulières sont instanciés et compilé une fois et réutilisés à des millions de fois.

Compilation généralement seulement améliore les performances si vous êtes économiser de l'objet Regex que vous créez. Puisque vous n'êtes pas, dans votre exemple, l'enregistrement de la Regex, vous ne devriez pas le compiler.

Vous pourriez vouloir restructurer le code de cette façon (remarque je l'ai ré-écrit le regex pour ce que je pense vous le souhaitez. Avoir le début-de-ligne carat dans une répétition de groupe ne fait pas beaucoup de sens, et je suppose un préfixe de nom se termine par un tiret):

    private static readonly Regex CompiledRegex = new Regex("^[a-zA-Z]+-", RegexOptions.Compiled);
private static string GetNameCompiled(string objString)
{
return CompiledRegex.Replace(objString, "");
}

J'ai écrit certains de test de code de ce aussi:

    public static void TestSpeed()
{
var testData = "fooooo-bar";
var timer = new Stopwatch();
timer.Start();
for (var i = 0; i < 10000; i++)
Assert.AreEqual("bar", GetNameCompiled(testData));
timer.Stop();
Console.WriteLine("Compiled took " + timer.ElapsedMilliseconds + "ms");
timer.Reset();
timer.Start();
for (var i = 0; i < 10000; i++)
Assert.AreEqual("bar", GetName(testData));
timer.Stop();
Console.WriteLine("Uncompiled took " + timer.ElapsedMilliseconds + "ms");
timer.Reset();
}
private static readonly Regex CompiledRegex = new Regex("^[a-zA-Z]+-", RegexOptions.Compiled);
private static string GetNameCompiled(string objString)
{
return CompiledRegex.Replace(objString, "");
}
private static string GetName(string objString)
{
return Regex.Replace(objString, "^[a-zA-Z]+-", "");
}

Sur ma machine, j'obtiens:

Compilé pris 21ms

Non pris 37ms