RegexOptions.Compiledmenginstruksikan mesin ekspresi reguler untuk mengkompilasi ekspresi ekspresi reguler ke IL menggunakan generasi kode ringan ( LCG ). Kompilasi ini terjadi selama konstruksi objek dan sangat memperlambatnya. Pada gilirannya, kecocokan menggunakan ekspresi reguler lebih cepat.
Jika Anda tidak menentukan tanda ini, ekspresi reguler Anda dianggap "ditafsirkan".
Ambil contoh ini:
public static void TimeAction(string description, int times, Action func)
{
// warmup
func();
var watch = new Stopwatch();
watch.Start();
for (int i = 0; i < times; i++)
{
func();
}
watch.Stop();
Console.Write(description);
Console.WriteLine(" Time Elapsed {0} ms", watch.ElapsedMilliseconds);
}
static void Main(string[] args)
{
var simple = "^\\d+$";
var medium = @"^((to|from)\W)?(?<url>http://[\w\.:]+)/questions/(?<questionId>\d+)(/(\w|-)*)?(/(?<answerId>\d+))?";
var complex = @"^(([^<>()[\]\\.,;:\s@""]+"
+ @"(\.[^<>()[\]\\.,;:\s@""]+)*)|("".+""))@"
+ @"((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"
+ @"\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+"
+ @"[a-zA-Z]{2,}))$";
string[] numbers = new string[] {"1","two", "8378373", "38737", "3873783z"};
string[] emails = new string[] { "sam@sam.com", "sss@s", "sjg@ddd.com.au.au", "onelongemail@oneverylongemail.com" };
foreach (var item in new[] {
new {Pattern = simple, Matches = numbers, Name = "Simple number match"},
new {Pattern = medium, Matches = emails, Name = "Simple email match"},
new {Pattern = complex, Matches = emails, Name = "Complex email match"}
})
{
int i = 0;
Regex regex;
TimeAction(item.Name + " interpreted uncached single match (x1000)", 1000, () =>
{
regex = new Regex(item.Pattern);
regex.Match(item.Matches[i++ % item.Matches.Length]);
});
i = 0;
TimeAction(item.Name + " compiled uncached single match (x1000)", 1000, () =>
{
regex = new Regex(item.Pattern, RegexOptions.Compiled);
regex.Match(item.Matches[i++ % item.Matches.Length]);
});
regex = new Regex(item.Pattern);
i = 0;
TimeAction(item.Name + " prepared interpreted match (x1000000)", 1000000, () =>
{
regex.Match(item.Matches[i++ % item.Matches.Length]);
});
regex = new Regex(item.Pattern, RegexOptions.Compiled);
i = 0;
TimeAction(item.Name + " prepared compiled match (x1000000)", 1000000, () =>
{
regex.Match(item.Matches[i++ % item.Matches.Length]);
});
}
}
Ia melakukan 4 tes pada 3 ekspresi reguler yang berbeda. Pertama menguji satu pertandingan sekali (dikompilasi vs tidak dikompilasi). Kedua, tes ini mengulangi kecocokan yang menggunakan kembali persamaan reguler yang sama.
Hasil di mesin saya (dikompilasi dalam rilis, tidak ada debugger terpasang)
1000 pertandingan tunggal (buat Regex, Cocokkan dan buang)
Ketik | Platform | Nomor Trivial | Pemeriksaan Email Sederhana | Pemeriksaan Email Ekst
-------------------------------------------------- ----------------------------
Diterjemahkan | x86 | 4 ms | 26 ms | 31 md
Diterjemahkan | x64 | 5 ms | 29 ms | 35 ms
Disusun | x86 | 913 ms | 3775 ms | 4487 ms
Disusun | x64 | 3300 ms | 21985 ms | 22793 ms
1.000.000 kecocokan - menggunakan kembali objek Regex
Ketik | Platform | Nomor Trivial | Pemeriksaan Email Sederhana | Pemeriksaan Email Ekst
-------------------------------------------------- ----------------------------
Diterjemahkan | x86 | 422 ms | 461 ms | 2122 ms
Diterjemahkan | x64 | 436 ms | 463 ms | 2167 ms
Disusun | x86 | 279 ms | 166 ms | 1268 ms
Disusun | x64 | 281 ms | 176 ms | 1180 ms
Hasil ini menunjukkan bahwa ekspresi reguler yang dikompilasi dapat mencapai 60% lebih cepat untuk kasus di mana Anda menggunakan kembali Regexobjek. Namun dalam beberapa kasus bisa lebih dari 3 urutan besarnya lebih lambat untuk dibangun.
Ini juga menunjukkan bahwa versi .NET x64 bisa 5 sampai 6 kali lebih lambat ketika datang ke kompilasi ekspresi reguler.
Rekomendasi akan menggunakan versi yang dikompilasi dalam kasus di mana baik
- Anda tidak peduli dengan biaya inisialisasi objek dan memerlukan peningkatan kinerja ekstra. (perhatikan kita berbicara pecahan satu milidetik di sini)
- Anda sedikit peduli tentang biaya inisialisasi, tetapi menggunakan kembali objek Regex berkali-kali sehingga akan menggantinya selama siklus hidup aplikasi Anda.
Spanner dalam karya, cache regex
Mesin ekspresi reguler berisi cache LRU yang menampung 15 ekspresi reguler terakhir yang diuji menggunakan metode statis di Regexkelas.
Sebagai contoh: Regex.Replace, Regex.Matchdll .. semua menggunakan cache Regex.
Ukuran cache dapat ditingkatkan dengan pengaturan Regex.CacheSize. Ini menerima perubahan ukuran setiap saat selama siklus hidup aplikasi Anda.
Ekspresi reguler baru hanya di-cache oleh pembantu statis di kelas Regex. Namun, jika Anda membuat objek, cache diperiksa (untuk digunakan kembali dan dihantam), ekspresi reguler yang Anda buat tidak ditambahkan ke cache .
Cache ini adalah cache LRU yang sepele , ini diimplementasikan menggunakan daftar ditautkan sederhana. Jika Anda meningkatkannya menjadi 5.000, dan menggunakan 5.000 panggilan berbeda pada pembantu statis, setiap konstruksi ekspresi reguler akan merayapi 5.000 entri untuk melihat apakah sebelumnya telah di-cache. Ada kunci di sekitar cek, sehingga pemeriksaan dapat mengurangi paralelisme dan memperkenalkan pemblokiran ulir.
Jumlahnya diatur cukup rendah untuk melindungi diri dari kasus-kasus seperti ini, meskipun dalam beberapa kasus Anda mungkin tidak punya pilihan selain menambahnya.
Rekomendasi kuat saya tidak akan pernah meneruskan RegexOptions.Compiledopsi ke pembantu statis.
Sebagai contoh:
\\ WARNING: bad code
Regex.IsMatch("10000", @"\\d+", RegexOptions.Compiled)
Alasannya adalah Anda berisiko besar kehilangan cache LRU yang akan memicu kompilasi yang sangat mahal . Selain itu, Anda tidak tahu apa yang perpustakaan Anda tergantung pada melakukan, sehingga memiliki sedikit kemampuan untuk kontrol atau memprediksi terbaik ukuran cache.
Lihat juga: blog tim BCL
Catatan : ini relevan untuk .NET 2.0 dan .NET 4.0. Ada beberapa perubahan yang diharapkan pada 4,5 yang dapat menyebabkan ini direvisi.