C# TryParseとは？使い方・変換失敗の原因・Parseとの違いを初心者向けに徹底解説

はじめに

C#で文字列を数値や日付に変換するとき、よく使われるのがTryParseです。

たとえば、画面の入力フォームから受け取った値は、見た目が数字でもプログラム上は文字列として扱われることがあります。

C#
string input = "123";

この"123"を計算に使うには、intやdecimalなどの数値型に変換しなければなりません。

しかし、ユーザーが必ず正しい値を入力してくれるとは限りません。

C#
string input = "abc";

このような文字列を無理に数値へ変換しようとすると、エラーの原因になります。

そこで便利なのがTryParseです。TryParseを使うと、変換できるかどうかを安全に判定しながら、成功した場合だけ変換後の値を取得できます。

この記事では、C#のTryParseについて、基本的な使い方、失敗する原因、ParseやConvert.ToInt32との違い、実務での使い方まで初心者向けに分かりやすく解説します。

1. C# TryParseとは？初心者向けに基本を解説

1-1. TryParseの役割：文字列を安全に数値や日付へ変換するメソッド

TryParseは、文字列を指定した型に変換できるかどうかを試すメソッドです。

たとえば、文字列"100"を整数に変換したい場合は、int.TryParseを使います。

C#
string text = "100";

bool success = int.TryParse(text, out int number);

このコードでは、textをint型に変換できるか試しています。変換に成功すればsuccessはtrueになり、変換後の値がnumberに入ります。

TryParseの大きな特徴は、変換に失敗しても例外が発生しないことです。

C#
string text = "abc";

bool success = int.TryParse(text, out int number);

この場合、"abc"は整数に変換できないためsuccessはfalseになります。ただし、プログラムはそこで止まりません。

つまり、TryParseは「変換できるか分からない文字列」を安全に扱うためのメソッドです。

1-2. TryParseが使われる場面：入力フォーム・CSV・設定ファイル・APIレスポンス

TryParseは、外部から受け取った文字列を扱う場面でよく使われます。

代表的な例は、ユーザー入力です。

C#
Console.WriteLine("年齢を入力してください");
string input = Console.ReadLine();

if (int.TryParse(input, out int age))
{
    Console.WriteLine($"年齢は{age}歳です");
}
else
{
    Console.WriteLine("年齢は数値で入力してください");
}

ユーザーが20と入力すれば変換に成功しますが、二十歳やabcと入力した場合は失敗します。TryParseを使えば、失敗時に適切なメッセージを表示できます。

また、CSVファイルを読み込む場合にも便利です。

C#
string priceText = "1980";

if (decimal.TryParse(priceText, out decimal price))
{
    Console.WriteLine($"価格: {price}円");
}

CSVの中身は基本的に文字列です。そのため、金額、数量、日付などを扱うには型変換が必要になります。

設定ファイルやAPIレスポンスでも同じです。外部から取得した値は、必ずしも想定どおりの形式とは限りません。

C#
string timeoutText = "30";

if (int.TryParse(timeoutText, out int timeout))
{
    Console.WriteLine($"タイムアウト秒数: {timeout}");
}

このように、TryParseは「正しい形式か保証できない文字列」を扱うときに活躍します。

1-3. TryParseの戻り値はbool：変換成功ならtrue、失敗ならfalse

TryParseの戻り値はboolです。

変換に成功した場合はtrue、失敗した場合はfalseが返ります。

C#
bool result1 = int.TryParse("123", out int number1);
Console.WriteLine(result1);  // True
Console.WriteLine(number1);  // 123

bool result2 = int.TryParse("abc", out int number2);
Console.WriteLine(result2);  // False
Console.WriteLine(number2);  // 0

TryParseは、名前のとおり「変換を試す」メソッドです。

成功するか分からない変換を実行し、その結果をtrueまたはfalseで教えてくれます。

そのため、通常はif文と組み合わせて使います。

C#
if (int.TryParse("123", out int number))
{
    Console.WriteLine("変換に成功しました");
}
else
{
    Console.WriteLine("変換に失敗しました");
}

初心者のうちは、TryParseは「変換できたかどうかをboolで返すメソッド」と覚えておくと理解しやすいです。

1-4. 変換後の値はout引数で受け取る

TryParseでは、変換後の値をout引数で受け取ります。

C#
int.TryParse("123", out int number);

このout int numberの部分が、変換後の値を受け取る場所です。

TryParseは戻り値で変換結果を返します。

C#
true または false

一方で、変換された実際の値はout引数に入ります。

C#
string text = "123";

bool success = int.TryParse(text, out int number);

Console.WriteLine(success); // True
Console.WriteLine(number);  // 123

戻り値と変換後の値を分けて考えるのがポイントです。

TryParseでは、以下のように役割が分かれています。

つまり、TryParseは「成功したかどうか」と「変換後の値」を同時に扱えるメソッドです。

2. C# TryParseの基本的な使い方

2-1. int.TryParseの基本構文

まずは、もっともよく使うint.TryParseの基本構文を見てみましょう。

C#
bool result = int.TryParse(変換したい文字列, out 変換後の変数);

具体例は次のとおりです。

C#
string text = "123";

bool result = int.TryParse(text, out int number);

Console.WriteLine(result); // True
Console.WriteLine(number); // 123

textには文字列の"123"が入っています。int.TryParseによって、この文字列をint型の数値123へ変換しています。

変換に成功すると、戻り値はtrueになります。そして、変換された値はnumberに入ります。

変換に失敗する例も見てみましょう。

C#
string text = "abc";

bool result = int.TryParse(text, out int number);

Console.WriteLine(result); // False
Console.WriteLine(number); // 0

"abc"は整数ではないため、変換に失敗します。そのため、resultはfalseになります。

int.TryParseの基本は、次の形で覚えれば問題ありません。

C#
if (int.TryParse(text, out int number))
{
    // 変換成功時の処理
}
else
{
    // 変換失敗時の処理
}

2-2. if文と組み合わせて成功時・失敗時の処理を分ける

TryParseは、ほとんどの場合if文と組み合わせて使います。

C#
string input = "25";

if (int.TryParse(input, out int age))
{
    Console.WriteLine($"年齢は{age}歳です");
}
else
{
    Console.WriteLine("年齢は数字で入力してください");
}

このコードでは、inputを整数に変換できるかどうかを判定しています。

変換に成功した場合は、ifブロックの中が実行されます。

C#
Console.WriteLine($"年齢は{age}歳です");

変換に失敗した場合は、elseブロックの中が実行されます。

C#
Console.WriteLine("年齢は数字で入力してください");

ユーザー入力では、必ずしも正しい値が入力されるとは限りません。そのため、失敗時の処理を書くことが重要です。

悪い例は次のようなコードです。

C#
int.TryParse(input, out int age);
Console.WriteLine($"年齢は{age}歳です");

このコードでもコンパイルは通りますが、変換に失敗した場合でも処理が続いてしまいます。たとえば、inputが"abc"だった場合、ageには0が入ります。

その結果、ユーザーが年齢を正しく入力していないのに「年齢は0歳です」と表示される可能性があります。

そのため、TryParseを使うときは戻り値のtrueまたはfalseを必ず確認するのが基本です。

2-3. out varを使ったシンプルな書き方

C#では、out varを使って変換後の変数を簡潔に書くこともできます。

C#
string text = "123";

if (int.TryParse(text, out var number))
{
    Console.WriteLine(number);
}

この場合、numberの型はコンパイラが自動的に判断します。

int.TryParseを使っているため、numberはint型になります。

C#
out var number

これは次の書き方とほぼ同じ意味です。

C#
out int number

型が明らかな場合は、out varを使うとコードがすっきりします。

C#
if (decimal.TryParse("1980.5", out var price))
{
    Console.WriteLine(price);
}

if (DateTime.TryParse("2026/01/01", out var date))
{
    Console.WriteLine(date);
}

ただし、初心者のうちはout int numberのように型を明示して書いたほうが分かりやすい場合もあります。

慣れてきたら、out varを使うとよいでしょう。

2-4. TryParseで失敗したとき変数には何が入るのか

TryParseで変換に失敗した場合、out引数の変数には、その型の既定値が入ります。

たとえば、intの場合は0です。

C#
bool success = int.TryParse("abc", out int number);

Console.WriteLine(success); // False
Console.WriteLine(number);  // 0

doubleやdecimalの場合も、失敗時は0になります。

C#
double.TryParse("abc", out double d);
Console.WriteLine(d); // 0

decimal.TryParse("abc", out decimal m);
Console.WriteLine(m); // 0

DateTimeの場合は、DateTime型の既定値が入ります。

C#
DateTime.TryParse("abc", out DateTime date);
Console.WriteLine(date); // 0001/01/01 0:00:00

boolの場合はfalseです。

C#
bool.TryParse("abc", out bool flag);
Console.WriteLine(flag); // False

ここで注意したいのは、変換に失敗した結果として0やfalseが入ることです。

たとえば、次のコードでは問題が起きる可能性があります。

C#
int.TryParse("abc", out int count);

Console.WriteLine(count);

この場合、countは0になります。しかし、この0は本当に入力された値ではなく、変換失敗によって入った既定値です。

そのため、TryParseの戻り値を確認せずにout変数だけ使うのは避けましょう。

2-5. 初心者がつまずきやすいout引数の考え方

out引数は、初心者にとって少し分かりにくいポイントです。

通常、メソッドは戻り値で結果を返します。

C#
int number = SomeMethod();

しかし、TryParseでは戻り値はboolです。

C#
bool success = int.TryParse("123", out int number);

では、変換後の123はどこに返されるのでしょうか。

答えは、out int numberです。

outは、メソッドの中で値を入れてもらうための仕組みです。

イメージとしては、次のように考えると分かりやすいです。

C#
int.TryParse("123", out int number);

このコードは、int.TryParseに対して次のように頼んでいます。

「この文字列を整数に変換してみてください。変換できたら、その値をnumberに入れてください」

そして、戻り値のtrueまたはfalseで、成功したかどうかを教えてもらいます。

C#
if (int.TryParse("123", out int number))
{
    Console.WriteLine(number);
}

この書き方では、numberはif文の中でも使えます。

C#
if (int.TryParse("123", out int number))
{
    Console.WriteLine(number); // 123
}

out引数は最初は慣れないかもしれませんが、TryParseでは非常によく使うので、ぜひ覚えておきましょう。

3. 型別に見るTryParseの使い方

3-1. int.TryParse：整数に変換する

int.TryParseは、文字列を整数に変換するために使います。

C#
string text = "100";

if (int.TryParse(text, out int number))
{
    Console.WriteLine($"変換成功: {number}");
}
else
{
    Console.WriteLine("整数に変換できません");
}

int.TryParseで変換できるのは、基本的に整数として正しい文字列です。

C#
int.TryParse("123", out int a);  // true
int.TryParse("-123", out int b); // true
int.TryParse("abc", out int c);  // false
int.TryParse("12.3", out int d); // false

"12.3"は数値に見えますが、小数なのでintには変換できません。

また、intには扱える範囲があります。

C#
int.TryParse("2147483647", out int max); // true
int.TryParse("2147483648", out int over); // false

intの最大値を超える文字列は変換に失敗します。

整数を扱いたい場合はint.TryParse、より大きな整数を扱いたい場合はlong.TryParseを検討しましょう。

C#
if (long.TryParse("2147483648", out long value))
{
    Console.WriteLine(value);
}

3-2. double.TryParse・decimal.TryParse：小数に変換する

小数を扱う場合は、double.TryParseやdecimal.TryParseを使います。

C#
string text = "123.45";

if (double.TryParse(text, out double value))
{
    Console.WriteLine(value);
}

doubleは浮動小数点数を扱う型です。科学技術計算や一般的な小数計算で使われます。

一方、金額のように誤差を避けたい値にはdecimalがよく使われます。

C#
string priceText = "1980.50";

if (decimal.TryParse(priceText, out decimal price))
{
    Console.WriteLine($"価格: {price}円");
}

doubleとdecimalはどちらも小数を扱えますが、用途が異なります。

たとえば、商品価格や請求金額などを扱う場合はdecimal.TryParseを使うのが一般的です。

C#
if (decimal.TryParse("1200.75", out decimal amount))
{
    Console.WriteLine(amount);
}

ただし、小数点の記号は環境のカルチャ設定によって扱いが変わる場合があります。日本語環境では通常.が小数点として使われますが、国や設定によっては,が小数点として扱われることもあります。

3-3. DateTime.TryParse：日付文字列を変換する

DateTime.TryParseは、文字列を日付や時刻に変換するために使います。

C#
string text = "2026/01/01";

if (DateTime.TryParse(text, out DateTime date))
{
    Console.WriteLine(date);
}
else
{
    Console.WriteLine("日付に変換できません");
}

DateTime.TryParseでは、次のような文字列を日付として解釈できる場合があります。

C#
DateTime.TryParse("2026/01/01", out DateTime d1);
DateTime.TryParse("2026-01-01", out DateTime d2);
DateTime.TryParse("2026年1月1日", out DateTime d3);

ただし、日付の解釈は実行環境のカルチャに影響されます。

たとえば、"01/02/2026"という文字列は、環境によって「2026年1月2日」と解釈される場合もあれば、「2026年2月1日」と解釈される場合もあります。

日付形式を厳密に指定したい場合は、DateTime.TryParseExactを使うのが安全です。

C#
using System.Globalization;

string text = "2026-01-01";

if (DateTime.TryParseExact(
    text,
    "yyyy-MM-dd",
    CultureInfo.InvariantCulture,
    DateTimeStyles.None,
    out DateTime date))
{
    Console.WriteLine(date);
}
else
{
    Console.WriteLine("指定した形式の日付ではありません");
}

DateTime.TryParseは柔軟に変換してくれる便利なメソッドですが、厳密な入力チェックにはTryParseExactが向いています。

3-4. bool.TryParse：true・falseを変換する

bool.TryParseは、文字列をbool型に変換します。

C#
string text = "true";

if (bool.TryParse(text, out bool flag))
{
    Console.WriteLine(flag);
}

bool.TryParseで変換できる代表的な文字列は、"true"と"false"です。

C#
bool.TryParse("true", out bool a);  // true
bool.TryParse("false", out bool b); // true
bool.TryParse("True", out bool c);  // true
bool.TryParse("False", out bool d); // true

大文字・小文字の違いは基本的に許容されます。

ただし、"1"や"0"は通常bool.TryParseでは変換できません。

C#
bool.TryParse("1", out bool x); // false
bool.TryParse("0", out bool y); // false

そのため、設定ファイルなどで1をtrue、0をfalseとして扱いたい場合は、自分で判定を書く必要があります。

C#
string text = "1";

bool flag;

if (text == "1")
{
    flag = true;
}
else if (text == "0")
{
    flag = false;
}
else
{
    Console.WriteLine("真偽値に変換できません");
}

bool.TryParseは、あくまでtrueまたはfalseという文字列を変換するためのメソッドだと考えると分かりやすいです。

3-5. Enum.TryParse：文字列を列挙型に変換する

Enum.TryParseは、文字列を列挙型に変換するときに使います。

列挙型とは、あらかじめ決まった値の一覧を表す型です。

C#
enum OrderStatus
{
    Pending,
    Paid,
    Shipped,
    Cancelled
}

この列挙型に対して、文字列を変換してみます。

C#
string text = "Paid";

if (Enum.TryParse(text, out OrderStatus status))
{
    Console.WriteLine(status);
}
else
{
    Console.WriteLine("ステータスに変換できません");
}

"Paid"はOrderStatusに存在する名前なので、変換に成功します。

大文字・小文字を無視したい場合は、次のように書きます。

C#
string text = "paid";

if (Enum.TryParse(text, ignoreCase: true, out OrderStatus status))
{
    Console.WriteLine(status);
}

ignoreCase: trueを指定すると、"paid"でもPaidとして変換できます。

ただし、Enum.TryParseには注意点があります。数値文字列を渡すと、列挙型に定義されていない値でも変換できてしまう場合があります。

C#
Enum.TryParse("999", out OrderStatus status);
Console.WriteLine(status); // 999

このような値を防ぎたい場合は、Enum.IsDefinedも組み合わせると安全です。

C#
string text = "999";

if (Enum.TryParse(text, out OrderStatus status) &&
    Enum.IsDefined(typeof(OrderStatus), status))
{
    Console.WriteLine(status);
}
else
{
    Console.WriteLine("定義されていないステータスです");
}

列挙型を安全に扱う場合は、TryParseだけでなく、定義済みの値かどうかも確認しましょう。

3-6. Guid.TryParse：GUID文字列を変換する

Guid.TryParseは、文字列をGuid型に変換するときに使います。

GUIDは、識別子としてよく使われる値です。データベースのIDやAPIのリクエストIDなどで登場します。

C#
string text = "6f9619ff-8b86-d011-b42d-00cf4fc964ff";

if (Guid.TryParse(text, out Guid id))
{
    Console.WriteLine(id);
}
else
{
    Console.WriteLine("GUIDに変換できません");
}

正しい形式のGUIDであれば変換に成功します。

一方、形式が不正な文字列は変換に失敗します。

C#
Guid.TryParse("abc", out Guid id); // false

変換に失敗した場合、idにはGuid.Emptyが入ります。

C#
Guid.TryParse("abc", out Guid id);

Console.WriteLine(id); // 00000000-0000-0000-0000-000000000000

GUIDを扱う場面では、文字列が正しいGUID形式かどうかを確認するためにGuid.TryParseがよく使われます。

APIで受け取ったIDやURLパラメータのIDを検証するときに便利です。

4. TryParseで変換に失敗する主な原因

4-1. 空文字・null・スペースだけの文字列を渡している

TryParseでよくある失敗原因のひとつが、空文字やnullを渡しているケースです。

C#
string text = "";

bool success = int.TryParse(text, out int number);

Console.WriteLine(success); // False

空文字は整数として解釈できないため、変換に失敗します。

nullの場合も同じです。

C#
string text = null;

bool success = int.TryParse(text, out int number);

Console.WriteLine(success); // False

TryParseはnullを渡しても例外を出さず、falseを返します。この点は安全ですが、未入力と不正入力を区別したい場合は、事前にチェックする必要があります。

C#
if (string.IsNullOrWhiteSpace(input))
{
    Console.WriteLine("値を入力してください");
}
else if (int.TryParse(input, out int number))
{
    Console.WriteLine(number);
}
else
{
    Console.WriteLine("数値を入力してください");
}

また、スペースだけの文字列も変換できません。

C#
int.TryParse("   ", out int number); // false

ただし、前後に空白があるだけなら変換できる場合があります。

C#
int.TryParse(" 123 ", out int number); // true

とはいえ、実務では変換前にTrimで前後の空白を取り除くと安心です。

C#
string text = input?.Trim();

if (int.TryParse(text, out int number))
{
    Console.WriteLine(number);
}

4-2. 数字以外の文字が含まれている

数値に変換したい文字列に、数字以外の文字が含まれていると失敗します。

C#
int.TryParse("123abc", out int number); // false
int.TryParse("1,000円", out int price); // false
int.TryParse("No.123", out int id);     // false

人間から見ると「123が含まれている」と分かっても、int.TryParseは文字列全体を整数として解釈しようとします。

そのため、不要な文字が入っていると変換できません。

たとえば、金額に円が付いている場合は、事前に取り除く必要があります。

C#
string text = "1000円";
text = text.Replace("円", "");

if (int.TryParse(text, out int price))
{
    Console.WriteLine(price);
}

ただし、むやみに文字を削除すると、想定外の値を受け入れてしまう危険もあります。

たとえば、"abc1000円"を単純にReplaceしても"abc1000"が残り、結局変換に失敗します。

入力仕様を明確にして、どの形式を許可するのか決めることが大切です。

4-3. 小数点やカンマの扱いが想定と違う

小数やカンマの扱いも、TryParseで失敗する原因になります。

たとえば、int.TryParseでは小数は変換できません。

C#
int.TryParse("12.3", out int number); // false

小数を扱いたい場合は、double.TryParseやdecimal.TryParseを使います。

C#
decimal.TryParse("12.3", out decimal value); // true

また、カンマ区切りの数値にも注意が必要です。

C#
int.TryParse("1,000", out int number);

この結果は、使用するオーバーロードや指定するNumberStylesによって変わります。

カンマ区切りを明示的に許可したい場合は、次のように書きます。

C#
using System.Globalization;

string text = "1,000";

if (int.TryParse(
    text,
    NumberStyles.AllowThousands,
    CultureInfo.InvariantCulture,
    out int number))
{
    Console.WriteLine(number);
}

小数点やカンマは、国や地域によって意味が異なる場合があります。

たとえば、日本やアメリカでは1,234.56のように書くことが多いですが、別の地域では1.234,56のように表記されることもあります。

そのため、小数やカンマを含む文字列を扱う場合は、CultureInfoを意識しましょう。

4-4. 全角数字や日本語表記が含まれている

ユーザー入力では、全角数字が入力されることがあります。

C#
int.TryParse("１２３", out int number);

環境や処理方法によっては期待どおりに変換できない場合があります。特に、半角数字だけを想定しているシステムでは、全角数字を不正な入力として扱うことがあります。

また、日本語表記もそのままでは数値に変換できません。

C#
int.TryParse("百二十三", out int number); // false
int.TryParse("一二三", out int number);   // false

金額でも同じです。

C#
decimal.TryParse("千円", out decimal amount); // false

このような文字列を扱う場合は、事前に入力ルールを決めておくことが重要です。

たとえば、入力フォームで「半角数字で入力してください」と表示したり、入力時に全角数字を半角数字へ変換したりします。

C#
string text = "１２３";
string normalized = text
    .Replace('０', '0')
    .Replace('１', '1')
    .Replace('２', '2')
    .Replace('３', '3')
    .Replace('４', '4')
    .Replace('５', '5')
    .Replace('６', '6')
    .Replace('７', '7')
    .Replace('８', '8')
    .Replace('９', '9');

if (int.TryParse(normalized, out int number))
{
    Console.WriteLine(number);
}

実務では、全角・半角のゆれをどこまで許可するかを仕様として決める必要があります。

4-5. 日付の形式が環境やカルチャに合っていない

DateTime.TryParseで失敗する原因として多いのが、日付形式の違いです。

C#
DateTime.TryParse("2026/01/01", out DateTime date); // 成功しやすい
DateTime.TryParse("20260101", out DateTime date);   // 環境によって扱いに注意
DateTime.TryParse("01-31-2026", out DateTime date); // カルチャによって結果が変わる

日付は国や地域によって表記が異なります。

たとえば、01/02/2026という文字列は、次のように解釈が分かれる可能性があります。

このように、同じ文字列でもカルチャによって意味が変わることがあります。

入力形式が決まっている場合は、DateTime.TryParseExactを使いましょう。

C#
using System.Globalization;

string text = "2026-01-31";

if (DateTime.TryParseExact(
    text,
    "yyyy-MM-dd",
    CultureInfo.InvariantCulture,
    DateTimeStyles.None,
    out DateTime date))
{
    Console.WriteLine(date);
}
else
{
    Console.WriteLine("日付形式が正しくありません");
}

TryParseExactを使うと、指定した形式に一致した場合だけ変換できます。

日付入力のバリデーションでは、DateTime.TryParseよりDateTime.TryParseExactのほうが適していることが多いです。

4-6. intの範囲を超える大きな数値を変換している

int.TryParseは、整数であれば何でも変換できるわけではありません。

intには扱える範囲があります。

C#
int.MinValue // -2147483648
int.MaxValue //  2147483647

この範囲を超える数値は、intに変換できません。

C#
int.TryParse("2147483647", out int a); // true
int.TryParse("2147483648", out int b); // false

見た目は数字だけでも、型の範囲を超えていると失敗します。

大きな整数を扱いたい場合は、long.TryParseを使います。

C#
if (long.TryParse("2147483648", out long value))
{
    Console.WriteLine(value);
}

さらに大きな数値を扱う必要がある場合は、decimalやBigIntegerを検討します。

C#
using System.Numerics;

if (BigInteger.TryParse("999999999999999999999999999999", out BigInteger big))
{
    Console.WriteLine(big);
}

どの型を使うべきかは、扱うデータの範囲によって決めましょう。

4-7. TryParseがfalseになるのに理由が分からないときの確認ポイント

TryParseがfalseになる理由が分からないときは、次の点を確認しましょう。

まず、文字列の中身をそのまま表示して確認します。

C#
Console.WriteLine($"[{input}]");

角括弧を付けて表示すると、前後の空白に気づきやすくなります。

C#
[ 123 ]

次に、nullや空文字を確認します。

C#
if (string.IsNullOrWhiteSpace(input))
{
    Console.WriteLine("未入力です");
}

数値変換の場合は、数字以外の文字が入っていないか確認しましょう。

C#
Console.WriteLine(input);

見た目では分かりにくい全角数字、改行、タブ、通貨記号などが含まれていることもあります。

C#
string input = "123\n";

必要に応じて、Trimを使って前後の空白を取り除きます。

C#
string text = input?.Trim();

小数や日付の場合は、カルチャの違いも確認します。

C#
using System.Globalization;

decimal.TryParse(
    input,
    NumberStyles.Number,
    CultureInfo.InvariantCulture,
    out decimal value);

日付形式を固定したい場合は、TryParseExactを使います。

C#
DateTime.TryParseExact(
    input,
    "yyyy-MM-dd",
    CultureInfo.InvariantCulture,
    DateTimeStyles.None,
    out DateTime date);

TryParseが失敗する場合は、文字列の中身、空白、型の範囲、カルチャ、形式指定を順番に確認すると原因を見つけやすくなります。

5. TryParseとParseの違い

5-1. Parseは変換失敗時に例外が発生する

Parseは、文字列を指定した型に変換するメソッドです。

C#
int number = int.Parse("123");
Console.WriteLine(number); // 123

正しい文字列であれば問題なく変換できます。

しかし、変換できない文字列を渡すと例外が発生します。

C#
int number = int.Parse("abc");

この場合、FormatExceptionが発生します。

また、数値が型の範囲を超えている場合は、OverflowExceptionが発生します。

C#
int number = int.Parse("2147483648");

このように、Parseは「変換できることが前提」のメソッドです。

そのため、ユーザー入力や外部データのように、正しい形式か分からない文字列に対して使うと、例外処理が必要になります。

C#
try
{
    int number = int.Parse(input);
    Console.WriteLine(number);
}
catch (FormatException)
{
    Console.WriteLine("数値形式ではありません");
}
catch (OverflowException)
{
    Console.WriteLine("数値が大きすぎます");
}

このように書くこともできますが、入力チェック目的であればTryParseのほうがシンプルです。

5-2. TryParseは例外を出さずにtrue・falseで判定できる

TryParseは、変換に失敗しても例外を発生させません。

C#
if (int.TryParse("abc", out int number))
{
    Console.WriteLine(number);
}
else
{
    Console.WriteLine("数値に変換できません");
}

失敗した場合はfalseが返るだけです。

そのため、ユーザー入力のように失敗が想定される処理に向いています。

ParseとTryParseの違いを簡単に比較すると、次のようになります。

C#
// Parse
int number = int.Parse(input); // 失敗すると例外

// TryParse
bool success = int.TryParse(input, out int number); // 失敗するとfalse

TryParseを使うと、例外処理を書かなくても変換可否を判定できます。

C#
if (!int.TryParse(input, out int number))
{
    Console.WriteLine("入力値が正しくありません");
    return;
}

Console.WriteLine(number);

このように、失敗時の処理を自然な流れで書けるのがTryParseのメリットです。

5-3. ユーザー入力にはTryParseが向いている理由

ユーザー入力にはTryParseが向いています。

理由は、ユーザーが必ず正しい値を入力するとは限らないからです。

たとえば、年齢入力欄に次のような値が入力される可能性があります。

C#
"20"
"abc"
"二十"
""
"  "
"20歳"

このような入力をすべてint.Parseで処理すると、変換できない値が来たときに例外が発生します。

C#
int age = int.Parse(input);

一方、TryParseなら失敗を前提に処理を書けます。

C#
if (int.TryParse(input, out int age))
{
    Console.WriteLine($"年齢: {age}");
}
else
{
    Console.WriteLine("年齢は半角数字で入力してください");
}

ユーザー入力では、変換失敗は異常事態ではなく、普通に起こり得ることです。

そのため、例外で処理するよりも、TryParseで判定するほうが自然です。

また、コードも読みやすくなります。

C#
if (!int.TryParse(input, out int age))
{
    Console.WriteLine("入力エラー");
    return;
}

このように、ユーザー入力チェックではTryParseを使うのが基本です。

5-4. 確実に変換できる文字列ならParseでもよいケース

TryParseが便利だからといって、常にTryParseだけを使う必要はありません。

変換できることが確実な文字列であれば、Parseを使ってもよい場合があります。

たとえば、プログラム内で固定の文字列を変換する場合です。

C#
int number = int.Parse("123");

この文字列は開発者が直接書いているため、通常は変換失敗を想定しなくても問題ありません。

また、事前に厳密なバリデーションが済んでいる場合も、Parseを使えることがあります。

C#
if (Regex.IsMatch(input, @"^\d+$"))
{
    int number = int.Parse(input);
}

ただし、このようなケースでもTryParseを使ったほうがシンプルになることが多いです。

C#
if (int.TryParse(input, out int number))
{
    Console.WriteLine(number);
}

実務では、外部から来る値にはTryParse、内部で確実に正しいと分かっている値にはParse、という使い分けが分かりやすいです。

5-5. ParseとTryParseの使い分け早見表

ParseとTryParseの使い分けは、次の表で整理できます。

基本的には、初心者はTryParseを優先して使うと安全です。

特に、外部から受け取る文字列は、想定外の値が入っている可能性があります。

そのため、次のように覚えておくとよいでしょう。

C#
// 安全に変換したいならTryParse
if (int.TryParse(input, out int number))
{
    Console.WriteLine(number);
}

一方、Parseは「失敗したら例外にしたい」「正しい値であることが保証されている」場合に使います。

6. TryParseとConvert.ToInt32の違い

6-1. Convert.ToInt32はnullを0に変換する

Convert.ToInt32も、文字列などを整数に変換するために使われます。

C#
int number = Convert.ToInt32("123");
Console.WriteLine(number); // 123

しかし、Convert.ToInt32にはTryParseやParseとは異なる特徴があります。

特に注意したいのが、nullを渡した場合です。

C#
string text = null;

int number = Convert.ToInt32(text);

Console.WriteLine(number); // 0

Convert.ToInt32は、nullを0に変換します。

一方、int.TryParseではnullを渡すとfalseになります。

C#
string text = null;

bool success = int.TryParse(text, out int number);

Console.WriteLine(success); // False
Console.WriteLine(number);  // 0

結果の値だけ見るとどちらも0ですが、意味が違います。

Convert.ToInt32では、nullが0として扱われます。

TryParseでは、変換に失敗したことをfalseで判定できます。

この違いは重要です。

未入力を0として扱ってよいのか、それとも未入力としてエラーにしたいのかによって、使うメソッドを選ぶ必要があります。

6-2. TryParseは変換可否を明示的に判定できる

TryParseのメリットは、変換できたかどうかを明示的に判定できることです。

C#
if (int.TryParse(input, out int number))
{
    Console.WriteLine($"変換成功: {number}");
}
else
{
    Console.WriteLine("変換できません");
}

Convert.ToInt32の場合、変換できない文字列を渡すと例外が発生します。

C#
int number = Convert.ToInt32("abc");

この場合、FormatExceptionが発生します。

また、範囲を超える場合はOverflowExceptionが発生します。

C#
int number = Convert.ToInt32("2147483648");

つまり、Convert.ToInt32はParseに近い使い方になります。

変換できるか分からない値を扱う場合は、TryParseのほうが安全です。

特に、ユーザー入力や外部データでは次のように書くのがおすすめです。

C#
if (!int.TryParse(input, out int number))
{
    Console.WriteLine("数値を入力してください");
    return;
}

Console.WriteLine(number);

変換の成功・失敗を明確に分けたい場合は、TryParseを使いましょう。

6-3. Parse・TryParse・Convertの違いを比較

Parse、TryParse、Convert.ToInt32の違いを整理すると、次のようになります。

具体的な挙動を見てみましょう。

C#
int.Parse("123");        // 123
int.TryParse("123", out int a); // true
Convert.ToInt32("123");  // 123

不正な文字列の場合です。

C#
int.Parse("abc");        // 例外
int.TryParse("abc", out int b); // false
Convert.ToInt32("abc");  // 例外

nullの場合です。

C#
string text = null;

int.Parse(text);               // 例外
int.TryParse(text, out int c); // false
Convert.ToInt32(text);         // 0

このように、同じ「整数に変換する処理」でも、失敗時やnullの扱いが異なります。

6-4. 初心者が選ぶべき変換方法

初心者が文字列を数値に変換する場合、まずはTryParseを選ぶのがおすすめです。

理由は、失敗してもプログラムが止まらず、成功・失敗を分かりやすく分岐できるからです。

C#
if (int.TryParse(input, out int number))
{
    Console.WriteLine(number);
}
else
{
    Console.WriteLine("数値に変換できません");
}

特に、次のような値を扱う場合はTryParseを使いましょう。

C#
Console.ReadLine()で受け取った文字列
Webフォームの入力値
CSVファイルの値
設定ファイルの値
APIから取得した文字列
データベースから取得した文字列

外部から来る値は、基本的に信用しすぎないことが大切です。

Parseは、変換できることが確実な場合に使います。

C#
int number = int.Parse("123");

Convert.ToInt32は、nullを0として扱いたい場合など、挙動を理解したうえで使いましょう。

迷ったら、まずはTryParseです。

7. TryParseを実務で安全に使うコツ

7-1. ユーザー入力チェックでは必ず失敗時の処理を書く

TryParseを使うときは、失敗時の処理を必ず書きましょう。

悪い例は次のコードです。

C#
int.TryParse(input, out int age);

Console.WriteLine($"年齢: {age}");

このコードでは、変換に失敗しても処理が続いてしまいます。

inputが"abc"の場合、ageには0が入ります。その結果、誤った値で処理が進む可能性があります。

正しくは、次のように書きます。

C#
if (!int.TryParse(input, out int age))
{
    Console.WriteLine("年齢は数値で入力してください");
    return;
}

Console.WriteLine($"年齢: {age}");

このように、変換に失敗した場合はそこで処理を止める、またはエラーメッセージを表示するようにします。

フォーム入力の場合も同じです。

C#
if (!decimal.TryParse(priceText, out decimal price))
{
    ModelState.AddModelError("Price", "価格は数値で入力してください");
}

TryParseは、戻り値を確認してこそ意味があります。

7-2. エラーメッセージを分かりやすく表示する

変換に失敗したときは、ユーザーに分かりやすいエラーメッセージを表示しましょう。

悪い例です。

C#
Console.WriteLine("エラーです");

これでは、ユーザーは何を直せばよいのか分かりません。

良い例です。

C#
Console.WriteLine("年齢は半角数字で入力してください");

金額の場合は、次のように具体的に書きます。

C#
Console.WriteLine("金額は数値で入力してください。例: 1200");

日付の場合です。

C#
Console.WriteLine("日付はyyyy-MM-dd形式で入力してください。例: 2026-01-01");

エラーメッセージでは、次の点を意識すると親切です。

TryParseは失敗理由を詳しく返してくれるわけではありません。そのため、アプリ側で入力ルールに合わせたメッセージを用意することが大切です。

7-3. 変換前にTrimで前後の空白を取り除く

ユーザー入力には、意図せず空白が入ることがあります。

C#
string input = " 123 ";

前後の空白だけであれば、変換できる場合もあります。しかし、実務では変換前にTrimしておくと安全です。

C#
string text = input?.Trim();

if (int.TryParse(text, out int number))
{
    Console.WriteLine(number);
}

Trimは、文字列の前後にある空白を取り除くメソッドです。

C#
string text = "  hello  ";
Console.WriteLine(text.Trim()); // hello

ただし、inputがnullの可能性がある場合は、次のように?.を使うと安全です。

C#
string text = input?.Trim();

inputがnullなら、textもnullになります。

その後、TryParseに渡せばfalseになります。

C#
if (int.TryParse(input?.Trim(), out int number))
{
    Console.WriteLine(number);
}

入力値を扱うときは、まずTrimで余計な空白を取り除く習慣をつけるとよいでしょう。

7-4. 日付や小数はCultureInfoを意識する

日付や小数を扱う場合は、CultureInfoを意識することが重要です。

たとえば、小数点やカンマの意味は国や地域によって異なります。

C#
1,234.56
1.234,56

どちらも数値のように見えますが、文化圏によって解釈が変わります。

TryParseには、カルチャを指定できるオーバーロードがあります。

C#
using System.Globalization;

string text = "1234.56";

if (decimal.TryParse(
    text,
    NumberStyles.Number,
    CultureInfo.InvariantCulture,
    out decimal value))
{
    Console.WriteLine(value);
}

CultureInfo.InvariantCultureは、環境に依存しにくい固定のカルチャです。APIやCSVなど、形式を統一したデータを扱うときによく使われます。

日本語環境を明示したい場合は、次のように書けます。

C#
var culture = new CultureInfo("ja-JP");

if (decimal.TryParse(
    "1,234.56",
    NumberStyles.Number,
    culture,
    out decimal value))
{
    Console.WriteLine(value);
}

日付の場合も同じです。

C#
using System.Globalization;

string text = "2026-01-01";

if (DateTime.TryParseExact(
    text,
    "yyyy-MM-dd",
    CultureInfo.InvariantCulture,
    DateTimeStyles.None,
    out DateTime date))
{
    Console.WriteLine(date);
}

実務では、日付や小数の入力形式を決めて、CultureInfoやTryParseExactで明示的に変換するのが安全です。

7-5. nullable型と組み合わせて未入力を表現する

入力値では、「0」と「未入力」を区別したい場合があります。

たとえば、年齢入力で次の2つは意味が異なります。

C#
"0"  // 0歳として入力された
""   // 入力されていない

このような場合は、nullable型を使うと便利です。

C#
int? age = null;

int?は、intの値またはnullを持てる型です。

入力値を変換する例です。

C#
string input = "";

int? age = null;

if (!string.IsNullOrWhiteSpace(input))
{
    if (int.TryParse(input, out int parsedAge))
    {
        age = parsedAge;
    }
    else
    {
        Console.WriteLine("年齢は数値で入力してください");
    }
}

このコードでは、未入力の場合はageをnullのままにします。

入力がある場合だけTryParseで変換します。

金額でも同じです。

C#
decimal? amount = null;

if (!string.IsNullOrWhiteSpace(amountText))
{
    if (decimal.TryParse(amountText, out decimal parsedAmount))
    {
        amount = parsedAmount;
    }
}

nullable型を使うと、「未入力」と「変換後の値」を自然に表現できます。

7-6. 例外処理よりTryParseを使うべき理由

変換に失敗する可能性が高い処理では、例外処理よりTryParseを使うほうが適しています。

例外処理で書くと、次のようになります。

C#
try
{
    int number = int.Parse(input);
    Console.WriteLine(number);
}
catch
{
    Console.WriteLine("数値に変換できません");
}

このコードでも動きますが、入力チェックとしてはやや大げさです。

TryParseを使うと、次のようにシンプルに書けます。

C#
if (int.TryParse(input, out int number))
{
    Console.WriteLine(number);
}
else
{
    Console.WriteLine("数値に変換できません");
}