added a single value cache to improve performance for repeated calls to unmodified instances

Author: Thomas Biel

VerbalExpressions/RegexCache.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace CSharpVerbalExpressions
+{
+    public sealed class RegexCache
+    {
+        private bool hasValue;
+        private Key key;
+        private Regex regex;
+        
+        private class Key
+        {
+            public Key(string pattern, RegexOptions options)
+            {
+                this.Pattern = pattern;
+                this.Options = options;
+            }
+
+            public string Pattern { get; private set; }
+            public RegexOptions Options { get; private set; }
+            
+            public override bool Equals(object obj)
+            {
+                var key = obj as Key;
+                return key != null &&
+                       key.Pattern == this.Pattern &&
+                       key.Options == this.Options;
+            }
+
+            public override int GetHashCode()
+            {
+                return this.Pattern.GetHashCode() ^ this.Options.GetHashCode();
+            }
+        }
+
+        /// <summary>
+        /// Gets the already cached value for a key, or calculates the value and stores it.
+        /// </summary>
+        /// <param name="pattern">The pattern used to create the regular expression.</param>
+        /// <param name="options">The options for regex.</param>
+        /// <returns>The calculated or cached value.</returns>
+        public Regex Get(string pattern, RegexOptions options)
+        {
+            if (pattern == null) throw new ArgumentNullException("pattern");
+
+            lock (this)
+            {
+                var current = new Key(pattern, options);
+                if (this.hasValue && current.Equals(this.key))
+                {
+                    return this.regex;
+                }
+
+                this.regex = new Regex(pattern, options);
+                this.key = current;
+                this.hasValue = true;
+                return this.regex;
+            }
+        }
+    }
+}

VerbalExpressions/VerbalExpressions.cs

@@ -36,11 +36,13 @@ public static VerbalExpressions DefaultExpression
 
         #region Private Members
 
+        private readonly RegexCache regexCache = new RegexCache();
+
         private string _prefixes = "";
         private string _source = "";
         private string _suffixes = "";
         private RegexOptions _modifiers = RegexOptions.Multiline;
-
+        
         #endregion Private Members
 
         #region Private Properties
@@ -52,23 +54,11 @@ private string RegexString
 
         private Regex PatternRegex
         {
-            get { return new Regex(this.RegexString, _modifiers); }
+            get { return regexCache.Get(this.RegexString, _modifiers); }
         }
 
         #endregion Private Properties
-
-        #region Constructors
-
-        public VerbalExpressions()
-        {
-        }
-
-        static VerbalExpressions()
-        {
-        }
-
-        #endregion Constructors
-
+        
         #region Public Methods
 
         #region Helpers

VerbalExpressions/VerbalExpressions.csproj

@@ -70,6 +70,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CommonRegex.cs" />
+    <Compile Include="RegexCache.cs" />
     <Compile Include="VerbalExpressions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

VerbalExpressionsUnitTests/PerformanceTests.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+using CSharpVerbalExpressions;
+using NUnit.Framework;
+
+namespace VerbalExpressionsUnitTests
+{
+    [TestFixture]
+    public class PerformanceTests
+    {
+
+        [Test]
+        public void VerbalExpression_Is_Not_Slower_Than_Direct_Use_Of_Regex()
+        {
+            const string someUrl = "https://www.google.com";
+
+            var verbEx = VerbalExpressions.DefaultExpression
+                .StartOfLine()
+                .Then("http")
+                .Maybe("s")
+                .Then("://")
+                .Maybe("www.")
+                .AnythingBut(" ")
+                .EndOfLine();
+
+            var regex = new Regex(@"^http(s)?://([\w-]+.)+[\w-]+(/[\w- ./?%&=])?$");
+
+            var timeVerbEx = MeasureCallDuration(() => verbEx.IsMatch(someUrl));
+            var timeRegex = MeasureCallDuration(() => regex.IsMatch(someUrl));
+
+            Assert.That(timeVerbEx - timeRegex, Is.LessThan(TimeSpan.FromSeconds(0.1)));
+        }
+
+        private static TimeSpan MeasureCallDuration(Action action)
+        {
+            var sw = Stopwatch.StartNew();
+
+            for (var i = 0; i < 10000; i++)
+            {
+                action();
+            }
+
+            sw.Stop();
+            return sw.Elapsed;
+        }
+    }
+}

VerbalExpressionsUnitTests/VerbalExpressionsUnitTests.csproj

@@ -43,6 +43,7 @@
     <Compile Include="AddModifierTests.cs" />
     <Compile Include="AddTests.cs" />
     <Compile Include="CaptureTests.cs" />
+    <Compile Include="PerformanceTests.cs" />
     <Compile Include="RepeatPreviousTest.cs" />
     <Compile Include="EndOfLineTests.cs" />
     <Compile Include="MaybeTests.cs" />