C#のvarとは？使い方・型推論・使わない方がいいケースを初心者向けに徹底解説
はじめに
C#を学び始めると、変数宣言でよく見かけるのがvarです。
C#var name = "Taro";
var age = 20;
一見すると、JavaScriptのvarのように「何でも入れられる変数」のように見えるかもしれません。しかし、C#のvarはそれとは大きく異なります。
C#のvarは、コンパイラが右辺の値から型を推論してくれる仕組みです。つまり、型を書かなくても、実際にはintやstringなどの具体的な型が決まっています。
この記事では、C#のvarとは何か、基本的な使い方、型推論の仕組み、メリット、注意点、使わない方がいいケースまで、初心者向けにわかりやすく解説します。
1. C#のvarとは？初心者がまず押さえる基本
C#のvarを理解するうえで大切なのは、varは「型そのもの」ではなく、型をコンパイラに推論させるためのキーワードだという点です。
1-1. varは「型を省略できる」ローカル変数宣言のキーワード
通常、C#では変数を宣言するときに型を書きます。
C#int number = 10;
string text = "hello";
bool isActive = true;
これをvarで書くと、次のようになります。
C#var number = 10;
var text = "hello";
var isActive = true;
右辺を見れば、10はint、"hello"はstring、trueはboolだと判断できます。
このように、varを使うと変数宣言時の型名を省略できます。ただし、使えるのは主にメソッド内などのローカル変数です。
1-2. varを使っても型がなくなるわけではない
varを使うと、型があいまいになると思う人もいます。しかし、C#ではvarを使っても型がなくなるわけではありません。
たとえば次のコードを見てください。
C#var number = 10;
この場合、numberの型はintです。
次のように書いた場合と、ほぼ同じ意味になります。
C#int number = 10;
つまり、varは「型を書かない」のではなく、「型名をコンパイラに判断してもらう」書き方です。
1-3. コンパイル時に型が決まるため安全性は保たれる
C#のvarは、コンパイル時に型が決まります。
C#var number = 10;
number = 20; // OK
number = "hello"; // エラー
最初にnumberはintとして推論されるため、後からstringを代入することはできません。
この点は、実行時に型が決まるdynamicとは異なります。varはあくまで静的型付けの仕組みの中で使われるため、C#らしい型安全性は保たれます。
1-4. varが導入された背景と使われる場面
varは、特にLINQや匿名型と組み合わせて使いやすくするために導入されました。
たとえば、LINQの結果や匿名型は、型名が長くなったり、そもそも明示的に型名を書けなかったりすることがあります。
C#var user = new { Name = "Taro", Age = 20 };
このような匿名型では、型名を直接書くことができないため、varが必要になります。
現在では、LINQや匿名型だけでなく、右辺から型が明らかな場面でも広く使われています。
2. C#のvarの基本的な使い方
ここからは、C#のvarを実際にどのように使うのかを具体例で見ていきましょう。
2-1. 数値・文字列・boolでのvarの書き方
基本的な値であれば、varはとてもシンプルに使えます。
C#var count = 10;
var price = 1200.5;
var name = "Alice";
var isEnabled = true;
この場合、それぞれ次のように推論されます。
C#int count = 10;
double price = 1200.5;
string name = "Alice";
bool isEnabled = true;
varを使っても、変数の型は右辺の値から明確に決まります。
2-2. クラスやコレクションでのvarの書き方
クラスのインスタンス生成でもvarはよく使われます。
C#var user = new User();
var list = new List<string>();
var dictionary = new Dictionary<string, int>();
明示的に書くと次のようになります。
C#User user = new User();
List<string> list = new List<string>();
Dictionary<string, int> dictionary = new Dictionary<string, int>();
特にDictionary<string, List<int>>のように型名が長くなる場合、varを使うとコードがすっきりします。
C#var scores = new Dictionary<string, List<int>>();
右辺にnew Dictionary<string, List<int>>()と書かれているため、型は十分に明らかです。
2-3. foreach文でvarを使う例
foreach文でもvarはよく使われます。
C#var names = new List<string> { "Alice", "Bob", "Charlie" };
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 item in items)のような書き方はよく使われます。
2-4. LINQの結果をvarで受け取る例
LINQではvarが非常によく使われます。
C#var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);
この場合、evenNumbersの型はIEnumerable<int>です。
明示的に書くこともできます。
C#IEnumerable<int> evenNumbers = numbers.Where(n => n % 2 == 0);
しかし、LINQの処理が複雑になると型名が長くなったり、読みづらくなったりします。そのため、LINQの結果を受け取るときはvarがよく使われます。
C#var result = users
.Where(user => user.Age >= 20)
.OrderBy(user => user.Name)
.Select(user => new
{
user.Name,
user.Age
});
このようなコードでは、varを使うことで処理の流れに集中しやすくなります。
2-5. 匿名型ではvarが必要になるケース
匿名型を使う場合、varはほぼ必須です。
C#var person = new
{
Name = "Taro",
Age = 25
};
Console.WriteLine(person.Name);
Console.WriteLine(person.Age);
匿名型は、名前のない型をコンパイラが自動的に作る仕組みです。そのため、次のように型名を明示して書くことはできません。
C#// 型名を直接書けない
LINQのSelectで一部のプロパティだけを取り出すときにも、匿名型とvarはよく使われます。
C#var users = new List<User>();
var names = users.Select(user => new
{
user.Id,
user.Name
});
このように、匿名型ではvarを使うことで、柔軟にデータを扱えます。
3. varと型推論の仕組み
varを正しく理解するには、型推論の仕組みを押さえることが重要です。
3-1. 右辺の値からコンパイラが型を判断する
varでは、変数宣言の右辺にある値や式から、コンパイラが型を判断します。
C#var value = 100;
この場合、右辺の100は整数リテラルなので、valueはintになります。
C#var message = "こんにちは";
この場合、右辺は文字列リテラルなので、messageはstringになります。
つまり、varを使うには、右辺から型が明確に決まる必要があります。
3-2. var number = 10 がintになる理由
次のコードを見てみましょう。
C#var number = 10;
10はC#では通常intとして扱われます。そのため、numberの型はintに推論されます。
次のコードと同じように扱われます。
C#int number = 10;
もしlongにしたい場合は、右辺で明示する必要があります。
C#var number = 10L;
この場合、10Lはlongリテラルなので、numberはlongになります。
3-3. var text = "hello" がstringになる理由
次のコードでは、textはstringになります。
C#var text = "hello";
"hello"は文字列リテラルであり、C#ではstring型です。
そのため、次のように書いた場合と同じです。
C#string text = "hello";
varは見た目上は型を書いていませんが、コンパイル後の扱いとしては明確な型を持っています。
3-4. 推論された型は後から別の型に変えられない
varで宣言した変数の型は、最初に決まったら変更できません。
C#var value = 10;
value = 20; // OK
value = "text"; // エラー
valueは最初にintとして推論されています。そのため、後からstringを代入することはできません。
これはC#が静的型付け言語であるためです。varを使っても、変数の型チェックはコンパイル時に行われます。
3-5. IDEでvarの実際の型を確認する方法
Visual StudioやVisual Studio CodeなどのIDEを使っている場合、varの上にマウスカーソルを合わせると、推論された型を確認できます。
C#var users = new List<string>();
IDE上では、usersがList<string>であることを確認できます。
また、Visual Studioではクイックアクションを使って、varを明示的な型に変換したり、逆に明示的な型をvarに変換したりできます。
初心者のうちは、varを使ったあとにIDEで実際の型を確認すると、型推論の理解が深まります。
4. varを使うメリット
varには、コードを短くするだけでなく、読みやすさや保守性を高めるメリットがあります。
4-1. 型名の重複を減らしてコードを短くできる
インスタンスを生成するときは、左辺と右辺で同じ型名を繰り返すことがあります。
C#List<string> names = new List<string>();
varを使うと、次のように書けます。
C#var names = new List<string>();
右辺を見ればList<string>であることが明らかなため、左辺の型名を省略しても意味は伝わります。
型名の重複を減らせるため、コードがすっきりします。
4-2. 長い型名を扱うコードが読みやすくなる
ジェネリック型を使うと、型名が長くなることがあります。
C#Dictionary<string, List<int>> userScores = new Dictionary<string, List<int>>();
varを使うと、次のように簡潔に書けます。
C#var userScores = new Dictionary<string, List<int>>();
型名が長い場合、明示的に書くとコードの本質が見えにくくなることがあります。varを使うことで、「何をしているコードなのか」に注目しやすくなります。
4-3. 右辺から型が明らかな場合に見通しがよくなる
次のようなコードでは、右辺を見れば型が明らかです。
C#var customer = new Customer();
var order = new Order();
var product = new Product();
この場合、左辺にCustomer、Order、Productと書かなくても、読み手は型を理解できます。
C#Customer customer = new Customer();
Order order = new Order();
Product product = new Product();
上のように明示的に書くよりも、varを使った方が視線の移動が少なく、コード全体を読みやすく感じることがあります。
4-4. LINQや匿名型との相性が良い
LINQでは、クエリの結果の型が複雑になることがあります。
C#var result = users
.Where(user => user.IsActive)
.Select(user => new
{
user.Id,
user.Name
});
このような場合、varを使うと型名を意識しすぎず、処理の内容に集中できます。
特に匿名型を使っている場合は、型名を直接書けないためvarが必要です。
C#var item = new { Id = 1, Name = "Pen" };
LINQや匿名型を使う場面では、varは自然で実用的な書き方です。
4-5. 型名変更時の修正範囲を減らせる
クラス名や型名を変更した場合、明示的な型宣言を多く使っていると修正箇所が増えることがあります。
C#OldCustomer customer = new OldCustomer();
型名を変更すると、左辺と右辺の両方を修正する必要があります。
一方、varを使っていれば、右辺だけを修正すればよい場合があります。
C#var customer = new NewCustomer();
もちろん、すべてのケースで修正が不要になるわけではありませんが、型名の重複を減らすことで保守しやすくなる場面があります。
5. varを使うときの注意点
varは便利ですが、どこでも自由に使えるわけではありません。いくつかのルールと注意点があります。
5-1. varは宣言と同時に初期化する必要がある
varを使う場合、変数宣言と同時に値を代入する必要があります。
C#var number = 10;
これはOKです。
しかし、次のような書き方はできません。
C#var number;
number = 10;
varは右辺の値から型を推論するため、初期値がなければ型を判断できません。
5-2. var x; のような書き方はできない
次のコードはエラーになります。
C#var x;
理由は、xの型を推論するための情報がないからです。
明示的な型であれば、次のように書くことはできます。
C#int x;
しかし、varでは必ず初期化が必要です。
C#var x = 0;
このように書けば、xはintとして推論されます。
5-3. nullだけでは型を推論できない
次のコードもエラーになります。
C#var value = null;
nullだけでは、stringなのか、objectなのか、他の参照型なのかを判断できません。
型を明確にしたい場合は、明示的に書きます。
C#string value = null;
または、キャストして型を示すこともできます。
C#var value = (string)null;
ただし、初心者のうちは無理にvarを使わず、string value = null;のように明示した方がわかりやすいでしょう。
5-4. フィールド・プロパティ・戻り値の型には使えない
varは主にローカル変数で使うキーワードです。
そのため、クラスのフィールドには使えません。
C#class Sample
{
// エラー
var count = 10;
}
プロパティの型にも使えません。
C#class Sample
{
// エラー
public var Name { get; set; }
}
メソッドの戻り値の型にも使えません。
C#// エラー
var GetNumber()
{
return 10;
}
戻り値の型は明示する必要があります。
C#int GetNumber()
{
return 10;
}
varは便利ですが、クラス設計やAPIの公開部分で型を隠すためのものではありません。
5-5. 複数の変数を同時にvarで宣言できない
明示的な型では、次のように複数の変数をまとめて宣言できます。
C#int x = 1, y = 2;
しかし、varでは次のような書き方はできません。
C#var x = 1, y = 2;
varを使う場合は、1つずつ宣言します。
C#var x = 1;
var y = 2;
複数の変数を宣言したい場合でも、可読性を考えると1行に1つずつ書いた方がわかりやすいことが多いです。
5-6. 右辺が分かりにくいとコードの可読性が下がる
varの大きな注意点は、右辺から型がわかりにくい場合に可読性が下がることです。
C#var result = GetData();
このコードだけを見ると、resultが何の型なのかわかりません。
GetData()の戻り値がstringなのか、List<User>なのか、boolなのか、読み手はメソッド定義を確認する必要があります。
このような場合は、明示的に型を書いた方が読みやすくなることがあります。
C#List<User> result = GetData();
varは便利ですが、読み手に必要な情報まで隠してしまわないように注意しましょう。
6. varを使わない方がいいケース
varは多くの場面で便利ですが、あえて使わない方がよいケースもあります。
6-1. 右辺を見ても型がすぐ分からない場合
次のようなコードでは、右辺から型がすぐにはわかりません。
C#var data = repository.Find(id);
dataがUserなのか、Orderなのか、IEnumerable<User>なのか、コードを追わないと判断できません。
このような場合は、明示的に型を書いた方が親切です。
C#User data = repository.Find(id);
読み手がすぐに理解できるコードを優先するなら、varを使わない選択も重要です。
6-2. 数値型の違いを明確にしたい場合
数値型には、int、long、float、double、decimalなどがあります。
C#var price = 1000;
var rate = 0.1;
この場合、priceはint、rateはdoubleとして推論されます。
しかし、金額計算などでdecimalを使いたい場合、varだけでは意図が伝わりにくいことがあります。
C#decimal price = 1000m;
または、varを使うなら右辺で明確にします。
C#var price = 1000m;
数値型の違いが重要な場面では、明示的な型宣言を使った方が安全で読みやすいことがあります。
6-3. メソッドの戻り値の型を読み手に伝えたい場合
メソッド呼び出しの結果を受け取るとき、varを使うと戻り値の型が見えにくくなることがあります。
C#var users = GetUsers();
GetUsers()がList<User>を返すのか、IEnumerable<User>を返すのか、配列を返すのかは、この行だけではわかりません。
型を読み手に伝えたい場合は、明示的に書くとわかりやすくなります。
C#IEnumerable<User> users = GetUsers();
特にインターフェース型として扱いたい場合や、戻り値の性質を明確にしたい場合は、varを使わない方がよいことがあります。
6-4. キャストや変換の意図を明確にしたい場合
型変換が関係するコードでは、varを使うと意図が伝わりにくくなる場合があります。
C#var value = (double)number;
この場合、右辺にキャストがあるためdoubleだとわかりますが、重要な変換であれば明示的に書いた方が読みやすいこともあります。
C#double value = (double)number;
特に、整数除算を避けたい、精度を保ちたい、APIに渡す型を明確にしたいといった場面では、型を明示することで意図が伝わりやすくなります。
6-5. チームのコーディング規約で明示的な型が求められる場合
実務では、個人の好みよりもチームのコーディング規約が優先されます。
たとえば、チームによっては次のようなルールがあります。
C#// 右辺がnewの場合のみvarを使う
var user = new User();
// メソッド戻り値では明示的な型を書く
List<User> users = GetUsers();
また、すべて明示的な型を使う方針のチームもあります。
C#のvarは便利ですが、プロジェクト全体で書き方がバラバラになると、かえって読みづらくなります。チーム開発では、既存コードや規約に合わせることが大切です。
6-6. 初心者が型の理解を深めたい学習段階の場合
C#を学び始めたばかりの段階では、あえて明示的な型を書いた方が学習に役立つことがあります。
C#int count = 10;
string name = "Taro";
bool isActive = true;
このように書くことで、「この値は何型なのか」を意識できます。
一方で、最初から何でもvarで書いてしまうと、int、string、bool、List<T>などの型の理解があいまいになる可能性があります。
初心者は、まず明示的な型で基本を理解し、慣れてきたらvarを使う範囲を広げていくのがおすすめです。
7. varと似たキーワード・型との違い
varは、dynamicやobjectと混同されることがあります。ここでは、それぞれの違いを整理します。
7-1. varとdynamicの違い
varとdynamicは、見た目は似ているように感じるかもしれませんが、仕組みは大きく違います。
C#var value1 = 10;
dynamic value2 = 10;
varはコンパイル時に型が決まります。
C#var value = 10;
value = "hello"; // エラー
一方、dynamicは実行時に型が扱われます。
C#dynamic value = 10;
value = "hello"; // OK
dynamicは柔軟ですが、コンパイル時の型チェックが弱くなるため、実行時エラーが発生しやすくなります。
通常のC#開発では、特別な理由がない限りdynamicよりもvarや明示的な型を使う方が安全です。
7-2. varとobjectの違い
objectは、C#のすべての型の基底となる型です。
C#object value = 10;
value = "hello"; // OK
object型の変数には、さまざまな型の値を入れることができます。
一方、varは最初に推論された型に固定されます。
C#var value = 10;
value = "hello"; // エラー
また、objectとして扱うと、元の型のメンバーを使うにはキャストが必要になることがあります。
C#object text = "hello";
// キャストが必要
string str = (string)text;
Console.WriteLine(str.Length);
varの場合はstringとして推論されるため、そのままLengthを使えます。
C#var text = "hello";
Console.WriteLine(text.Length);
varは型を失う仕組みではなく、具体的な型を保ったまま省略して書くための仕組みです。
7-3. varと明示的な型宣言の違い
明示的な型宣言では、左辺に型名を書きます。
C#string name = "Taro";
varでは、右辺から型を推論します。
C#var name = "Taro";
この2つは、結果的にはどちらもnameがstringになります。
違いは、コードを読んだときの情報の見え方です。
右辺から型が明らかな場合は、varの方が簡潔です。
C#var user = new User();
一方、右辺から型がわかりにくい場合は、明示的な型の方が読みやすくなります。
C#User user = GetCurrentUser();
どちらが常に正しいというより、読みやすさを基準に使い分けることが大切です。
7-4. varと匿名型の関係
匿名型では、varが重要な役割を持ちます。
C#var user = new
{
Id = 1,
Name = "Taro"
};
匿名型は、コンパイラが自動的に作る名前のない型です。そのため、開発者が型名を直接書くことはできません。
LINQで一部のデータだけを取り出すときにも、匿名型はよく使われます。
C#var result = users.Select(user => new
{
user.Id,
user.Name
});
このような場合、varを使うことで匿名型の結果を自然に受け取ることができます。
7-5. using varの意味と通常のvarとの違い
C#にはusing varという書き方もあります。
C#using var reader = new StreamReader("sample.txt");
これは、通常のvarに加えて、スコープを抜けたときに自動的にDisposeを呼び出すための書き方です。
従来のusing文は次のように書きます。
C#using (var reader = new StreamReader("sample.txt"))
{
var text = reader.ReadToEnd();
}
using varを使うと、ブロックを増やさずにリソース管理ができます。
C#using var reader = new StreamReader("sample.txt");
var text = reader.ReadToEnd();
通常のvarは型推論のためのキーワードですが、using varはそれに加えてリソース解放の意味を持ちます。
ファイル、ストリーム、データベース接続など、IDisposableを実装しているオブジェクトで使われます。
8. varの良い使い方・悪い使い方の具体例
ここでは、C#のvarをどのように使うと読みやすくなるのか、逆にどのような使い方は避けた方がよいのかを具体例で見ていきます。
8-1. 良い例：右辺から型が明らかなコード
右辺を見れば型がすぐわかる場合、varは良い選択です。
C#var user = new User();
var names = new List<string>();
var map = new Dictionary<string, int>();
このようなコードでは、左辺に型を書かなくても読み手は型を理解できます。
特にnewでインスタンスを作っている場合は、右辺に型名が出ているため、varを使っても可読性が下がりにくいです。
8-2. 良い例：長い型名を簡潔にするコード
型名が長い場合、varを使うとコードが読みやすくなります。
C#var settings = new Dictionary<string, List<ConfigurationItem>>();
明示的に書くと、かなり長くなります。
C#Dictionary<string, List<ConfigurationItem>> settings =
new Dictionary<string, List<ConfigurationItem>>();
このような場合、varを使うことでコードの見通しがよくなります。
また、LINQのように型が複雑になりやすい処理でもvarは有効です。
C#var activeUsers = users
.Where(user => user.IsActive)
.OrderBy(user => user.Name)
.ToList();
処理内容が自然に読めるため、型名よりもロジックに集中できます。
8-3. 悪い例：メソッド戻り値の型が分かりにくいコード
次のようなコードは、varを使うことで型がわかりにくくなっています。
C#var result = service.Execute();
Execute()が何を返すのか、この行だけでは判断できません。
このような場合は、明示的な型を書くとわかりやすくなります。
C#ExecutionResult result = service.Execute();
特に、業務ロジックや重要な処理では、戻り値の型が明確な方が読み手に親切です。
8-4. 悪い例：数値型の意図が伝わりにくいコード
数値型は、varを使うと意図が伝わりにくいことがあります。
C#var taxRate = 0.1;
この場合、taxRateはdoubleになります。
しかし、金額計算でdecimalを使いたい場合は、次のように書くべきです。
C#decimal taxRate = 0.1m;
または、varを使うなら右辺で明確にします。
C#var taxRate = 0.1m;
数値型の違いは、計算結果や精度に影響することがあります。そのため、数値型の意図を伝えたい場面では、明示的な型宣言を使うと安全です。
8-5. varを使うべきか迷ったときの判断基準
varを使うべきか迷ったら、次の基準で考えると判断しやすくなります。
右辺を見て型がすぐわかるなら、varを使っても問題ありません。
C#var customer = new Customer();
型名が長く、明示すると読みにくくなる場合も、varは有効です。
C#var cache = new Dictionary<string, List<Product>>();
一方、メソッドの戻り値など、右辺から型がわかりにくい場合は、明示的な型を検討しましょう。
C#List<Product> products = GetProducts();
大切なのは、「書く人にとって楽か」ではなく、「読む人にとってわかりやすいか」です。
varはコードを短くするためだけでなく、読みやすくするために使うものだと考えるとよいでしょう。
9. C#のvarに関するよくある疑問
最後に、C#のvarについて初心者が疑問に感じやすいポイントを解説します。
9-1. varを使うと処理速度は遅くなる？
varを使っても、処理速度が遅くなることは基本的にありません。
varはコンパイル時に具体的な型へ解決されます。
C#var number = 10;
このコードは、実質的には次のように扱われます。
C#int number = 10;
実行時に型を調べながら動くわけではないため、varを使ったからといってパフォーマンスが悪くなるわけではありません。
9-2. varを使うとメモリ使用量は増える？
varを使っても、メモリ使用量が増えるわけではありません。
varはあくまでソースコード上の書き方であり、実際にはコンパイラが具体的な型を決めます。
C#var text = "hello";
この場合、textはstringです。
C#string text = "hello";
上のように書いた場合と、メモリの使い方が大きく変わるわけではありません。
varはパフォーマンスやメモリよりも、コードの読みやすさや書きやすさに関係する機能です。
9-3. varは初心者でも使ってよい？
初心者でもvarを使って問題ありません。
ただし、最初は型の理解を深めるために、明示的な型も意識して書くのがおすすめです。
C#int count = 10;
string name = "Taro";
bool isActive = true;
慣れてきたら、右辺から型が明らかな場面でvarを使うとよいでしょう。
C#var user = new User();
var names = new List<string>();
初心者にとって重要なのは、varを暗記することではなく、「実際には何型として扱われているのか」を理解することです。
9-4. varはすべての変数に使ってよい？
技術的には、多くのローカル変数でvarを使えます。しかし、すべての変数に使うのが常に良いとは限りません。
たとえば、次のようなコードは型がわかりにくくなります。
C#var value = GetValue();
var result = Calculate(value);
var data = Convert(result);
このようにvarが続くと、それぞれの変数が何の型なのか読み取りにくくなることがあります。
型が明らかな場合はvar、型を伝えたい場合は明示的な型、というように使い分けるのが現実的です。
9-5. varとintやstringはどちらを使うべき？
varとint、stringのどちらを使うべきかは、状況によります。
次のように単純な値では、どちらでも意味は明確です。
C#var count = 10;
int count = 10;
C#var name = "Taro";
string name = "Taro";
初心者の学習段階では、intやstringを明示した方が型を覚えやすいです。
一方、実務では次のようにvarを使うことも一般的です。
C#var user = new User();
var items = new List<Item>();
迷ったときは、右辺から型が明らかならvar、型を読み手に伝えたいなら明示的な型を使うとよいでしょう。
まとめ
C#のvarは、変数の型を省略して書ける便利なキーワードです。
ただし、型がなくなるわけではありません。varを使うと、コンパイラが右辺の値から型を推論し、コンパイル時に具体的な型が決まります。
C#var number = 10; // int
var text = "hello"; // string
var flag = true; // bool
そのため、varを使ってもC#の型安全性は保たれます。
varは、右辺から型が明らかな場合、型名が長い場合、LINQや匿名型を扱う場合に便利です。
C#var user = new User();
var list = new List<string>();
var result = users.Select(user => new { user.Id, user.Name });
一方で、メソッドの戻り値の型がわかりにくい場合、数値型の意図を明確にしたい場合、初心者が型を学んでいる段階では、明示的な型を書いた方がよいこともあります。
C#List<User> users = GetUsers();
decimal price = 1000m;
varを使うかどうかの判断基準は、コードを読む人にとってわかりやすいかどうかです。
C#のvarは、正しく使えばコードを簡潔で読みやすくできます。しかし、使いすぎると型が見えにくくなり、可読性が下がることもあります。
右辺から型が明らかな場面ではvarを使い、型を明確に伝えたい場面では明示的な型を使う。このバランスを意識することが、C#で読みやすいコードを書くための大切なポイントです。