【C#】正規表現で小数点を含む数値をスマートに判定する方法

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 符号はオプション、整数部は1桁以上、小数点、小数部は0桁以上
        string pattern = @"^[+-]?(\d+\.\d*|\.\d+)$";
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123" };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123.456 → True
+123.456 → True
-.456 → True
123. → True
.456 → True
123 → False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 符号、整数部、小数点、小数部を名前付きキャプチャで分ける
        string pattern = @"^(?<sign>[+-])?(?<integer>\d+)?(\.(?<fraction>\d+))?$";
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123", "-123" };
        foreach (var value in testValues)
        {
            var match = Regex.Match(value, pattern);
            if (match.Success)
            {
                string sign = match.Groups["sign"].Value;
                string integer = match.Groups["integer"].Value;
                string fraction = match.Groups["fraction"].Value;
                Console.WriteLine($"入力: {value}");
                Console.WriteLine($"  符号: {(string.IsNullOrEmpty(sign) ? "(なし)" : sign)}");
                Console.WriteLine($"  整数部: {(string.IsNullOrEmpty(integer) ? "(なし)" : integer)}");
                Console.WriteLine($"  小数部: {(string.IsNullOrEmpty(fraction) ? "(なし)" : fraction)}");
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine($"{value} はマッチしません");
            }
        }
    }
}

入力: 123.456
  符号: (なし)
  整数部: 123
  小数部: 456

入力: +123.456
  符号: +
  整数部: 123
  小数部: 456

入力: -.456
  符号: -
  整数部: (なし)
  小数部: 456

123. はマッチしません
入力: .456
  符号: (なし)
  整数部: (なし)
  小数部: 456

入力: 123
  符号: (なし)
  整数部: 123
  小数部: (なし)

入力: -123
  符号: -
  整数部: 123
  小数部: (なし)

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"
            ^                       # 文字列の先頭
            [+-]?                   # 符号(+ または -)はオプション
            (
                (\d+)\.(\d*)        # 整数部1桁以上 + 小数点 + 小数部0桁以上

                |

                \.(\d+)             # 整数部なし + 小数点 + 小数部1桁以上
            )
            $                       # 文字列の末尾
        ";
        var options = RegexOptions.IgnorePatternWhitespace;
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123" };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern, options);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123.456 → True
+123.456 → True
-.456 → True
123. → True
.456 → True
123 → False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 小数点を含む数値の正規表現パターン
        string pattern = @"^[+-]?(\d+\.\d*|\.\d+)$";
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123", "abc", "12.34.56" };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123.456 → True
+123.456 → True
-.456 → True
123. → True
.456 → True
123 → False
abc → False
12.34.56 → False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 正規表現をコンパイルしてRegexオブジェクトを作成
        Regex regex = new Regex(@"^[+-]?(\d+\.\d*|\.\d+)$", RegexOptions.Compiled);
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123" };
        foreach (var value in testValues)
        {
            bool isMatch = regex.IsMatch(value);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123.456 → True
+123.456 → True
-.456 → True
123. → True
.456 → True
123 → False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"
            ^               # 文字列の先頭
            [+-]?           # 符号はオプション
            (               # グループ開始
                \d+\.\d*    # 整数部1桁以上 + 小数点 + 小数部0桁以上
                |           # または
                \.\d+       # 小数点 + 小数部1桁以上
            )
            $               # 文字列の末尾
        ";
        Regex regex = new Regex(pattern, RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123" };
        foreach (var value in testValues)
        {
            bool isMatch = regex.IsMatch(value);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123.456 → True
+123.456 → True
-.456 → True
123. → True
.456 → True
123 → False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"^[+-]?(\d+\.\d*|\.\d+)$";
        Console.WriteLine("数値を入力してください(小数点を含む数値のみ有効):");
        string input = Console.ReadLine();
        if (Regex.IsMatch(input, pattern))
        {
            Console.WriteLine("有効な小数点数値です。");
        }
        else
        {
            Console.WriteLine("無効な入力です。小数点を含む数値を入力してください。");
        }
    }
}

数値を入力してください(小数点を含む数値のみ有効):123.45
有効な小数点数値です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"^[+-]?(\d+\.\d*|\.\d+)$";
        string csvLine = "100.5,+200.0,-.75,300,abc";
        string[] fields = csvLine.Split(',');
        for (int i = 0; i < fields.Length; i++)
        {
            string field = fields[i];
            bool isValid = Regex.IsMatch(field, pattern);
            Console.WriteLine($"フィールド[{i}]: {field} → {(isValid ? "有効" : "無効")}");
        }
    }
}

フィールド[0]: 100.5 → 有効
フィールド[1]: +200.0 → 有効
フィールド[2]: -.75 → 有効
フィールド[3]: 300 → 無効
フィールド[4]: abc → 無効

using System;
using System.Text.RegularExpressions;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        string pattern = @"^[+-]?(\d+\.\d*|\.\d+)$";
        string[] apiData = { "12.34", "-56.78", "90", "abc", "+.123", "45.6.7" };
        List<string> sanitizedData = new List<string>();
        foreach (var item in apiData)
        {
            if (Regex.IsMatch(item, pattern))
            {
                sanitizedData.Add(item);
            }
        }
        Console.WriteLine("サニタイズ後のデータ:");
        foreach (var value in sanitizedData)
        {
            Console.WriteLine(value);
        }
    }
}

サニタイズ後のデータ:
12.34
-56.78
+.123

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"^[+-]?[\d.]+$";
        string[] testValues = { "12.34", "12..34", "1.2.3", "123", "..." };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

12.34 → True
12..34 → True
1.2.3 → True
123 → True
... → True

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"^[+-]?(\d+(\.\d*)?|\.\d+)$"; // 整数部と小数部の両方を許容
        string[] testValues = { "123", "123.45", ".45", "abc", "123." };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123 → True
123.45 → True
.45 → True
abc → False
123. → True

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"^\d+$";
        string halfWidth = "123";
        string fullWidth = "123";
        Console.WriteLine($"半角数字: {Regex.IsMatch(halfWidth, pattern)}");
        Console.WriteLine($"全角数字: {Regex.IsMatch(fullWidth, pattern)}");
    }
}

半角数字: True
全角数字: False

string pattern = @"^[\d0-9]+$";

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 小数点数値＋指数表記のパターン
        string pattern = @"^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$";
        string[] testValues = {
            "123.456",
            "-123.456e10",
            "+.456E-5",
            "0.123e+3",
            "123e5",
            "123.",
            ".456",
            "123",
            "abc",
            "1.2.3",
            "123e"
        };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

123.456 → True
-123.456e10 → True
+.456E-5 → True
0.123e+3 → True
123e5 → True
123. → True
.456 → True
123 → True
abc → False
1.2.3 → False
123e → False

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 小数点数値＋指数表記＋パーセント記号のパターン
        string pattern = @"^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?%?$";
        string[] testValues = {
            "50%",
            "100.0%",
            "-12.5%",
            "+.75%",
            "0.123e2%",
            "123",
            "123.45",
            "abc%",
            "123.%"
        };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

50% → True
100.0% → True
-12.5% → True
+.75% → True
0.123e2% → True
123 → True
123.45 → True
abc% → False
123.% → True

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 通貨記号($、¥、€)オプション、カンマ区切り、小数点数値のパターン
        string pattern = @"^[+-]?[\$\¥\€]?(\d{1,3}(,\d{3})*|\d+)(\.\d+)?$";
        string[] testValues = {
            "$1,234.56",
            "¥123456.78",
            "€12,345",
            "+$1,000",
            "-1234.56",
            "1234",
            "12,34.56",  // 不正なカンマ位置
            "$1234.56.78" // 不正な小数点
        };
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

$1,234.56 → True
¥123456.78 → True
€12,345 → True
+$1,000 → True
-1234.56 → True
1234 → True
12,34.56 → False
$1234.56.78 → False

string pattern = @"^[+-]?(\d+([.,]\d*)?|[.,]\d+)$";

using System;
using System.Globalization;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 現在のカルチャーのNumberFormatInfoを取得
        NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
        // 小数点記号をエスケープ(正規表現で特別な意味を持つ場合に備える)
        string decimalSeparator = Regex.Escape(nfi.NumberDecimalSeparator);
        // 正規表現パターンを動的に作成
        string pattern = $@"^[+-]?(\d+({decimalSeparator}\d*)?|{decimalSeparator}\d+)$";
        string[] testValues = { "123.45", "123,45", "+123.45", "-.45", ".45", "123" };
        Console.WriteLine($"現在のカルチャー: {CultureInfo.CurrentCulture.Name}");
        Console.WriteLine($"小数点記号: '{nfi.NumberDecimalSeparator}'");
        Console.WriteLine();
        foreach (var value in testValues)
        {
            bool isMatch = Regex.IsMatch(value, pattern);
            Console.WriteLine($"{value} → {isMatch}");
        }
    }
}

現在のカルチャー: ja-JP
小数点記号: '.'

123.45 → True
123,45 → False
+123.45 → True
-.45 → True
.45 → True
123 → True

CultureInfo.CurrentCulture = new CultureInfo("de-DE");

using System.Text.RegularExpressions;
using Xunit;
public class DecimalNumberRegexTests
{
    private const string Pattern = @"^[+-]?(\d+(\.\d*)?|\.\d+)$";
    [Theory]
    [InlineData("123.456", true)]
    [InlineData("+123.456", true)]
    [InlineData("-.456", true)]
    [InlineData("123.", true)]
    [InlineData(".456", true)]
    [InlineData("123", true)]
    [InlineData("abc", false)]
    [InlineData("12.34.56", false)]
    [InlineData("", false)]
    public void TestDecimalNumberRegex(string input, bool expected)
    {
        bool actual = Regex.IsMatch(input, Pattern);
        Assert.Equal(expected, actual);
    }
}

^[+-]?(\d+(\.\d*)?|\.\d+)$

const int MaxInputLength = 1000;
string input = GetUserInput();
if (input.Length > MaxInputLength)
{
    Console.WriteLine("入力が長すぎます。");
    return;
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string pattern = @"^[+-]?(\d+(\.\d*)?|\.\d+)$";
        string input = GetUserInput();
        try
        {
            // タイムアウトを1秒に設定
            bool isMatch = Regex.IsMatch(input, pattern, RegexOptions.None, TimeSpan.FromSeconds(1));
            Console.WriteLine($"マッチ結果: {isMatch}");
        }
        catch (RegexMatchTimeoutException)
        {
            Console.WriteLine("正規表現の処理がタイムアウトしました。入力を確認してください。");
        }
    }
    static string GetUserInput()
    {
        // ここでは例として長い文字列を返す
        return new string('1', 10000) + ".";
    }
}

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        // 名前付きキャプチャを使った正規表現パターン
        string pattern = @"^(?<sign>[+-])?(?<integer>\d+)?(\.(?<fraction>\d+))?$";
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123", "-123" };
        foreach (var value in testValues)
        {
            var match = Regex.Match(value, pattern);
            if (match.Success)
            {
                string sign = match.Groups["sign"].Value;
                string integer = match.Groups["integer"].Value;
                string fraction = match.Groups["fraction"].Value;
                Console.WriteLine($"入力: {value}");
                Console.WriteLine($"  符号: {(string.IsNullOrEmpty(sign) ? "(なし)" : sign)}");
                Console.WriteLine($"  整数部: {(string.IsNullOrEmpty(integer) ? "(なし)" : integer)}");
                Console.WriteLine($"  小数部: {(string.IsNullOrEmpty(fraction) ? "(なし)" : fraction)}");
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine($"{value} はマッチしません");
            }
        }
    }
}

入力: 123.456
  符号: (なし)
  整数部: 123
  小数部: 456
入力: +123.456
  符号: +
  整数部: 123
  小数部: 456
入力: -.456
  符号: -
  整数部: (なし)
  小数部: 456
入力: 123.
  符号: (なし)
  整数部: 123
  小数部: (なし)
入力: .456
  符号: (なし)
  整数部: (なし)
  小数部: 456
入力: 123
  符号: (なし)
  整数部: 123
  小数部: (なし)
入力: -123
  符号: -
  整数部: 123
  小数部: (なし)

using System;
using System.Text.RegularExpressions;
class Program
{
    // 小数点を含む数値の正規表現パターン
    // 符号(+/-)はオプション
    // 整数部は0回または1回の出現(省略可能)
    // 小数点以下はオプションで、存在する場合は1桁以上の数字
    private const string DecimalNumberPattern = @"
        ^                       # 文字列の先頭
        (?<sign>[+-])?           # 符号(+ または -)はオプション
        (?<integer>\d+)?         # 整数部は0回または1回の数字の繰り返し
        (\.(?<fraction>\d+))?    # 小数点以下はオプションで数字1回以上
        $                       # 文字列の末尾
    ";
    static void Main()
    {
        var regex = new Regex(DecimalNumberPattern, RegexOptions.IgnorePatternWhitespace);
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123", "-123" };
        foreach (var value in testValues)
        {
            var match = regex.Match(value);
            if (match.Success)
            {
                Console.WriteLine($"入力: {value}");
                Console.WriteLine($"  符号: {(string.IsNullOrEmpty(match.Groups["sign"].Value) ? "(なし)" : match.Groups["sign"].Value)}");
                Console.WriteLine($"  整数部: {(string.IsNullOrEmpty(match.Groups["integer"].Value) ? "(なし)" : match.Groups["integer"].Value)}");
                Console.WriteLine($"  小数部: {(string.IsNullOrEmpty(match.Groups["fraction"].Value) ? "(なし)" : match.Groups["fraction"].Value)}");
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine($"{value} はマッチしません");
            }
        }
    }
}

入力: 123.456
  符号: (なし)
  整数部: 123
  小数部: 456
入力: +123.456
  符号: +
  整数部: 123
  小数部: 456
入力: -.456
  符号: -
  整数部: (なし)
  小数部: 456
入力: 123.
  符号: (なし)
  整数部: 123
  小数部: (なし)
入力: .456
  符号: (なし)
  整数部: (なし)
  小数部: 456
入力: 123
  符号: (なし)
  整数部: 123
  小数部: (なし)
入力: -123
  符号: -
  整数部: 123
  小数部: (なし)

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string[] testValues = { "123.456", "+123.456", "-.456", "123.", ".456", "123", "abc", "1.23e4" };
        foreach (var value in testValues)
        {
            bool isValid = double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out double result);
            Console.WriteLine($"{value} → {isValid} (Parsed value: {(isValid ? result.ToString() : "N/A")})");
        }
    }
}

123.456 → True (Parsed value: 123.456)
+123.456 → True (Parsed value: 123.456)
-.456 → True (Parsed value: -0.456)

123. → True (Parsed value: 123)

.456 → True (Parsed value: 0.456)
123 → True (Parsed value: 123)
abc → False (Parsed value: N/A)
1.23e4 → True (Parsed value: 12300)

using System;
class CustomDecimalParser
{
    public static bool TryParse(string input, out double result)
    {
        result = 0;
        if (string.IsNullOrEmpty(input))
            return false;
        int pos = 0;
        int length = input.Length;
        bool isNegative = false;
        // 符号チェック
        if (input[pos] == '+')
        {
            pos++;
        }
        else if (input[pos] == '-')
        {
            isNegative = true;
            pos++;
        }
        double integerPart = 0;
        double fractionPart = 0;
        double fractionDivisor = 1;
        bool fractionMode = false;
        while (pos < length)
        {
            char c = input[pos];
            if (c == '.')
            {
                if (fractionMode) // 2回目の小数点はエラー
                    return false;
                fractionMode = true;
            }
            else if (char.IsDigit(c))
            {
                int digit = c - '0';
                if (!fractionMode)
                {
                    integerPart = integerPart * 10 + digit;
                }
                else
                {
                    fractionDivisor *= 10;
                    fractionPart += digit / fractionDivisor;
                }
            }
            else
            {
                // 不正な文字
                return false;
            }
            pos++;
        }
        result = integerPart + fractionPart;
        if (isNegative)
            result = -result;
        return true;
    }
}
class Program
{
    static void Main()
    {
        string[] testValues = { "123.456", "-123.456", "+.456", "123.", ".456", "abc", "12.34.56" };
        foreach (var value in testValues)
        {
            bool success = CustomDecimalParser.TryParse(value, out double parsed);
            Console.WriteLine($"{value} → {success} (Parsed: {(success ? parsed.ToString() : "N/A")})");
        }
    }
}

123.456 → True (Parsed: 123.456)
-123.456 → True (Parsed: -123.456)
+.456 → True (Parsed: 0.456)

123. → True (Parsed: 123)

.456 → True (Parsed: 0.456)
abc → False (Parsed: N/A)
12.34.56 → False (Parsed: N/A)