C#のout varとは？使い方・out引数との違い・エラー例を初心者向けに解説
はじめに
C#を学んでいると、int.TryParseやDictionary.TryGetValueなどでよく見かけるのがout varです。
C#if (int.TryParse(text, out var number))
{
Console.WriteLine(number);
}
このようなコードを見て、「outとは何か」「varとは何が違うのか」「out varはいつ使うのか」と疑問に思う初心者は多いです。
out varは、C#でout引数を使うときに、変数宣言をその場で簡潔に書ける構文です。特に、値の変換に失敗する可能性がある処理や、辞書から安全に値を取得する処理でよく使われます。
この記事では、C#のout varについて、基本的な意味、使い方、out引数との違い、スコープ、型推論、よくあるエラー例まで初心者向けに解説します。
1. C#のout varとは？
1-1. out varの基本的な意味
out varとは、out引数で値を受け取る変数を、その場でvarを使って宣言する書き方です。
たとえば、次のコードを見てください。
C#int.TryParse("123", out var number);
このコードでは、文字列"123"を数値に変換し、その結果をnumberという変数で受け取っています。
out var numberの意味は、次のように考えると分かりやすいです。
C#int number;
int.TryParse("123", out number);
従来は、out引数に渡す変数を事前に宣言する必要がありました。しかし、out varを使うと、メソッド呼び出しの中で変数宣言まで同時に行えます。
つまり、out varは「outで値を受け取る変数を、その場で作る書き方」です。
1-2. out varが使えるようになったC#のバージョン
out varは、C# 7.0から使えるようになった機能です。
C# 7.0より前のバージョンでは、次のように事前に変数を宣言する必要がありました。
C#int number;
bool result = int.TryParse("123", out number);
C# 7.0以降では、次のように書けます。
C#bool result = int.TryParse("123", out var number);
現在のC#では一般的に使われる書き方ですが、古いプロジェクトや古い言語バージョンを指定している環境では、out varが使えない場合があります。
1-3. out varを使うと何が便利になるのか
out varを使う最大のメリットは、コードが短く読みやすくなることです。
従来の書き方では、変数宣言とメソッド呼び出しが分かれていました。
C#int number;
if (int.TryParse(input, out number))
{
Console.WriteLine(number);
}
out varを使うと、次のように1行で変数宣言と値の受け取りを行えます。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
特に、TryParseのように「成功したら値を使う」という処理では、out varを使うことで自然な流れでコードを書けます。
また、varによって型が自動推論されるため、intやstringなどの型を明示しなくても済みます。
1-4. 初心者が混同しやすいout・var・out varの違い
out、var、out varは似て見えますが、それぞれ役割が違います。
outは、メソッドから追加の値を受け取るためのキーワードです。
C#int.TryParse("123", out number);
varは、変数の型をコンパイラに推論させるためのキーワードです。
C#var name = "Taro";
var age = 20;
out varは、out引数で使う変数を、その場でvarにより宣言する構文です。
C#int.TryParse("123", out var number);
つまり、out varはoutとvarを組み合わせた書き方です。outだけでもvarだけでも同じ意味にはなりません。
2. out varの基本的な使い方
2-1. out varを使わない従来の書き方
まずは、out varを使わない従来の書き方を確認しましょう。
C#string text = "100";
int number;
bool success = int.TryParse(text, out number);
if (success)
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("変換できませんでした");
}
このコードでは、int.TryParseを使って文字列を整数に変換しています。
TryParseは、変換に成功したかどうかをboolで返します。そして、変換に成功した場合の数値をout引数で受け取ります。
この書き方では、numberをメソッド呼び出しの前に宣言しておく必要があります。
2-2. out varを使ったシンプルな書き方
同じ処理をout varで書くと、次のようになります。
C#string text = "100";
bool success = int.TryParse(text, out var number);
if (success)
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("変換できませんでした");
}
out var numberと書くことで、numberという変数をその場で宣言しています。
さらに、TryParseはif文と一緒に使われることが多いため、次のように書くとより自然です。
C#string text = "100";
if (int.TryParse(text, out var number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("変換できませんでした");
}
この書き方では、「変換に成功したらnumberを使う」という処理の流れが分かりやすくなります。
2-3. int.TryParseでout varを使う例
out varの代表的な使い方が、int.TryParseです。
C#string input = "25";
if (int.TryParse(input, out var age))
{
Console.WriteLine($"年齢は{age}歳です");
}
else
{
Console.WriteLine("年齢を正しく入力してください");
}
int.TryParseは、文字列を整数に変換できるかどうかを判定します。
変換に成功した場合はtrueを返し、変換後の値をageに代入します。変換に失敗した場合はfalseを返します。
C#string input = "abc";
if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("数値ではありません");
}
この場合、"abc"は整数に変換できないため、else側の処理が実行されます。
2-4. TryGetValueでout varを使う例
DictionaryのTryGetValueでもout varはよく使われます。
C#var scores = new Dictionary<string, int>
{
{ "Taro", 80 },
{ "Hanako", 95 }
};
if (scores.TryGetValue("Taro", out var score))
{
Console.WriteLine($"点数は{score}点です");
}
else
{
Console.WriteLine("データが見つかりませんでした");
}
TryGetValueは、指定したキーが存在するかどうかを調べます。キーが存在する場合はtrueを返し、対応する値をout引数で受け取ります。
存在しないキーを指定した場合でも例外が発生しないため、安全に値を取得できます。
C#if (scores.TryGetValue("Jiro", out var jiroScore))
{
Console.WriteLine(jiroScore);
}
else
{
Console.WriteLine("Jiroの点数は登録されていません");
}
辞書から値を取り出すときは、dictionary[key]で直接アクセスするよりも、TryGetValueを使った方が安全な場面があります。
2-5. メソッドの戻り値とout varの関係
out varを使うメソッドでは、「戻り値」と「out引数で受け取る値」の2種類の結果があることが多いです。
たとえば、int.TryParseでは次のようになります。
C#bool success = int.TryParse("123", out var number);
この場合、戻り値のsuccessは「変換に成功したかどうか」を表します。
一方、out var numberで受け取るnumberは「変換後の数値」を表します。
つまり、戻り値とout varは別の役割を持っています。
C#if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
このコードでは、戻り値のtrueまたはfalseをif文で判定し、成功した場合だけnumberを使っています。
3. out引数とは？out varとの違い
3-1. out引数の役割
out引数とは、メソッドの中で値を代入して、呼び出し元に返すための引数です。
通常、メソッドの戻り値は1つだけです。
C#int Add(int a, int b)
{
return a + b;
}
しかし、メソッドから複数の情報を返したい場合があります。そのようなときにout引数を使うことがあります。
C#void GetName(out string firstName, out string lastName)
{
firstName = "Taro";
lastName = "Yamada";
}
このメソッドは戻り値を返していませんが、out引数を通じてfirstNameとlastNameに値を返しています。
3-2. out引数を使うメソッドの特徴
out引数を使うメソッドには、いくつかの特徴があります。
まず、メソッド側ではout引数に必ず値を代入する必要があります。
C#void SetValue(out int value)
{
value = 10;
}
次のように、値を代入しないままメソッドを終了しようとするとエラーになります。
C#void SetValue(out int value)
{
// valueに代入していないためエラー
}
また、呼び出し側ではoutキーワードを付けて引数を渡します。
C#SetValue(out var result);
Console.WriteLine(result);
out引数は、呼び出し元の変数にメソッド内から値を設定するための仕組みです。
3-3. out varはout引数を簡潔に書くための構文
out varは、out引数そのものとは少し違います。
out引数は、メソッド定義や呼び出しで使う仕組みです。
C#void GetValue(out int value)
{
value = 100;
}
一方、out varは、呼び出し側でout引数に渡す変数をその場で宣言するための書き方です。
C#GetValue(out var value);
つまり、out varは新しい種類の引数ではありません。out引数を簡潔に書くための構文です。
3-4. out varと事前に変数を宣言する書き方の違い
次の2つのコードは、基本的に同じような意味です。
C#int number;
bool success = int.TryParse("123", out number);
C#bool success = int.TryParse("123", out var number);
違いは、変数を事前に宣言するか、メソッド呼び出しの中で宣言するかです。
事前に宣言する書き方は、変数の型や存在が明確です。
C#int number;
out varを使う書き方は、コードが短くなります。
C#out var number
一般的には、TryParseやTryGetValueのように一時的な値を受け取る場面ではout varがよく使われます。
3-5. out varとref引数の違い
outと似たものにrefがあります。どちらもメソッドを通じて呼び出し元の変数に影響を与えますが、役割が違います。
out引数は、呼び出し前に変数へ値が入っていなくても使えます。メソッド内で必ず値を代入する必要があります。
C#void SetNumber(out int number)
{
number = 10;
}
ref引数は、呼び出し前に変数へ値が入っている必要があります。メソッド内でその値を読み取ったり、変更したりできます。
C#void AddOne(ref int number)
{
number++;
}
int value = 10;
AddOne(ref value);
Console.WriteLine(value);
outは「メソッドから値を受け取る」ために使います。refは「既存の値をメソッドに渡し、必要に応じて変更する」ために使います。
out varはout引数で使う構文なので、ref varのような同じ感覚では使えません。
4. out varのスコープと型推論
4-1. out varで宣言した変数を使える範囲
out varで宣言した変数には、使える範囲、つまりスコープがあります。
たとえば、次のコードでは、numberはif文の中で使えます。
C#if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
さらに、out varで宣言した変数は、宣言した場所を含むブロック内で使える場合があります。
C#if (int.TryParse("123", out var number))
{
Console.WriteLine($"成功: {number}");
}
Console.WriteLine($"結果: {number}");
このように、if文の条件式で宣言したnumberを、if文の後で使えることがあります。
ただし、コードの構造によってはスコープが変わるため、初心者は「どこまで使えるのか」を意識することが大切です。
4-2. if文の中でout varを使った場合のスコープ
if文でout varを使う場合、よくある書き方は次の通りです。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("変換に失敗しました");
}
このコードでは、numberはifブロックの中で使えます。
また、次のようにif文の後で使うこともできます。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine("変換成功");
}
Console.WriteLine(number);
ただし、この場合は注意が必要です。変換に失敗した場合でも、number自体は存在します。しかし、意味のある値として扱ってよいとは限りません。
そのため、初心者のうちは、out varで受け取った値は成功したブロックの中で使うのがおすすめです。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
この書き方の方が、安全で読みやすいコードになります。
4-3. out varの型はどのように決まるのか
out varの型は、呼び出すメソッドのout引数の型から自動的に決まります。
たとえば、int.TryParseのout引数はint型です。
C#int.TryParse("123", out var number);
この場合、numberはint型として扱われます。
C#Console.WriteLine(number + 10);
Dictionary<string, int>のTryGetValueであれば、値の型がintなので、out varで宣言した変数もint型になります。
C#var scores = new Dictionary<string, int>();
scores.TryGetValue("Taro", out var score);
この場合、scoreはint型です。
一方、Dictionary<string, string>であれば、out varの型はstringになります。
C#var names = new Dictionary<string, string>();
names.TryGetValue("id001", out var name);
このように、out varの型は右側の処理内容からコンパイラが判断します。
4-4. varではなく明示的な型を書くべきケース
out varは便利ですが、常にvarを使えばよいわけではありません。
型を明示した方が読みやすい場合は、次のように書くこともできます。
C#int.TryParse("123", out int number);
out int numberと書くことで、numberがint型であることが一目で分かります。
特に、次のような場面では型を明示した方が分かりやすいです。
C#someObject.TryGetValue("key", out Customer customer);
varを使うと型が分かりにくい場合は、明示的に型を書くことで可読性が上がります。
C#someObject.TryGetValue("key", out var customer);
このコードだけを見てcustomerの型がすぐ分からない場合は、out Customer customerのように書いた方が親切です。
4-5. discard（_）を使って不要なout値を無視する方法
out引数で値を受け取れるものの、その値を使わない場合があります。
たとえば、「文字列が数値に変換できるかだけ知りたい」場合です。
C#bool isNumber = int.TryParse("123", out _);
out _の_はdiscardと呼ばれ、不要な値を捨てるために使います。
C#if (int.TryParse(input, out _))
{
Console.WriteLine("数値です");
}
else
{
Console.WriteLine("数値ではありません");
}
このコードでは、変換後の数値そのものは使っていません。必要なのは、変換できたかどうかだけです。
不要な変数を作らずに済むため、コードの意図が分かりやすくなります。
5. out varでよくあるエラー例と解決方法
5-1. 「現在のコンテキストに名前が存在しません」の原因
out varで宣言した変数のスコープ外で使おうとすると、「現在のコンテキストに名前が存在しません」というエラーが出ることがあります。
たとえば、次のようなケースです。
C#void Test()
{
if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
}
Console.WriteLine(number);
numberはTestメソッドの中で宣言されています。そのため、メソッドの外では使えません。
解決するには、変数を使う場所をスコープ内にする必要があります。
C#void Test()
{
if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
Console.WriteLine(number);
}
ただし、実際には成功したときだけ値を使う方が安全です。
C#void Test()
{
if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
}
5-2. 「out引数は代入可能な変数である必要があります」の原因
out引数には、代入可能な変数を渡す必要があります。
次のようなコードはエラーになります。
C#int.TryParse("123", out 10);
10は値そのものであり、変数ではありません。そのため、メソッドが結果を代入できません。
また、プロパティや計算式など、状況によってはout引数として使えないものもあります。
正しくは、変数を渡します。
C#int.TryParse("123", out var number);
または、事前に変数を宣言します。
C#int number;
int.TryParse("123", out number);
out引数には「結果を入れる箱」が必要だと考えると分かりやすいです。
5-3. 型が合わない場合のエラー
out引数に渡す変数の型が、メソッドが求める型と合わない場合はエラーになります。
C#string text;
int.TryParse("123", out text);
int.TryParseのout引数はint型である必要があります。しかし、上のコードではstring型のtextを渡しているためエラーになります。
正しくは次のように書きます。
C#int number;
int.TryParse("123", out number);
out varを使えば、型は自動的に推論されるため、このような型の不一致を避けやすくなります。
C#int.TryParse("123", out var number);
この場合、numberは自動的にint型になります。
5-4. C#のバージョンが古くてout varが使えない場合
古いC#のバージョンでは、out varが使えません。
たとえば、次のコードがエラーになる場合があります。
C#int.TryParse("123", out var number);
この場合は、プロジェクトのC#言語バージョンが古い可能性があります。
解決方法は主に2つあります。
1つ目は、従来の書き方に変更する方法です。
C#int number;
int.TryParse("123", out number);
2つ目は、プロジェクトのC#言語バージョンを上げる方法です。
古い環境で学習している場合や、古いプロジェクトを保守している場合は、out varが使えないこともあるため注意しましょう。
5-5. 同じ名前の変数を重複して宣言した場合のエラー
同じスコープ内で、同じ名前の変数を重複して宣言するとエラーになります。
C#if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
var number = 456;
すでにout var numberでnumberを宣言しているため、同じスコープで再度var numberと宣言するとエラーになります。
解決するには、別の名前にするか、既存の変数をそのまま使います。
C#if (int.TryParse("123", out var number))
{
Console.WriteLine(number);
}
number = 456;
Console.WriteLine(number);
または、名前を変えます。
C#if (int.TryParse("123", out var parsedNumber))
{
Console.WriteLine(parsedNumber);
}
var number = 456;
変数名は、役割が分かる名前にすると読みやすくなります。
5-6. if文の外で変数を使うときの注意点
out varで宣言した変数をif文の外で使うことはできますが、必ずしもおすすめとは限りません。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine("変換成功");
}
Console.WriteLine(number);
このコードでは、TryParseが失敗した場合でもnumberを使っています。
しかし、変換に失敗した場合のnumberは、期待した値ではない可能性があります。
そのため、基本的には成功した場合のブロック内で使う方が安全です。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("変換できませんでした");
}
どうしてもif文の外で使いたい場合は、成功したかどうかを表す変数も一緒に扱うとよいでしょう。
C#bool success = int.TryParse(input, out var number);
if (success)
{
Console.WriteLine(number);
}
6. out varを使うメリット・デメリット
6-1. コードが短く読みやすくなる
out varを使うと、変数宣言とメソッド呼び出しをまとめて書けます。
従来の書き方です。
C#int number;
bool success = int.TryParse(input, out number);
out varを使った書き方です。
C#bool success = int.TryParse(input, out var number);
特に、if文と組み合わせると読みやすくなります。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
「変換できたら値を使う」という処理を、自然な形で表現できます。
6-2. 不要な変数宣言を減らせる
out varを使うと、メソッド呼び出しの前に変数を宣言する必要がありません。
C#int number;
このような事前宣言を省略できるため、コードの行数が減ります。
特に、一時的にしか使わない変数であれば、out varを使うことで余計な変数宣言を避けられます。
C#if (dictionary.TryGetValue("key", out var value))
{
Console.WriteLine(value);
}
このように、必要な場所で必要な変数を宣言できるのがout varの便利な点です。
6-3. 型を自動推論できる
out varでは、変数の型をコンパイラが自動的に判断します。
C#int.TryParse("123", out var number);
この場合、numberはint型です。
C#double.TryParse("3.14", out var value);
この場合、valueはdouble型です。
型を毎回書かなくてよいため、コードがすっきりします。
ただし、型が分かりにくくなる場合もあるため、読みやすさを優先して明示的な型を書くことも大切です。
6-4. スコープが分かりにくくなる場合がある
out varは便利ですが、スコープが分かりにくくなる場合があります。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
Console.WriteLine(number);
このようなコードでは、numberがどこまで使えるのかを初心者が誤解しやすいです。
また、if文の外で使えるとしても、その値が有効なものかどうかは別問題です。
TryParseが失敗した場合に、その値を使ってよいのかを考える必要があります。
そのため、初心者のうちはout varで受け取った変数は、できるだけ成功したブロック内で使うのがおすすめです。
6-5. 初心者には処理の流れが見えにくい場合がある
out varはコードを短くできますが、初心者には処理の流れが見えにくくなることがあります。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
慣れている人には分かりやすいコードですが、初心者にとっては「戻り値はどれか」「numberにはいつ値が入るのか」が分かりにくいかもしれません。
学習の最初は、次のような従来の書き方も理解しておくとよいです。
C#int number;
bool success = int.TryParse(input, out number);
if (success)
{
Console.WriteLine(number);
}
この書き方を理解したうえでout varを使うと、仕組みがより分かりやすくなります。
7. out varを使うべき場面・使わない方がよい場面
7-1. TryParse系メソッドで使う
out varを使う代表的な場面は、TryParse系メソッドです。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
TryParse系メソッドは、変換できるかどうかをboolで返し、変換後の値をout引数で返します。
C#if (DateTime.TryParse(input, out var date))
{
Console.WriteLine(date);
}
C#if (double.TryParse(input, out var price))
{
Console.WriteLine(price);
}
このような処理では、out varを使うとコードが自然で読みやすくなります。
7-2. DictionaryのTryGetValueで使う
DictionaryのTryGetValueでも、out varは非常によく使われます。
C#var users = new Dictionary<int, string>
{
{ 1, "Taro" },
{ 2, "Hanako" }
};
if (users.TryGetValue(1, out var userName))
{
Console.WriteLine(userName);
}
TryGetValueを使うと、キーが存在しない場合でも例外を避けられます。
C#if (users.TryGetValue(3, out var name))
{
Console.WriteLine(name);
}
else
{
Console.WriteLine("ユーザーが見つかりません");
}
辞書から安全に値を取り出したい場合、TryGetValueとout varの組み合わせは定番です。
7-3. 一時的な値を受け取るときに使う
out varは、一時的な値を受け取るときに向いています。
C#if (GetUserName(out var name))
{
Console.WriteLine(name);
}
このように、その場で使うだけの値であれば、事前に変数を宣言するよりもout varの方がすっきりします。
特に、値を使う範囲が狭い場合には、out varを使うことでコードの見通しがよくなります。
C#if (TryFindProduct(id, out var product))
{
Console.WriteLine(product.Name);
}
一時的な結果を受け取る場面では、out varを積極的に使ってよいでしょう。
7-4. 型を明示した方が読みやすい場面
一方で、型を明示した方が読みやすい場面もあります。
C#if (repository.TryGetUser(id, out var user))
{
Console.WriteLine(user.Name);
}
このコードだけでは、userがどの型なのか分かりにくい場合があります。
そのような場合は、次のように型を明示してもよいです。
C#if (repository.TryGetUser(id, out User user))
{
Console.WriteLine(user.Name);
}
varを使うか、明示的な型を書くかは、コードを読む人にとって分かりやすいかどうかで判断しましょう。
7-5. 複数のout引数があるメソッドでの注意点
複数のout引数があるメソッドでは、out varを多用すると分かりにくくなる場合があります。
C#GetUserInfo(out var id, out var name, out var age);
このコードでは、短く書けますが、それぞれの型や意味が分かりにくいことがあります。
そのような場合は、型を明示することも検討しましょう。
C#GetUserInfo(out int id, out string name, out int age);
また、そもそも複数の値を返すなら、クラス、構造体、タプルなどを使った方が読みやすい場合もあります。
C#var user = GetUserInfo();
Console.WriteLine(user.Name);
out varは便利ですが、複数の値を扱う場面では、コード全体の設計も考えることが大切です。
8. out varの実践コード例
8-1. 文字列を数値に変換する例
次は、ユーザーの入力を数値に変換する例です。
C#string input = "30";
if (int.TryParse(input, out var age))
{
Console.WriteLine($"入力された年齢は{age}歳です");
}
else
{
Console.WriteLine("正しい数値を入力してください");
}
int.TryParseを使うことで、変換に失敗しても例外が発生しません。
C#string input = "abc";
if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("数値に変換できませんでした");
}
out varを使うと、変換後の値を必要な場所で簡潔に受け取れます。
8-2. Dictionaryから値を安全に取得する例
次は、Dictionaryから値を安全に取得する例です。
C#var prices = new Dictionary<string, int>
{
{ "apple", 150 },
{ "banana", 100 },
{ "orange", 120 }
};
string key = "apple";
if (prices.TryGetValue(key, out var price))
{
Console.WriteLine($"{key}の価格は{price}円です");
}
else
{
Console.WriteLine($"{key}は登録されていません");
}
prices[key]のように直接アクセスすると、キーが存在しない場合に例外が発生します。
C#Console.WriteLine(prices["melon"]);
安全に取得したい場合は、TryGetValueを使いましょう。
C#if (prices.TryGetValue("melon", out var melonPrice))
{
Console.WriteLine(melonPrice);
}
else
{
Console.WriteLine("melonは見つかりませんでした");
}
8-3. 独自メソッドでout varを使う例
out varは、標準ライブラリのメソッドだけでなく、自分で作ったメソッドでも使えます。
C#static bool TryDivide(int a, int b, out int result)
{
if (b == 0)
{
result = 0;
return false;
}
result = a / b;
return true;
}
このメソッドは、割り算ができる場合はtrueを返し、結果をresultに代入します。割る数が0の場合はfalseを返します。
呼び出し側では、次のようにout varを使えます。
C#if (TryDivide(10, 2, out var answer))
{
Console.WriteLine($"結果は{answer}です");
}
else
{
Console.WriteLine("割り算できません");
}
out引数を使うメソッドを自分で作る場合は、すべての処理ルートでout引数に値を代入する必要があります。
8-4. out varとif文を組み合わせる例
out varは、if文と組み合わせると特に便利です。
C#string input = "2026/06/19";
if (DateTime.TryParse(input, out var date))
{
Console.WriteLine($"日付は{date:yyyy年MM月dd日}です");
}
else
{
Console.WriteLine("日付として認識できません");
}
このように、変換に成功した場合だけ値を使う処理に向いています。
もう1つ例を見てみましょう。
C#var members = new Dictionary<string, int>
{
{ "Taro", 20 },
{ "Hanako", 22 }
};
if (members.TryGetValue("Hanako", out var age))
{
Console.WriteLine($"Hanakoは{age}歳です");
}
if文の条件式で成功判定を行い、同時に値を受け取れるため、コードがコンパクトになります。
8-5. out varとdiscardを組み合わせる例
変換後の値を使わず、成功したかどうかだけ知りたい場合は、discardを使います。
C#string input = "123";
if (int.TryParse(input, out _))
{
Console.WriteLine("数値です");
}
else
{
Console.WriteLine("数値ではありません");
}
このコードでは、変換後の数値は使いません。そのため、out var numberではなくout _と書いています。
Dictionary.TryGetValueでも、値を使わず存在確認だけしたい場合に使えます。
C#var users = new Dictionary<int, string>
{
{ 1, "Taro" },
{ 2, "Hanako" }
};
if (users.TryGetValue(1, out _))
{
Console.WriteLine("ユーザーが存在します");
}
不要な変数を作らないことで、コードの意図が明確になります。
9. out varに関するよくある質問
9-1. out varはいつから使えますか？
out varはC# 7.0から使えます。
C# 7.0より前の環境では、次のような書き方はできません。
C#int.TryParse("123", out var number);
古い環境では、次のように事前に変数を宣言します。
C#int number;
int.TryParse("123", out number);
現在のC#ではout varは一般的に使えるため、新しいプロジェクトでは積極的に使って問題ありません。
9-2. out varとvarは同じですか？
out varとvarは同じではありません。
varは、変数の型を自動推論するためのキーワードです。
C#var number = 10;
out varは、out引数で受け取る変数をその場で宣言する書き方です。
C#int.TryParse("123", out var number);
つまり、out varはout引数とvarを組み合わせた構文です。
9-3. out varで宣言した変数はif文の外でも使えますか？
使える場合があります。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
Console.WriteLine(number);
ただし、if文の外で使う場合は注意が必要です。
TryParseが失敗した場合でも変数自体は存在しますが、その値を意味のある値として扱ってよいとは限りません。
基本的には、成功した場合のブロック内で使う方が安全です。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
else
{
Console.WriteLine("変換できませんでした");
}
9-4. out varは必ず使った方がよいですか？
必ず使う必要はありません。
out varはコードを短くし、読みやすくするための便利な構文です。しかし、型を明示した方が分かりやすい場合や、初心者向けに処理を丁寧に書きたい場合は、従来の書き方でも問題ありません。
C#int number;
bool success = int.TryParse(input, out number);
この書き方の方が、変数宣言、変換処理、成功判定の流れを理解しやすい場合もあります。
コードの短さだけでなく、読みやすさを基準に選ぶことが大切です。
9-5. out varを使うとパフォーマンスは変わりますか？
通常、out varを使ってもパフォーマンスが大きく変わることはありません。
out varは、主にコードの書き方を簡潔にするための構文です。
次の2つは、基本的に同じ目的のコードです。
C#int number;
int.TryParse("123", out number);
C#int.TryParse("123", out var number);
どちらを使うかは、パフォーマンスよりも可読性や書きやすさで判断して問題ありません。
まとめ
out varは、C#でout引数を使うときに、変数宣言をその場で簡潔に書ける構文です。
従来は、out引数で値を受け取るために、事前に変数を宣言する必要がありました。
C#int number;
int.TryParse("123", out number);
C# 7.0以降では、次のようにout varを使ってシンプルに書けます。
C#int.TryParse("123", out var number);
out varは、特にint.TryParseやDictionary.TryGetValueのようなメソッドでよく使われます。
C#if (int.TryParse(input, out var number))
{
Console.WriteLine(number);
}
C#if (dictionary.TryGetValue(key, out var value))
{
Console.WriteLine(value);
}
out varを使うメリットは、コードが短くなり、不要な変数宣言を減らせることです。一方で、スコープや型が分かりにくくなる場合もあるため、読みやすさを意識して使うことが大切です。
初心者のうちは、まずout引数の仕組みを理解し、そのうえでout varを使うとスムーズに理解できます。TryParseやTryGetValueなどの定番パターンから練習すると、実践的な使い方が身につきやすいでしょう。