【C#】FormatExceptionの原因を完全理解！TryParseと例外処理で安全に型変換する方法

using System;
class Program
{
    static void Main()
    {
        try
        {
            // 数値変換で不正な文字列を指定
            int number = int.Parse("abc"); // ここでFormatExceptionが発生
        }
        catch (FormatException ex)
        {
            Console.WriteLine("FormatExceptionが発生しました。");
            Console.WriteLine("エラーメッセージ: " + ex.Message);
        }
    }
}

FormatExceptionが発生しました。
エラーメッセージ: The input string 'abc' was not in a correct format.

using System;
class Program
{
    static void Main()
    {
        Console.Write("年齢を入力してください: ");
        string input = Console.ReadLine();
        try
        {
            int age = int.Parse(input); // 数値以外の入力で例外発生
            Console.WriteLine($"入力された年齢は {age} 歳です。");
        }
        catch (FormatException)
        {
            Console.WriteLine("入力が数値の形式ではありません。正しい数字を入力してください。");
        }
    }
}

年齢を入力してください: 25歳
入力が数値の形式ではありません。正しい数字を入力してください。

using System;
class Program
{
    static void Main()
    {
        string[] csvData = { "100", "200", "abc", "", "300" };
        foreach (var item in csvData)
        {
            try
            {
                int value = int.Parse(item); // "abc"や空文字で例外発生
                Console.WriteLine($"読み込んだ値: {value}");
            }
            catch (FormatException)
            {
                Console.WriteLine($"不正な数値データ: '{item}'");
            }
        }
    }
}

読み込んだ値: 100
読み込んだ値: 200
不正な数値データ: 'abc'
不正な数値データ: ''
読み込んだ値: 300

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string dateStr = "2023年04月01日";
        string format = "yyyy年MM月dd日";
        try
        {
            DateTime date = DateTime.ParseExact(dateStr, format, CultureInfo.InvariantCulture);
            Console.WriteLine($"変換成功: {date.ToShortDateString()}");
        }
        catch (FormatException)
        {
            Console.WriteLine("日付の形式が正しくありません。");
        }
    }
}

変換成功: 2023/04/01

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string isoDate = "2023-04-01T15:30:00Z";
        string format = "yyyy-MM-ddTHH:mm:ssZ";
        try
        {
            DateTime date = DateTime.ParseExact(isoDate, format, CultureInfo.InvariantCulture);
            Console.WriteLine($"ISO8601形式の変換成功: {date.ToString("u")}");
        }
        catch (FormatException)
        {
            Console.WriteLine("ISO8601形式の変換に失敗しました。");
        }
    }
}

ISO8601形式の変換成功: 2023-04-01 15:30:00Z

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string numberStr = "1,234.56"; // 英語圏の表記
        CultureInfo usCulture = new CultureInfo("en-US");
        CultureInfo jpCulture = new CultureInfo("ja-JP");
        try
        {
            double valueUS = double.Parse(numberStr, usCulture);
            Console.WriteLine($"USカルチャでの変換成功: {valueUS}");
        }
        catch (FormatException)
        {
            Console.WriteLine("USカルチャでの変換失敗");
        }
        try
        {
            double valueJP = double.Parse(numberStr, jpCulture);
            Console.WriteLine($"JPカルチャでの変換成功: {valueJP}");
        }
        catch (FormatException)
        {
            Console.WriteLine("JPカルチャでの変換失敗");
        }
    }
}

USカルチャでの変換成功: 1234.56
JPカルチャでの変換失敗

using System;
class Program
{
    static void Main()
    {
        string input = "123a";
        try
        {
            int number = int.Parse(input);
            Console.WriteLine($"変換成功: {number}");
        }
        catch (FormatException)
        {
            Console.WriteLine("変換に失敗しました。入力が数値ではありません。");
        }
    }
}

変換に失敗しました。入力が数値ではありません。

using System;
class Program
{
    static void Main()
    {
        string input = "123a";
        if (int.TryParse(input, out int number))
        {
            Console.WriteLine($"変換成功: {number}");
        }
        else
        {
            Console.WriteLine("変換に失敗しました。入力が数値ではありません。");
        }
    }
}

変換に失敗しました。入力が数値ではありません。

using System;
class Program
{
    static int? ParseNullableInt(string input)
    {
        if (int.TryParse(input, out int result))
        {
            return result;
        }
        else
        {
            return null;
        }
    }
    static void Main()
    {
        string[] inputs = { "100", "abc", "200" };
        foreach (var input in inputs)
        {
            int? value = ParseNullableInt(input);
            if (value.HasValue)
            {
                Console.WriteLine($"変換成功: {value.Value}");
            }
            else
            {
                Console.WriteLine($"変換失敗: '{input}' は数値ではありません。");
            }
        }
    }
}

変換成功: 100
変換失敗: 'abc' は数値ではありません。
変換成功: 200

using System;
class Program
{
    static void Main()
    {
        string input = "123";
        // 変数宣言をTryParseの引数内で行う
        if (int.TryParse(input, out int number))
        {
            Console.WriteLine($"変換成功: {number}");
        }
        else
        {
            Console.WriteLine("変換失敗");
        }
    }
}

変換成功: 123

using System;
class Program
{
    static void Main()
    {
        string input = "456";
        if (int.TryParse(input, out var number)) // C# 7.0以降で可能
        {
            Console.WriteLine($"変換成功: {number}");
        }
        else
        {
            Console.WriteLine("変換失敗");
        }
    }
}

変換成功: 456

using System;
static class StringExtensions
{
    public static int? ToNullableInt(this string s)
    {
        return int.TryParse(s, out int result) ? result : (int?)null;
    }
}
class Program
{
    static void Main()
    {
        string[] inputs = { "100", "abc", "200" };
        foreach (var input in inputs)
        {
            int? value = input.ToNullableInt();
            if (value.HasValue)
            {
                Console.WriteLine($"変換成功: {value.Value}");
            }
            else
            {
                Console.WriteLine($"変換失敗: '{input}' は数値ではありません。");
            }
        }
    }
}

変換成功: 100
変換失敗: 'abc' は数値ではありません。
変換成功: 200

using System;
class Program
{
    static bool ValidateAndParseInt(string input, out int result, out string errorMessage)
    {
        result = 0;
        errorMessage = string.Empty;
        if (string.IsNullOrWhiteSpace(input))
        {
            errorMessage = "入力が空です。数値を入力してください。";
            return false;
        }
        if (!int.TryParse(input, out result))
        {
            errorMessage = "入力が数値の形式ではありません。";
            return false;
        }
        return true;
    }
    static void Main()
    {
        string[] testInputs = { "", "abc", "123" };
        foreach (var input in testInputs)
        {
            if (ValidateAndParseInt(input, out int number, out string error))
            {
                Console.WriteLine($"変換成功: {number}");
            }
            else
            {
                Console.WriteLine($"エラー: {error}");
            }
        }
    }
}

エラー: 入力が空です。数値を入力してください。
エラー: 入力が数値の形式ではありません。
変換成功: 123

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string dateStr = "2023/04/01 15:30:00";
        string format = "yyyy/MM/dd HH:mm:ss";
        DateTime date = DateTime.ParseExact(dateStr, format, CultureInfo.InvariantCulture);
        Console.WriteLine(date.ToString("u")); // 2023-04-01 15:30:00Z
    }
}

2023-04-01 15:30:00Z

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string dateStr = "2023-04-01T15:30:45.123+09:00";
        string format = "yyyy-MM-dd'T'HH:mm:ss.fffzzz";
        if (DateTimeOffset.TryParseExact(dateStr, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto))
        {
            Console.WriteLine($"変換成功: {dto}");
            Console.WriteLine($"UTC時間: {dto.UtcDateTime}");
        }
        else
        {
            Console.WriteLine("変換失敗");
        }
    }
}

変換成功: 2023/04/01 15:30:45 +09:00
UTC時間: 2023/04/01 6:30:45

using System;
using System.Globalization;
using System.Threading;
class Program
{
    static void Main()
    {
        Console.WriteLine($"初期CurrentCulture: {Thread.CurrentThread.CurrentCulture.Name}");
        Console.WriteLine($"初期CurrentUICulture: {Thread.CurrentThread.CurrentUICulture.Name}");
        // スレッドカルチャをドイツに変更
        Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
        // UIカルチャをフランスに変更
        Thread.CurrentThread.CurrentUICulture = new CultureInfo("fr-FR");
        Console.WriteLine($"変更後CurrentCulture: {Thread.CurrentThread.CurrentCulture.Name}");
        Console.WriteLine($"変更後CurrentUICulture: {Thread.CurrentThread.CurrentUICulture.Name}");
        double number = 1234.56;
        Console.WriteLine(number.ToString()); // ドイツ式の小数点・桁区切りで表示
    }
}

初期CurrentCulture: ja-JP
初期CurrentUICulture: ja-JP
変更後CurrentCulture: de-DE
変更後CurrentUICulture: fr-FR
1234,56

using System;
using System.Globalization;
using System.Globalization;
class Program
{
    static void Main()
    {
        var builder = new CultureAndRegionInfoBuilder("ja-JP-Custom", CultureAndRegionModifiers.None);
        var baseCulture = new CultureInfo("ja-JP");
        builder.LoadDataFromCultureInfo(baseCulture);
        // 小数点記号をカンマに変更
        builder.NumberFormat.NumberDecimalSeparator = ",";
        // カスタムカルチャを登録(管理者権限が必要)
        builder.Register();
        // 登録したカスタムカルチャを使用
        var customCulture = new CultureInfo("ja-JP-Custom");
        Console.WriteLine(customCulture.NumberFormat.NumberDecimalSeparator); // ","
    }
}

using System;
using System.Globalization;
using System.Threading;
class Program
{
    static void Main()
    {
        string numberStr = "1,234.56";
        // 日本カルチャ(ja-JP)での解析(カンマは桁区切り、ドットは小数点)
        Thread.CurrentThread.CurrentCulture = new CultureInfo("ja-JP");
        double numberJP = double.Parse(numberStr);
        Console.WriteLine($"ja-JPで解析: {numberJP}");
        // ドイツカルチャ(de-DE)での解析(カンマは小数点、ドットは桁区切り)
        Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
        try
        {
            double numberDE = double.Parse(numberStr);
            Console.WriteLine($"de-DEで解析: {numberDE}");
        }
        catch (FormatException)
        {
            Console.WriteLine("de-DEでの解析に失敗しました。");
        }
    }
}

ja-JPで解析: 1234.56
de-DEでの解析に失敗しました。

using System;
class Program
{
    static void Main()
    {
        try
        {
            Console.WriteLine("数値を入力してください:");
            string input = Console.ReadLine();
            int number = int.Parse(input); // FormatExceptionが発生する可能性あり
            Console.WriteLine($"入力された数値は {number} です。");
        }
        catch (FormatException ex)
        {
            Console.WriteLine("入力が数値の形式ではありません。");
            Console.WriteLine($"エラー詳細: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("処理が終了しました。");
        }
    }
}

数値を入力してください:
abc
入力が数値の形式ではありません。
エラー詳細: Input string was not in a correct format.
処理が終了しました。

using System;
class Program
{
    static void Main()
    {
        try
        {
            string input = "abc";
            int number = int.Parse(input);
        }
        catch (FormatException ex) when (ex.Message.Contains("correct format"))
        {
            Console.WriteLine("フォーマットが正しくない入力です。");
        }
        catch (FormatException)
        {
            Console.WriteLine("その他のFormatExceptionが発生しました。");
        }
    }
}

フォーマットが正しくない入力です。

using System;
using System.IO;
class Program
{
    static void Main()
    {
        try
        {
            string input = "abc";
            int number = int.Parse(input);
        }
        catch (FormatException ex)
        {
            // ログファイルに例外情報を書き込む
            File.AppendAllText("error.log", $"{DateTime.Now}: {ex}\n");
            // ユーザーにわかりやすいメッセージを表示
            Console.WriteLine("入力が正しい数値形式ではありません。再度入力してください。");
        }
    }
}

入力が正しい数値形式ではありません。再度入力してください。

using System;
class Program
{
    static void Main()
    {
        int number = 123;
        // 正しいフォーマット指定子
        string correct = $"{number:D5}"; // 5桁のゼロ埋め
        Console.WriteLine(correct); // 00123
        // 誤ったフォーマット指定子(存在しない)
        try
        {
            string wrong = string.Format("{0:XZ}", number); // FormatException発生
            Console.WriteLine(wrong);
        }
        catch (FormatException ex)
        {
            Console.WriteLine("フォーマット指定子が不正です。");
            Console.WriteLine(ex.Message);
        }
    }
}

00123
フォーマット指定子が不正です。
Format specifier was invalid.

using System;
using System.Text.Json;
class Sample
{
    public DateTime Date { get; set; }
}
class Program
{
    static void Main()
    {
        string json = "{\"Date\":\"2023-13-01T00:00:00\"}"; // 月が13で不正
        try
        {
            var obj = JsonSerializer.Deserialize<Sample>(json);
        }
        catch (FormatException ex)
        {
            Console.WriteLine("シリアライズ時にFormatExceptionが発生しました。");
            Console.WriteLine(ex.Message);
        }
        catch (JsonException ex)
        {
            // JsonSerializerは通常JsonExceptionを投げるためこちらが捕捉されることが多い
            Console.WriteLine("JsonExceptionが発生しました。");
            Console.WriteLine(ex.Message);
        }
    }
}

JsonExceptionが発生しました。
The JSON value could not be converted to System.DateTime. Path: $.Date | LineNumber: 0 | BytePositionInLine: 18.

using System;
using System.Text.RegularExpressions;
class Program
{
    static bool IsValidDecimal(string input)
    {
        string pattern = @"^[+-]?(\d+)(\.\d+)?$";
        return Regex.IsMatch(input, pattern);
    }
    static void Main()
    {
        string[] testInputs = { "123", "-123.45", "+0.99", "12a", "1.2.3", "" };
        foreach (var input in testInputs)
        {
            Console.WriteLine($"{input}: {(IsValidDecimal(input) ? "有効" : "無効")}");
        }
    }
}

123: 有効
-123.45: 有効
+0.99: 有効
12a: 無効
1.2.3: 無効
: 無効

^\d{4}/(0[1-9]|1[0-2])/(0[1-9]|[12]\d|3[01])$

using System;
using System.Text.RegularExpressions;
class Program
{
    static bool IsValidDate(string input)
    {
        string pattern = @"^\d{4}/(0[1-9]|1[0-2])/(0[1-9]|[12]\d|3[01])$";
        return Regex.IsMatch(input, pattern);
    }
    static void Main()
    {
        string[] testDates = { "2023/04/01", "2023/13/01", "2023/02/30", "2023-04-01", "20230401" };
        foreach (var date in testDates)
        {
            Console.WriteLine($"{date}: {(IsValidDate(date) ? "有効" : "無効")}");
        }
    }
}

2023/04/01: 有効
2023/13/01: 無効
2023/02/30: 有効
2023-04-01: 無効
20230401: 無効

using System;
using System.Text.RegularExpressions;
class Program
{
    static Regex decimalRegex = new Regex(@"^[+-]?(\d+)(\.\d+)?$", RegexOptions.Compiled);
    static bool IsValidDecimal(string input)
    {
        return decimalRegex.IsMatch(input);
    }
    static void Main()
    {
        string input = "123.45";
        Console.WriteLine(IsValidDecimal(input) ? "有効" : "無効");
    }
}

有効

using System;
class Program
{
    static bool ValidateAge(string input, out int age)
    {
        age = 0;
        if (string.IsNullOrWhiteSpace(input))
        {
            Console.WriteLine("年齢を入力してください。");
            return false;
        }
        if (!int.TryParse(input, out age))
        {
            Console.WriteLine("年齢は数値で入力してください。");
            return false;
        }
        if (age < 0 || age > 150)
        {
            Console.WriteLine("年齢は0から150の範囲で入力してください。");
            return false;
        }
        return true;
    }
    static void Main()
    {
        Console.Write("年齢を入力してください: ");
        string input = Console.ReadLine();
        if (ValidateAge(input, out int age))
        {
            Console.WriteLine($"入力された年齢は {age} 歳です。");
        }
    }
}

年齢を入力してください: abc
年齢は数値で入力してください。

using System;
class Person
{
    private int _age;
    public int Age
    {
        get => _age;
        set
        {
            if (value < 0 || value > 150)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "年齢は0から150の範囲でなければなりません。");
            }
            _age = value;
        }
    }
    public Person(int age)
    {
        Age = age; // セッターで検証される
    }
}
class Program
{
    static void Main()
    {
        try
        {
            var person = new Person(200); // 例外発生
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"エラー: {ex.Message}");
        }
    }
}

エラー: 年齢は0から150の範囲でなければなりません。 (パラメーター名: value)

using System;
using FluentValidation;
class Person
{
    public int Age { get; set; }
}
class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor(person => person.Age)
            .InclusiveBetween(0, 150)
            .WithMessage("年齢は0から150の範囲で入力してください。");
    }
}
class Program
{
    static void Main()
    {
        var person = new Person { Age = 200 };
        var validator = new PersonValidator();
        var result = validator.Validate(person);
        if (!result.IsValid)
        {
            foreach (var failure in result.Errors)
            {
                Console.WriteLine($"検証エラー: {failure.ErrorMessage}");
            }
        }
        else
        {
            Console.WriteLine("検証成功");
        }
    }
}

検証エラー: 年齢は0から150の範囲で入力してください。

using System;
using NLog;
class Program
{
    private static readonly Logger logger = LogManager.GetCurrentClassLogger();
    static void Main()
    {
        try
        {
            int.Parse("abc"); // FormatException発生
        }
        catch (FormatException ex)
        {
            logger.Error(ex, "数値変換に失敗しました。入力値が不正です。");
            Console.WriteLine("エラーが発生しました。ログを確認してください。");
        }
    }
}

using System;
using Serilog;
class Program
{
    static void Main()
    {
        Log.Logger = new LoggerConfiguration()
            .WriteTo.Console()
            .WriteTo.File("log.txt")
            .CreateLogger();
        try
        {
            int.Parse("abc"); // FormatException発生
        }
        catch (FormatException ex)
        {
            Log.Error(ex, "数値変換に失敗しました。入力値が不正です。");
            Console.WriteLine("エラーが発生しました。ログを確認してください。");
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }
}

using System;
class Program
{
    static void MethodA()
    {
        try
        {
            int.Parse("abc");
        }
        catch (FormatException ex)
        {
            // throw; // スタックトレースを保持して再スロー
            throw ex; // スタックトレースがリセットされる
        }
    }
    static void Main()
    {
        try
        {
            MethodA();
        }
        catch (FormatException ex)
        {
            Console.WriteLine("例外メッセージ: " + ex.Message);
            Console.WriteLine("スタックトレース:\n" + ex.StackTrace);
        }
    }
}

using System;
using Xunit;
public class FormatExceptionTests
{
    [Fact]
    public void IntParse_InvalidString_ThrowsFormatException()
    {
        // Arrange
        string invalidInput = "abc";
        // Act & Assert
        var ex = Assert.Throws<FormatException>(() => int.Parse(invalidInput));
        Assert.Equal("Input string was not in a correct format.", ex.Message);
    }
}

using System;
using System.Collections.Generic;
using Xunit;
public class CsvProcessor
{
    public List<int> ParseNumbers(IEnumerable<string> lines)
    {
        var results = new List<int>();
        foreach (var line in lines)
        {
            results.Add(int.Parse(line)); // FormatExceptionが発生する可能性あり
        }
        return results;
    }
}
public class CsvProcessorTests
{
    [Fact]
    public void ParseNumbers_InvalidData_ThrowsFormatException()
    {
        // Arrange
        var processor = new CsvProcessor();
        var mockData = new List<string> { "100", "abc", "200" };
        // Act & Assert
        Assert.Throws<FormatException>(() => processor.ParseNumbers(mockData));
    }
}

Install-Package BenchmarkDotNet

using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class ParseBenchmarks
{
    private string validNumber = "12345";
    private string invalidNumber = "12a45";
    [Benchmark]
    public int Parse_Valid()
    {
        return int.Parse(validNumber);
    }
    [Benchmark]
    public bool TryParse_Valid()
    {
        return int.TryParse(validNumber, out _);
    }
    [Benchmark]
    public int Parse_Invalid()
    {
        try
        {
            return int.Parse(invalidNumber);
        }
        catch
        {
            return -1;
        }
    }
    [Benchmark]
    public bool TryParse_Invalid()
    {
        return int.TryParse(invalidNumber, out _);
    }
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<ParseBenchmarks>();
    }
}

using System;
using System.Globalization;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class CultureParseBenchmarks
{
    private string numberStr = "1,234.56";
    private CultureInfo invariant = CultureInfo.InvariantCulture;
    private CultureInfo jp = new CultureInfo("ja-JP");
    [Benchmark]
    public double Parse_DefaultCulture()
    {
        return double.Parse(numberStr);
    }
    [Benchmark]
    public double Parse_InvariantCulture()
    {
        return double.Parse(numberStr, invariant);
    }
    [Benchmark]
    public double Parse_JPCulture()
    {
        return double.Parse(numberStr, jp);
    }
}
class Program
{
    static void Main()
    {
        BenchmarkRunner.Run<CultureParseBenchmarks>();
    }
}

using System;
using Microsoft.AspNetCore.Mvc;
public class InputDto
{
    public string Quantity { get; set; } // 数値を文字列で受け取る
}
[ApiController]
[Route("api/[controller]")]
public class SampleController : ControllerBase
{
    [HttpPost("process")]
    public IActionResult ProcessData([FromBody] InputDto input)
    {
        if (!int.TryParse(input.Quantity, out int quantity))
        {
            return BadRequest("Quantityは有効な整数で入力してください。");
        }
        // 変換成功後の処理
        return Ok(new { Message = $"受け取った数量は {quantity} です。" });
    }
}

using System;
using System.IO;
class BatchProcessor
{
    public void ProcessFile(string filePath)
    {
        int lineNumber = 0;
        foreach (var line in File.ReadLines(filePath))
        {
            lineNumber++;
            if (int.TryParse(line, out int value))
            {
                Console.WriteLine($"Line {lineNumber}: 数値 {value} を処理しました。");
                // ここに処理ロジックを記述
            }
            else
            {
                Console.WriteLine($"Line {lineNumber}: 不正な数値データ '{line}' をスキップしました。");
                // ログファイルに記録することも推奨
            }
        }
    }
}
class Program
{
    static void Main()
    {
        var processor = new BatchProcessor();
        processor.ProcessFile("numbers.txt");
    }
}

Line 1: 数値 100 を処理しました。
Line 2: 不正な数値データ 'abc' をスキップしました。
Line 3: 数値 200 を処理しました。

using System;
using System.IO;
using System.Text.Json;
public class AppSettings
{
    public string TimeoutSeconds { get; set; }
}
class Program
{
    static void Main()
    {
        string json = File.ReadAllText("appsettings.json");
        var settings = JsonSerializer.Deserialize<AppSettings>(json);
        if (!int.TryParse(settings.TimeoutSeconds, out int timeout))
        {
            Console.WriteLine("設定ファイルのTimeoutSecondsが不正です。デフォルト値を使用します。");
            timeout = 30; // デフォルト値
        }
        Console.WriteLine($"タイムアウト設定: {timeout}秒");
    }
}

{
    "TimeoutSeconds": "60"
}

using System;
class Program
{
    static void Main()
    {
        string[] inputs = { "100", "abc", "200" };
        foreach (var input in inputs)
        {
            try
            {
                int value = int.Parse(input);
                Console.WriteLine($"変換成功: {value}");
            }
            catch (FormatException)
            {
                Console.WriteLine($"変換失敗: '{input}' は数値ではありません。");
            }
        }
    }
}

using System;
class Program
{
    static void Main()
    {
        string[] inputs = { "100", "abc", "200" };
        foreach (var input in inputs)
        {
            if (int.TryParse(input, out int value))
            {
                Console.WriteLine($"変換成功: {value}");
            }
            else
            {
                Console.WriteLine($"変換失敗: '{input}' は数値ではありません。");
            }
        }
    }
}

using System;
public static class StringExtensions
{
    public static int? ToNullableInt(this string s)
    {
        return int.TryParse(s, out int result) ? result : (int?)null;
    }
}
class Program
{
    static void Main()
    {
        string[] inputs = { "100", "abc", "200" };
        foreach (var input in inputs)
        {
            int? value = input.ToNullableInt();
            if (value.HasValue)
            {
                Console.WriteLine($"変換成功: {value.Value}");
            }
            else
            {
                Console.WriteLine($"変換失敗: '{input}' は数値ではありません。");
            }
        }
    }
}