C#を用いて開発を行う際、変数宣言で頻繁に目にするのが var キーワードです。

この var は「型推論」と呼ばれる機能を提供しますが、エンジニアの間では「コードが読みづらくなるため非推奨ではないか」「乱用すべきではない」といった議論が交わされることが少なくありません。

しかし、結論から申し上げますと、現代のC#開発においてvarは決して非推奨の機能ではありません。

むしろ、Microsoftの公式ガイドラインや多くのモダンな開発現場では、特定の条件下において var の使用が強く推奨されています。

大切なのは「何でも var で書く」ことでも「一切使わない」ことでもなく、コードの可読性と保守性を最大化するための適切な使い分けを理解することです。

本記事では、var の仕組みから、メリット・デメリット、そして現場で役立つ具体的な判断基準までを徹底的に解説します。

目次 [ close ]
  1. C#におけるvar（型推論）の基本概念
  2. なぜ「varは非推奨」という誤解が生まれたのか
    1. 1. 型が直感的に分かりにくくなる懸念
    2. 2. IDE（統合開発環境）への依存
    3. 3. 初期C#からの慣習
  3. varを使用するメリット
    1. 冗長な記述の排除
    2. リファクタリングの容易性
    3. 匿名型の利用
  4. varを使用するデメリットと注意点
    1. コードの意図が不透明になる
    2. プリミティブ型における混乱
  5. Microsoftが推奨するベストプラクティス
  6. 実践的な使い分け：推奨されるケースと避けるべきケース
    1. 推奨：new 演算子で型が明示されている場合
    2. 推奨：LINQクエリの戻り値
    3. 避けるべき：プリミティブ型の単純な代入
    4. 避けるべき：戻り値の型が推測しにくいメソッド呼び出し
  7. C#の進化とvarの立ち位置
    1. ターゲット型 new 式 (C# 9.0以降)
  8. チーム開発におけるコーディング規約の重要性
  9. プログラム例：varの効果的な活用
  10. まとめ

C#におけるvar（型推論）の基本概念

まず、var の正確な性質を整理しておきましょう。

var はC# 3.0で導入されたキーワードで、コンパイラが右辺の式から変数の型を自動的に決定する 「暗黙的な型指定」 を行うためのものです。

ここで非常に重要な点は、var は JavaScript などの動的型付け言語における変数宣言とは根本的に異なるという点です。

C#の var は、あくまでコンパイル時に型が確定する 静的型付け です。

一度型が決定すれば、その後に異なる型の値を代入することはできません。

C#
// varを用いた宣言
var message = "Hello, C#"; // コンパイラがstring型と判断する

// 以下のコードはコンパイルエラーになる
// message = 100; // string型の変数にint型は代入できない

このように、var は開発者のタイピング量を減らすだけでなく、プログラムの堅牢性を維持したまま記述を簡略化する役割を担っています。

なぜ「varは非推奨」という誤解が生まれたのか

「var は使わないほうが良い」という意見の背景には、主に可読性への懸念と、古いプログラミング慣習への固執があります。

1. 型が直感的に分かりにくくなる懸念

コードをエディタやレビュー画面で見た際、明示的に int や string と書かれていれば一目で型が分かります。

しかし、var を多用しすぎると、メソッドの戻り値などが何であるかを推測するために、定義元まで遡らなければならない場面が生じます。

これが「可読性を損なう」という批判の主な根拠です。

2. IDE（統合開発環境）への依存

Visual Studio などの高機能なIDEを使用していれば、var の上にマウスをホバーするだけで実際の型を確認できます。

しかし、GitHub上でのコードレビューや、簡易的なテキストエディタでソースコードを読む場合、IDEの支援が受けられず、型が不明なままロジックを読み解かなければなりません。

3. 初期C#からの慣習

C# 1.0や2.0の頃から開発に携わっているエンジニアの中には、すべての型を明示的に記述するスタイルを好む層が一定数存在します。

また、Javaなどの他言語から移行してきた開発者にとっても、型を隠蔽する記述に抵抗を感じるケースがあるようです。

varを使用するメリット

var を適切に使用することで、開発効率とコードの品質は大きく向上します。

主なメリットは以下の通りです。

冗長な記述の排除

C#では、クラス名が長くなる傾向があります。

特にジェネリクスを使用する場合、左辺と右辺の両方に同じ長い型名を記述するのは非常に冗長です。

C#
// 明示的な型指定（冗長な例）
Dictionary<string, List<int>> data = new Dictionary<string, List<int>>();

// varを使用した例（スッキリする）
var data = new Dictionary<string, List<int>>();

このように、右辺を見れば型が明らかな場合、var を使うことでコードのノイズを減らし、「何を作成しているか」という本質的な情報に集中できるようになります。

リファクタリングの容易性

変数の型を変更したい場合、明示的な宣言を行っていると、宣言箇所と代入箇所の両方を修正する必要があります。

しかし、var を使用していれば、右辺の型を変更するだけで済むため、変更の影響範囲を最小限に抑えることができます。

匿名型の利用

LINQ（Language Integrated Query）などで生成される「名前のない型（匿名型）」を扱う場合、var の使用は必須となります。

匿名型には明示的な型名が存在しないため、var がなければそのデータを受け取ることができません。

C#
var userInfo = new { Name = "田中", Age = 30 };
Console.WriteLine($"{userInfo.Name}さんの年齢は{userInfo.Age}です。");

varを使用するデメリットと注意点

一方で、無計画な var の使用は、チーム開発において負債となる可能性があります。

コードの意図が不透明になる

例えば、以下のようなコードでは var が可読性を下げています。

C#
var result = service.Execute();

この result が bool なのか、実行結果のオブジェクトなのか、あるいはエラーコードの整数なのか、変数名やメソッド名から推測できない場合、コードを読む人の負担が増大します。

プリミティブ型における混乱

int、double、float などの数値型を var で宣言すると、リテラルの書き方次第で意図しない型として推論されるリスクがあります。

C#
var value = 10.0; // double型と推論される
// float型を意図していた場合、10.0f と書く必要がある

Microsoftが推奨するベストプラクティス

Microsoftの公式なコーディング規約（C# Coding Conventions）では、var の使用について以下のような指針を示しています。

使用場面推奨される選択理由
右辺で型が明らかな場合var冗長性を排除し、読みやすくするため
匿名型を扱う場合var型名が存在しないため必須
プリミティブ型（int, stringなど）明示的な型基本的な型は明示したほうが意図が伝わりやすいため
ループ変数（foreach）varコレクションから型が自明な場合が多いため

このガイドラインの根底にある考え方は、「開発者がコードを読んだときに、型を即座に判別できるかどうか」です。

実践的な使い分け：推奨されるケースと避けるべきケース

具体的なコード例を通して、現場でどのように使い分けるべきかを詳しく見ていきましょう。

推奨：new 演算子で型が明示されている場合

右辺に new キーワードと型名が記述されている場合は、var を積極的に使うべきです。

C#
// 推奨される書き方
var customerList = new List<Customer>();
var logger = new FileLogger("log.txt");
var httpClient = new HttpClient();

これらの例では、左辺を List<Customer> と書かなくても、右辺を見れば型は一目瞭然です。

推奨：LINQクエリの戻り値

LINQを使用する場合、戻り値の型が複雑になりやすいため、var の使用が一般的です。

C#
var employees = GetEmployees();
var highEarners = employees
    .Where(e => e.Salary > 500000)
    .Select(e => new { e.Name, e.Department }); // 匿名型

foreach (var person in highEarners)
{
    Console.WriteLine($"{person.Name} ({person.Department})");
}

避けるべき：プリミティブ型の単純な代入

数値や文字列の単純な初期化では、var を使うメリットはほとんどありません。

C#
// 非推奨（型名をそのまま書いたほうが短く、明確）
var count = 0;
var name = "Unknown";

// 推奨
int count = 0;
string name = "Unknown";

避けるべき：戻り値の型が推測しにくいメソッド呼び出し

メソッド名から型が想像できない場合は、型を明示するか、変数名を工夫する必要があります。

C#
// 避けるべき例（型が何かわからない）
var data = repository.Fetch();

// 改善例1：型を明示する
UserEntity data = repository.Fetch();

// 改善例2：変数名を具体的にする
var user = repository.Fetch();

C#の進化とvarの立ち位置

C#はバージョンアップを重ねるごとに、より簡潔な記述ができるよう進化しています。

最新のC#では、var 以外の選択肢も増えています。

ターゲット型 new 式 (C# 9.0以降)

C# 9.0からは「ターゲット型 new 式」が導入されました。

これにより、左辺で型を明示していれば、右辺の new 以降の型名を省略できるようになりました。

C#
// varを使用するスタイル
var list = new List<string>();

// ターゲット型 new を使用するスタイル
List<string> list = new();

この「ターゲット型 new」は、var の「型名が右側にしかない」というメリットと、明示的宣言の「型が左側に必ずある」というメリットを両立させた非常に強力な構文です。

現在では、「変数宣言時には var を使い、フィールド（メンバ変数）の初期化にはターゲット型 new を使う」といった使い分けも一般的になっています。

なぜなら、フィールドの宣言では var が使用できないという制約があるためです。

チーム開発におけるコーディング規約の重要性

var の使用基準は、最終的にはプロジェクトやチームの規約に依存します。

どれだけ言語仕様として正しくても、チームメンバーが読みづらいと感じれば、それはそのプロジェクトにとっての正解ではありません。

もしあなたがチームリーダーやアーキテクトであれば、以下のルールをチーム内で共有することをお勧めします。

  1. 「右辺から型が自明な場合は var を推奨する」
  2. 「型を明示することで可読性が上がる場合は、var を禁止する」
  3. 「迷ったときは型を明示する」

また、静的解析ツール（StyleCop や .editorconfig）を活用することで、var の使用ルールを自動的にチェックし、コードの品質を一定に保つことが可能です。

プログラム例：varの効果的な活用

最後に、実際の開発シーンを想定したプログラム例で、var の使い分けを確認してみましょう。

C#
using System;
using System.Collections.Generic;
using System.Linq;

namespace VarUsageExample
{
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 【推奨】newにより型が明らかな場合
            var users = new List<User>
            {
                new User { Id = 1, Name = "Alice" },
                new User { Id = 2, Name = "Bob" },
                new User { Id = 3, Name = "Charlie" }
            };

            // 【推奨】LINQの複雑な型・匿名型
            var query = users
                .Where(u => u.Id > 1)
                .Select(u => new { u.Name, UpperName = u.Name.ToUpper() });

            // 【推奨】foreachのループ変数
            foreach (var item in query)
            {
                Console.WriteLine($"Name: {item.Name}, Upper: {item.UpperName}");
            }

            // 【避けるべき】プリミティブ型は明示的に書く
            int threshold = 1;
            string label = "Result: ";

            // メソッドの戻り値を受け取る場合（型が重要な場合は明示）
            User firstUser = users.First();
            Console.WriteLine($"{label}{firstUser.Name}");
        }
    }
}
実行結果
Name: Bob, Upper: BOB
Name: Charlie, Upper: CHARLIE
Result: Alice

このコードでは、リストの生成やLINQのクエリ結果には var を使い、コードの記述を簡潔にしています。

一方で、閾値を示す int 型や、特定のオブジェクトを取得する際には型を明示することで、プログラムの意図を明確に伝えています。

まとめ

C#の var キーワードは、決して「初心者が使うべきではない機能」や「可読性を下げるだけの非推奨機能」ではありません。

むしろ、冗長なコードを排除し、ロジックの本質を際立たせるための洗練された道具です。

本記事のポイントを振り返ります。

  • var は静的型付けであり、パフォーマンス上のデメリットはない。
  • 右辺から型が明白な場合（new 演算子、キャスト、リテラルなど）は積極的に活用する。
  • 匿名型やLINQを扱う際には必須の機能である。
  • プリミティブ型や、型が推測しにくいメソッド戻り値には使用を避ける。
  • 最新のC#では ターゲット型 new との使い分けも検討する。

大切なのは「型が見えること」そのものではなく、「コードの意図が正しく伝わること」です。

var を適切に使いこなし、クリーンでメンテナンスしやすいC#コードを目指しましょう。