Add some Regex extension methods

Author: engineering87

SharpHelpers/SharpHelpers.UnitTest/Regex/RegexTests.cs

@@ -0,0 +1,96 @@
+// (c) 2019 SharpCoding
+// This code is licensed under MIT license (see LICENSE.txt for details)
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SharpCoding.SharpHelpers;
+
+namespace SharpHelpers.UnitTest.Regex
+{
+    [TestClass]
+    public class RegexTests
+    {
+        [TestMethod]
+        public void IsMatch_ShouldReturnTrue_WhenPatternMatches()
+        {
+            // Arrange
+            string input = "hello world";
+            string pattern = @"hello";
+
+            // Act
+            bool result = input.IsMatchRegex(pattern);
+
+            // Assert
+            Assert.IsTrue(result, "Expected the pattern to match the input string.");
+        }
+
+        [TestMethod]
+        public void IsMatch_ShouldReturnFalse_WhenPatternDoesNotMatch()
+        {
+            // Arrange
+            string input = "hello world";
+            string pattern = @"goodbye";
+
+            // Act
+            bool result = input.IsMatchRegex(pattern);
+
+            // Assert
+            Assert.IsFalse(result, "Expected the pattern not to match the input string.");
+        }
+
+        [TestMethod]
+        public void Match_ShouldReturnFirstMatch_WhenPatternMatches()
+        {
+            // Arrange
+            string input = "hello world";
+            string pattern = @"hello";
+
+            // Act
+            string result = input.Match(pattern);
+
+            // Assert
+            Assert.AreEqual("hello", result, "Expected the first match to be 'hello'.");
+        }
+
+        [TestMethod]
+        public void Match_ShouldReturnNull_WhenPatternDoesNotMatch()
+        {
+            // Arrange
+            string input = "hello world";
+            string pattern = @"goodbye";
+
+            // Act
+            string result = input.Match(pattern);
+
+            // Assert
+            Assert.IsNull(result, "Expected no match to be found.");
+        }
+
+        [TestMethod]
+        public void Replace_ShouldReplaceAllOccurrences_WhenPatternMatches()
+        {
+            // Arrange
+            string input = "hello world world";
+            string pattern = @"world";
+            string replacement = "universe";
+
+            // Act
+            string result = input.Replace(pattern, replacement);
+
+            // Assert
+            Assert.AreEqual("hello universe universe", result, "Expected 'world' to be replaced with 'universe'.");
+        }
+
+        [TestMethod]
+        public void Split_ShouldReturnArray_WhenPatternIsUsedAsDelimiter()
+        {
+            // Arrange
+            string input = "hello world universe";
+            string pattern = @" ";
+
+            // Act
+            string[] result = input.Split(pattern);
+
+            // Assert
+            CollectionAssert.AreEqual(new[] { "hello", "world", "universe" }, result, "Expected the input string to be split by spaces.");
+        }
+    }
+}

SharpHelpers/SharpHelpers/RegexHelper.cs

@@ -1,5 +1,6 @@
 // (c) 2019 SharpCoding
 // This code is licensed under MIT license (see LICENSE.txt for details)
+using System;
 using System.Text.RegularExpressions;
 
 namespace SharpCoding.SharpHelpers
@@ -14,8 +15,56 @@ public static class RegexHelper
         /// <returns></returns>
         public static bool IsMatchRegex(this string value, string pattern)
         {
+            if (value == null) throw new ArgumentNullException(nameof(value));
+            if (pattern == null) throw new ArgumentNullException(nameof(pattern));
+
             var regex = new Regex(pattern);
-            return (regex.IsMatch(value));
+            return regex.IsMatch(value);
+        }
+
+        /// <summary>
+        /// Retrieves the first match found in the input string.
+        /// </summary>
+        /// <param name="input">The input string to search.</param>
+        /// <param name="pattern">The regular expression pattern.</param>
+        /// <returns>The first match found, or null if no match is found.</returns>
+        public static string Match(this string input, string pattern)
+        {
+            if (input == null) throw new ArgumentNullException(nameof(input));
+            if (pattern == null) throw new ArgumentNullException(nameof(pattern));
+
+            var match = Regex.Match(input, pattern);
+            return match.Success ? match.Value : null;
+        }
+
+        /// <summary>
+        /// Replaces all occurrences of a pattern with a replacement string.
+        /// </summary>
+        /// <param name="input">The input string to modify.</param>
+        /// <param name="pattern">The regular expression pattern.</param>
+        /// <param name="replacement">The replacement string.</param>
+        /// <returns>A new string with all occurrences replaced.</returns>
+        public static string Replace(this string input, string pattern, string replacement)
+        {
+            if (input == null) throw new ArgumentNullException(nameof(input));
+            if (pattern == null) throw new ArgumentNullException(nameof(pattern));
+            if (replacement == null) throw new ArgumentNullException(nameof(replacement));
+
+            return Regex.Replace(input, pattern, replacement);
+        }
+
+        /// <summary>
+        /// Splits a string into an array of substrings using a regex pattern as a delimiter.
+        /// </summary>
+        /// <param name="input">The input string to split.</param>
+        /// <param name="pattern">The regular expression pattern to use as a delimiter.</param>
+        /// <returns>An array of substrings.</returns>
+        public static string[] Split(this string input, string pattern)
+        {
+            if (input == null) throw new ArgumentNullException(nameof(input));
+            if (pattern == null) throw new ArgumentNullException(nameof(pattern));
+
+            return Regex.Split(input, pattern);
         }
     }
 }