C# 型推論とは？varの使い方・メリット・注意点を初心者向けに解説

はじめに

C#を学び始めると、サンプルコードの中でよく見かけるのがvarというキーワードです。

C#
var name = "Taro";
var age = 20;

一見すると、型を書かずに変数を宣言しているように見えるため、「C#は型を書かなくてもよい言語なの？」「varを使うと型が曖昧になるの？」と不安に感じる初心者も多いでしょう。

結論から言うと、C#のvarは型をなくすための機能ではありません。コンパイラが右辺の値から型を自動で判断する「型推論」という仕組みを使って、型名の記述を省略しているだけです。

この記事では、C#の型推論とは何か、varの基本的な使い方、メリット、注意点、よくあるエラーまで初心者向けにわかりやすく解説します。

1. C#の型推論とは？初心者向けにわかりやすく解説

1-1. 型推論とは「型をコンパイラが自動で判断する仕組み」

型推論とは、変数や式の型をプログラマーが明示しなくても、コンパイラが文脈から自動的に判断してくれる仕組みです。

たとえば、次のコードを見てみましょう。

C#
var count = 10;

この場合、右辺の10は整数なので、C#コンパイラはcountの型をintだと判断します。

つまり、上のコードは実質的に次のコードと同じ意味です。

C#
int count = 10;

varを使っても、変数に型がないわけではありません。型はきちんと存在しており、その型をコンパイラが自動で決めているだけです。

1-2. C#で型推論が使われる代表的な場面

C#で型推論がよく使われる代表的な場面には、次のようなものがあります。

C#
var number = 100;
var text = "Hello";
var isActive = true;

この例では、それぞれ次のように型が推論されます。

C#
int number = 100;
string text = "Hello";
bool isActive = true;

また、コレクションやLINQ、匿名型を扱うときにも型推論はよく使われます。

C#
var names = new List<string>();
var result = names.Where(name => name.Length >= 3);
var user = new { Name = "Taro", Age = 20 };

特にLINQや匿名型では、型名が長くなったり、明示的に書けなかったりするため、varが非常に便利です。

1-3. 型推論と動的型付けの違い

初心者が混同しやすいのが、型推論と動的型付けの違いです。

C#のvarは、動的型付けではありません。varで宣言された変数の型は、コンパイル時に決まります。

C#
var message = "Hello";
message = "World"; // OK
message = 123;     // エラー

最初に"Hello"を代入しているため、messageはstring型として推論されます。その後に別の文字列を代入することはできますが、整数を代入することはできません。

一方、dynamicを使うと、実行時に型が扱われます。

C#
dynamic value = "Hello";
value = 123; // OK

varは型安全な仕組みであり、C#の静的型付けを保ったままコードを簡潔に書くための機能です。

1-4. 型推論を理解するとC#コードが読みやすくなる理由

C#のコードでは、varが頻繁に使われます。そのため、型推論を理解していないと、コードを読んだときに「この変数は何型なのか」がわかりにくく感じることがあります。

しかし、型推論のルールを理解していれば、右辺を見るだけで型を予測できるようになります。

C#
var price = 1200;
var productName = "Keyboard";
var products = new List<string>();

このようなコードを見たときに、priceはint、productNameはstring、productsはList<string>だと自然に読み取れるようになります。

型推論を理解することは、C#のコードを読む力を高めるうえで重要です。

2. C#のvarとは？基本的な使い方

2-1. varは変数の型を省略して書けるキーワード

varは、ローカル変数の型をコンパイラに推論させるためのキーワードです。

通常、C#では変数を宣言するときに型を書きます。

C#
int age = 20;
string name = "Taro";

これをvarで書くと、次のようになります。

C#
var age = 20;
var name = "Taro";

型名を省略しているだけで、ageはint型、nameはstring型として扱われます。

2-2. varを使った基本構文

varの基本構文は次のとおりです。

C#
var 変数名 = 初期値;

具体例を見てみましょう。

C#
var count = 5;
var title = "C#入門";
var isCompleted = false;

それぞれの型は、右辺の初期値から推論されます。

C#
// count は int
// title は string
// isCompleted は bool

重要なのは、varを使う場合は必ず初期値が必要だという点です。

C#
var x; // エラー

初期値がないと、コンパイラは型を判断できません。

2-3. varを使わない書き方との比較

varを使わない場合と使う場合を比較してみましょう。

C#
Dictionary<string, List<int>> scores = new Dictionary<string, List<int>>();

このコードは型名が長く、少し読みにくくなっています。varを使うと次のように書けます。

C#
var scores = new Dictionary<string, List<int>>();

右辺を見れば型がわかるため、左辺に同じ型名を繰り返す必要がありません。

一方で、次のようなコードではどうでしょうか。

C#
var result = GetData();

この場合、GetData()の戻り値を知らないとresultの型がわかりません。こうした場面では、型を明示したほうが読みやすいこともあります。

2-4. varで宣言した変数の型はコンパイル時に決まる

varで宣言した変数の型は、コンパイル時に決まります。

C#
var number = 10;

この時点で、numberはint型として扱われます。実行中に型が変わるわけではありません。

C#
number = 20;    // OK
number = "abc"; // エラー

varは型を曖昧にする機能ではなく、型の記述を省略するための機能です。

2-5. varは一度決まった型を変更できない

varで宣言した変数は、最初に推論された型から変更できません。

C#
var value = 100;
value = 200;    // OK
value = "text"; // エラー

最初に100を代入しているため、valueはint型です。その後、string型の値を代入しようとするとコンパイルエラーになります。

この性質により、varを使ってもC#の型安全性は保たれます。

3. varが使えるケース・使えないケース

3-1. ローカル変数の宣言で使える

varは、主にメソッド内のローカル変数で使います。

C#
void ShowMessage()
{
    var message = "Hello";
    Console.WriteLine(message);
}

このように、メソッドやブロックの中で一時的に使う変数に対してvarを使えます。

3-2. 初期値がある場合に使える

varを使うには、宣言と同時に初期値を代入する必要があります。

C#
var name = "Taro"; // OK

次のように、初期値なしでは使えません。

C#
var name; // エラー

コンパイラが型を判断するためには、右辺の値が必要です。

3-3. フィールドやプロパティでは基本的に使えない

varはクラスのフィールドには使えません。

C#
class User
{
    var name = "Taro"; // エラー
}

この場合は、型を明示する必要があります。

C#
class User
{
    string name = "Taro";
}

プロパティにもvarは使えません。

C#
public var Name { get; set; } // エラー

プロパティでは次のように型を明示します。

C#
public string Name { get; set; }

3-4. メソッドの引数や戻り値には使えない

varはメソッドの引数や戻り値の型としては使えません。

C#
var GetName()
{
    return "Taro";
}

これはエラーになります。正しくは次のように書きます。

C#
string GetName()
{
    return "Taro";
}

引数にもvarは使えません。

C#
void Show(var message) // エラー
{
    Console.WriteLine(message);
}

正しくは、型を明示します。

C#
void Show(string message)
{
    Console.WriteLine(message);
}

3-5. nullだけを代入する宣言には使えない

varにnullだけを代入することはできません。

C#
var value = null; // エラー

nullだけでは、stringなのか、objectなのか、別の参照型なのかをコンパイラが判断できないためです。

この場合は、型を明示します。

C#
string? value = null;

または、キャストして型を示すこともできます。

C#
var value = (string?)null;

3-6. 匿名型ではvarが必要になる

匿名型を使う場合、varが必要になります。

C#
var user = new { Name = "Taro", Age = 20 };

匿名型は名前のない型なので、通常の型名を書いて宣言することができません。そのため、varを使ってコンパイラに型を推論させます。

匿名型は、LINQの結果や一時的なデータのまとまりを扱うときによく使われます。

4. C#で型推論が役立つ具体例

4-1. ListやDictionaryなど長い型名を短く書く

ListやDictionaryなどのコレクションでは、型名が長くなることがあります。

C#
Dictionary<string, List<int>> scoreMap = new Dictionary<string, List<int>>();

varを使うと、次のように簡潔に書けます。

C#
var scoreMap = new Dictionary<string, List<int>>();

右辺に型が明確に書かれているため、左辺で同じ型名を繰り返す必要がありません。

4-2. LINQの結果を受け取る

LINQを使うと、条件に合うデータを簡潔に取得できます。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

evenNumbersの型は、LINQの結果に応じて推論されます。LINQでは戻り値の型が長くなりやすいため、varを使うとコードが読みやすくなります。

4-3. 匿名型を扱う

匿名型を扱う場合、varは特に重要です。

C#
var product = new
{
    Name = "Mouse",
    Price = 1500
};

Console.WriteLine(product.Name);
Console.WriteLine(product.Price);

匿名型は型名を明示できないため、varを使って受け取ります。

4-4. foreachで要素の型を推論する

foreachでもvarを使うことができます。

C#
var names = new List<string> { "Taro", "Hanako", "Jiro" };

foreach (var name in names)
{
    Console.WriteLine(name);
}

この場合、nameはstring型として推論されます。

明示的に書くと次のようになります。

C#
foreach (string name in names)
{
    Console.WriteLine(name);
}

どちらも正しい書き方ですが、varを使うと柔軟で簡潔に書けます。

4-5. new式と組み合わせてコードを簡潔にする

new式とvarを組み合わせると、コードを短くできます。

C#
var users = new List<string>();
var today = new DateTime(2026, 6, 18);
var random = new Random();

右辺を見れば型が明らかなため、varを使っても読みやすさは保たれます。

5. varを使うメリット

5-1. コードが短くなり読みやすくなる

varを使う最大のメリットは、コードを短く書けることです。

C#
List<string> names = new List<string>();

このコードは、同じ型名が左右に出てきます。

C#
var names = new List<string>();

varを使えば、重複を減らしてスッキリ書けます。

5-2. 型名の重複を避けられる

C#では、変数宣言時に左辺と右辺で型名が重複することがあります。

C#
CustomerRepository repository = new CustomerRepository();

varを使うと、次のようになります。

C#
var repository = new CustomerRepository();

右辺に型が明確に書かれているため、左辺ではvarで十分です。

5-3. 複雑な型を扱いやすくなる

ジェネリック型を使うと、型名が長くなりがちです。

C#
Dictionary<string, Dictionary<int, List<string>>> data =
    new Dictionary<string, Dictionary<int, List<string>>>();

varを使うと、かなり読みやすくなります。

C#
var data = new Dictionary<string, Dictionary<int, List<string>>>();

複雑な型を扱う場合、varはコードの見通しをよくするために役立ちます。

5-4. リファクタリング時の修正箇所を減らせる

型名を明示していると、クラス名や戻り値の型を変更したときに、変数宣言の型も修正する必要があります。

C#
OldService service = new OldService();

クラス名を変更した場合、左辺と右辺の両方を修正しなければなりません。

C#
var service = new NewService();

varを使っていれば、右辺を修正するだけで済む場合があります。リファクタリング時の変更箇所を減らせる点もメリットです。

5-5. LINQや匿名型との相性が良い

LINQや匿名型では、varが特に便利です。

C#
var users = new[]
{
    new { Name = "Taro", Age = 20 },
    new { Name = "Hanako", Age = 25 }
};

var adults = users.Where(user => user.Age >= 20);

匿名型は型名を明示できないため、varが必要です。また、LINQの戻り値は複雑になることがあるため、varを使うことでコードを簡潔に保てます。

6. varを使うときの注意点

6-1. 型がわかりにくい場面では可読性が下がる

varは便利ですが、使いどころを間違えるとコードが読みにくくなります。

C#
var result = GetResult();

このコードだけを見ると、resultが何型なのかわかりません。GetResult()の戻り値を確認しないと理解できないため、可読性が下がる可能性があります。

このような場合は、型を明示したほうが親切です。

C#
UserResult result = GetResult();

6-2. 意図しない型として推論されることがある

varは右辺から型を推論するため、書き方によっては意図しない型になることがあります。

C#
var number = 10;

この場合、numberはint型です。もしlong型として扱いたい場合は、次のように書く必要があります。

C#
var number = 10L;

または、型を明示します。

C#
long number = 10;

6-3. 数値リテラルの型推論に注意する

数値リテラルでは、書き方によって推論される型が変わります。

C#
var a = 10;    // int
var b = 10L;   // long
var c = 10.0;  // double
var d = 10.0f; // float
var e = 10.0m; // decimal

特に小数を扱う場合、double、float、decimalの違いに注意が必要です。

金額計算などでdecimalを使いたい場合は、mを付けます。

C#
var price = 1200.5m;

6-4. null許容参照型との関係に注意する

C#では、null許容参照型を有効にしている場合、nullを扱うときに型の意図を明確にすることが重要です。

C#
string? name = null;

varでnullだけを代入することはできません。

C#
var name = null; // エラー

nullを許容する変数を宣言したい場合は、型を明示したほうがわかりやすいです。

C#
string? name = GetNameOrNull();

varを使う場合でも、戻り値がnullを返す可能性があるかどうかを意識する必要があります。

C#
var name = GetNameOrNull();

このコードでは、GetNameOrNull()の戻り値の型に応じて推論されます。null許容の意図を読み手に伝えたい場合は、型を明示するのもよい判断です。

6-5. varを使いすぎると初心者には読みにくいコードになる

varを多用すると、初心者にとっては型が追いにくいコードになることがあります。

C#
var user = GetUser();
var orders = GetOrders(user);
var total = CalculateTotal(orders);

慣れている人には問題なく読める場合もありますが、初心者はそれぞれの戻り値の型を確認しなければ理解しにくいことがあります。

学習中は、型を明示するコードとvarを使うコードの両方を書いて、型の感覚を身につけることが大切です。

7. varを使うべき場面・使わないほうがよい場面

7-1. 右辺を見れば型が明らかな場合は使いやすい

右辺を見ただけで型が明らかな場合は、varを使いやすい場面です。

C#
var user = new User();
var names = new List<string>();
var stream = new FileStream(path, FileMode.Open);

このようなコードでは、右辺に型名が書かれているため、varを使っても読みやすさが損なわれにくいです。

7-2. 型名が長く冗長な場合はvarが便利

型名が長い場合も、varが便利です。

C#
var map = new Dictionary<string, List<int>>();

型名を明示すると、次のように長くなります。

C#
Dictionary<string, List<int>> map = new Dictionary<string, List<int>>();

同じ型名を繰り返すより、varを使ったほうが読みやすいことがあります。

7-3. 型を明示したほうが読みやすい場合

右辺から型がわかりにくい場合は、型を明示したほうがよいです。

C#
var result = service.Execute();

このコードでは、resultの型がすぐにはわかりません。戻り値の型が重要な意味を持つ場合は、次のように書くと読みやすくなります。

C#
PaymentResult result = service.Execute();

型名を明示することで、変数の役割やデータの意味が伝わりやすくなります。

7-4. チーム開発でのコーディング規約を確認する

チーム開発では、varの使い方についてコーディング規約が決められていることがあります。

たとえば、次のようなルールです。

C#
// 右辺で型が明らかな場合のみvarを使う
var user = new User();

// 戻り値がわかりにくい場合は型を明示する
User user = repository.FindById(id);

プロジェクトによっては「基本的にvarを使う」という方針もあれば、「型が明らかな場合だけ使う」という方針もあります。

個人の好みだけで判断せず、チームのルールに合わせることが大切です。

7-5. 初心者が意識すべき判断基準

初心者がvarを使うか迷ったときは、次の基準で考えるとよいです。

右辺を見ただけで型がわかるなら、varを使っても問題ありません。

C#
var user = new User();
var numbers = new List<int>();

一方、メソッドの戻り値など、型がすぐにわからない場合は型を明示すると読みやすくなります。

C#
User user = GetUser();

最初のうちは、型を理解するために明示的に書く練習も重要です。慣れてきたら、冗長な部分から少しずつvarを使うとよいでしょう。

8. 型推論とvarに関するよくある誤解

8-1. varはobject型になるわけではない

varを使うと、すべてobject型になると誤解されることがあります。しかし、これは間違いです。

C#
var name = "Taro";

この場合、nameはobject型ではなくstring型です。

C#
name = 123; // エラー

もしobject型として扱いたい場合は、明示的に書く必要があります。

C#
object name = "Taro";

8-2. varはJavaScriptのvarとは違う

C#のvarは、JavaScriptのvarとはまったく別のものです。

JavaScriptのvarは変数宣言のためのキーワードですが、C#のvarはコンパイラによる型推論を使うためのキーワードです。

C#
var count = 10;
count = "text"; // C#ではエラー

C#では、最初に推論された型と違う型の値を代入することはできません。

8-3. varを使っても型安全性は失われない

varを使っても、C#の型安全性は失われません。

C#
var age = 20;
age = 30;      // OK
age = "thirty"; // エラー

コンパイラが型チェックを行うため、間違った型を代入しようとするとコンパイルエラーになります。

8-4. varは実行時に型が決まるわけではない

varの型は実行時ではなく、コンパイル時に決まります。

C#
var value = 100;

この時点で、valueはint型としてコンパイルされます。実行中にstring型へ変わることはありません。

実行時に型を扱いたい場合は、dynamicを使います。

C#
dynamic value = 100;
value = "text"; // OK

ただし、dynamicは実行時エラーが起きやすくなるため、初心者は慎重に使う必要があります。

8-5. varを使うとパフォーマンスが悪くなるわけではない

varを使っても、基本的にパフォーマンスが悪くなることはありません。

C#
var number = 10;

これはコンパイル時にint number = 10;と同じように扱われます。varは実行時に型を探す仕組みではないため、余分な処理が増えるわけではありません。

パフォーマンスではなく、可読性を基準に使い分けることが大切です。

9. C#の型推論でよくあるエラーと対処法

9-1. 初期化されていないローカル変数にvarは使えない

varを使う場合、初期値が必要です。

C#
var count; // エラー

型を推論する材料がないため、コンパイラは型を判断できません。

対処法は、初期値を指定することです。

C#
var count = 0;

または、型を明示します。

C#
int count;

9-2. nullを直接代入すると型を推論できない

次のコードはエラーになります。

C#
var value = null;

nullだけでは型がわからないためです。

対処法は、型を明示することです。

C#
string? value = null;

または、キャストで型を指定します。

C#
var value = (string?)null;

9-3. ラムダ式だけでは型推論できない場合がある

ラムダ式を直接varに代入しようとすると、エラーになる場合があります。

C#
var func = x => x * 2; // エラー

ラムダ式は、どのデリゲート型に変換するかが必要です。

対処法として、型を明示します。

C#
Func<int, int> func = x => x * 2;

このように書けば、xがintで、戻り値もintだと判断できます。

9-4. 暗黙的な型変換で想定外の型になる

varは右辺の型をそのまま推論するため、想定と違う型になることがあります。

C#
var value = 1 / 2;
Console.WriteLine(value); // 0

この場合、1と2はどちらもintなので、整数同士の割り算になります。結果は0.5ではなく0です。

小数として扱いたい場合は、次のように書きます。

C#
var value = 1.0 / 2;
Console.WriteLine(value); // 0.5

または、型を明示します。

C#
double value = 1.0 / 2;

9-5. エラー時はIDEで推論された型を確認する

varを使っていて型がわからなくなった場合は、Visual StudioやVisual Studio CodeなどのIDEで変数にマウスカーソルを合わせると、推論された型を確認できます。

C#
var users = GetUsers();

このようなコードでusersの型がわからない場合は、IDEの補完や型情報を確認しましょう。

また、一時的に型を明示してみるのも有効です。

C#
List<User> users = GetUsers();

型を確認してから、必要に応じてvarに戻すと理解しやすくなります。

10. 型推論を理解するための実践コード例

10-1. int・string・boolでの基本例

まずは基本的な型の例です。

C#
var age = 25;
var name = "Taro";
var isMember = true;

Console.WriteLine(age);
Console.WriteLine(name);
Console.WriteLine(isMember);

このコードでは、次のように型推論されます。

C#
// age は int
// name は string
// isMember は bool

varを使っても、それぞれの変数は明確な型を持っています。

10-2. 配列やコレクションでの使用例

配列やコレクションでもvarを使えます。

C#
var numbers = new int[] { 1, 2, 3 };
var names = new List<string> { "Taro", "Hanako", "Jiro" };

foreach (var number in numbers)
{
    Console.WriteLine(number);
}

foreach (var name in names)
{
    Console.WriteLine(name);
}

numbersはint[]、namesはList<string>として推論されます。

foreachの中のnumberはint、nameはstringです。

10-3. LINQでの使用例

LINQとvarの相性は非常に良いです。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach (var number in evenNumbers)
{
    Console.WriteLine(number);
}

evenNumbersは、偶数だけを取り出した結果です。LINQの戻り値の型は長くなることがあるため、varを使うとコードが簡潔になります。

10-4. 匿名型での使用例

匿名型ではvarが必要です。

C#
var user = new
{
    Id = 1,
    Name = "Taro",
    Email = "taro@example.com"
};

Console.WriteLine(user.Id);
Console.WriteLine(user.Name);
Console.WriteLine(user.Email);

このように、一時的なデータのまとまりを作るときに匿名型は便利です。

LINQのselectでもよく使われます。

C#
var users = new[]
{
    new { Id = 1, Name = "Taro", Age = 20 },
    new { Id = 2, Name = "Hanako", Age = 25 }
};

var userNames = users.Select(user => new
{
    user.Id,
    user.Name
});

foreach (var user in userNames)
{
    Console.WriteLine($"{user.Id}: {user.Name}");
}

10-5. varを使わないほうがよい例

次のようなコードでは、varを使うと型がわかりにくくなります。

C#
var result = GetResult();
var data = Load();
var item = repository.Find(id);

メソッド名だけでは戻り値の型が判断しにくいため、読み手に負担がかかります。

型を明示すると、意味がわかりやすくなります。

C#
SearchResult result = GetResult();
UserData data = Load();
Product item = repository.Find(id);

varを使うかどうかは、コードの短さだけでなく、読みやすさを基準に判断することが大切です。

11. C#の型推論に関するよくある質問

11-1. C#ではvarを積極的に使うべき？

varを積極的に使うべきかどうかは、プロジェクトやチームの方針によります。

右辺を見れば型が明らかな場合や、型名が長い場合はvarを使うと便利です。

C#
var user = new User();
var list = new List<string>();

一方、メソッドの戻り値がわかりにくい場合は、型を明示したほうが読みやすくなります。

C#
User user = GetUser();

初心者は、最初からすべてvarにするのではなく、型が明らかな場面から使い始めるとよいでしょう。

11-2. varとdynamicの違いは？

varとdynamicは大きく違います。

varはコンパイル時に型が決まります。

C#
var value = "Hello";
value = 123; // エラー

dynamicは実行時に型が扱われます。

C#
dynamic value = "Hello";
value = 123; // OK

varは型安全ですが、dynamicはコンパイル時の型チェックが弱くなります。通常のC#開発では、必要な場面以外でdynamicを使うことはあまりありません。

11-3. varと暗黙的な型変換は同じ？

varと暗黙的な型変換は同じではありません。

varは、右辺の型を推論して変数の型を決める仕組みです。

C#
var number = 10; // int

暗黙的な型変換は、ある型の値を別の型に自動変換する仕組みです。

C#
int number = 10;
long bigNumber = number; // int から long へ暗黙的に変換

varは型を推論するだけで、意図的に別の型へ変換するわけではありません。

11-4. varで宣言した変数の型を確認する方法は？

IDEを使うと簡単に確認できます。Visual StudioやVisual Studio Codeでは、varで宣言した変数にマウスカーソルを合わせると、推論された型が表示されます。

また、学習目的であればGetType()を使って実行時の型を確認することもできます。

C#
var name = "Taro";
Console.WriteLine(name.GetType());

出力例は次のようになります。

C#
System.String

ただし、GetType()は実行時の型を確認する方法です。コンパイル時の型を理解するには、IDEの型情報やコンパイルエラーを確認するのが有効です。

11-5. 初心者はvarをいつから使えばよい？

初心者は、まずint、string、bool、List<T>など基本的な型を理解してからvarを使うとよいです。

最初からすべてvarにすると、型の感覚が身につきにくくなることがあります。

おすすめは、次のような段階的な使い方です。

C#
int age = 20;
string name = "Taro";
bool isActive = true;

基本的な型に慣れたら、右辺で型が明らかな場面からvarを使ってみましょう。

C#
var user = new User();
var names = new List<string>();

型を理解したうえでvarを使うと、C#のコードをより簡潔に、読みやすく書けるようになります。

まとめ

C#の型推論とは、コンパイラが変数や式の型を自動で判断する仕組みです。varはその型推論を利用して、ローカル変数の型名を省略して書くためのキーワードです。

varを使っても、変数の型がなくなるわけではありません。型はコンパイル時に決まり、一度決まった型を別の型に変更することはできません。そのため、C#の型安全性は保たれます。

varは、右辺を見れば型が明らかな場合、型名が長い場合、LINQや匿名型を扱う場合に便利です。

C#
var user = new User();
var names = new List<string>();
var result = names.Where(name => name.Length >= 3);

一方で、メソッドの戻り値がわかりにくい場合や、変数の型を明示したほうが読みやすい場合は、無理にvarを使う必要はありません。

C#
User user = GetUser();
PaymentResult result = service.Execute();

初心者は、まず基本的な型を理解し、右辺から型が明らかな場面でvarを使うことから始めるのがおすすめです。型推論とvarを正しく理解すれば、C#のコードをより短く、読みやすく、安全に書けるようになります。