C#でIsNumeric相当の数値判定をする方法｜文字列が数値か確認する実装例付き
はじめに
C#で文字列が数値かどうかを判定したいとき、「VBのIsNumericのような関数はないの？」と感じることがあります。
たとえば、フォーム入力やCSVの読み込み、設定ファイルの値チェックなどで、次のような判定をしたいケースです。
C#"123" // 数値として扱える
"12.34" // 小数として扱える
"-100" // 負の数として扱える
"abc" // 数値ではない
"" // 数値ではない
null // 数値ではない
C#にはVBのIsNumericと同じ名前の標準メソッドは基本的に用意されていません。そのため、C#でIsNumeric相当の処理を実装する場合は、int.TryParse、double.TryParse、decimal.TryParse、正規表現、Char.IsDigitなどを目的に応じて使い分けるのが一般的です。
この記事では、C#で文字列が数値か確認する方法を、実装例付きでわかりやすく解説します。
1. C#にIsNumericはある？まず結論と代替方法を確認
1-1. C#にはVBのIsNumeric関数が標準で用意されていない
Visual Basicには、値が数値として評価できるかを判定するIsNumeric関数があります。
一方、C#にはIsNumericという名前の標準メソッドは用意されていません。
そのため、C#で次のようなコードを書こうとしても、そのままでは使えません。
C#if (IsNumeric("123"))
{
Console.WriteLine("数値です");
}
C#で同じような数値判定を行いたい場合は、判定したい型に応じてTryParse系のメソッドを使うのが基本です。
たとえば、整数かどうかを確認したいならint.TryParse、小数も含めて確認したいならdouble.TryParseやdecimal.TryParseを使います。
1-2. C#で数値判定するなら基本はTryParseを使う
C#で文字列が数値かどうかを判定する代表的な方法は、TryParseです。
C#bool result = int.TryParse("123", out int number);
TryParseは、変換に成功した場合はtrue、失敗した場合はfalseを返します。
C#Console.WriteLine(int.TryParse("123", out _)); // True
Console.WriteLine(int.TryParse("abc", out _)); // False
Parseと違い、変換できない文字列を渡しても例外が発生しないため、入力チェックやバリデーションに向いています。
C#int.Parse("abc"); // FormatExceptionが発生する
数値判定だけをしたい場合は、まずTryParseを候補にするとよいでしょう。
1-3. 判定したい「数値」の種類によって使うメソッドが変わる
一口に「数値」といっても、実際にはいくつかの種類があります。
整数だけを許可したいのか、小数も許可したいのか、負の数を許可するのか、カンマ区切りや通貨記号を許可するのかによって、使うべき方法が変わります。
たとえば、次のように使い分けます。
C#int.TryParse("123", out _); // 整数の判定
double.TryParse("12.34", out _); // 小数や指数表記を含む判定
decimal.TryParse("12.34", out _); // 金額や高精度な小数の判定
また、郵便番号や会員番号のように「数値として計算したい」のではなく「数字だけで構成されているか」を確認したい場合は、TryParseよりもChar.IsDigitや正規表現のほうが適していることがあります。
1-4. この記事で扱う数値判定の前提とサンプルコード
この記事では、主にstring型の文字列を対象に、C#でIsNumeric相当の数値判定を行う方法を扱います。
基本的な前提は次のとおりです。
C#string input = "123";
このinputが、整数として扱えるか、小数として扱えるか、数字だけで構成されているかなどを判定していきます。
サンプルコードでは、判定結果だけを使う場合にout _を使います。
C#bool isNumeric = int.TryParse(input, out _);
out _は、変換後の値を使わない場合の書き方です。
変換後の値も使いたい場合は、次のように変数を受け取ります。
C#if (int.TryParse(input, out int value))
{
Console.WriteLine(value);
}
2. C#でIsNumeric相当の処理を書く基本形
2-1. int.TryParseで整数かどうか判定する
整数かどうかを判定したい場合は、int.TryParseを使います。
C#string input = "123";
if (int.TryParse(input, out int number))
{
Console.WriteLine("整数です");
Console.WriteLine(number);
}
else
{
Console.WriteLine("整数ではありません");
}
実行結果は次のようになります。
整数です
123
int.TryParseでは、次のような文字列はtrueになります。
C#Console.WriteLine(int.TryParse("123", out _)); // True
Console.WriteLine(int.TryParse("-123", out _)); // True
Console.WriteLine(int.TryParse("0", out _)); // True
一方、小数や文字列はfalseになります。
C#Console.WriteLine(int.TryParse("12.3", out _)); // False
Console.WriteLine(int.TryParse("abc", out _)); // False
Console.WriteLine(int.TryParse("", out _)); // False
整数だけを許可したい入力チェックでは、int.TryParseが最もシンプルです。
ただし、intの範囲を超える値はfalseになります。
C#Console.WriteLine(int.TryParse("999999999999", out _)); // False
より大きな整数を扱いたい場合は、long.TryParseを使います。
C#Console.WriteLine(long.TryParse("999999999999", out _)); // True
2-2. double.TryParseで小数や指数表記を含む数値を判定する
小数を含む数値を判定したい場合は、double.TryParseを使います。
C#string input = "12.34";
if (double.TryParse(input, out double number))
{
Console.WriteLine("数値です");
Console.WriteLine(number);
}
else
{
Console.WriteLine("数値ではありません");
}
double.TryParseでは、次のような文字列を数値として判定できます。
C#Console.WriteLine(double.TryParse("123", out _)); // True
Console.WriteLine(double.TryParse("12.34", out _)); // True
Console.WriteLine(double.TryParse("-12.34", out _)); // True
Console.WriteLine(double.TryParse("1.23E+4", out _)); // True
指数表記も許可されるため、科学技術計算などでは便利です。
ただし、通常のフォーム入力で「123」や「12.34」だけを許可したい場合、double.TryParseは許可範囲が広くなりすぎることがあります。
たとえば、指数表記を入力値として受け付けたくない場合は、正規表現やNumberStylesを使って形式を制御したほうがよいです。
2-3. decimal.TryParseで金額や高精度な小数を判定する
金額や高精度な小数を扱う場合は、decimal.TryParseがよく使われます。
C#string input = "1234.56";
if (decimal.TryParse(input, out decimal amount))
{
Console.WriteLine("金額として扱えます");
Console.WriteLine(amount);
}
else
{
Console.WriteLine("金額として扱えません");
}
decimalは、doubleよりも10進数の精度を重視した型です。
そのため、金額、料金、数量、税率など、丸め誤差を避けたい場面ではdecimal.TryParseを選ぶのが一般的です。
C#Console.WriteLine(decimal.TryParse("1000", out _)); // True
Console.WriteLine(decimal.TryParse("1000.50", out _)); // True
Console.WriteLine(decimal.TryParse("abc", out _)); // False
ただし、decimalにも扱える範囲があります。
非常に大きな値や特殊な指数表記などを扱う場合は、用途に応じて型を選びましょう。
2-4. out変数を使わずに判定だけ行う書き方
数値に変換した結果を使わず、判定だけ行いたい場合は、out _を使うと簡潔に書けます。
C#bool isNumeric = int.TryParse("123", out _);
Console.WriteLine(isNumeric); // True
小数を許可したい場合は次のように書きます。
C#bool isNumeric = double.TryParse("12.34", out _);
Console.WriteLine(isNumeric); // True
out _を使うことで、不要な変数を宣言せずに済みます。
C#if (decimal.TryParse("100.50", out _))
{
Console.WriteLine("数値です");
}
入力チェックだけを目的とする場合は、この書き方が読みやすく便利です。
2-5. null・空文字・空白文字列を判定した場合の挙動
TryParseにnull、空文字、空白文字列を渡した場合、基本的にはfalseになります。
C#Console.WriteLine(int.TryParse(null, out _)); // False
Console.WriteLine(int.TryParse("", out _)); // False
Console.WriteLine(int.TryParse(" ", out _)); // False
一方、数値の前後に空白がある場合は、TryParseでtrueになることがあります。
C#Console.WriteLine(int.TryParse(" 123 ", out _)); // True
これは、既定の数値スタイルで前後の空白が許可されるためです。
もし前後の空白も許可したくない場合は、事前に文字列をチェックするか、正規表現で厳密に判定します。
C#string input = " 123 ";
bool isInteger = input == input.Trim()
&& int.TryParse(input, out _);
Console.WriteLine(isInteger); // False
単純にユーザー入力の前後の空白を無視したい場合は、Trimしてから判定する方法もあります。
C#string input = " 123 ";
bool isInteger = int.TryParse(input.Trim(), out _);
3. 実装例：IsNumericメソッドを自作する
3-1. 文字列が数値か確認する汎用的なIsNumericメソッド
C#でVBのIsNumericのように使いたい場合は、自分でIsNumericメソッドを定義すると便利です。
C#public static bool IsNumeric(string value)
{
return double.TryParse(value, out _);
}
使用例は次のとおりです。
C#Console.WriteLine(IsNumeric("123")); // True
Console.WriteLine(IsNumeric("12.34")); // True
Console.WriteLine(IsNumeric("-12.34")); // True
Console.WriteLine(IsNumeric("abc")); // False
ただし、この実装ではdouble.TryParseを使っているため、整数だけでなく小数や指数表記も許可されます。
C#Console.WriteLine(IsNumeric("1.23E+4")); // True
「どの形式を数値として許可するか」を明確にしたうえで、実装を選ぶことが重要です。
3-2. 整数のみを許可するIsIntegerメソッド
整数のみを許可したい場合は、int.TryParseを使ってIsIntegerメソッドを作ります。
C#public static bool IsInteger(string value)
{
return int.TryParse(value, out _);
}
使用例です。
C#Console.WriteLine(IsInteger("123")); // True
Console.WriteLine(IsInteger("-123")); // True
Console.WriteLine(IsInteger("12.34")); // False
Console.WriteLine(IsInteger("abc")); // False
intの範囲を超える値も受け付けたい場合は、long.TryParseを使います。
C#public static bool IsLongInteger(string value)
{
return long.TryParse(value, out _);
}
入力値がIDや件数などの整数であれば、int.TryParseまたはlong.TryParseを使うとわかりやすいです。
3-3. 小数を許可するIsDecimalメソッド
小数を許可したい場合は、decimal.TryParseを使ってIsDecimalメソッドを作れます。
C#public static bool IsDecimal(string value)
{
return decimal.TryParse(value, out _);
}
使用例です。
C#Console.WriteLine(IsDecimal("123")); // True
Console.WriteLine(IsDecimal("12.34")); // True
Console.WriteLine(IsDecimal("-12.34")); // True
Console.WriteLine(IsDecimal("abc")); // False
金額や数量など、業務アプリケーションで扱う小数にはdecimalが向いています。
C#if (IsDecimal("1000.50"))
{
Console.WriteLine("金額として有効です");
}
ただし、decimal.TryParseでも、既定では前後の空白などが許可される場合があります。
厳密な入力形式を求める場合は、NumberStylesや正規表現を組み合わせましょう。
3-4. 負の数を許可する場合の実装例
int.TryParse、double.TryParse、decimal.TryParseは、既定でマイナス記号付きの数値を判定できます。
C#Console.WriteLine(int.TryParse("-123", out _)); // True
Console.WriteLine(double.TryParse("-12.34", out _)); // True
Console.WriteLine(decimal.TryParse("-12.34", out _)); // True
負の数を許可するIsNumericメソッドは、次のように書けます。
C#public static bool IsNumericAllowNegative(string value)
{
return decimal.TryParse(value, out _);
}
一方、負の数を許可したくない場合は、変換後の値を確認します。
C#public static bool IsNonNegativeInteger(string value)
{
return int.TryParse(value, out int number) && number >= 0;
}
使用例です。
C#Console.WriteLine(IsNonNegativeInteger("123")); // True
Console.WriteLine(IsNonNegativeInteger("0")); // True
Console.WriteLine(IsNonNegativeInteger("-123")); // False
小数で負の数を禁止したい場合は、decimalで同じように判定します。
C#public static bool IsNonNegativeDecimal(string value)
{
return decimal.TryParse(value, out decimal number) && number >= 0;
}
3-5. カンマ区切りや通貨記号を許可する場合の実装例
カンマ区切りの数値を許可したい場合は、NumberStylesを指定します。
C#using System.Globalization;
public static bool IsNumberWithThousandsSeparator(string value)
{
return decimal.TryParse(
value,
NumberStyles.AllowThousands | NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign,
CultureInfo.InvariantCulture,
out _);
}
使用例です。
C#Console.WriteLine(IsNumberWithThousandsSeparator("1,234")); // True
Console.WriteLine(IsNumberWithThousandsSeparator("1,234.56")); // True
Console.WriteLine(IsNumberWithThousandsSeparator("1234.56")); // True
通貨記号を許可したい場合は、NumberStyles.Currencyを使う方法があります。
C#using System.Globalization;
public static bool IsCurrency(string value)
{
return decimal.TryParse(
value,
NumberStyles.Currency,
CultureInfo.GetCultureInfo("ja-JP"),
out _);
}
使用例です。
C#Console.WriteLine(IsCurrency("¥1,234")); // True
Console.WriteLine(IsCurrency("1,234円")); // Trueになる場合がある
Console.WriteLine(IsCurrency("abc")); // False
通貨表記は文化圏によって許可される形式が変わるため、CultureInfoを明示することが重要です。
4. TryParseで数値判定するときの注意点
4-1. int.TryParseでは小数や範囲外の数値はfalseになる
int.TryParseは整数を判定するためのメソッドです。
そのため、小数を渡すとfalseになります。
C#Console.WriteLine(int.TryParse("12.34", out _)); // False
また、intで扱える範囲を超えた数値もfalseになります。
C#Console.WriteLine(int.TryParse("999999999999", out _)); // False
この場合、文字列の形式は数字だけに見えても、intとして表現できないため変換に失敗します。
大きな整数を扱う可能性がある場合は、long.TryParseやdecimal.TryParseを検討します。
C#Console.WriteLine(long.TryParse("999999999999", out _)); // True
Console.WriteLine(decimal.TryParse("999999999999", out _)); // True
「数字だけかどうか」と「int型に変換できるか」は別の判定である点に注意しましょう。
4-2. double.TryParseではNaNやInfinityに注意する
doubleには、通常の数値以外にNaNやInfinityのような特殊な値があります。
環境や指定条件によっては、これらの文字列がdouble.TryParseで扱える場合があります。
そのため、通常の数値だけを許可したい場合は、変換後にdouble.IsNaNやdouble.IsInfinityを使って除外すると安全です。
C#public static bool IsFiniteDouble(string value)
{
if (!double.TryParse(value, out double result))
{
return false;
}
return !double.IsNaN(result) && !double.IsInfinity(result);
}
使用例です。
C#Console.WriteLine(IsFiniteDouble("123.45")); // True
Console.WriteLine(IsFiniteDouble("abc")); // False
通常の業務入力では、doubleよりもdecimalのほうが適している場面も多くあります。
とくに金額や小数点以下の精度が重要な値では、decimal.TryParseを優先するとよいでしょう。
4-3. 全角数字や文化圏による小数点・カンマの違いに注意する
数値判定では、文化圏による表記の違いにも注意が必要です。
たとえば、日本や米国では小数点に.を使うことが一般的ですが、国や地域によっては,を小数点として扱う場合があります。
123.45
123,45
また、桁区切り記号も文化圏によって解釈が変わります。
1,234
1.234
このような違いがあるため、TryParseを使うときはCultureInfoを明示すると、環境による判定結果の違いを避けやすくなります。
C#using System.Globalization;
bool result = decimal.TryParse(
"123.45",
NumberStyles.Number,
CultureInfo.InvariantCulture,
out _);
CultureInfo.InvariantCultureを使うと、環境に依存しにくい形式で判定できます。
外部ファイル、API、データベースなど、一定の形式で数値を扱う場合に便利です。
4-4. NumberStylesを指定して許可する形式を制御する
TryParseでは、NumberStylesを使って許可する数値形式を制御できます。
たとえば、整数だけを許可したい場合はNumberStyles.Integerを使います。
C#using System.Globalization;
public static bool IsIntegerStrict(string value)
{
return int.TryParse(
value,
NumberStyles.Integer,
CultureInfo.InvariantCulture,
out _);
}
小数点を許可したい場合は、NumberStyles.AllowDecimalPointなどを指定します。
C#public static bool IsDecimalPointNumber(string value)
{
return decimal.TryParse(
value,
NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint,
CultureInfo.InvariantCulture,
out _);
}
カンマ区切りを許可する場合は、NumberStyles.AllowThousandsを追加します。
C#public static bool IsDecimalWithComma(string value)
{
return decimal.TryParse(
value,
NumberStyles.AllowLeadingSign |
NumberStyles.AllowDecimalPoint |
NumberStyles.AllowThousands,
CultureInfo.InvariantCulture,
out _);
}
NumberStylesを指定することで、何を数値として許可するのかをコード上で明確にできます。
4-5. CultureInfoを指定して環境依存の判定を避ける
TryParseは、現在のカルチャ設定の影響を受けることがあります。
そのため、実行環境によって小数点やカンマの扱いが変わる可能性があります。
環境依存を避けたい場合は、CultureInfoを明示します。
C#using System.Globalization;
public static bool IsNumericInvariant(string value)
{
return decimal.TryParse(
value,
NumberStyles.Number,
CultureInfo.InvariantCulture,
out _);
}
使用例です。
C#Console.WriteLine(IsNumericInvariant("123.45")); // True
Console.WriteLine(IsNumericInvariant("1,234.56")); // True
日本の通貨表記を想定する場合は、ja-JPを指定します。
C#public static bool IsJapaneseCurrency(string value)
{
return decimal.TryParse(
value,
NumberStyles.Currency,
CultureInfo.GetCultureInfo("ja-JP"),
out _);
}
入力元がユーザーの画面入力なのか、CSVやJSONなどの固定フォーマットなのかによって、適切なCultureInfoを選びましょう。
5. 正規表現で数値判定する方法
5-1. 数字だけの文字列を判定する正規表現
数字だけで構成された文字列を判定したい場合は、正規表現を使う方法があります。
C#using System.Text.RegularExpressions;
public static bool IsDigitsOnly(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^\d+$");
}
使用例です。
C#Console.WriteLine(IsDigitsOnly("123")); // True
Console.WriteLine(IsDigitsOnly("00123")); // True
Console.WriteLine(IsDigitsOnly("12.3")); // False
Console.WriteLine(IsDigitsOnly("abc")); // False
^\d+$は、文字列の先頭から末尾までが数字で構成されていることを表します。
ただし、\dは半角数字以外の数字文字にマッチする場合があります。
半角数字だけを許可したい場合は、次のように書きます。
C#public static bool IsHalfWidthDigitsOnly(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[0-9]+$");
}
5-2. 小数を許可する正規表現
小数を許可したい場合は、次のような正規表現を使えます。
C#using System.Text.RegularExpressions;
public static bool IsDecimalFormat(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[0-9]+(\.[0-9]+)?$");
}
この正規表現では、次のような文字列がtrueになります。
C#Console.WriteLine(IsDecimalFormat("123")); // True
Console.WriteLine(IsDecimalFormat("123.45")); // True
一方、次のような文字列はfalseになります。
C#Console.WriteLine(IsDecimalFormat(".45")); // False
Console.WriteLine(IsDecimalFormat("123.")); // False
Console.WriteLine(IsDecimalFormat("abc")); // False
.45や123.も許可したい場合は、正規表現を変更する必要があります。
C#public static bool IsDecimalFormatFlexible(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^([0-9]+(\.[0-9]*)?|\.[0-9]+)$");
}
正規表現は、許可する形式を細かく決められる点がメリットです。
5-3. 符号付き数値を許可する正規表現
マイナス記号やプラス記号を許可したい場合は、先頭に[+-]?を追加します。
C#using System.Text.RegularExpressions;
public static bool IsSignedDecimalFormat(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[+-]?[0-9]+(\.[0-9]+)?$");
}
使用例です。
C#Console.WriteLine(IsSignedDecimalFormat("123")); // True
Console.WriteLine(IsSignedDecimalFormat("-123")); // True
Console.WriteLine(IsSignedDecimalFormat("+123")); // True
Console.WriteLine(IsSignedDecimalFormat("-12.34")); // True
Console.WriteLine(IsSignedDecimalFormat("12.34.56")); // False
マイナスだけ許可してプラスを許可しない場合は、-?を使います。
C#public static bool IsNegativeAllowedDecimal(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^-?[0-9]+(\.[0-9]+)?$");
}
入力フォームで「小数点は1つまで」「符号は先頭のみ」といったルールを厳密にチェックしたい場合、正規表現は有効です。
5-4. 桁数や入力形式を厳密にチェックする場合の使いどころ
正規表現は、単に数値かどうかを判定するだけでなく、桁数や形式を厳密に制限したい場合に便利です。
たとえば、5桁の数字だけを許可する場合は次のように書けます。
C#public static bool IsFiveDigits(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[0-9]{5}$");
}
使用例です。
C#Console.WriteLine(IsFiveDigits("12345")); // True
Console.WriteLine(IsFiveDigits("1234")); // False
Console.WriteLine(IsFiveDigits("123456")); // False
小数点以下2桁までの金額形式を許可したい場合は、次のように書けます。
C#public static bool IsAmountFormat(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[0-9]+(\.[0-9]{1,2})?$");
}
使用例です。
C#Console.WriteLine(IsAmountFormat("100")); // True
Console.WriteLine(IsAmountFormat("100.5")); // True
Console.WriteLine(IsAmountFormat("100.50")); // True
Console.WriteLine(IsAmountFormat("100.500")); // False
このように、入力形式そのものを制限したい場合は、TryParseよりも正規表現のほうが向いています。
5-5. TryParseと正規表現の使い分け
TryParseと正規表現は、目的によって使い分けるのが重要です。
数値に変換して計算に使いたい場合は、TryParseが適しています。
C#if (decimal.TryParse(input, out decimal amount))
{
decimal taxIncluded = amount * 1.1m;
}
一方、入力形式を厳密にチェックしたい場合は、正規表現が適しています。
C#bool isValid = Regex.IsMatch(input, @"^[0-9]{3}-[0-9]{4}$");
たとえば、郵便番号や会員番号のように、数値として計算する必要がないものは、TryParseで数値に変換しないほうがよい場合があります。
C#Console.WriteLine(int.TryParse("00123", out int number)); // True
Console.WriteLine(number); // 123
00123のような先頭ゼロが意味を持つ値は、数値ではなく文字列として扱うべきです。
6. Char.IsDigitやLINQで数字だけか判定する方法
6-1. Char.IsDigitで1文字ずつ数字か確認する
文字列が数字だけで構成されているかを確認する方法として、Char.IsDigitがあります。
C#public static bool IsDigitsOnlyByChar(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
foreach (char c in value)
{
if (!char.IsDigit(c))
{
return false;
}
}
return true;
}
使用例です。
C#Console.WriteLine(IsDigitsOnlyByChar("123")); // True
Console.WriteLine(IsDigitsOnlyByChar("12a")); // False
Console.WriteLine(IsDigitsOnlyByChar("12.3")); // False
Char.IsDigitは、1文字ずつ数字かどうかを確認するため、シンプルで読みやすい方法です。
ただし、半角数字だけでなく、Unicode上の数字文字を数字として扱う場合があります。
半角数字だけを許可したい場合は、c >= '0' && c <= '9'で判定します。
6-2. Allを使って文字列が数字だけか判定する
LINQのAllを使うと、文字列が数字だけかどうかを簡潔に書けます。
C#using System.Linq;
public static bool IsDigitsOnlyByLinq(string value)
{
return !string.IsNullOrEmpty(value)
&& value.All(char.IsDigit);
}
使用例です。
C#Console.WriteLine(IsDigitsOnlyByLinq("123")); // True
Console.WriteLine(IsDigitsOnlyByLinq("12a")); // False
Console.WriteLine(IsDigitsOnlyByLinq("")); // False
Allは、すべての文字が条件を満たすかを判定します。
C#value.All(char.IsDigit)
このコードは、文字列内のすべての文字が数字ならtrueを返します。
ただし、空文字に対してAllを直接使うとtrueになるため、string.IsNullOrEmptyで事前チェックすることが大切です。
C#Console.WriteLine("".All(char.IsDigit)); // True
空文字を数字だけの文字列として扱いたくない場合は、必ず空チェックを入れましょう。
6-3. 半角数字だけを許可したい場合の実装例
半角数字だけを許可したい場合は、char.IsDigitではなく、文字の範囲を明示的にチェックします。
C#using System.Linq;
public static bool IsHalfWidthDigits(string value)
{
return !string.IsNullOrEmpty(value)
&& value.All(c => c >= '0' && c <= '9');
}
使用例です。
C#Console.WriteLine(IsHalfWidthDigits("123")); // True
Console.WriteLine(IsHalfWidthDigits("１２３")); // False
Console.WriteLine(IsHalfWidthDigits("12a")); // False
この方法では、0から9までの半角数字だけを許可できます。
郵便番号、電話番号の一部、会員番号、認証コードなど、入力文字を半角数字に限定したい場合に便利です。
正規表現で書く場合は、次のようになります。
C#Regex.IsMatch(value, @"^[0-9]+$")
どちらを使ってもよいですが、単純な「半角数字だけ」の判定なら、Allを使った方法は読みやすく保守しやすいです。
6-4. 「数値」と「数字だけ」の違いを理解する
C#で数値判定をするときは、「数値」と「数字だけ」の違いを理解しておく必要があります。
たとえば、次の文字列は数値としては有効です。
-123
12.34
1,234
しかし、数字だけで構成されているわけではありません。
C#Console.WriteLine(decimal.TryParse("-123", out _)); // True
Console.WriteLine("-123".All(char.IsDigit)); // False
逆に、次の文字列は数字だけで構成されています。
00123
しかし、数値に変換すると先頭のゼロは失われます。
C#int.TryParse("00123", out int number);
Console.WriteLine(number); // 123
そのため、計算に使う値ならTryParse、コードや番号として扱う値なら文字列のままAllや正規表現で判定するのが基本です。
6-5. 郵便番号・会員番号・IDなどで使う場合の注意点
郵便番号、会員番号、商品コード、ユーザーIDなどは、数字で構成されていても数値として扱わないほうがよい場合があります。
たとえば、会員番号が001234の場合、intに変換すると1234になり、先頭のゼロが消えてしまいます。
C#int.TryParse("001234", out int id);
Console.WriteLine(id); // 1234
このような値は、計算対象ではなく識別子です。
そのため、数値型ではなく文字列として保持し、形式だけをチェックするのが適切です。
C#public static bool IsMemberId(string value)
{
return !string.IsNullOrEmpty(value)
&& value.Length == 6
&& value.All(c => c >= '0' && c <= '9');
}
使用例です。
C#Console.WriteLine(IsMemberId("001234")); // True
Console.WriteLine(IsMemberId("1234")); // False
Console.WriteLine(IsMemberId("12A234")); // False
「数字だけだから数値型にする」と考えるのではなく、その値を計算に使うかどうかで判断しましょう。
7. 用途別：どの数値判定方法を選ぶべきか
7-1. 入力値を数値に変換したい場合はTryParse
入力値を数値に変換して計算や比較に使いたい場合は、TryParseを使うのが基本です。
C#string input = "100";
if (int.TryParse(input, out int quantity))
{
Console.WriteLine(quantity * 2);
}
TryParseを使えば、判定と変換を同時に行えます。
C#if (decimal.TryParse(input, out decimal price))
{
decimal total = price * 1.1m;
}
入力チェックだけでなく、変換後の値をそのまま使える点が大きなメリットです。
例外が発生しないため、ユーザー入力のバリデーションにも向いています。
7-2. フォーム入力の形式を厳密に制限したい場合は正規表現
フォーム入力で形式を厳密に制限したい場合は、正規表現が便利です。
たとえば、小数点以下2桁までの金額だけを許可したい場合は、次のように書けます。
C#public static bool IsPriceFormat(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[0-9]+(\.[0-9]{1,2})?$");
}
使用例です。
C#Console.WriteLine(IsPriceFormat("100")); // True
Console.WriteLine(IsPriceFormat("100.5")); // True
Console.WriteLine(IsPriceFormat("100.50")); // True
Console.WriteLine(IsPriceFormat("100.500")); // False
TryParseでは数値として扱えるかどうかは判定できますが、「小数点以下は2桁まで」「桁区切りは禁止」「先頭ゼロは禁止」といった形式チェックは苦手です。
このような場合は、正規表現で形式を確認してからTryParseで数値に変換すると安全です。
7-3. 数字だけのコードを判定したい場合はChar.IsDigitやAll
郵便番号、認証コード、会員番号など、数字だけのコードを判定したい場合は、Char.IsDigitやAllが適しています。
C#public static bool IsCode(string value)
{
return !string.IsNullOrEmpty(value)
&& value.All(c => c >= '0' && c <= '9');
}
使用例です。
C#Console.WriteLine(IsCode("123456")); // True
Console.WriteLine(IsCode("123A56")); // False
コードやIDは、数値として計算しないことが多いため、int.TryParseで変換しないほうがよい場合があります。
とくに先頭ゼロを保持する必要がある場合は、文字列として扱いましょう。
C#string code = "001234";
数字だけかどうかを見たいなら、数値判定ではなく文字チェックとして考えることが大切です。
7-4. 金額や小数を扱う場合はdecimal.TryParse
金額や高精度な小数を扱う場合は、decimal.TryParseを使うのが一般的です。
C#string input = "1234.56";
if (decimal.TryParse(input, out decimal amount))
{
Console.WriteLine(amount);
}
doubleは浮動小数点数であり、計算結果に丸め誤差が出ることがあります。
金額計算では、decimalを使うほうが適しています。
C#decimal price = 100.25m;
decimal tax = 1.1m;
decimal total = price * tax;
数値判定でも、金額として入力された文字列を扱うならdecimal.TryParseを選ぶとよいでしょう。
C#public static bool IsAmount(string value)
{
return decimal.TryParse(value, out _);
}
7-5. パフォーマンスと可読性を重視した選び方
通常の入力チェックでは、パフォーマンスよりも可読性と意図の明確さを優先するのがおすすめです。
整数ならint.TryParse、小数や金額ならdecimal.TryParse、数字だけのコードならAllや正規表現を使うと、コードの目的がわかりやすくなります。
C#bool isQuantity = int.TryParse(input, out _);
bool isAmount = decimal.TryParse(input, out _);
bool isCode = input.All(c => c >= '0' && c <= '9');
正規表現は便利ですが、複雑になりすぎると読みにくくなります。
単純な数字チェックなら、Allのほうが読みやすい場合もあります。
C#value.All(c => c >= '0' && c <= '9')
一方、桁数や小数点以下の桁数まで厳密に制限する場合は、正規表現のほうが適しています。
用途に合った方法を選ぶことで、バグの少ない数値判定を実装できます。
8. よくあるエラーと失敗例
8-1. Parseを使って例外が発生するケース
数値判定でよくある失敗は、Parseを使ってしまうことです。
C#int number = int.Parse("abc");
このコードは、文字列"abc"を整数に変換できないため、FormatExceptionが発生します。
ユーザー入力や外部ファイルの値は、必ずしも正しい形式とは限りません。
そのため、数値かどうかを判定したい場合は、ParseではなくTryParseを使うのが基本です。
C#if (int.TryParse("abc", out int number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("数値ではありません");
}
TryParseであれば、変換に失敗しても例外は発生せず、falseで判定できます。
8-2. try-catchで数値判定する方法が推奨されにくい理由
Parseをtry-catchで囲んで数値判定することもできます。
C#public static bool IsNumericByTryCatch(string value)
{
try
{
int.Parse(value);
return true;
}
catch
{
return false;
}
}
しかし、この方法はあまり推奨されません。
理由は、数値でない入力が通常のケースとして想定される場合、例外処理を判定ロジックとして使うことになるためです。
例外は、本来は予期しないエラーを扱うための仕組みです。
入力値が数値でないことは、バリデーションでは十分に起こり得る通常のケースです。
そのため、最初から失敗をfalseで返せるTryParseを使うほうが自然です。
C#public static bool IsNumeric(string value)
{
return int.TryParse(value, out _);
}
コードも短く、意図が明確になります。
8-3. 空文字やnullのチェック漏れ
数値判定では、nullや空文字のチェック漏れにも注意が必要です。
TryParseを使う場合、nullや空文字はfalseになるため、例外は発生しません。
C#Console.WriteLine(int.TryParse(null, out _)); // False
Console.WriteLine(int.TryParse("", out _)); // False
しかし、Allや正規表現を使う場合は注意が必要です。
C#string value = null;
bool result = value.All(char.IsDigit); // NullReferenceException
このようなエラーを避けるために、事前にstring.IsNullOrEmptyやstring.IsNullOrWhiteSpaceでチェックします。
C#public static bool IsDigitsOnly(string value)
{
return !string.IsNullOrEmpty(value)
&& value.All(char.IsDigit);
}
空白だけの文字列も除外したい場合は、string.IsNullOrWhiteSpaceを使います。
C#public static bool IsValidInput(string value)
{
return !string.IsNullOrWhiteSpace(value)
&& decimal.TryParse(value, out _);
}
8-4. 想定外の記号やスペースを数値として判定してしまうケース
TryParseは、既定の設定で前後の空白を許可することがあります。
C#Console.WriteLine(int.TryParse(" 123 ", out _)); // True
ユーザー入力としては問題ない場合もありますが、厳密に「空白なしの数字だけ」を許可したい場合には注意が必要です。
また、NumberStylesの指定によっては、カンマや通貨記号を許可することもできます。
C#decimal.TryParse(
"¥1,234",
NumberStyles.Currency,
CultureInfo.GetCultureInfo("ja-JP"),
out _);
これは便利ですが、意図しない形式まで許可してしまう可能性があります。
厳密な形式チェックが必要な場合は、正規表現で入力形式を制限しましょう。
C#Regex.IsMatch(value, @"^[0-9]+$")
「数値として変換できるか」と「入力形式として許可するか」は、分けて考えることが大切です。
8-5. 型の範囲外でfalseになるケース
TryParseは、形式が正しくても型の範囲外であればfalseになります。
C#Console.WriteLine(int.TryParse("2147483647", out _)); // True
Console.WriteLine(int.TryParse("2147483648", out _)); // False
intで扱える最大値を超えているため、2147483648はfalseになります。
大きな整数を扱う場合は、long.TryParseを使います。
C#Console.WriteLine(long.TryParse("2147483648", out _)); // True
さらに大きな値や小数も扱う場合は、decimal.TryParseを検討します。
C#Console.WriteLine(decimal.TryParse("999999999999999999", out _)); // True
数値判定では、入力形式だけでなく、変換先の型の範囲も意識しましょう。
9. C#の数値判定に関するよくある質問
9-1. C#でVBのIsNumericを使うことはできる？
C#には、VBのIsNumericと同じ名前の標準メソッドはありません。
ただし、Microsoft.VisualBasic名前空間を参照すれば、VB由来の機能を使える場合があります。
しかし、C#で数値判定を行うだけなら、通常はTryParseを使うほうが自然です。
C#public static bool IsNumeric(string value)
{
return double.TryParse(value, out _);
}
整数だけを判定したいなら、次のようにします。
C#public static bool IsInteger(string value)
{
return int.TryParse(value, out _);
}
C#らしい実装としては、判定したい型に合わせてTryParseを使う方法がおすすめです。
9-2. int.TryParseとdouble.TryParseはどちらを使うべき？
整数だけを許可したい場合は、int.TryParseを使います。
C#Console.WriteLine(int.TryParse("123", out _)); // True
Console.WriteLine(int.TryParse("12.3", out _)); // False
小数も許可したい場合は、double.TryParseまたはdecimal.TryParseを使います。
C#Console.WriteLine(double.TryParse("12.3", out _)); // True
Console.WriteLine(decimal.TryParse("12.3", out _)); // True
ただし、金額や業務データの小数では、doubleよりdecimalが向いています。
C#decimal.TryParse("100.50", out _);
迷った場合は、次のように考えると選びやすいです。
整数だけ → int.TryParse または long.TryParse
小数も許可 → decimal.TryParse
科学技術計算 → double.TryParse
金額 → decimal.TryParse
9-3. 文字列が数字だけか判定するには？
文字列が数字だけで構成されているかを判定するには、Allを使う方法が簡単です。
C#using System.Linq;
public static bool IsDigitsOnly(string value)
{
return !string.IsNullOrEmpty(value)
&& value.All(c => c >= '0' && c <= '9');
}
使用例です。
C#Console.WriteLine(IsDigitsOnly("123")); // True
Console.WriteLine(IsDigitsOnly("00123")); // True
Console.WriteLine(IsDigitsOnly("12.3")); // False
Console.WriteLine(IsDigitsOnly("-123")); // False
正規表現で書く場合は、次のようになります。
C#using System.Text.RegularExpressions;
public static bool IsDigitsOnlyByRegex(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^[0-9]+$");
}
「数値として変換できるか」ではなく「数字だけか」を確認したい場合は、TryParseではなく文字チェックを使いましょう。
9-4. 全角数字を数値として判定できる？
全角数字をどう扱うかは、判定方法やカルチャ、実装によって変わります。
たとえば、char.IsDigitは全角数字を数字として扱う場合があります。
C#Console.WriteLine(char.IsDigit('１')); // True
一方、半角数字だけを許可したい場合は、次のように範囲を指定します。
C#public static bool IsHalfWidthDigits(string value)
{
return !string.IsNullOrEmpty(value)
&& value.All(c => c >= '0' && c <= '9');
}
使用例です。
C#Console.WriteLine(IsHalfWidthDigits("123")); // True
Console.WriteLine(IsHalfWidthDigits("１２３")); // False
全角数字を許可したい場合は、入力時に半角へ正規化してから判定する方法もあります。
C#string normalized = Microsoft.VisualBasic.Strings.StrConv(
"１２３",
Microsoft.VisualBasic.VbStrConv.Narrow);
ただし、アプリケーション全体で全角数字を許可するのか、半角数字に統一するのかを決めておくことが重要です。
9-5. 小数点やマイナス記号を許可するには？
小数点やマイナス記号を許可したい場合は、decimal.TryParseを使う方法が簡単です。
C#public static bool IsDecimalNumber(string value)
{
return decimal.TryParse(value, out _);
}
使用例です。
C#Console.WriteLine(IsDecimalNumber("123")); // True
Console.WriteLine(IsDecimalNumber("-123")); // True
Console.WriteLine(IsDecimalNumber("12.34")); // True
Console.WriteLine(IsDecimalNumber("-12.34")); // True
入力形式を厳密に制限したい場合は、正規表現を使います。
C#public static bool IsStrictDecimalNumber(string value)
{
return !string.IsNullOrEmpty(value)
&& Regex.IsMatch(value, @"^-?[0-9]+(\.[0-9]+)?$");
}
この正規表現では、マイナス記号は先頭に1つだけ、小数点は1つだけ許可されます。
C#Console.WriteLine(IsStrictDecimalNumber("-12.34")); // True
Console.WriteLine(IsStrictDecimalNumber("12.34.5")); // False
Console.WriteLine(IsStrictDecimalNumber("--123")); // False
小数点や符号を許可するだけならTryParse、入力形式まで厳密に制御したいなら正規表現を使うとよいでしょう。
まとめ
C#にはVBのIsNumericのような標準関数はありません。
そのため、C#で文字列が数値かどうかを判定する場合は、目的に応じてTryParse、正規表現、Char.IsDigit、LINQのAllなどを使い分けます。
整数かどうかを判定したい場合は、int.TryParseまたはlong.TryParseを使います。
C#bool isInteger = int.TryParse(input, out _);
小数や金額を判定したい場合は、decimal.TryParseが便利です。
C#bool isDecimal = decimal.TryParse(input, out _);
小数や指数表記も含めて広く判定したい場合は、double.TryParseを使えます。
C#bool isDouble = double.TryParse(input, out _);
ただし、金額や業務データではdecimalを選ぶほうが適していることが多いです。
数字だけの文字列を判定したい場合は、Allや正規表現を使います。
C#bool isDigitsOnly = !string.IsNullOrEmpty(input)
&& input.All(c => c >= '0' && c <= '9');
また、カンマ区切り、通貨記号、小数点、マイナス記号、文化圏ごとの表記を扱う場合は、NumberStylesとCultureInfoを明示すると安全です。
C#bool result = decimal.TryParse(
input,
NumberStyles.Number,
CultureInfo.InvariantCulture,
out _);
C#でIsNumeric相当の処理を書くときは、「何を数値として許可するのか」を先に決めることが大切です。
単に数値へ変換したいならTryParse、入力形式を厳密に制限したいなら正規表現、数字だけのコードを確認したいならChar.IsDigitやAllを使いましょう。