Split Luhn class

- Clear separation of concerns:
  The project is well-structured, with distinct classes for calculation (`LuhnCalculator`), validation (`LuhnValidator`), and core algorithm logic (`LuhnAlgorithm`).
  This promotes maintainability and testability.
- Extension methods:
  The use of extension methods for string manipulation and validation provides a fluent and convenient API.

Resolves: No entry

Author: shinji-san

CHANGELOG.md

@@ -10,7 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add `RemoveSeparators` method to remove all separators from a string. Use it, for example, with credit card numbers.
 
 ### Changed
-- Renamed `Luhn.ConvertAlphaNumericToNumeric` to `Luhn.AlphaNumericToNumeric`
+- Renamed `ConvertAlphaNumericToNumeric` to `AlphaNumericToNumeric`
 
 ### Removed
 - Removed `Luhn.IsValid` methods

benchmark/LuhnDotNetBenchmark.cs

@@ -15,66 +15,146 @@ public class LuhnDotNetBenchmark
     private const string ComputeLuhnCheckDigitCategory = "Compute Luhn check digit";
     private const string IsValidLuhnNumberCategory = "Validate Luhn number";
     private const string IsValidLuhnCheckDigitCategory = "Validate Luhn check digit";
+    private const string AlphaNumericToNumericCategory = "AlphaNumeric to Numeric";
+    private const string RemoveSeparatorCategory = "Remove separators";
+    private const string ValidationChainCategory = "Validation chain";
+    private const string ComputeChainCategory = "Compute chain";
 
-    public static IEnumerable<string> NumbersAsString()
+    public static IEnumerable<string> NumericNumbersAsString()
     {
         yield return "79927398713";
         yield return "79927398718234234134645645645624563445654634343462545462546546245624356245625624565265432";
     }
 
+    public static IEnumerable<string> AlphaNumericNumbersAsString()
+    {
+        yield return "US79927398713";
+        yield return "79927398713DE";
+        yield return "ABCDEF";
+        yield return "DE79927398718234234134645645645624563445654634343462545462546546245624356245625624565265432";
+    }
+
+    public static IEnumerable<string> SeparatedNumbersAsString()
+    {
+        yield return "7992-7398-7134";
+        yield return "79927398/71823423413464564564562456344565463434346254546254654/6245624356245625624565265432";
+    }
+    
+    public static IEnumerable<string> SeparatedAlphaNumericNumbersAsString()
+    {
+        yield return "US-7992-7398-7134";
+        yield return "A7992-B7398-C7134";
+    }
+
     [Benchmark(Baseline = true), BenchmarkCategory(ComputeLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnNumberBasedOnString(string number)
     {
         number.ComputeLuhnNumber();
     }
 
     [Benchmark(Baseline = true), BenchmarkCategory(ComputeLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnCheckDigitBasedOnString(string number)
     {
         number.ComputeLuhnCheckDigit();
     }
 
     [Benchmark(Baseline = true), BenchmarkCategory(IsValidLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnNumberBasedOnString(string number)
     {
         number.IsValidLuhnNumber();
     }
 
     [Benchmark(Baseline = true), BenchmarkCategory(IsValidLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnCheckDigitBasedOnString(string number)
     {
         byte.MinValue.IsValidLuhnCheckDigit(number);
     }
 
     [Benchmark, BenchmarkCategory(ComputeLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnNumberBasedOnSpan(string number)
     {
         number.AsSpan().ComputeLuhnNumber();
     }
 
     [Benchmark, BenchmarkCategory(ComputeLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnCheckDigitBasedOnSpan(string number)
     {
         number.AsSpan().ComputeLuhnCheckDigit();
     }
 
     [Benchmark, BenchmarkCategory(IsValidLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnNumberBasedOnSpan(string number)
     {
         number.AsSpan().IsValidLuhnNumber();
     }
 
     [Benchmark, BenchmarkCategory(IsValidLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnCheckDigitBasedOnSpan(string number)
     {
         byte.MinValue.IsValidLuhnCheckDigit(number.AsSpan());
     }
-}
+
+    [Benchmark(Baseline = true), BenchmarkCategory(AlphaNumericToNumericCategory)]
+    [ArgumentsSource(nameof(AlphaNumericNumbersAsString))]
+    public void AlphaNumericToNumericBasedOnString(string number)
+    {
+        number.AlphaNumericToNumeric();
+    }
+
+    [Benchmark, BenchmarkCategory(AlphaNumericToNumericCategory)]
+    [ArgumentsSource(nameof(AlphaNumericNumbersAsString))]
+    public void AlphaNumericToNumericBasedOnSpan(string number)
+    {
+        number.AsSpan().AlphaNumericToNumeric();
+    }
+
+    [Benchmark(Baseline = true), BenchmarkCategory(RemoveSeparatorCategory)]
+    [ArgumentsSource(nameof(SeparatedNumbersAsString))]
+    public void RemoveSeparatorBasedOnString(string number)
+    {
+        number.RemoveSeparators();
+    }
+
+    [Benchmark, BenchmarkCategory(RemoveSeparatorCategory)]
+    [ArgumentsSource(nameof(SeparatedNumbersAsString))]
+    public void RemoveSeparatorBasedOnSpan(string number)
+    {
+        number.AsSpan().RemoveSeparators();
+    }
+
+    [Benchmark(Baseline = true), BenchmarkCategory(ComputeChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ComputeChainBasedOnString(string number)
+    {
+        number.RemoveSeparators().AlphaNumericToNumeric().ComputeLuhnNumber();
+    }
+
+    [Benchmark, BenchmarkCategory(ComputeChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ComputeChainBasedOnSpan(string number)
+    {
+        number.AsSpan().RemoveSeparators().AlphaNumericToNumeric().ComputeLuhnNumber();
+    }
+
+    [Benchmark(Baseline = true), BenchmarkCategory(ValidationChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ValidationChainBasedOnString(string number)
+    {
+        number.RemoveSeparators().AlphaNumericToNumeric().IsValidLuhnNumber();
+    }
+
+    [Benchmark, BenchmarkCategory(ValidationChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ValidationChainBasedOnSpan(string number)
+    {
+        number.AsSpan().RemoveSeparators().AlphaNumericToNumeric().IsValidLuhnNumber();
+    }
+}