文字列

【C#】負の数を含む文字列を安全に整数へ変換する方法とTryParse活用術

2025-05-15更新日: 2025-05-15

c#で文字列を数値に変換する際、マイナスを含む場合でもint.ParseやConvert.ToInt32でそのまま整数に変換できます。

ただし失敗時には例外が出るため、不確定な入力にはint.TryParseを使うと安全です。

NumberStylesを併用すればカンマ付きや先頭符号付きも柔軟に扱えます。

目次から探す

なぜ負の数の文字列変換が重要か
- 実務で頻繁に遭遇する典型例
- エラーが招くリスク
文字列を整数に変換する基本メソッド
- int.Parse の動作と特徴
- Convert.ToInt32 の動作と特徴
TryParse を使った安全な変換
NumberStyles と CultureInfo で柔軟に対応
範囲外数値と OverflowException の回避
浮動小数点・小数への変換
- double.Parse と double.TryParse
- decimal.Parse と decimal.TryParse
null・空文字列・ホワイトスペースの扱い
- String.IsNullOrWhiteSpace で事前チェック
- Nullable<int> で表現する不在値
先頭・末尾に余分な文字がある場合の対策
- 正規表現で数値部分を抽出
- Span<char> と手動トリムで高速化
Unicode のマイナス記号問題
- U+2212 とハイフンマイナスの違い
- 置換による正規化方法
全角数字・全角符号の処理
- Normalize(NFKC) で統一
- TryParse との相互作用
変換失敗時の代替戦略
- 既定値を返す実装例
- 例外ラッピングで詳細情報を付加
パフォーマンス測定と最適化
新しい C# 機能との連携
よくある落とし穴と対策一覧
まとめ

なぜ負の数の文字列変換が重要か

プログラミングにおいて、文字列から整数への変換は非常に基本的な処理の一つです。

特に負の数を含む文字列を正しく整数に変換することは、多くのアプリケーションで欠かせません。

ここでは、なぜ負の数の文字列変換が重要なのか、その背景を具体的に見ていきます。

実務で頻繁に遭遇する典型例

負の数を含む文字列の変換は、実務のさまざまなシーンで頻繁に発生します。

例えば、以下のようなケースが挙げられます。

ユーザー入力の処理

ユーザーがフォームやコンソールから数値を入力する際、負の数を入力することがあります。

例えば、温度の変化や残高のマイナス表示などです。

これらの入力を正しく整数に変換しなければ、誤った計算や表示につながります。

ファイルやデータベースからの読み込み

CSVファイルやテキストファイル、あるいはデータベースから数値データを文字列として読み込む場合、負の数が含まれていることがあります。

たとえば、売上の損失額や在庫のマイナス調整などです。

これらのデータを安全に整数に変換し、正確に処理する必要があります。

APIや外部サービスからのレスポンス

外部のAPIやサービスから数値データを文字列形式で受け取ることがあります。

負の数が含まれている場合も多く、これを適切に変換しないと、システム全体の整合性に影響を及ぼします。

計算処理やロジックの基盤

負の数を含む整数値は、計算ロジックの基盤となることが多いです。

例えば、差分計算や在庫管理、財務計算などでマイナスの値を扱うことは避けられません。

文字列から正しく変換できなければ、計算結果が誤り、システムの信頼性が損なわれます。

これらの例からもわかるように、負の数を含む文字列を安全かつ正確に整数に変換することは、実務上非常に重要な処理です。

エラーが招くリスク

負の数を含む文字列の変換に失敗すると、さまざまなリスクが発生します。

主なリスクは以下の通りです。

例外の発生によるアプリケーションの停止

int.Parse や Convert.ToInt32 などのメソッドは、無効な文字列や範囲外の数値が入力されると例外をスローします。

これを適切にハンドリングしないと、アプリケーションがクラッシュしたり、ユーザーに不親切なエラーメッセージが表示されたりします。

誤ったデータ処理による計算ミス

変換に失敗しても例外をキャッチせずに処理を続行すると、誤ったデフォルト値(例えば0)が使われてしまい、計算結果が大きく狂うことがあります。

特に負の数が重要な意味を持つ場合、これが致命的なバグにつながります。

セキュリティ上の問題

入力値の検証が不十分なまま変換処理を行うと、悪意のある文字列が原因で予期せぬ動作を引き起こす可能性があります。

例えば、SQLインジェクションやバッファオーバーフローのリスクが高まることもあります。

ユーザー体験の低下

変換エラーが頻発すると、ユーザーは何度も入力をやり直す必要があり、ストレスが溜まります。

特に負の数を入力した際に正しく処理されないと、ユーザーの信頼を失う原因になります。

デバッグや保守の難易度増加

変換エラーが原因で発生する問題は、原因の特定が難しいことがあります。

特に負の数の扱いが不適切な場合、バグの再現性が低く、保守コストが増大します。

これらのリスクを回避するためには、負の数を含む文字列を安全に整数に変換する方法を理解し、適切に実装することが不可欠です。

文字列を整数に変換する基本メソッド

C#で文字列を整数に変換する際に最も基本的なメソッドとしてint.ParseとConvert.ToInt32があります。

これらは似ているようで挙動に違いがあるため、正しく理解して使い分けることが重要です。

int.Parse の動作と特徴

int.Parseは、指定した文字列を整数に変換します。

変換できない文字列や範囲外の数値が渡された場合は例外をスローします。

マイナス符号を含む入力での挙動

int.Parseはマイナス符号-を含む文字列を正しく認識し、負の整数として変換します。

例えば、"-123"という文字列は整数-123に変換されます。

using System;
class Program
{
    static void Main()
    {
        string negativeStr = "-12345";
        int number = int.Parse(negativeStr);
        Console.WriteLine(number); // 出力: -12345
    }
}

-12345

このように、マイナス符号が先頭にある場合は問題なく変換されます。

ただし、マイナス符号が途中にある場合や複数ある場合はFormatExceptionが発生します。

string invalidStr = "12-345";
int number = int.Parse(invalidStr); // FormatExceptionが発生

空白やタブの許容範囲

int.Parseは文字列の先頭や末尾にある空白文字(スペースやタブ)を自動的にトリム(除去)してから変換を行います。

つまり、" -123 "のような文字列も問題なく変換できます。

string spacedStr = "   -789   ";
int number = int.Parse(spacedStr);
Console.WriteLine(number); // 出力: -789

-789

ただし、文字列の途中に空白やタブがある場合は変換できず、FormatExceptionが発生します。

string invalidStr = "-12 34";
int number = int.Parse(invalidStr); // FormatExceptionが発生

Convert.ToInt32 の動作と特徴

Convert.ToInt32は、文字列を整数に変換するメソッドで、int.Parseと似ていますが、nullの扱いに違いがあります。

null 処理の違い

Convert.ToInt32は引数がnullの場合、例外をスローせずに0を返します。

一方、int.Parseはnullを渡すとArgumentNullExceptionが発生します。

string nullStr = null;
int number1 = Convert.ToInt32(nullStr);
Console.WriteLine(number1); // 出力: 0
int number2 = int.Parse(nullStr); // ArgumentNullExceptionが発生

このため、nullの可能性がある文字列を整数に変換する場合は、Convert.ToInt32のほうが安全に使えます。

例外パターンの比較

int.ParseとConvert.ToInt32は、無効な形式の文字列や数値の範囲外の場合に例外をスローしますが、例外の種類や発生条件に若干の違いがあります。

例外の種類	int.Parse	Convert.ToInt32
引数がnull	`ArgumentNullException`	返り値は`0`(例外なし)
無効な形式の文字列	`FormatException`	`FormatException`
数値がintの範囲外	`OverflowException`	`OverflowException`

例えば、文字列が空文字や数字以外の文字を含む場合は両者ともFormatExceptionが発生します。

string invalidStr = "abc";
int number1 = int.Parse(invalidStr);       // FormatException
int number2 = Convert.ToInt32(invalidStr); // FormatException

数値がintの範囲を超える場合も両者ともOverflowExceptionが発生します。

string largeNumber = "999999999999999999999";
int number1 = int.Parse(largeNumber);       // OverflowException
int number2 = Convert.ToInt32(largeNumber); // OverflowException

このように、Convert.ToInt32はnullに対して例外をスローしない点が大きな違いですが、その他の例外はint.Parseと同様に発生します。

用途に応じて使い分けることが望ましいです。

TryParse を使った安全な変換

int.TryParseは、文字列を整数に変換する際に例外を発生させず、安全に処理を行うためのメソッドです。

例外処理のコストを抑えつつ、変換の成否を簡単に判定できるため、ユーザー入力や外部データの処理に適しています。

メソッドシグニチャの確認

int.TryParseの基本的なシグニチャは以下の通りです。

public static bool TryParse(string s, out int result);

s：変換対象の文字列です
result：変換に成功した場合に整数値が格納される出力パラメータです
戻り値はbool型で、変換が成功すればtrue、失敗すればfalseを返します

このメソッドは例外をスローしないため、変換失敗時の例外処理が不要で、パフォーマンス面でも優れています。

out 変数のスコープと型推論

C# 7.0以降では、outパラメータの変数をメソッド呼び出し時に宣言できます。

これにより、コードが簡潔になります。

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

この場合、numberはif文のスコープ内で有効です。

スコープ外で使いたい場合は、事前に変数を宣言しておく必要があります。

int number;
if (int.TryParse("456", out number))
{
    Console.WriteLine(number);
}
// numberはここでも使用可能
Console.WriteLine(number);

型推論により、out int numberのintは省略できませんが、C# 7.3以降ではvarを使うことはできません。

必ず型を明示してください。

TryParse の戻り値でフロー制御

TryParseの戻り値を使って、変換の成否に応じた処理を分岐させることができます。

成功時の処理

変換が成功した場合は、outパラメータに変換後の整数が格納されます。

これを使って計算や表示などの処理を行います。

string input = "-789";
if (int.TryParse(input, out int result))
{
    Console.WriteLine($"変換成功: {result}");
}

変換成功: -789

このように、負の数を含む文字列も問題なく変換されます。

失敗時のフォールバック

変換に失敗した場合はfalseが返り、outパラメータには0が設定されます。

失敗時の処理を明示的に記述することで、入力エラーの通知やデフォルト値の設定が可能です。

string input = "abc";
if (int.TryParse(input, out int result))
{
    Console.WriteLine($"変換成功: {result}");
}
else
{
    Console.WriteLine("変換に失敗しました。デフォルト値を使用します。");
    result = -1; // フォールバック値を設定
    Console.WriteLine($"結果: {result}");
}

変換に失敗しました。デフォルト値を使用します。
結果: -1

この方法は例外処理を使わずに安全に変換を試みるため、ユーザー入力や外部データの検証に最適です。

NumberStyles と CultureInfo で柔軟に対応

C#の数値変換では、NumberStylesとCultureInfoを組み合わせることで、符号の有無やカンマ区切り、小数点の扱いなどを柔軟に制御できます。

これにより、さまざまな形式の文字列を正確に整数や浮動小数点数に変換可能です。

AllowLeadingSign で符号を許可

NumberStyles.AllowLeadingSignは、文字列の先頭にあるプラス+やマイナス-の符号を許可するオプションです。

これを指定しないと、符号付きの数値は変換に失敗します。

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string signedStr = "-12345";
        int number = int.Parse(signedStr, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture);
        Console.WriteLine(number); // 出力: -12345
    }
}

-12345

符号がある文字列を扱う場合は、AllowLeadingSignを必ず指定しましょう。

複数のスタイルを組み合わせる場合はビット演算子|でつなげます。

AllowThousands を使ったカンマ区切りの処理

NumberStyles.AllowThousandsは、数値の中にあるカンマ,などの千区切り記号を許可します。

これを指定しないと、カンマが含まれる文字列は変換に失敗します。

string thousandStr = "1,234,567";
int number = int.Parse(thousandStr, NumberStyles.AllowThousands, CultureInfo.InvariantCulture);
Console.WriteLine(number); // 出力: 1234567

カンマ区切りと符号を同時に許可したい場合は、以下のように複数のNumberStylesを組み合わせます。

string signedThousandStr = "-1,234,567";
int number = int.Parse(signedThousandStr, NumberStyles.AllowLeadingSign | NumberStyles.AllowThousands, CultureInfo.InvariantCulture);
Console.WriteLine(number); // 出力: -1234567

-1234567

カルチャ別の小数点と千区切り

数値の表記は文化圏によって異なり、小数点や千区切りの記号が変わります。

CultureInfoを指定することで、これらの違いに対応できます。

CultureInfo.InvariantCulture の使い所

CultureInfo.InvariantCultureは、文化に依存しない固定の書式を提供します。

主にデータの保存や通信、ログ出力など、文化に左右されない一貫した数値表現が必要な場面で使います。

string numberStr = "1,234,567.89";
double value = double.Parse(numberStr, NumberStyles.AllowThousands | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
Console.WriteLine(value); // 出力: 1234567.89

1234567.89

この例では、カンマが千区切り、ピリオドが小数点として正しく認識されます。

ja-JP と en-US の違い

日本ja-JPとアメリカen-USの文化圏では、数値の表記が似ていますが、他の文化圏では異なる場合があります。

例えば、ドイツde-DEでは小数点がカンマ、千区切りがピリオドです。

string germanNumber = "1.234.567,89";
double value = double.Parse(germanNumber, NumberStyles.AllowThousands | NumberStyles.AllowDecimalPoint, new CultureInfo("de-DE"));
Console.WriteLine(value); // 出力: 1234567.89

1234567.89

一方、日本やアメリカの文化圏では以下のように表記します。

文化圏	千区切り記号	小数点記号
ja-JP	カンマ(,)	ピリオド(.)
en-US	カンマ(,)	ピリオド(.)
de-DE	ピリオド(.)	カンマ(,)

この違いを考慮しないと、数値の変換に失敗したり誤った値になることがあります。

CultureInfoを適切に指定して、対象の文化圏に合わせた変換を行いましょう。

範囲外数値と OverflowException の回避

整数型の変換で注意すべきポイントの一つに、変換対象の数値が型の許容範囲を超える場合があります。

C#ではこのような場合にOverflowExceptionが発生することがあり、適切に対処しなければプログラムの異常終了や誤動作につながります。

int.MaxValue と int.MinValue の確認

int型は32ビット符号付き整数で、表現できる範囲はint.MinValueからint.MaxValueまでです。

int.MinValueは-2,147,483,648
int.MaxValueは2,147,483,647

これらの範囲を超える数値をintに変換しようとすると、OverflowExceptionが発生します。

using System;
class Program
{
    static void Main()
    {
        string tooLarge = "2147483648"; // int.MaxValue + 1
        try
        {
            int number = int.Parse(tooLarge);
            Console.WriteLine(number);
        }
        catch (OverflowException)
        {
            Console.WriteLine("数値がintの範囲外です。");
        }
    }
}

数値がintの範囲外です。

このように、変換前に文字列の数値がintの範囲内かどうかを意識することが重要です。

checked / unchecked コンテキストの利用

C#ではcheckedとuncheckedキーワードを使って、算術演算や変換時のオーバーフロー検出を制御できます。

checkedブロック内では、オーバーフローが発生するとOverflowExceptionがスローされます
uncheckedブロック内では、オーバーフローが発生しても例外はスローされず、値がラップアラウンド(循環)します

int a = int.MaxValue;
int b = 1;
try
{
    checked
    {
        int c = a + b; // OverflowExceptionが発生
        Console.WriteLine(c);
    }
}
catch (OverflowException)
{
    Console.WriteLine("オーバーフローが検出されました。");
}
unchecked
{
    int d = a + b; // ラップアラウンドして-2147483648になる
    Console.WriteLine(d);
}

オーバーフローが検出されました。
-2147483648

数値変換時もcheckedを使うことで、オーバーフローを検出しやすくなります。

逆にパフォーマンス重視で例外を避けたい場合はuncheckedを使うこともありますが、誤動作の原因になるため注意が必要です。

long へのキャストで対応するケース

intの範囲を超える数値を扱う必要がある場合は、より大きな型であるlong(64ビット符号付き整数)を使う方法があります。

longの範囲は約-9京から9京までと非常に広いため、多くのケースでオーバーフローを回避できます。

string largeNumberStr = "9223372036854775807"; // long.MaxValue
try
{
    long largeNumber = long.Parse(largeNumberStr);
    Console.WriteLine(largeNumber);
}
catch (OverflowException)
{
    Console.WriteLine("数値がlongの範囲外です。");
}

9223372036854775807

また、intに変換する前にlongでパースし、範囲チェックを行ってからintにキャストする方法もあります。

string input = "2147483648"; // int.MaxValue + 1
if (long.TryParse(input, out long longValue))
{
    if (longValue >= int.MinValue && longValue <= int.MaxValue)
    {
        int intValue = (int)longValue;
        Console.WriteLine($"intに変換可能: {intValue}");
    }
    else
    {
        Console.WriteLine("intの範囲外の数値です。");
    }
}
else
{
    Console.WriteLine("数値として無効な文字列です。");
}

intの範囲外の数値です。

このように、longを活用することで、範囲外の数値を安全に検出し、適切な処理を行えます。

特に外部からの入力や大きな数値を扱う場合は、intの範囲に収まっているかを必ず確認しましょう。

浮動小数点・小数への変換

整数だけでなく、浮動小数点数や小数点を含む数値を文字列から変換するケースも多くあります。

C#ではdouble型とdecimal型を使った変換メソッドが用意されており、用途に応じて使い分けることが重要です。

double.Parse と double.TryParse

double.Parseは文字列を倍精度浮動小数点数doubleに変換します。

小数点や指数表記を含む文字列も正しく処理可能ですが、無効な文字列や範囲外の値の場合は例外をスローします。

using System;
class Program
{
    static void Main()
    {
        string str = "-1234.5678e2";
        double value = double.Parse(str);
        Console.WriteLine(value); // 出力: -123456.78
    }
}

-123456.78

double.TryParseは例外をスローせず、変換の成否をboolで返します。

安全に変換を試みたい場合はこちらを使います。

string input = "12.34abc";
if (double.TryParse(input, out double result))
{
    Console.WriteLine($"変換成功: {result}");
}
else
{
    Console.WriteLine("変換に失敗しました。");
}

変換に失敗しました。

doubleは科学技術計算や大きな範囲の数値を扱うのに適していますが、丸め誤差が発生しやすい点に注意が必要です。

decimal.Parse と decimal.TryParse

decimal型は高精度な固定小数点数を扱うための型で、特に金融計算や金額データの処理に適しています。

decimal.Parseとdecimal.TryParseはdoubleと同様の使い方ができますが、より正確な小数点計算が可能です。

string moneyStr = "12345.67";
decimal money = decimal.Parse(moneyStr);
Console.WriteLine(money); // 出力: 12345.67

12345.67

decimal.TryParseを使うと、変換失敗時に例外を避けられます。

string input = "12.34abc";
if (decimal.TryParse(input, out decimal result))
{
    Console.WriteLine($"変換成功: {result}");
}
else
{
    Console.WriteLine("変換に失敗しました。");
}

変換に失敗しました。

金額データでの利点

金額や財務データの計算では、decimal型の利用が推奨されます。

理由は以下の通りです。

高精度な小数点計算

decimalは10進数ベースの固定小数点演算を行うため、doubleのような二進数ベースの丸め誤差が少なく、正確な計算が可能です。

通貨単位の扱いに適している

金額は小数点以下の桁数が決まっていることが多く、decimalはその要件に合致します。

金融業界の標準

多くの金融システムや会計ソフトウェアでdecimalが標準的に使われており、互換性が高いです。

decimal price = 19.99m;
decimal quantity = 3m;
decimal total = price * quantity;
Console.WriteLine($"合計金額: {total}"); // 出力: 合計金額: 59.97

合計金額: 59.97

このように、金額データの正確な計算にはdecimal型を使い、文字列からの変換もdecimal.Parseやdecimal.TryParseで行うことが望ましいです。

null・空文字列・ホワイトスペースの扱い

文字列を整数に変換する際、nullや空文字列、ホワイトスペースのみの文字列が入力されるケースはよくあります。

これらを適切に処理しないと、例外が発生したり誤った値が返されたりするため、事前のチェックや適切な型の利用が重要です。

String.IsNullOrWhiteSpace で事前チェック

String.IsNullOrWhiteSpaceメソッドは、文字列がnull、空文字列("")、または空白文字(スペース、タブ、改行など)のみで構成されているかを判定します。

これを使うことで、変換前に無効な入力を簡単に検出できます。

using System;
class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "123", "-456" };
        foreach (var input in inputs)
        {
            if (String.IsNullOrWhiteSpace(input))
            {
                Console.WriteLine("入力がnullまたは空白のみです。変換をスキップします。");
            }
            else if (int.TryParse(input, out int number))
            {
                Console.WriteLine($"変換成功: {number}");
            }
            else
            {
                Console.WriteLine("変換に失敗しました。");
            }
        }
    }
}

入力がnullまたは空白のみです。変換をスキップします。
入力がnullまたは空白のみです。変換をスキップします。
入力がnullまたは空白のみです。変換をスキップします。
変換成功: 123
変換成功: -456

このように、String.IsNullOrWhiteSpaceを使うことで、無効な入力を事前に除外し、変換処理の安全性を高められます。

Nullable<int> で表現する不在値

整数型は値型であり、通常はnullを許容しません。

しかし、入力が存在しない場合や変換できなかった場合にnullを表現したいことがあります。

その場合はNullable<int>int?を使います。

int? ConvertToNullableInt(string input)
{
    if (String.IsNullOrWhiteSpace(input))
    {
        return null; // 入力なしを表現
    }
    if (int.TryParse(input, out int number))
    {
        return number;
    }
    return null; // 変換失敗もnullで表現
}
class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "  ", "789", "-321", "abc" };
        foreach (var input in inputs)
        {
            int? result = ConvertToNullableInt(input);
            if (result.HasValue)
            {
                Console.WriteLine($"変換成功: {result.Value}");
            }
            else
            {
                Console.WriteLine("変換できませんでした(null)。");
            }
        }
    }
}

変換できませんでした(null)。
変換できませんでした(null)。
変換できませんでした(null)。
変換成功: 789
変換成功: -321
変換できませんでした(null)。

Nullable<int>を使うことで、変換結果が存在しない場合を明示的に扱え、呼び出し側でnullチェックを行うことで安全に処理を分岐できます。

これにより、0などの特定の値を不在値として誤解するリスクを避けられます。

先頭・末尾に余分な文字がある場合の対策

文字列の先頭や末尾に余分な文字や記号が含まれていると、通常の数値変換メソッドでは変換に失敗することがあります。

こうしたケースに対応するためには、数値部分だけを抽出したり、効率的にトリム処理を行う工夫が必要です。

正規表現で数値部分を抽出

正規表現(Regex)を使うと、文字列の中から数値に該当する部分だけを抽出できます。

特に、負の符号や数字、カンマ、小数点などを含むパターンを指定して、余分な文字を除去したい場合に有効です。

以下は、負の符号を含む整数部分を抽出する例です。

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "abc -12345 xyz";
        // 負の符号と数字のみを抽出する正規表現パターン
        string pattern = @"-?\d+";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
            string numericPart = match.Value;
            if (int.TryParse(numericPart, out int number))
            {
                Console.WriteLine($"抽出した数値: {number}");
            }
            else
            {
                Console.WriteLine("数値変換に失敗しました。");
            }
        }
        else
        {
            Console.WriteLine("数値部分が見つかりませんでした。");
        }
    }
}

抽出した数値: -12345

この例では、-?\d+というパターンで「マイナス符号が0回または1回、その後に1つ以上の数字」という部分を抽出しています。

複雑なフォーマットや小数点、カンマを含む場合はパターンを拡張することも可能です。

Span<char> と手動トリムで高速化

正規表現は便利ですが、パフォーマンスが求められる場面ではオーバーヘッドになることがあります。

C# 7.2以降で使えるSpan<char>を活用すると、文字列の部分参照を効率的に扱い、手動でトリムや数値部分の抽出を行うことが可能です。

以下は、先頭と末尾の空白や特定の余分な文字を手動でトリムし、数値部分を抽出する例です。

using System;
class Program
{
    static void Main()
    {
        string input = "  \t -12345abc  ";
        ReadOnlySpan<char> span = input.AsSpan();
        // 先頭の空白・タブをスキップ
        int start = 0;
        while (start < span.Length && (span[start] == ' ' || span[start] == '\t'))
        {
            start++;
        }
        // 末尾の空白・タブをスキップ
        int end = span.Length - 1;
        while (end >= start && (span[end] == ' ' || span[end] == '\t'))
        {
            end--;
        }
        // 数値部分の終端を探す(数字とマイナス符号のみ許可)
        int numericEnd = start;
        if (numericEnd <= end && (span[numericEnd] == '-' || char.IsDigit(span[numericEnd])))
        {
            numericEnd++;
            while (numericEnd <= end && char.IsDigit(span[numericEnd]))
            {
                numericEnd++;
            }
        }
        else
        {
            Console.WriteLine("数値の開始位置が不正です。");
            return;
        }
        ReadOnlySpan<char> numericSpan = span.Slice(start, numericEnd - start);
        if (int.TryParse(numericSpan, out int number))
        {
            Console.WriteLine($"抽出した数値: {number}");
        }
        else
        {
            Console.WriteLine("数値変換に失敗しました。");
        }
    }
}

抽出した数値: -12345

この方法は文字列のコピーを伴わず、Span<char>のスライス操作で部分文字列を扱うため、メモリ効率と速度の両面で優れています。

特に大量のデータを処理する場合やリアルタイム性が求められるシステムで効果的です。

これらの方法を使い分けることで、先頭や末尾に余分な文字が含まれる文字列からでも安全かつ効率的に数値を抽出し、変換処理を行えます。

Unicode のマイナス記号問題

文字列を整数に変換する際、マイナス符号として使われる文字が複数存在することに注意が必要です。

特にUnicodeには「ハイフンマイナス」と「マイナス記号」という異なるコードポイントがあり、これが原因で変換エラーが発生することがあります。

U+2212 とハイフンマイナスの違い

ハイフンマイナス(Hyphen-Minus)
- Unicodeコードポイント：U+002D
- ASCIIコードの-に相当し、プログラミング言語や多くのシステムで負の符号として標準的に使われます
- 例："-123"の-はこのハイフンマイナスです
マイナス記号(Minus Sign)
- Unicodeコードポイント：U+2212
- 数学的なマイナス記号として定義されており、見た目はハイフンマイナスと似ていますが別の文字です
- ワードプロセッサや一部のフォントではこちらが使われることがあります

この違いは見た目ではほとんど区別がつきませんが、int.Parseやint.TryParseなどの標準的な数値変換メソッドはU+002Dのハイフンマイナスのみを負の符号として認識します。

U+2212が含まれていると変換に失敗します。

using System;
class Program
{
    static void Main()
    {
        string hyphenMinus = "-123"; // U+002D
        string minusSign = "\u2212" + "123"; // U+2212
        Console.WriteLine(int.TryParse(hyphenMinus, out int num1)); // True
        Console.WriteLine(int.TryParse(minusSign, out int num2));   // False
    }
}

True
False

このように、マイナス記号の種類によって変換結果が異なるため注意が必要です。

置換による正規化方法

U+2212のマイナス記号をU+002Dのハイフンマイナスに置換することで、変換エラーを回避できます。

文字列の正規化処理として、変換前に置換を行うのが一般的です。

using System;
class Program
{
    static void Main()
    {
        string input = "\u2212" + "456"; // マイナス記号を含む文字列
        // U+2212をU+002Dに置換
        string normalized = input.Replace('\u2212', '-');
        if (int.TryParse(normalized, out int number))
        {
            Console.WriteLine($"変換成功: {number}");
        }
        else
        {
            Console.WriteLine("変換に失敗しました。");
        }
    }
}

変換成功: -456

この方法は、外部からの入力やコピー＆ペーストで混入しやすいUnicodeマイナス記号を安全に処理するために有効です。

必要に応じて他の類似文字も正規化対象に加えることができます。

Unicodeのマイナス記号問題は見落としがちですが、数値変換の信頼性を高めるために必ず対策しておきたいポイントです。

全角数字・全角符号の処理

日本語環境などで入力される数値文字列には、全角数字や全角の符号(プラス・マイナス)が含まれることがあります。

これらは半角の数字や符号とは異なるUnicodeコードポイントを持つため、そのままではint.Parseやint.TryParseで正しく変換できません。

全角文字を半角に統一する処理が必要です。

Normalize(NFKC) で統一

.NETのstring.NormalizeメソッドにNormalizationForm.FormKC(NFKC)を指定すると、全角文字を半角に変換するなどの互換文字の正規化が行われます。

これにより、全角数字や全角符号が半角に変換され、数値変換がスムーズになります。

using System;
class Program
{
    static void Main()
    {
        string fullWidthNumber = "-12345"; // 全角マイナスと全角数字
        // NFKC正規化で全角文字を半角に変換
        string normalized = fullWidthNumber.Normalize(NormalizationForm.FormKC);
        Console.WriteLine($"正規化前: {fullWidthNumber}");
        Console.WriteLine($"正規化後: {normalized}");
        if (int.TryParse(normalized, out int number))
        {
            Console.WriteLine($"変換成功: {number}");
        }
        else
        {
            Console.WriteLine("変換に失敗しました。");
        }
    }
}

正規化前: -12345
正規化後: -12345
変換成功: 12345

このように、Normalize(NFKC)を使うことで、全角のマイナス記号や数字が半角に変換され、int.TryParseで問題なく変換できるようになります。

TryParse との相互作用

int.TryParseは半角の数字と符号のみを認識します。

全角文字が含まれていると変換に失敗しますが、Normalize(NFKC)で正規化した文字列を渡すことで、全角文字を含む入力でも安全に変換できます。

string input = "＋123"; // 全角プラスと全角数字
// 正規化しない場合
bool success1 = int.TryParse(input, out int result1);
// 正規化した場合
string normalizedInput = input.Normalize(NormalizationForm.FormKC);
bool success2 = int.TryParse(normalizedInput, out int result2);
Console.WriteLine($"正規化なし: 成功={success1}, 結果={result1}");
Console.WriteLine($"正規化あり: 成功={success2}, 結果={result2}");

正規化なし: 成功=False, 結果=0
正規化あり: 成功=True, 結果=123

この例からもわかるように、全角文字を含む入力は正規化を行わないとTryParseで失敗します。

正規化を前処理として組み込むことで、ユーザー入力や外部データの多様な表記に対応でき、変換の信頼性が向上します。

変換失敗時の代替戦略

文字列から整数への変換が失敗した場合、単に例外を投げるだけでなく、適切な代替処理を行うことが重要です。

ここでは、変換失敗時に既定値を返す方法と、例外に詳細情報を付加してラッピングする方法を紹介します。

既定値を返す実装例

変換に失敗した際に、例外をスローせずに既定値を返す実装は、ユーザー入力や外部データの不確実性が高い場合に有効です。

int.TryParseを活用し、失敗時に安全なデフォルト値を返す例を示します。

using System;
class Program
{
    static int ParseOrDefault(string input, int defaultValue = 0)
    {
        if (int.TryParse(input, out int result))
        {
            return result;
        }
        else
        {
            return defaultValue;
        }
    }
    static void Main()
    {
        string[] inputs = { "123", "abc", null, "-456" };
        foreach (var input in inputs)
        {
            int value = ParseOrDefault(input, -1);
            Console.WriteLine($"入力: {input ?? "null"}, 変換結果: {value}");
        }
    }
}

入力: 123, 変換結果: 123
入力: abc, 変換結果: -1
入力: null, 変換結果: -1
入力: -456, 変換結果: -456

この方法は例外処理のオーバーヘッドを避けつつ、変換失敗時に明示的な既定値を返すため、後続処理での誤動作を防げます。

例外ラッピングで詳細情報を付加

変換失敗時に例外をスローしたい場合でも、元の例外に加えて入力値や処理状況などの詳細情報を付加すると、デバッグやログ解析が容易になります。

以下は、FormatExceptionやOverflowExceptionをキャッチしてカスタム例外にラップする例です。

using System;
class ParseException : Exception
{
    public string InputValue { get; }
    public ParseException(string message, string inputValue, Exception innerException)
        : base(message, innerException)
    {
        InputValue = inputValue;
    }
}
class Program
{
    static int ParseWithException(string input)
    {
        try
        {
            return int.Parse(input);
        }
        catch (FormatException ex)
        {
            throw new ParseException("無効な形式の文字列です。", input, ex);
        }
        catch (OverflowException ex)
        {
            throw new ParseException("数値がintの範囲外です。", input, ex);
        }
    }
    static void Main()
    {
        string[] inputs = { "123", "abc", "999999999999999999999" };
        foreach (var input in inputs)
        {
            try
            {
                int value = ParseWithException(input);
                Console.WriteLine($"入力: {input}, 変換結果: {value}");
            }
            catch (ParseException ex)
            {
                Console.WriteLine($"入力: {ex.InputValue}, エラー: {ex.Message}");
            }
        }
    }
}

入力: 123, 変換結果: 123
入力: abc, エラー: 無効な形式の文字列です。
入力: 999999999999999999999, エラー: 数値がintの範囲外です。

このように例外をラップすることで、例外の原因と入力値をセットで管理でき、問題の特定や対応がしやすくなります。

ログ出力やユーザーへのフィードバックにも役立つため、堅牢なシステム設計におすすめです。

パフォーマンス測定と最適化

文字列から整数への変換は多くのアプリケーションで頻繁に行われる処理です。

特に大量のデータを扱う場合やリアルタイム性が求められるシステムでは、変換処理のパフォーマンスが重要になります。

ここでは、int.Parseとtry-catchを使った例外処理方式と、int.TryParseを使った方式の速度比較、BenchmarkDotNetを用いたベンチマークの実施例、そしてメモリアロケーションを減らす工夫について解説します。

Parse+try-catch と TryParse の速度比較

int.Parseは変換に失敗すると例外をスローします。

例外処理はコストが高いため、失敗が頻発する場合はパフォーマンスに大きな影響を与えます。

一方、int.TryParseは例外をスローせず、戻り値で成功・失敗を判定するため高速です。

以下のコードは、失敗するケースを含む変換処理で両者の速度を比較する簡単な例です。

using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string[] inputs = { "123", "abc", "456", "def", "789" };
        int dummy;
        // int.Parse + try-catch
        var swParse = Stopwatch.StartNew();
        for (int i = 0; i < 100000; i++)
        {
            foreach (var input in inputs)
            {
                try
                {
                    dummy = int.Parse(input);
                }
                catch
                {
                    // 例外は無視
                }
            }
        }
        swParse.Stop();
        Console.WriteLine($"Parse+try-catch: {swParse.ElapsedMilliseconds} ms");
        // int.TryParse
        var swTryParse = Stopwatch.StartNew();
        for (int i = 0; i < 100000; i++)
        {
            foreach (var input in inputs)
            {
                int.TryParse(input, out dummy);
            }
        }
        swTryParse.Stop();
        Console.WriteLine($"TryParse: {swTryParse.ElapsedMilliseconds} ms");
    }
}

実行結果例(環境により異なります)：

Parse+try-catch: 782 ms
TryParse: 2 ms

このように、例外処理を伴うint.Parseは失敗時のコストが非常に高く、int.TryParseのほうが圧倒的に高速です。

失敗が予想される入力にはTryParseを使うことがベストプラクティスです。

BenchmarkDotNet で数値比較

より正確なパフォーマンス測定には、BenchmarkDotNetというベンチマークライブラリを使うのが便利です。

BenchmarkDotNetは詳細な統計情報や環境情報を提供し、信頼性の高い測定が可能です。

以下はBenchmarkDotNetを使ったint.Parseとint.TryParseの比較例です。

using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class ParseBenchmark
{
    private string[] inputs = { "123", "abc", "456", "def", "789" };
    private int dummy;
    [Benchmark]
    public void ParseWithTryCatch()
    {
        foreach (var input in inputs)
        {
            try
            {
                dummy = int.Parse(input);
            }
            catch
            {
                // 例外は無視
            }
        }
    }
    [Benchmark]
    public void TryParse()
    {
        foreach (var input in inputs)
        {
            int.TryParse(input, out dummy);
        }
    }
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<ParseBenchmark>();
    }
}

このコードを実行すると、ParseWithTryCatchとTryParseの詳細な実行時間やメモリ使用量がレポートされます。

一般的にTryParseのほうが高速かつメモリ効率が良い結果が得られます。

メモリアロケーションを減らす工夫

パフォーマンス最適化では、CPU時間だけでなくメモリアロケーションも重要です。

文字列変換時に不要な文字列コピーやインスタンス生成を減らすことでGC負荷を軽減できます。

Span<char>の活用

Span<char>を使うと、文字列の部分参照をコピーせずに扱えます。

これにより、トリムや部分抽出を効率的に行い、メモリ割り当てを減らせます。

正規化や前処理の最適化

変換前の正規化処理(例：Normalize(NFKC))は必要ですが、頻繁に呼び出す場合は結果をキャッシュするなど工夫すると良いでしょう。

例外処理の回避

例外はスタックトレースの生成などで多くのメモリを消費します。

TryParseを使い例外を避けること自体がメモリ効率の向上につながります。

文字列の再利用

可能な限り同じ文字列インスタンスを使い回すことで、メモリの断片化や割り当てを抑制できます。

これらの工夫を組み合わせることで、数値変換処理のパフォーマンスとメモリ効率を大幅に改善できます。

特に大量データのバッチ処理やリアルタイム処理では効果が顕著です。

新しい C# 機能との連携

C#の最新バージョンでは、コードの可読性や安全性を高めるための新機能が多数追加されています。

文字列から整数への変換処理においても、これらの機能を活用することで、より簡潔で堅牢な実装が可能になります。

パターンマッチングで分岐を簡潔に

パターンマッチングは、条件分岐をより直感的かつ簡潔に記述できる機能です。

is演算子やswitch文で型や値のパターンを判定し、処理を分けることができます。

以下は、文字列の変換結果をパターンマッチングで判定し、成功・失敗を簡潔に処理する例です。

using System;
class Program
{
    static void Main()
    {
        string input = "-123";
        if (int.TryParse(input, out int number) is true)
        {
            Console.WriteLine($"変換成功: {number}");
        }
        else
        {
            Console.WriteLine("変換に失敗しました。");
        }
        // 型パターンを使った例
        object obj = input;
        if (obj is string s && int.TryParse(s, out int n))
        {
            Console.WriteLine($"パターンマッチング成功: {n}");
        }
    }
}

変換成功: -123
パターンマッチング成功: -123

このように、is演算子とパターンマッチングを組み合わせることで、条件分岐がスッキリし、ネストが浅くなります。

switch 式で結果を返す設計

C# 8.0以降で導入されたswitch式は、従来のswitch文よりも式として値を返せるため、関数の戻り値を直接返す設計に適しています。

以下は、文字列を整数に変換し、成功・失敗に応じて異なる値を返す例です。

using System;
class Program
{
    static int ParseOrDefault(string input) =>
        input switch
        {
            null => 0,
            "" => 0,
            _ when int.TryParse(input, out int n) => n,
            _ => -1 // 変換失敗時のデフォルト値
        };
    static void Main()
    {
        string[] inputs = { "123", null, "", "abc" };
        foreach (var input in inputs)
        {
            int result = ParseOrDefault(input);
            Console.WriteLine($"入力: {input ?? "null"}, 結果: {result}");
        }
    }
}

入力: 123, 結果: 123
入力: null, 結果: 0
入力: , 結果: 0
入力: abc, 結果: -1

switch式を使うことで、複数の条件を簡潔にまとめて処理でき、コードの見通しが良くなります。

Nullable Reference Types で安全性向上

C# 8.0で導入されたNullable Reference Types(NRT)は、参照型の変数がnullを許容するかどうかを明示的に示す機能です。

これにより、null参照による例外をコンパイル時に検出しやすくなります。

文字列から整数への変換では、入力文字列がnullである可能性があるため、NRTを活用して安全に扱うことが推奨されます。

#nullable enable
using System;
class Program
{
    static int ParseSafe(string? input)
    {
        if (string.IsNullOrWhiteSpace(input))
        {
            return 0;
        }
        return int.TryParse(input, out int number) ? number : -1;
    }
    static void Main()
    {
        string? input1 = null;
        string? input2 = "456";
        Console.WriteLine(ParseSafe(input1)); // 出力: 0
        Console.WriteLine(ParseSafe(input2)); // 出力: 456
    }
}

0
456

NRTを有効にすると、string?のようにnull許容型を明示でき、nullチェックを怠ると警告が出るため、null安全なコードを書く習慣が身につきます。

これにより、変換処理の信頼性が向上します。

よくある落とし穴と対策一覧

文字列から整数への変換は一見シンプルですが、実際にはさまざまな落とし穴が存在します。

ここでは特に多く見られる問題点とその対策をまとめて解説します。

トリム漏れによる失敗

文字列の先頭や末尾に空白やタブなどのホワイトスペースが含まれている場合、int.Parseやint.TryParseは基本的に自動でトリム(除去)しますが、特殊な空白文字や全角スペースが混入していると変換に失敗することがあります。

また、手動でトリムを行わずに変換処理を行うと、意図しない文字列が含まれているためにFormatExceptionが発生することもあります。

対策例

変換前にString.Trim()やString.TrimStart(), String.TrimEnd()で明示的にトリムを行います
String.IsNullOrWhiteSpaceで空白のみの文字列を事前に除外します
全角スペースなど特殊な空白文字も考慮し、必要に応じて正規表現で除去します

string input = "　 123 "; // 全角スペースと半角スペース混在
string trimmed = input.Trim().Replace("　", ""); // 全角スペースを除去してからトリム
if (int.TryParse(trimmed, out int number))
{
    Console.WriteLine(number);
}
else
{
    Console.WriteLine("変換失敗");
}

文化依存のカンマ・ピリオド問題

数値の表記は文化圏によって異なり、カンマ,やピリオド.の使い方が変わります。

例えば、日本やアメリカではカンマが千区切り、小数点がピリオドですが、ドイツなど一部の国では逆になります。

このため、int.Parseやdouble.ParseでCultureInfoを指定しないと、誤った解釈や例外が発生します。

対策例

変換時に適切なCultureInfoを指定します
可能であればCultureInfo.InvariantCultureを使い、文化に依存しない一貫したフォーマットで処理します
ユーザー入力の場合は、入力フォームで文化圏に合わせたフォーマットを強制します

using System.Globalization;
string input = "1.234.567"; // ドイツ式の千区切り
var culture = new CultureInfo("de-DE");
if (int.TryParse(input, NumberStyles.AllowThousands, culture, out int number))
{
    Console.WriteLine(number); // 1234567
}
else
{
    Console.WriteLine("変換失敗");
}

桁数オーバーによる例外

int型は32ビット符号付き整数で、表現できる範囲は-2,147,483,648から2,147,483,647までです。

これを超える数値を変換しようとするとOverflowExceptionが発生します。

特に外部データやユーザー入力で大きな数値が混入している場合は注意が必要です。

対策例

変換前に文字列の長さや数値の範囲をチェックします
long型やBigInteger型への変換を検討します
TryParseを使い、例外を避けて安全に判定します

string input = "3000000000"; // int.MaxValueを超える
if (long.TryParse(input, out long longValue))
{
    if (longValue >= int.MinValue && longValue <= int.MaxValue)
    {
        int intValue = (int)longValue;
        Console.WriteLine($"intに変換可能: {intValue}");
    }
    else
    {
        Console.WriteLine("intの範囲外の数値です。");
    }
}
else
{
    Console.WriteLine("数値として無効な文字列です。");
}