【C#】Regex.IsMatchで簡単正規表現チェック—基礎からエラー対策・高速化まで一気にわかる

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "example@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$"; // 簡易的なメールアドレスの正規表現
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "file123.txt";
        string pattern = @"file\d+\.txt"; // fileに続く数字と.txtで終わるパターン
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "hello123";
        string pattern = @"hello\d+";
        bool result = Regex.IsMatch(input, pattern);
        Console.WriteLine(result); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "HELLO123";
        string pattern = @"hello\d+";
        // 大文字・小文字を区別しないマッチングを指定
        bool result = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(result); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123def456";
        string pattern = @"\d+";
        // 文字列の6文字目(インデックス5)からマッチング開始
        bool result = Regex.IsMatch(input, pattern, RegexOptions.None, 5);
        Console.WriteLine(result); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "file.txt";
        string pattern = @"file\.txt"; // ドットを文字として扱う
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123";
        string pattern = @"[a-z]+\d+"; // 小文字の連続 + 数字の連続
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "<div>content</div><div>more</div>";
        string patternGreedy = @"<div>.*</div>";
        string patternLazy = @"<div>.*?</div>";
        bool greedyMatch = Regex.IsMatch(input, patternGreedy);
        bool lazyMatch = Regex.IsMatch(input, patternLazy);
        Console.WriteLine($"貪欲マッチ: {greedyMatch}"); // True
        Console.WriteLine($"非貪欲マッチ: {lazyMatch}"); // True
        // 実際のマッチ内容を確認
        var matchGreedy = Regex.Match(input, patternGreedy);
        var matchLazy = Regex.Match(input, patternLazy);
        Console.WriteLine($"貪欲マッチ内容: {matchGreedy.Value}");
        Console.WriteLine($"非貪欲マッチ内容: {matchLazy.Value}");
    }
}

貪欲マッチ: True
非貪欲マッチ: True
貪欲マッチ内容: <div>content</div><div>more</div>
非貪欲マッチ内容: <div>content</div>

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Hello World";
        string pattern = @"^Hello";
        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"(abc)(\d+)(xyz)";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
            Console.WriteLine($"全体マッチ: {match.Value}");
            Console.WriteLine($"グループ1: {match.Groups[1].Value}");
            Console.WriteLine($"グループ2: {match.Groups[2].Value}");
            Console.WriteLine($"グループ3: {match.Groups[3].Value}");
        }
    }
}

全体マッチ: abc123xyz
グループ1: abc
グループ2: 123
グループ3: xyz

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "2023-06-15";
        string pattern = @"(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
            Console.WriteLine($"年: {match.Groups["year"].Value}");
            Console.WriteLine($"月: {match.Groups["month"].Value}");
            Console.WriteLine($"日: {match.Groups["day"].Value}");
        }
    }
}

年: 2023
月: 06
日: 15

string pattern = @"(?<word>\w+)\s+\k<word>";

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "color";
        string pattern = @"colou?r"; // uは0回か1回
        // 非キャプチャグループを使った例
        string patternNonCapture = @"col(?:ou)?r";
        bool isMatch = Regex.IsMatch(input, patternNonCapture);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "100USD 200JPY 300USD";
        string pattern = @"\d+(?=USD)";
        MatchCollection matches = Regex.Matches(input, pattern);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}

100
300

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "100USD 200JPY 300USD";
        string pattern = @"(?<=\d)USD";
        MatchCollection matches = Regex.Matches(input, pattern);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}

USD
USD

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "aaaaab";
        string patternBacktracking = @"a+a+b";
        string patternAtomic = @"(?>a+)a+b";
        bool matchBacktracking = Regex.IsMatch(input, patternBacktracking);
        bool matchAtomic = Regex.IsMatch(input, patternAtomic);
        Console.WriteLine($"バックトラッキングあり: {matchBacktracking}");
        Console.WriteLine($"アトミックグループ使用: {matchAtomic}");
    }
}

バックトラッキングあり: True
アトミックグループ使用: False

(?(条件)真の場合のパターン|偽の場合のパターン)

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input1 = "abc123";
        string input2 = "123abc";
        string pattern = @"^(?<letters>[a-z]+)?(?(letters)\d+|[a-z]+)$";
        Console.WriteLine(Regex.IsMatch(input1, pattern)); // True
        Console.WriteLine(Regex.IsMatch(input2, pattern)); // True
        Console.WriteLine(Regex.IsMatch("123", pattern));  // False
    }
}

True
True
False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "漢字とEnglish123";
        string pattern = @"\p{L}+";
        MatchCollection matches = Regex.Matches(input, pattern);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}

漢字とEnglish

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "HELLO world";
        string pattern = "hello";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "first line\nsecond line";
        string pattern = "^second";
        bool isMatchWithoutMultiline = Regex.IsMatch(input, pattern);
        bool isMatchWithMultiline = Regex.IsMatch(input, pattern, RegexOptions.Multiline);
        Console.WriteLine(isMatchWithoutMultiline); // 結果: False
        Console.WriteLine(isMatchWithMultiline);    // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "line1\nline2";
        string pattern = "line1.line2";
        bool isMatchWithoutSingleline = Regex.IsMatch(input, pattern);
        bool isMatchWithSingleline = Regex.IsMatch(input, pattern, RegexOptions.Singleline);
        Console.WriteLine(isMatchWithoutSingleline); // 結果: False
        Console.WriteLine(isMatchWithSingleline);    // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"\d+";
        var stopwatch = new Stopwatch();
        // 非コンパイル版
        stopwatch.Start();
        for (int i = 0; i < 100000; i++)
        {
            Regex.IsMatch(input, pattern);
        }
        stopwatch.Stop();
        Console.WriteLine($"非コンパイル: {stopwatch.ElapsedMilliseconds} ms");
        // コンパイル版
        var regexCompiled = new Regex(pattern, RegexOptions.Compiled);
        stopwatch.Restart();
        for (int i = 0; i < 100000; i++)
        {
            regexCompiled.IsMatch(input);
        }
        stopwatch.Stop();
        Console.WriteLine($"コンパイル: {stopwatch.ElapsedMilliseconds} ms");
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"(abc)(123)(xyz)";
        var matchDefault = Regex.Match(input, pattern);
        Console.WriteLine($"デフォルトグループ数: {matchDefault.Groups.Count}"); // 4 (全体+3グループ)
        var regexExplicit = new Regex(pattern, RegexOptions.ExplicitCapture);
        var matchExplicit = regexExplicit.Match(input);
        Console.WriteLine($"ExplicitCaptureグループ数: {matchExplicit.Groups.Count}"); // 1 (全体のみ)
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"
            (abc)    # abcにマッチ
            (\d+)    # 数字にマッチ
            (xyz)    # xyzにマッチ
        ";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnorePatternWhitespace);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string fileName = "document.txt";
        string pattern = @"\.txt$"; // 文字列の末尾が .txt であることを表す
        bool isMatch = Regex.IsMatch(fileName, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string fileName = "report.PDF";
        string pattern = @"\.(txt|doc|pdf)$";
        bool isMatch = Regex.IsMatch(fileName, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string email = "user@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        bool isMatch = Regex.IsMatch(email, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string email = "user.name+tag+sorting@example.co.jp";
        string pattern = @"^(?("")(""[^""]+?""@)|(([0-9a-zA-Z](([\.\-\+][0-9a-zA-Z])?)*)))@([0-9a-zA-Z][\-0-9a-zA-Z]+\.)+[a-zA-Z]{2,6}$";
        bool isMatch = Regex.IsMatch(email, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string url = "https://www.example.com";
        string pattern = @"^https?://[\w\-]+(\.[\w\-]+)+";
        bool isMatch = Regex.IsMatch(url, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string url = "https://www.example.com/search?q=regex&lang=ja";
        string pattern = @"^https?://[\w\-]+(\.[\w\-]+)+(/[^\s]*)?$";
        bool isMatch = Regex.IsMatch(url, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string phone = "03-1234-5678";
        string pattern = @"^0\d{1,4}-\d{1,4}-\d{4}$";
        bool isMatch = Regex.IsMatch(phone, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string mobile = "090-1234-5678";
        string pattern = @"^0(70|80|90)-\d{4}-\d{4}$";
        bool isMatch = Regex.IsMatch(mobile, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string postalCode = "123-4567";
        string pattern = @"^\d{3}-\d{4}$";
        bool isMatch = Regex.IsMatch(postalCode, pattern);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"(abc"; // 括弧の閉じ忘れ
        string input = "abc";
        try
        {
            bool isMatch = Regex.IsMatch(input, pattern);
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"正規表現の文法エラー: {ex.Message}");
        }
    }
}

正規表現の文法エラー: parsing "(abc" - Unterminated group.

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = new string('a', 10000) + "!";
        string pattern = @"(a+)+!";
        try
        {
            bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.None, TimeSpan.FromMilliseconds(500));
        }
        catch (RegexMatchTimeoutException ex)
        {
            Console.WriteLine("マッチング処理がタイムアウトしました。");
        }
    }
}

マッチング処理がタイムアウトしました。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = new string('a', 10000) + "!";
        string pattern = @"(a+)+!";
        try
        {
            bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.None, TimeSpan.FromMilliseconds(100));
            Console.WriteLine($"マッチ結果: {isMatch}");
        }
        catch (RegexMatchTimeoutException ex)
        {
            Console.WriteLine("正規表現のマッチングがタイムアウトしました。");
            Console.WriteLine($"タイムアウトしたパターン: {ex.Pattern}");
            Console.WriteLine($"タイムアウトした入力: {ex.Input.Substring(0, 20)}...");
        }
    }
}

正規表現のマッチングがタイムアウトしました。
タイムアウトしたパターン: (a+)+!
タイムアウトした入力: aaaaaaaaaaaaaaaaaaaa...

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string userInput = ".*"; // ユーザーが入力した文字列
        string pattern = $"^{userInput}$"; // 直接パターンに埋め込む
        string test = "anything";
        bool isMatch = Regex.IsMatch(test, pattern);
        Console.WriteLine(isMatch); // 結果: True(意図しないマッチ)
    }
}

string safeInput = Regex.Escape(userInput);
string pattern = $"^{safeInput}$";

using System;
using System.Text.RegularExpressions;
class Program
{
    // 静的にRegexインスタンスを作成しキャッシュ
    private static readonly Regex EmailRegex = new Regex(@"^[\w\.-]+@[\w\.-]+\.\w+$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    static void Main()
    {
        string email = "user@example.com";
        bool isMatch = EmailRegex.IsMatch(email);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"\d+";
        var stopwatch = new Stopwatch();
        // 非コンパイル版
        stopwatch.Start();
        for (int i = 0; i < 100000; i++)
        {
            Regex.IsMatch(input, pattern);
        }
        stopwatch.Stop();
        Console.WriteLine($"非コンパイル: {stopwatch.ElapsedMilliseconds} ms");
        // コンパイル版
        var regexCompiled = new Regex(pattern, RegexOptions.Compiled);
        stopwatch.Restart();
        for (int i = 0; i < 100000; i++)
        {
            regexCompiled.IsMatch(input);
        }
        stopwatch.Stop();
        Console.WriteLine($"コンパイル: {stopwatch.ElapsedMilliseconds} ms");
    }
}

using System;
using System.Text.RegularExpressions;
[GeneratedRegex(@"^\d{3}-\d{4}$")]
partial class PostalCodeRegex
{
}
class Program
{
    static void Main()
    {
        var regex = new PostalCodeRegex();
        string postalCode = "123-4567";
        bool isMatch = regex.IsMatch(postalCode);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "Header: value\nContent: 12345\nFooter: end";
        ReadOnlySpan<char> span = input.AsSpan();
        // Content行だけを抽出してマッチング
        int start = input.IndexOf("Content:");
        if (start >= 0)
        {
            ReadOnlySpan<char> contentSpan = span.Slice(start, input.Length - start);
            string contentStr = contentSpan.ToString();
            string pattern = @"\d+";
            bool isMatch = Regex.IsMatch(contentStr, pattern);
            Console.WriteLine(isMatch); // 結果: True
        }
    }
}

using System;
using System.Diagnostics;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc123xyz";
        string pattern = @"\d+";
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < 100000; i++)
        {
            Regex.IsMatch(input, pattern);
        }
        stopwatch.Stop();
        Console.WriteLine($"処理時間: {stopwatch.ElapsedMilliseconds} ms");
    }
}

using System.Text.RegularExpressions;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class RegexBenchmark
{
    private readonly string input = "abc123xyz";
    private readonly Regex regexCompiled = new Regex(@"\d+", RegexOptions.Compiled);
    private readonly string pattern = @"\d+";
    [Benchmark]
    public bool StaticIsMatch() => Regex.IsMatch(input, pattern);
    [Benchmark]
    public bool CompiledRegex() => regexCompiled.IsMatch(input);
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<RegexBenchmark>();
    }
}

using NUnit.Framework;
using System.Text.RegularExpressions;
namespace RegexTests
{
    public class EmailValidationTests
    {
        private const string Pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        [Test]
        public void ValidEmail_ShouldMatch()
        {
            string email = "user@example.com";
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.IsTrue(result, "有効なメールアドレスがマッチしませんでした。");
        }
        [Test]
        public void InvalidEmail_ShouldNotMatch()
        {
            string email = "user@@example..com";
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.IsFalse(result, "無効なメールアドレスがマッチしてしまいました。");
        }
    }
}

using NUnit.Framework;
using System.Text.RegularExpressions;
namespace RegexTests
{
    public class EmailValidationTests
    {
        private const string Pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        [TestCase("user@example.com", true)]
        [TestCase("user.name+tag@example.co.jp", true)]
        [TestCase("user@@example.com", false)]
        [TestCase("user@example", false)]
        public void EmailValidation_TestCases(string email, bool expected)
        {
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.AreEqual(expected, result, $"メールアドレス '{email}' の検証結果が期待値と異なります。");
        }
    }
}

using NUnit.Framework;
using System.Collections.Generic;
using System.Text.RegularExpressions;
namespace RegexTests
{
    public class EmailValidationTests
    {
        private const string Pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        public static IEnumerable<TestCaseData> EmailTestData()
        {
            yield return new TestCaseData("valid@example.com", true);
            yield return new TestCaseData("invalid@@example.com", false);
            yield return new TestCaseData("user.name+tag@example.co.jp", true);
            yield return new TestCaseData("user@.com", false);
            // ランダム生成例(簡易)
            for (int i = 0; i < 5; i++)
            {
                string randomEmail = GenerateRandomEmail();
                yield return new TestCaseData(randomEmail, false);
            }
        }
        private static string GenerateRandomEmail()
        {
            // 簡易的にランダム文字列を生成(実際はより複雑に生成可能)
            var chars = "abcdefghijklmnopqrstuvwxyz0123456789";
            var random = new System.Random();
            char[] buffer = new char[10];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = chars[random.Next(chars.Length)];
            }
            return new string(buffer) + "@example.com";
        }
        [Test, TestCaseSource(nameof(EmailTestData))]
        public void EmailValidation_WithGeneratedData(string email, bool expected)
        {
            bool result = Regex.IsMatch(email, Pattern, RegexOptions.IgnoreCase);
            Assert.AreEqual(expected, result, $"メールアドレス '{email}' の検証結果が期待値と異なります。");
        }
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "user@example.com";
        string pattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase);
        Console.WriteLine($"入力: {input}");
        Console.WriteLine($"パターン: {pattern}");
        Console.WriteLine($"マッチ結果: {isMatch}");
        if (isMatch)
        {
            Match match = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            Console.WriteLine($"マッチした部分: {match.Value}");
        }
    }
}

入力: user@example.com
パターン: ^[\w\.-]+@[\w\.-]+\.\w+$
マッチ結果: True
マッチした部分: user@example.com

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "user.name@example.com";
        string pattern = @"
            ^                   # 文字列の先頭
            [\w\.-]+            # ユーザー名(英数字、ドット、ハイフン)
            @                   # @記号
            [\w\.-]+            # ドメイン名
            \.                  # ドット
            \w+                 # トップレベルドメイン
            $                   # 文字列の末尾
        ";
        bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
class Program
{
    static void Main()
    {
        string input = "example.txt";
        bool containsTxt = input.Contains(".txt", StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(containsTxt); // 結果: True
    }
}

using System;
class Program
{
    static void Main()
    {
        string input = "HelloWorld";
        bool startsWithHello = input.StartsWith("hello", StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(startsWithHello); // 結果: True
    }
}

using System;
class Program
{
    static void Main()
    {
        ReadOnlySpan<char> input = "example.txt".AsSpan();
        bool containsTxt = input.Slice(input.Length - 4).SequenceEqual(".txt".AsSpan());
        Console.WriteLine(containsTxt); // 結果: True
        bool startsWithEx = input.StartsWith("ex".AsSpan(), StringComparison.OrdinalIgnoreCase);
        Console.WriteLine(startsWithEx); // 結果: True
    }
}

using System;
class Program
{
    static void Main()
    {
        string input = "HelloWorld";
        bool startsWithHello = input switch
        {
            string s when s.StartsWith("Hello", StringComparison.OrdinalIgnoreCase) => true,
            _ => false
        };
        Console.WriteLine(startsWithHello); // 結果: True
    }
}

using System;
class Program
{
    static void Main()
    {
        string input = "123-4567";
        string result = input switch
        {
            string s when System.Text.RegularExpressions.Regex.IsMatch(s, @"^\d{3}-\d{4}$") => "郵便番号形式",
            string s when s.StartsWith("http") => "URL形式",
            _ => "不明な形式"
        };
        Console.WriteLine(result); // 結果: 郵便番号形式
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    private const string EmailPattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
    static void Main()
    {
        string email = "user@example.com";
        bool isMatch = Regex.IsMatch(email, EmailPattern, RegexOptions.IgnoreCase);
        Console.WriteLine(isMatch); // 結果: True
    }
}

using System;
using System.Text.RegularExpressions;
class Validator
{
    private const string EmailPattern = @"^[\w\.-]+@[\w\.-]+\.\w+$";
    public static bool IsValidEmail(string input)
    {
        return Regex.IsMatch(input, EmailPattern, RegexOptions.IgnoreCase);
    }
}
class Program
{
    static void Main()
    {
        string email = "user@example.com";
        bool isValid = Validator.IsValidEmail(email);
        Console.WriteLine(isValid); // 結果: True
    }
}