C#のvarとは？使い方・型推論・使うべき場面と注意点を初心者向けに解説
はじめに
C#を学び始めると、変数宣言でよく見かけるのがvarです。
C#var number = 10;
var name = "Taro";
一見すると「型を書かなくてもよい便利な書き方」に見えますが、C#のvarは単なる省略記法ではありません。コンパイラが右辺の値から型を判断する「型推論」という仕組みによって成り立っています。
この記事では、C#のvarとは何か、基本的な使い方、型推論の仕組み、使うべき場面、注意点、dynamicやobjectとの違いまで、初心者向けにわかりやすく解説します。
1. C#のvarとは？初心者向けにわかりやすく解説
1-1. varは「型を省略できる」キーワード
C#のvarは、ローカル変数を宣言するときに型名の代わりに使える書き方です。
通常、C#では次のように型を明示して変数を宣言します。
C#int age = 20;
string name = "Taro";
これをvarで書くと、次のようになります。
C#var age = 20;
var name = "Taro";
intやstringといった型名を書かなくても、C#のコンパイラが自動的に型を判断してくれます。
1-2. varはコンパイラが右辺から型を推論する仕組み
varを使った場合、コンパイラは右辺の値を見て変数の型を決めます。
C#var count = 10;
この場合、右辺の10は整数リテラルなので、countはint型として扱われます。
C#var message = "Hello";
この場合、右辺の"Hello"は文字列なので、messageはstring型になります。
つまり、varは「型が何でもよくなる」という意味ではなく、「型をコンパイラに判断させる」という意味です。
1-3. varを使っても型がなくなるわけではない
初心者が誤解しやすいポイントとして、varを使うと変数の型がなくなると思ってしまうことがあります。
しかし、C#は静的型付け言語です。varを使っても、変数には必ず具体的な型が決まります。
C#var number = 10;
number = 20; // OK
number = "text"; // エラー
numberは最初にint型として推論されているため、後からstring型の値を代入することはできません。
1-4. varはC#のローカル変数で使う機能
varは主にメソッド内のローカル変数で使います。
C#void Sample()
{
var message = "こんにちは";
Console.WriteLine(message);
}
一方で、クラスのフィールド、プロパティ、メソッドの戻り値などには基本的に使えません。
C#class User
{
// var name = "Taro"; // エラー
}
varは便利ですが、使える場所が限られていることを覚えておきましょう。
2. C#のvarの基本的な使い方
2-1. varを使った変数宣言の基本構文
varを使った基本構文は次のとおりです。
C#var 変数名 = 値;
例を見てみましょう。
C#var price = 1000;
var productName = "Keyboard";
var isActive = true;
varを使う場合は、宣言と同時に値を代入する必要があります。右辺の値から型を推論するためです。
2-2. int・string・boolでのvarの使用例
基本的な型でvarを使う例です。
C#var age = 25;
var name = "Yamada";
var isMember = true;
Console.WriteLine(age);
Console.WriteLine(name);
Console.WriteLine(isMember);
このコードでは、次のように型が推論されます。
C#var age = 25; // int
var name = "Yamada"; // string
var isMember = true; // bool
varを使っていても、内部的にはint、string、boolとして扱われます。
2-3. 配列・List・Dictionaryでのvarの使用例
配列やコレクションでもvarはよく使われます。
C#var numbers = new int[] { 1, 2, 3 };
var names = new List<string>
{
"Taro",
"Hanako",
"Jiro"
};
var scores = new Dictionary<string, int>
{
{ "Taro", 80 },
{ "Hanako", 95 }
};
型を明示すると次のようになります。
C#int[] numbers = new int[] { 1, 2, 3 };
List<string> names = new List<string>();
Dictionary<string, int> scores = new Dictionary<string, int>();
List<string>やDictionary<string, int>のように型名が長い場合、varを使うとコードがすっきりします。
2-4. オブジェクト生成時にvarを使う例
クラスのインスタンスを生成するときにもvarはよく使います。
C#var user = new User();
右辺にnew User()と書かれているため、userがUser型であることは明確です。
C#User user = new User();
このように明示的に書いても意味は同じですが、右辺から型が明らかな場合はvarを使うと読みやすくなることがあります。
2-5. foreach文でvarを使う例
foreach文でもvarはよく使われます。
C#var names = new List<string> { "Taro", "Hanako", "Jiro" };
foreach (var name in names)
{
Console.WriteLine(name);
}
この場合、namesはList<string>なので、foreachで取り出されるnameはstring型になります。
明示的に書くと次のようになります。
C#foreach (string name in names)
{
Console.WriteLine(name);
}
要素の型が明らかな場合は、foreachでvarを使うと自然に書けます。
3. varの型推論の仕組み
3-1. コンパイラは右辺の値から型を決める
C#のvarでは、コンパイラが右辺の式を見て型を判断します。
C#var value = 100;
この場合、右辺の100がintとして扱われるため、valueもint型になります。
C#var value = 100.5;
この場合、右辺の100.5はdouble型なので、valueもdouble型になります。
3-2. var number = 10 がint型になる理由
次のコードを見てください。
C#var number = 10;
C#では、整数リテラルの10は通常int型として扱われます。そのため、numberの型もintになります。
C#number = 20; // OK
number = 1.5; // エラー
numberはint型なので、小数をそのまま代入することはできません。
小数を扱いたい場合は、次のように書きます。
C#var number = 10.0;
この場合、numberはdouble型になります。
3-3. var text = "Hello" がstring型になる理由
次のコードでは、textはstring型になります。
C#var text = "Hello";
ダブルクォーテーションで囲まれた文字列リテラルはstring型です。そのため、コンパイラはtextをstring型として推論します。
C#text = "World"; // OK
text = 123; // エラー
一度string型として決まった変数には、数値を代入できません。
3-4. 一度推論された型は後から変更できない
varで宣言した変数の型は、コンパイル時に決まります。そして、一度決まった型は後から変更できません。
C#var data = "Hello";
data = "C#"; // OK
data = 100; // エラー
dataは最初にstring型として推論されているため、後からint型の値を入れることはできません。
この点が、JavaScriptなどの動的型付け言語のvarとは大きく異なります。
3-5. IDEでvarの実際の型を確認する方法
Visual StudioやVisual Studio CodeなどのIDEでは、varの上にマウスカーソルを合わせると、実際に推論された型を確認できます。
C#var users = new List<string>();
このvarにカーソルを合わせると、List<string>のような型情報が表示されます。
初心者のうちは、varを使ったときに「この変数は何型になっているのか」をIDEで確認する習慣をつけると、型推論の理解が深まります。
4. varと明示的な型指定の違い
4-1. var name = "Taro" と string name = "Taro" の違い
次の2つのコードは、結果として同じ意味になります。
C#var name = "Taro";
C#string name = "Taro";
どちらの場合も、nameはstring型です。
違いは、型を人間が書くか、コンパイラに推論させるかです。
string name = "Taro"は型が明示されているため、コードを読んだ瞬間に型がわかります。一方で、var name = "Taro"も右辺を見れば文字列だとわかるため、十分に読みやすいコードです。
4-2. 実行時の動作やパフォーマンスに違いはあるのか
varを使っても、明示的な型指定をしても、実行時の動作やパフォーマンスに基本的な違いはありません。
C#var count = 10;
C#int count = 10;
この2つは、コンパイル後にはどちらもint型の変数として扱われます。
varは実行時に型を調べる仕組みではなく、コンパイル時に型が決まる仕組みです。そのため、「varを使うと遅くなる」という心配は基本的に不要です。
4-3. コードの読みやすさに与える影響
varはコードを短くできますが、使い方によっては読みやすさを下げることもあります。
読みやすい例です。
C#var user = new User();
var names = new List<string>();
右辺を見れば型がすぐにわかります。
読みにくい例です。
C#var result = GetData();
GetData()の戻り値が何型なのか、メソッド名だけでは判断しにくい場合があります。このような場合は、明示的に型を書いたほうが読みやすくなります。
C#List<User> result = GetData();
4-4. 初心者はvarと明示的な型指定をどう使い分けるべきか
初心者のうちは、次の基準で使い分けるとよいでしょう。
右辺を見て型がすぐにわかる場合はvarを使っても問題ありません。
C#var message = "Hello";
var user = new User();
一方で、右辺だけでは型がわかりにくい場合は、明示的に型を書くのがおすすめです。
C#List<User> users = GetUsers();
C#のvarは便利ですが、常に使えばよいわけではありません。大切なのは、コードを読む人にとってわかりやすいかどうかです。
5. varを使うべき場面
5-1. 右辺から型が明確にわかる場合
varを使うべき代表的な場面は、右辺から型が明確にわかる場合です。
C#var user = new User();
var order = new Order();
var product = new Product();
右辺に型名が書かれているため、左辺でも同じ型名を書くと少し冗長になります。
C#User user = new User();
Order order = new Order();
Product product = new Product();
このような場合、varを使うとコードがすっきりします。
5-2. 型名が長くてコードが冗長になる場合
ジェネリック型を使うと、型名が長くなることがあります。
C#Dictionary<string, List<int>> scores = new Dictionary<string, List<int>>();
varを使うと次のように短く書けます。
C#var scores = new Dictionary<string, List<int>>();
右辺に型が書かれているため、読みやすさを保ちながらコードを簡潔にできます。
5-3. LINQや匿名型を扱う場合
LINQを使う場面では、varがよく使われます。
C#var users = new[]
{
new { Name = "Taro", Age = 20 },
new { Name = "Hanako", Age = 25 }
};
var adultUsers = users.Where(user => user.Age >= 20);
また、匿名型を使う場合は、型名を明示できないためvarが必要になります。
C#var user = new { Name = "Taro", Age = 20 };
Console.WriteLine(user.Name);
Console.WriteLine(user.Age);
匿名型は一時的なデータの形を作るときに便利で、LINQと組み合わせて使われることが多いです。
5-4. foreachで要素の型が明らかな場合
foreachでコレクションを処理する場合、要素の型が明らかであればvarを使って問題ありません。
C#var names = new List<string> { "Taro", "Hanako", "Jiro" };
foreach (var name in names)
{
Console.WriteLine(name);
}
namesがList<string>なので、nameはstring型だとわかります。
コレクションの型が複雑な場合でも、foreachではvarを使うことでコードを簡潔にできます。
5-5. new演算子で型が右辺に書かれている場合
new演算子でオブジェクトを生成する場合、右辺に型名が書かれているため、varとの相性がよいです。
C#var customer = new Customer();
var repository = new UserRepository();
var service = new OrderService();
このようなコードでは、左辺に型を書かなくても意味が明確です。
ただし、インターフェース型として扱いたい場合は、明示的に型を書くこともあります。
C#IUserRepository repository = new UserRepository();
この場合は「変数をインターフェース型として扱いたい」という意図があるため、明示的な型指定のほうが適しています。
6. varを使わないほうがよい場面と注意点
6-1. 右辺だけでは型がわかりにくい場合
メソッドの戻り値を受け取る場合、varを使うと型がわかりにくくなることがあります。
C#var result = GetResult();
GetResult()が何を返すのか、名前だけでは判断できない場合があります。
このような場合は、型を明示したほうが読みやすくなります。
C#UserResult result = GetResult();
コードは書く時間よりも読む時間のほうが長いものです。読む人が迷う場合は、varを避ける判断も大切です。
6-2. 数値型の違いが重要な場合
数値型には、int、long、float、double、decimalなどがあります。
C#var value = 10;
この場合、valueはint型です。
C#var value = 10L;
この場合はlong型です。
C#var value = 10.0;
この場合はdouble型です。
C#var value = 10.0m;
この場合はdecimal型です。
金額計算などでdecimalを使いたい場合、var price = 100.0;と書くとdouble型になってしまいます。
C#var price = 100.0m; // decimal
数値型の違いが重要な場面では、明示的に型を書くか、リテラルの書き方に注意しましょう。
6-3. メソッドの戻り値の型が読み取りづらくなる場合
次のようなコードは、戻り値の型がわかりにくい場合があります。
C#var users = repository.GetActiveUsers();
メソッド名からある程度予想できる場合もありますが、List<User>なのか、IEnumerable<User>なのか、配列なのかはすぐにはわかりません。
型が重要な意味を持つ場合は、次のように明示的に書くと親切です。
C#IEnumerable<User> users = repository.GetActiveUsers();
特にチーム開発では、自分以外の人がコードを読むことを意識して使い分けましょう。
6-4. nullだけではvarを使えない
varは右辺から型を推論します。そのため、nullだけを代入することはできません。
C#var value = null; // エラー
nullだけでは、コンパイラが型を判断できないからです。
この場合は、明示的に型を書く必要があります。
C#string value = null;
User user = null;
6-5. 宣言だけして後から代入する使い方はできない
varでは、宣言だけして後から値を代入することはできません。
C#var name; // エラー
name = "Taro";
varは右辺の値から型を推論するため、宣言時に値が必要です。
正しくは次のように書きます。
C#var name = "Taro";
後から代入したい場合は、明示的に型を書きます。
C#string name;
name = "Taro";
6-6. フィールド・プロパティ・メソッドの戻り値には基本的に使えない
varはローカル変数で使う機能です。クラスのフィールドやプロパティ、メソッドの戻り値には使えません。
C#class Sample
{
// var count = 10; // エラー
// public var Name { get; set; } // エラー
// public var GetName() // エラー
// {
// return "Taro";
// }
}
これらの場合は、型を明示する必要があります。
C#class Sample
{
private int count = 10;
public string Name { get; set; }
public string GetName()
{
return "Taro";
}
}
varは便利ですが、どこでも使えるわけではありません。
7. varとdynamic・objectの違い
7-1. varとdynamicの違い
varとdynamicは混同されやすいですが、まったく異なる仕組みです。
C#var value = "Hello";
この場合、valueはコンパイル時にstring型として決まります。
C#dynamic value = "Hello";
この場合、valueは実行時に型やメンバーが判断されます。
varは型安全ですが、dynamicは実行時までエラーがわからないことがあります。
C#dynamic value = "Hello";
Console.WriteLine(value.NotExists()); // 実行時エラー
7-2. varとobjectの違い
objectは、C#のすべての型の基底型です。さまざまな型の値を入れることができます。
C#object value = "Hello";
value = 100;
一方、varは最初に推論された型で固定されます。
C#var value = "Hello";
value = 100; // エラー
objectは何でも入れられるように見えますが、取り出して使うときにキャストが必要になる場合があります。
C#object value = "Hello";
string text = (string)value;
通常の変数宣言では、objectよりも具体的な型やvarを使うほうが安全で読みやすいです。
7-3. varはコンパイル時に型が決まる
varの型はコンパイル時に決まります。
C#var number = 10;
この時点で、numberはint型です。
コンパイル時に型が決まるため、存在しないメソッドを呼び出そうとすると、コンパイルエラーになります。
C#var text = "Hello";
// text.NotExists(); // コンパイルエラー
このように、varは型安全な仕組みです。
7-4. dynamicは実行時に型が判断される
dynamicは、コンパイル時の型チェックを一部遅らせ、実行時に判断します。
C#dynamic text = "Hello";
text.ToUpper(); // OK
しかし、存在しないメソッドを呼んでもコンパイル時にはエラーにならない場合があります。
C#dynamic text = "Hello";
text.NotExists(); // 実行時エラー
dynamicは、外部APIやCOM連携など特殊な場面で使うことがありますが、通常のC#コードでは多用しないほうが安全です。
7-5. 初心者が混同しやすいポイント
初心者が特に混同しやすいのは、varを「何でも入れられる型」だと思ってしまうことです。
しかし、varは次のような仕組みです。
C#var value = 10;
この時点でvalueはint型です。
C#value = "Hello"; // エラー
varは型を省略しているだけで、型が曖昧になるわけではありません。
dynamicやobjectとは目的も安全性も異なります。通常のC#開発では、まずvarと明示的な型指定を使い分けることを覚えれば十分です。
8. varを使った具体的なコード例
8-1. 基本型でのコード例
C#var age = 30;
var name = "Suzuki";
var isActive = true;
var height = 170.5;
Console.WriteLine(age);
Console.WriteLine(name);
Console.WriteLine(isActive);
Console.WriteLine(height);
このコードでは、それぞれ次のように型が推論されます。
C#// age : int
// name : string
// isActive : bool
// height : double
右辺から型が明確にわかるため、varを使っても読みやすい例です。
8-2. コレクションでのコード例
C#var fruits = new List<string>
{
"Apple",
"Banana",
"Orange"
};
foreach (var fruit in fruits)
{
Console.WriteLine(fruit);
}
fruitsはList<string>型、fruitはstring型として扱われます。
辞書を使う例も見てみましょう。
C#var prices = new Dictionary<string, int>
{
{ "Apple", 100 },
{ "Banana", 80 },
{ "Orange", 120 }
};
foreach (var item in prices)
{
Console.WriteLine($"{item.Key}: {item.Value}円");
}
Dictionary<string, int>のように型名が長い場合、varを使うとコードが簡潔になります。
8-3. クラスのインスタンス生成でのコード例
次のようなUserクラスがあるとします。
C#class User
{
public string Name { get; set; }
public int Age { get; set; }
}
varを使ってインスタンスを生成できます。
C#var user = new User
{
Name = "Taro",
Age = 20
};
Console.WriteLine(user.Name);
Console.WriteLine(user.Age);
右辺にnew Userと書かれているため、userがUser型であることは明確です。
8-4. LINQでのコード例
LINQでは、varがよく使われます。
C#var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(number => number % 2 == 0);
foreach (var number in evenNumbers)
{
Console.WriteLine(number);
}
evenNumbersは、条件に合う要素を取り出した結果です。LINQの戻り値は型が長くなることがあるため、varを使うとコードが読みやすくなります。
匿名型を使う例です。
C#var users = new[]
{
new { Name = "Taro", Age = 20 },
new { Name = "Hanako", Age = 25 },
new { Name = "Jiro", Age = 17 }
};
var adultUsers = users
.Where(user => user.Age >= 20)
.Select(user => new
{
user.Name,
user.Age
});
foreach (var user in adultUsers)
{
Console.WriteLine($"{user.Name}: {user.Age}");
}
匿名型には明示的な型名がないため、varを使う必要があります。
8-5. varを使うと読みにくくなるコード例
varは便利ですが、使いすぎると読みにくくなることがあります。
C#var result = service.Execute();
このコードだけを見ると、resultが何型なのかわかりにくいです。
戻り値の型が重要な場合は、次のように書くと読みやすくなります。
C#OrderResult result = service.Execute();
また、変数名が曖昧だとさらに読みにくくなります。
C#var data = GetData();
var value = Calculate();
var result = Process();
このようなコードでは、型も目的もわかりにくくなります。
改善例です。
C#List<User> activeUsers = GetActiveUsers();
decimal totalPrice = CalculateTotalPrice();
OrderResult orderResult = ProcessOrder();
varを使う場合でも、変数名を具体的にすることが大切です。
9. varを使うメリット・デメリット
9-1. varを使うメリット
varを使うメリットは、コードを簡潔に書けることです。
C#var users = new List<User>();
明示的に書くと次のようになります。
C#List<User> users = new List<User>();
右辺に型が書かれている場合、左辺でも同じ型を書くと冗長です。varを使うことで重複を避けられます。
また、LINQや匿名型のように、型名が複雑または明示できない場面でもvarは役立ちます。
C#var user = new { Name = "Taro", Age = 20 };
コードの見通しがよくなり、変更にも強くなる場合があります。
9-2. varを使うデメリット
varのデメリットは、使い方によって型がわかりにくくなることです。
C#var result = GetResult();
このコードでは、resultの型がすぐにはわかりません。
特に、メソッドの戻り値を受け取る場合や、数値型の違いが重要な場合は注意が必要です。
C#var amount = 100.0;
この場合、amountはdouble型です。金額計算でdecimalを期待しているなら、次のように書く必要があります。
C#var amount = 100.0m;
または、明示的に型を書きます。
C#decimal amount = 100.0m;
9-3. 可読性を下げないための命名のコツ
varを使うときは、変数名を具体的にすることが重要です。
悪い例です。
C#var data = GetUsers();
var result = CalculatePrice();
var item = FindOrder();
変数名が曖昧だと、型や意味がわかりにくくなります。
良い例です。
C#var users = GetUsers();
var totalPrice = CalculatePrice();
var order = FindOrder();
変数名から中身を想像できるようにすると、varを使っても読みやすいコードになります。
特に、data、value、resultのような名前は便利ですが、多用すると意味が曖昧になりやすいので注意しましょう。
9-4. チーム開発でvarの使い方を統一する重要性
チーム開発では、varを使う基準を統一することが大切です。
ある人はすべてvarを使い、別の人はすべて明示的に型を書く、という状態だとコードの書き方にばらつきが出ます。
たとえば、次のようなルールを決めるとよいでしょう。
右辺に型が明確に書かれている場合はvarを使う。
C#var user = new User();
メソッドの戻り値がわかりにくい場合は型を明示する。
C#List<User> users = GetUsers();
数値型が重要な場合は型を明示する。
C#decimal price = 1000m;
チームでルールを決めることで、コードの可読性と保守性を高められます。
10. C#のvarに関するよくある質問
10-1. varは初心者でも使ってよいのか
初心者でもvarを使って問題ありません。
ただし、最初のうちは「このvarは何型に推論されているのか」を意識しながら使うことが大切です。
C#var number = 10; // int
var text = "Hello"; // string
var flag = true; // bool
型を理解しないままvarを使いすぎると、C#の型システムの理解が曖昧になることがあります。
学習中は、明示的な型指定とvarの両方を書いて比較してみると理解しやすくなります。
10-2. varを使うと処理速度は遅くなるのか
varを使っても、処理速度は基本的に遅くなりません。
varはコンパイル時に型が決まるため、実行時に型を調べる処理が追加されるわけではありません。
C#var count = 10;
これは、コンパイル後にはint count = 10;と同じように扱われます。
そのため、パフォーマンスを理由にvarを避ける必要はありません。判断基準にすべきなのは、主にコードの読みやすさです。
10-3. varはどんな型にも使えるのか
varは、右辺から型を推論できる場合であれば、さまざまな型に使えます。
C#var number = 10;
var text = "Hello";
var users = new List<User>();
var user = new { Name = "Taro", Age = 20 };
ただし、nullだけを代入することはできません。
C#var value = null; // エラー
また、宣言だけして後から代入することもできません。
C#var name; // エラー
varを使うには、宣言時に型を推論できる値が必要です。
10-4. varと型推論は同じ意味なのか
varは、C#で型推論を利用するための書き方の一つです。
型推論とは、コンパイラが式や値から型を判断する仕組みです。
C#var message = "Hello";
この場合、コンパイラは右辺の"Hello"からmessageをstring型だと推論します。
つまり、varそのものが型推論というより、varを使うことで型推論が行われると考えるとわかりやすいです。
10-5. varを使いすぎるのはよくないのか
varを使いすぎると、コードが読みにくくなることがあります。
特に次のようなコードは注意が必要です。
C#var result = GetResult();
var data = Load();
var value = Convert();
型も意味もわかりにくいため、読む人がメソッド定義を確認しなければならない場合があります。
一方で、次のようなコードではvarを使っても読みやすいです。
C#var user = new User();
var names = new List<string>();
var message = "Hello";
varを使うかどうかは、「短く書けるか」ではなく「読みやすいか」で判断しましょう。
まとめ
C#のvarは、変数の型を省略して書ける便利な機能です。コンパイラが右辺の値から型を推論するため、var number = 10;ならint型、var text = "Hello";ならstring型として扱われます。
重要なのは、varを使っても型がなくなるわけではないという点です。C#は静的型付け言語なので、varで宣言した変数もコンパイル時に具体的な型が決まります。一度決まった型は後から変更できません。
varは、右辺から型が明確にわかる場合、型名が長くなる場合、LINQや匿名型を扱う場合に便利です。一方で、メソッドの戻り値がわかりにくい場合、数値型の違いが重要な場合、nullだけを代入したい場合などには注意が必要です。
また、varはdynamicやobjectとは異なります。varはコンパイル時に型が決まる安全な仕組みであり、何でも入れられる型ではありません。
C#のvarを上手に使うコツは、コードを読む人にとって型や意味がわかりやすいかを意識することです。右辺から型が明らかな場面ではvarを使い、わかりにくい場面では明示的に型を書くことで、読みやすく保守しやすいC#コードを書けるようになります。