【C#】RegexとAllメソッドで文字列がアルファベットだけかを高速判定する方法

using System;
using System.Linq;
public class Program
{
    public static void Main()
    {
        string input1 = "HelloWorld";    // 英語アルファベットのみ
        string input2 = "Café";          // アクセント付き文字を含む
        string input3 = "こんにちは";     // 日本語
        Console.WriteLine(input1.All(char.IsLetter)); // True
        Console.WriteLine(input2.All(char.IsLetter)); // True
        Console.WriteLine(input3.All(char.IsLetter)); // True
    }
}

True
True
True

using System;
using System.Linq;
public class Program
{
    public static void Main()
    {
        string input = "HelloWorld";
        bool isAllLetters = input.All(char.IsLetter);
        Console.WriteLine($"すべての文字が文字か: {isAllLetters}");
        string input2 = "Hello123";
        bool isAllLetters2 = input2.All(char.IsLetter);
        Console.WriteLine($"すべての文字が文字か: {isAllLetters2}");
    }
}

すべての文字が文字か: True
すべての文字が文字か: False

using System;
using System.Diagnostics;
using System.Linq;
using System.Text;
public class Program
{
    private static string GenerateRandomString(int length)
    {
        var rnd = new Random(0);
        var sb = new StringBuilder(length);
        for (int i = 0; i < length; i++)
        {
            // 英字の範囲からランダムに選択(A-Z, a-z)
            char c = (char)(rnd.Next(0, 2) == 0 ? rnd.Next('A', 'Z' + 1) : rnd.Next('a', 'z' + 1));
            sb.Append(c);
        }
        return sb.ToString();
    }
    public static void Main()
    {
        string testString = GenerateRandomString(10000);
        int iterations = 1000;
        // forループによる判定
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            bool result = IsAllLettersForLoop(testString);
        }
        sw.Stop();
        Console.WriteLine($"forループ判定: {sw.ElapsedMilliseconds} ms");
        // LINQ Allによる判定
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            bool result = testString.All(char.IsLetter);
        }
        sw.Stop();
        Console.WriteLine($"LINQ All判定: {sw.ElapsedMilliseconds} ms");
    }
    private static bool IsAllLettersForLoop(string input)
    {
        for (int i = 0; i < input.Length; i++)
        {
            if (!char.IsLetter(input[i]))
                return false;
        }
        return true;
    }
}

forループ判定: 23 ms
LINQ All判定: 34 ms

using System;
using System.Text.RegularExpressions;
public class Program
{
    public static void Main()
    {
        string input1 = "HelloWorld";
        string input2 = "Hello123";
        string input3 = "";
        Regex regex = new Regex("^[a-zA-Z]+$");
        Console.WriteLine(regex.IsMatch(input1)); // True
        Console.WriteLine(regex.IsMatch(input2)); // False
        Console.WriteLine(regex.IsMatch(input3)); // False
    }
}

True
False
False

using System;
using System.Text.RegularExpressions;
public class Program
{
    public static void Main()
    {
        string input = "HelloWorld";
        Regex regex = new Regex("^[a-z]+$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
        bool isAlphabet = regex.IsMatch(input);
        Console.WriteLine(isAlphabet); // True
    }
}

True

using System;
using System.Text.RegularExpressions;
public static class AlphabetValidator
{
    // 静的にコンパイル済みRegexを用意
    private static readonly Regex regex = new Regex("^[a-z]+$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    public static bool IsAlphabet(string input)
    {
        return regex.IsMatch(input);
    }
}
public class Program
{
    public static void Main()
    {
        string input = "TestString";
        Console.WriteLine(AlphabetValidator.IsAlphabet(input)); // True
    }
}

True

using System;
using System.Text.RegularExpressions;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class RegexBenchmark
{
    private readonly string testString = "HelloWorldHelloWorldHelloWorld";
    private readonly Regex regexCompiled = new Regex("^[a-z]+$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    private readonly Regex regexNonCompiled = new Regex("^[a-z]+$", RegexOptions.IgnoreCase);
    [Benchmark]
    public bool CompiledRegex()
    {
        return regexCompiled.IsMatch(testString);
    }
    [Benchmark]
    public bool NonCompiledRegex()
    {
        return regexNonCompiled.IsMatch(testString);
    }
}
public class Program
{
    public static void Main()
    {
        var summary = BenchmarkRunner.Run<RegexBenchmark>();
    }
}

using System;
public class Program
{
    public static bool IsAsciiAlphabet(string input)
    {
        if (string.IsNullOrEmpty(input))
            return false;
        foreach (char c in input)
        {
            // 'A'～'Z' または 'a'～'z' の範囲かを判定
            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                return false;
        }
        return true;
    }
    public static void Main()
    {
        string test1 = "HelloWorld";
        string test2 = "Hello123";
        string test3 = "";
        Console.WriteLine(IsAsciiAlphabet(test1)); // True
        Console.WriteLine(IsAsciiAlphabet(test2)); // False
        Console.WriteLine(IsAsciiAlphabet(test3)); // False
    }
}

True
False
False

using System;
public class Program
{
    public static bool IsAsciiAlphabetSpan(ReadOnlySpan<char> input)
    {
        if (input.Length == 0)
            return false;
        for (int i = 0; i < input.Length; i++)
        {
            char c = input[i];
            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                return false;
        }
        return true;
    }
    public static void Main()
    {
        string test = "SpanExample";
        ReadOnlySpan<char> span = test.AsSpan();
        Console.WriteLine(IsAsciiAlphabetSpan(span)); // True
        Console.WriteLine(IsAsciiAlphabetSpan("123".AsSpan())); // False
        Console.WriteLine(IsAsciiAlphabetSpan(ReadOnlySpan<char>.Empty)); // False
    }
}

True
False
False

using System;
public class Program
{
    public static unsafe bool IsAsciiAlphabetUnsafe(string input)
    {
        if (string.IsNullOrEmpty(input))
            return false;
        fixed (char* ptr = input)
        {
            char* p = ptr;
            for (int i = 0; i < input.Length; i++, p++)
            {
                char c = *p;
                if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                    return false;
            }
        }
        return true;
    }
    public static void Main()
    {
        string test = "UnsafeCheck";
        Console.WriteLine(IsAsciiAlphabetUnsafe(test)); // True
        Console.WriteLine(IsAsciiAlphabetUnsafe("Unsafe123")); // False
    }
}

True
False

using System;
using System.Numerics;
using System.Runtime.InteropServices;

public class Program
{
    // SIMD で ASCII 英字かどうかを判定
    public static bool IsAsciiAlphabetSimd(ReadOnlySpan<char> input)
    {
        if (input.Length == 0) return false;

        int vectorSize = Vector<ushort>.Count;
        int i = 0;

        // 比較用定数ベクトル
        var vUpperA = new Vector<ushort>((ushort)'A');
        var vUpperZ = new Vector<ushort>((ushort)'Z');
        var vLowerA = new Vector<ushort>((ushort)'a');
        var vLowerZ = new Vector<ushort>((ushort)'z');
        var vAllBits = new Vector<ushort>(ushort.MaxValue);

        // ベクトル単位で判定
        for (; i <= input.Length - vectorSize; i += vectorSize)
        {
            // char -> ushort にキャストしてロード
            ReadOnlySpan<char> slice = input.Slice(i, vectorSize);
            ReadOnlySpan<ushort> ushortSlice = MemoryMarshal.Cast<char, ushort>(slice);
            var chars = new Vector<ushort>(ushortSlice);

            var isUpper = Vector.GreaterThanOrEqual(chars, vUpperA) &
                          Vector.LessThanOrEqual(chars, vUpperZ);

            var isLower = Vector.GreaterThanOrEqual(chars, vLowerA) &
                          Vector.LessThanOrEqual(chars, vLowerZ);

            var isAlpha = isUpper | isLower;

            // 1文字でも英字でなければ即座に false
            if (!Vector.EqualsAll(isAlpha, vAllBits))
                return false;
        }

        // 端数（vectorSize に満たない分）の判定
        for (; i < input.Length; i++)
        {
            char c = input[i];
            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                return false;
        }
        return true;
    }

    public static void Main()
    {
        string test = "SimdExampleString";
        Console.WriteLine(IsAsciiAlphabetSimd(test));     // True
        Console.WriteLine(IsAsciiAlphabetSimd("Simd123"));// False
    }
}

True
False

using System;
using System.Globalization;
public class Program
{
    public static void Main()
    {
        char[] chars = { 'A', 'a', 'Α', 'α', 'Ж', 'ж', 'あ' };
        foreach (var c in chars)
        {
            UnicodeCategory category = Char.GetUnicodeCategory(c);
            Console.WriteLine($"{c} : {category} : IsLetter={char.IsLetter(c)}");
        }
    }
}

A : UppercaseLetter : True
a : LowercaseLetter : True
Α : UppercaseLetter : True
α : LowercaseLetter : True
Ж : UppercaseLetter : True
ж : LowercaseLetter : True
あ : OtherLetter : True

using System;
using System.Text;
public class Program
{
    public static void Main()
    {
        string composed = "é"; // 合成済み文字 (U+00E9)
        string decomposed = "e\u0301"; // 分解済み文字 (e + 結合アクセント)
        Console.WriteLine($"composed == decomposed: {composed == decomposed}"); // False
        string normalizedComposed = composed.Normalize(NormalizationForm.FormC);
        string normalizedDecomposed = decomposed.Normalize(NormalizationForm.FormC);
        Console.WriteLine($"normalizedComposed == normalizedDecomposed: {normalizedComposed == normalizedDecomposed}"); // True
    }
}

composed == decomposed: False
normalizedComposed == normalizedDecomposed: True

using System;
using System.Globalization;
public class Program
{
    public static bool IsLetterOrCombining(ReadOnlySpan<char> input)
    {
        if (input.Length == 0)
            return false;
        foreach (var c in input)
        {
            var category = Char.GetUnicodeCategory(c);
            if (!(category == UnicodeCategory.UppercaseLetter ||
                  category == UnicodeCategory.LowercaseLetter ||
                  category == UnicodeCategory.TitlecaseLetter ||
                  category == UnicodeCategory.ModifierLetter ||
                  category == UnicodeCategory.OtherLetter ||
                  category == UnicodeCategory.NonSpacingMark))
            {
                return false;
            }
        }
        return true;
    }
    public static void Main()
    {
        string composed = "é"; // 合成済み
        string decomposed = "e\u0301"; // 分解済み
        Console.WriteLine(IsLetterOrCombining(composed));   // True
        Console.WriteLine(IsLetterOrCombining(decomposed)); // True
        Console.WriteLine(IsLetterOrCombining("e1"));       // False
    }
}

True
True
False

using System;
using System.Linq;
public class Program
{
    public static bool IsAlphabetOnly(string input)
    {
        if (string.IsNullOrEmpty(input))
            return false; // null または空文字列は false とする
        return input.All(c => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
    }
    public static void Main()
    {
        string nullString = null;
        string emptyString = "";
        string validString = "TestString";
        string invalidString = "Test123";
        Console.WriteLine(IsAlphabetOnly(nullString));   // False
        Console.WriteLine(IsAlphabetOnly(emptyString));  // False
        Console.WriteLine(IsAlphabetOnly(validString));  // True
        Console.WriteLine(IsAlphabetOnly(invalidString));// False
    }
}

False
False
True
False

string input = "Hello123";
Console.WriteLine(IsAlphabetOnly(input)); // False

string input = "Hello World!";
Console.WriteLine(IsAlphabetOnly(input)); // False

string input = "HelloABC";
Console.WriteLine(IsAlphabetOnly(input)); // False

string input = "Café";
Console.WriteLine(IsAlphabetOnly(input)); // False(ASCII限定の場合)

string input = "   ";
Console.WriteLine(IsAlphabetOnly(input)); // False

using System;
using System.Linq;
public class Program
{
    public static bool IsAlphabetOnly(string input)
    {
        if (string.IsNullOrEmpty(input))
            return false;
        return input.All(c => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
    }
    public static void Main()
    {
        string[] testCases = {
            "HelloWorld",
            "Hello123",
            "Hello World!",
            "HelloABC",
            "Café",
            "   ",
            null,
            ""
        };
        foreach (var test in testCases)
        {
            Console.WriteLine($"\"{test}\": {IsAlphabetOnly(test)}");
        }
    }
}

"HelloWorld": True
"Hello123": False
"Hello World!": False
"HelloABC": False
"Café": False
"   ": False
"": False
"": False

using System;
public class Program
{
    // stackalloc を使った一時バッファの例
    public static bool CheckAsciiAlphabetStackAlloc(ReadOnlySpan<char> input)
    {
        if (input.Length == 0)
            return false;
        Span<char> buffer = input.Length <= 256
            ? stackalloc char[256]  // スタック上に256文字分確保
            : new char[input.Length]; // 大きい場合はヒープ割り当て
        input.CopyTo(buffer);
        for (int i = 0; i < input.Length; i++)
        {
            char c = buffer[i];
            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                return false;
        }
        return true;
    }
    // 配列を使った例
    public static bool CheckAsciiAlphabetArray(string input)
    {
        if (string.IsNullOrEmpty(input))
            return false;
        char[] buffer = input.ToCharArray();
        foreach (var c in buffer)
        {
            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                return false;
        }
        return true;
    }
    public static void Main()
    {
        string test = "StackAllocExample";
        Console.WriteLine(CheckAsciiAlphabetStackAlloc(test)); // True
        Console.WriteLine(CheckAsciiAlphabetArray(test));     // True
    }
}

True
True

using System;
using System.Buffers;
public class Program
{
    public static bool CheckAsciiAlphabetWithPool(string input)
    {
        if (string.IsNullOrEmpty(input))
            return false;
        char[] buffer = ArrayPool<char>.Shared.Rent(input.Length);
        try
        {
            input.CopyTo(0, buffer, 0, input.Length);
            for (int i = 0; i < input.Length; i++)
            {
                char c = buffer[i];
                if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                    return false;
            }
            return true;
        }
        finally
        {
            ArrayPool<char>.Shared.Return(buffer);
        }
    }
    public static void Main()
    {
        string test = "ArrayPoolExample";
        Console.WriteLine(CheckAsciiAlphabetWithPool(test)); // True
    }
}

True

using System;
using System.Text.RegularExpressions;
public static class StringExtensions
{
    private static readonly Regex asciiAlphabetRegex = new Regex("^[a-z]+$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    /// <summary>
    /// 文字列が英語のアルファベットのみで構成されているか判定します。
    /// null または空文字列の場合は false を返します。
    /// </summary>
    /// <param name="input">判定対象の文字列</param>
    /// <returns>英語アルファベットのみの場合は true、それ以外は false</returns>
    public static bool IsAsciiAlphabet(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return false;
        return asciiAlphabetRegex.IsMatch(input);
    }
    /// <summary>
    /// ReadOnlySpan<char> に対する英語アルファベット判定。
    /// </summary>
    public static bool IsAsciiAlphabet(this ReadOnlySpan<char> input)
    {
        if (input.IsEmpty)
            return false;
        foreach (var c in input)
        {
            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                return false;
        }
        return true;
    }
}

string test = "HelloWorld";
bool result = test.IsAsciiAlphabet();
Console.WriteLine(result); // True

dotnet new classlib -n AlphabetValidator

<PropertyGroup>
  <PackageId>AlphabetValidator</PackageId>
  <Version>1.0.0</Version>
  <Authors>あなたの名前</Authors>
  <Company>あなたの会社名</Company>
  <Description>英語アルファベット判定用の拡張メソッドライブラリ</Description>
  <PackageTags>alphabet;validation;string</PackageTags>
  <RepositoryUrl>https://github.com/yourrepo/AlphabetValidator</RepositoryUrl>
</PropertyGroup>

dotnet pack -c Release

dotnet nuget push bin/Release/AlphabetValidator.1.0.0.nupkg --api-key YOUR_API_KEY --source https://api.nuget.org/v3/index.json

dotnet add package AlphabetValidator

using AlphabetValidator;
string input = "SampleText";
bool isAlpha = input.IsAsciiAlphabet();
Console.WriteLine(isAlpha);

using System;
using System.ComponentModel.DataAnnotations;
public class AlphabetOnlyAttribute : ValidationAttribute
{
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        string input = value as string;
        if (string.IsNullOrEmpty(input))
        {
            // 空文字や null は無効とする場合
            return new ValidationResult("値を入力してください。");
        }
        if (!input.IsAsciiAlphabet())
        {
            return new ValidationResult("英字のみで入力してください。");
        }
        return ValidationResult.Success;
    }
}

public class UserInputModel
{
    [Required]
    [AlphabetOnly]
    public string UserName { get; set; }
}

using Microsoft.AspNetCore.Mvc;
public class UserController : Controller
{
    [HttpPost]
    public IActionResult Submit(UserInputModel model)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        // バリデーション成功時の処理
        return Ok("入力が有効です。");
    }
}

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.ModelBinding;
public class AlphabetOnlyModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (valueProviderResult == ValueProviderResult.None)
        {
            bindingContext.Result = ModelBindingResult.Failed();
            return Task.CompletedTask;
        }
        string value = valueProviderResult.FirstValue;
        if (string.IsNullOrEmpty(value) || !value.IsAsciiAlphabet())
        {
            bindingContext.ModelState.AddModelError(bindingContext.ModelName, "英字のみで入力してください。");
            bindingContext.Result = ModelBindingResult.Failed();
            return Task.CompletedTask;
        }
        bindingContext.Result = ModelBindingResult.Success(value);
        return Task.CompletedTask;
    }
}

using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.Extensions.DependencyInjection;
public class AlphabetOnlyModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType == typeof(string) &&
            context.Metadata.Name == "UserName") // 特定のプロパティ名に限定可能
        {
            return new AlphabetOnlyModelBinder();
        }
        return null;
    }
}
// Startup.cs または Program.cs の ConfigureServices 内で登録
services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new AlphabetOnlyModelBinderProvider());
});

public class UserInputModel
{
    public string UserName { get; set; }
}
public class UserController : Controller
{
    [HttpPost]
    public IActionResult Submit(UserInputModel model)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        return Ok("入力が有効です。");
    }
}

using Xunit;
public class AlphabetValidatorTests
{
    [Theory]
    [InlineData("HELLO", true)]
    [InlineData("world", true)]
    [InlineData("HelloWorld", true)]
    [InlineData("Test123", false)]
    [InlineData("Hello!", false)]
    [InlineData("", false)]
    [InlineData(null, false)]
    [InlineData("ABC", false)] // 全角
    [InlineData("Café", false)]  // アクセント付き
    public void IsAsciiAlphabet_TestCases(string input, bool expected)
    {
        bool actual = input.IsAsciiAlphabet(); // 拡張メソッドを想定
        Assert.Equal(expected, actual);
    }
}

[Theory]
[InlineData(" ", false)]          // 空白
[InlineData("\t\n", false)]       // 制御文字
[InlineData("ABC", false)]     // 全角
[InlineData("Café", false)]       // アクセント付き
[InlineData(null, false)]         // null
[InlineData("", false)]           // 空文字列
public void EdgeCases_Test(string input, bool expected)
{
    bool actual = input.IsAsciiAlphabet();
    Assert.Equal(expected, actual);
}

var regex = new Regex("^[a-zA-Z]+$", RegexOptions.Compiled, TimeSpan.FromMilliseconds(100));

using System;
using System.Text.RegularExpressions;
public class Program
{
    public static void Main()
    {
        string input = new string('a', 10000) + "!"; // 悪意ある長い文字列
        try
        {
            var regex = new Regex("^[a-zA-Z]+$", RegexOptions.Compiled, TimeSpan.FromMilliseconds(100));
            bool isMatch = regex.IsMatch(input);
            Console.WriteLine($"判定結果: {isMatch}");
        }
        catch (RegexMatchTimeoutException)
        {
            Console.WriteLine("正規表現の処理がタイムアウトしました。");
        }
    }
}

正規表現の処理がタイムアウトしました。

public static bool ValidateUserInput(string input, int maxLength = 100)
{
    if (string.IsNullOrEmpty(input) || input.Length > maxLength)
        return false;
    foreach (char c in input)
    {
        if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
            return false;
    }
    return true;
}

public static bool IsAsciiOrFullWidthAlphabet(string input)
{
    if (string.IsNullOrEmpty(input))
        return false;
    foreach (char c in input)
    {
        bool isHalfWidth = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
        bool isFullWidth = (c >= '\uFF21' && c <= '\uFF3A') || (c >= '\uFF41' && c <= '\uFF5A');
        if (!isHalfWidth && !isFullWidth)
            return false;
    }
    return true;
}