【C#】target-typed new完全ガイド｜var vs new()・使えるコンテキスト・コレクション式・.editorconfig設定まで

// Before（C# 8 以前）: 左辺と右辺に同じ型を書く冗長なコード
Dictionary<string, List<int>> scores = new Dictionary<string, List<int>>();
StringBuilder sb = new StringBuilder(256);
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));

// After（C# 9+）: 左辺で型が分かるので右辺は new() だけ
Dictionary<string, List<int>> scores = new();
StringBuilder sb = new(256);
CancellationTokenSource cts = new(TimeSpan.FromSeconds(30));

// コンストラクタ引数・初期化子もそのまま使える
Dictionary<string, int> map = new()
{
    ["Alice"] = 90,
    ["Bob"]   = 85,
};

List<string> names = new(capacity: 100) { "A", "B", "C" };

// var 派: 「右辺で型が分かるなら左辺は var」
var list   = new List<string>();        // 右辺に型名がある
var user   = new User("Alice", 30);    // 右辺に型名がある
var scores = new Dictionary<string, int>();

// new() 派: 「左辺で型が分かるなら右辺は new()」
List<string> list2              = new();
User user2                      = new("Alice", 30);
Dictionary<string, int> scores2 = new();

// 両方が使えるとき、チームでどちらかに統一するのがベスト
// → .editorconfig で制御（後述）

// 型が「どちらにも」書かれない場合はコンパイルエラー
// var x = new();  // CS8754: 型が推論できません

List<int> numbers = new();
StringBuilder sb  = new(128);

public class OrderService
{
    // フィールド初期化
    private readonly List<Order> _orders = new();
    private readonly SemaphoreSlim _gate = new(10);

    // プロパティ初期化（init / set どちらでも）
    public List<string> Tags { get; init; } = new();
    public ConcurrentDictionary<string, int> Cache { get; } = new();
}

// 引数の型が確定しているなら new() で渡せる
public void Configure(JsonSerializerOptions options) { }

Configure(new() { WriteIndented = true });  // 型推論で JsonSerializerOptions

// コレクション引数
public void AddRange(List<int> items) { }
AddRange(new() { 1, 2, 3 });

public List<User> GetDefaultUsers()
{
    return new()   // List<User> と推論
    {
        new("Alice", 30),
        new("Bob", 25),
    };
}

// 式形式
public List<int> Empty() => new();

// 例外の new にも使える
public string Name { get; init; } = ""
    ?? throw new();  // NullReferenceException() ← 型が文脈から推論されない場合は使えない

// 一般的には例外は型名を明示する方が読みやすいのでこの用途は稀
public string Name2 => _name ?? throw new InvalidOperationException("Name is required");

// C# 9+ では三項演算子の結果型をターゲット型から推論できる
ILogger logger = useConsole
    ? new ConsoleLogger()     // ILogger に暗黙変換可能
    : new FileLogger("app");  // ILogger に暗黙変換可能

// C# 8 以前ではキャストが必要だった
ILogger logger2 = useConsole
    ? (ILogger)new ConsoleLogger()
    : (ILogger)new FileLogger("app");

// new() と組み合わせることもできる（左辺の型が確定していれば）
List<string> items = condition ? new() { "a" } : new() { "b", "c" };

// ?? の右辺で new()
List<string> tags = existingTags ?? new();

// ??= の右辺で new()（遅延初期化パターン）
private List<Order>? _orders;
public List<Order> Orders => _orders ??= new();

// init 付きプロパティのデフォルト値として
public HashSet<string> AllowedRoles { get; init; } = new() { "admin", "user" };

// 配列型が確定していれば各要素に new()
Point[] triangle = { new(0, 0), new(1, 0), new(0, 1) };

// ジェネリックコレクション内
List<Point> points = new() { new(0, 0), new(1, 0), new(0, 1) };

IShape shape = type switch
{
    "circle"    => new Circle(radius: 5),
    "rectangle" => new Rectangle(10, 20),
    _           => new UnknownShape(),
};

// Select の戻り値型が推論されるケース
IEnumerable<User> users = names.Select(n => new User(n, 0));
// → Select<string, User> で User が推論されるため new User(...) は必須

// ToList の型指定あり
List<Point> points = coords.Select(c => new Point(c.X, c.Y)).ToList();

// Before（C# 9 target-typed new）
List<int> a = new() { 1, 2, 3 };
int[] b     = new[] { 1, 2, 3 };
Span<int> c = stackalloc int[] { 1, 2, 3 };

// After（C# 12 コレクション式）
List<int> a2 = [1, 2, 3];
int[] b2     = [1, 2, 3];
Span<int> c2 = [1, 2, 3];

// 空コレクション
List<string> empty = [];   // new() の代わりに []

// スプレッド演算子で結合
int[] first = [1, 2, 3];
int[] second = [4, 5, 6];
int[] combined = [.. first, .. second]; // [1, 2, 3, 4, 5, 6]

// ImmutableArray にも使える
ImmutableArray<string> names = ["Alice", "Bob"];

// Dictionary はコレクション式の対象外（C# 12 時点）
// → 引き続き new() { ["key"] = value } を使う
Dictionary<string, int> scores = new() { ["Alice"] = 90 };

// .editorconfig に以下を設定するとIDEが警告/エラーを出す

// 「型が明らかなときは new() を使え」（new() 派向け）
// csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion

// IDE0090: 'new' 式を簡略化できます
// → Dictionary<string, int> scores = new Dictionary<string, int>();
//    と書くと IDE が new() への変更を提案する

// ルールの厳格度:
// :silent     → 非表示（自動修正のみ）
// :suggestion → メッセージとして表示
// :warning    → 警告（黄色の波線）
// :error      → エラー（ビルドを止める）

// 推奨設定（.editorconfig の [*.cs] セクション）:
// csharp_style_implicit_object_creation_when_type_is_apparent = true:warning

// var 派 vs new() 派の両方をカバーする設定例:
// csharp_style_var_for_built_in_types = true:suggestion
// csharp_style_var_when_type_is_apparent = true:suggestion
// csharp_style_var_elsewhere = false:suggestion
// csharp_style_implicit_object_creation_when_type_is_apparent = true:warning

// 値型では new() と default の動作が異なる場合がある

// パラメータなしコンストラクタがある struct（C# 10+）
public struct Counter
{
    public int Value { get; set; }
    public Counter() => Value = 1;  // カスタムパラメータなしコンストラクタ
}

Counter a = new();      // Value = 1（コンストラクタが呼ばれる）
Counter b = default;    // Value = 0（全フィールドゼロ初期化、コンストラクタは呼ばれない）
Counter c = new Counter(); // Value = 1（new() と同じ）

// readonly record struct
public readonly record struct Point(int X, int Y);
Point p = new(3, 4);  // target-typed new で生成

// 重要: default と new() は struct では異なる結果になり得る
// default は常にゼロ初期化、new() はコンストラクタを呼ぶ

// ① var と組み合わせ不可（型情報がどこにもない）
// var x = new();  // CS8754

// ② dynamic 型への推論不可
// dynamic d = new();  // CS8754

// ③ オーバーロード解決が曖昧な場合
public void Process(List<int> items) { }
public void Process(HashSet<int> items) { }
// Process(new() { 1, 2, 3 });  // CS0121: オーバーロードが曖昧

// ④ 匿名型は new() で作れない（匿名型にはコンストラクタがない）
// var anon = new { Name = "Alice" };  // これは従来の匿名型（new() ではない）

// ⑤ インターフェース型への直接 new()
// IList<int> x = new();  // CS8754: IList は new() で生成できない
// IList<int> x = new List<int>(); // OK: 具象型を明示

// ⑥ Nullable<T> への new()
// int? x = new();  // これは int? の new() = 0 になる（意図と違う可能性）
int? x = new();
Console.WriteLine(x);        // 0（null ではない）
Console.WriteLine(x is null); // false

// ⑦ ジェネリック型パラメータ T への new()
public T Create<T>() where T : new()
{
    return new T();  // OK（new 制約があるため。明示的に型を書く方が読みやすい）
    // return new(); // C# 9+ で動作する場合もあるが、T が具象型でないため可読性が低い
}

builder.Services.Configure<SmtpOptions>(opt =>
{
    opt.Host = "smtp.example.com";
    opt.Port = 587;
});

// PostConfigure のデフォルト値設定
builder.Services.PostConfigure<SmtpOptions>(opt =>
{
    opt.AllowedRecipients ??= new();  // null なら空リストを設定
});

[Fact]
public async Task Order_Succeeds()
{
    // Arrange: 長い型名を new() で省略
    var svc = new OrderService(
        new FakeOrderRepository(),
        new FakePaymentGateway(),
        NullLogger<OrderService>.Instance);

    // フィールド初期化も new() で
    Order order = new()
    {
        Id         = 1,
        CustomerId = 42,
        Items      = new() { new("Book", 1500), new("Pen", 200) },
        CreatedAt  = DateTime.UtcNow,
    };

    // Act
    var result = await svc.ProcessAsync(order);

    // Assert
    Assert.True(result.Success);
}

// switch 式で異なる型のインスタンスを返す
public INotification CreateNotification(string type, string message)
    => type switch
    {
        "email" => new EmailNotification { To = "a@x", Body = message },
        "slack" => new SlackNotification { Channel = "#dev", Text = message },
        "sms"   => new SmsNotification   { Phone = "090...", Body = message },
        _       => throw new ArgumentException($"Unknown type: {type}"),
    };

public class LazyCache
{
    private Dictionary<string, object>? _store;

    // 最初のアクセスで初期化
    public Dictionary<string, object> Store => _store ??= new();
}

// init 付きでもデフォルト値として
public class Config
{
    public required string Name { get; init; }
    public List<string> Tags { get; init; } = new();
    public Dictionary<string, string> Metadata { get; init; } = new();
}

// NG: ジェネリックメソッドチェーンの深い位置で new() を使うと読みづらい
var result = Process(new(), new(), new());  // 引数の型がシグネチャを見ないと分からない

// OK: 引数が多いときは変数に分ける or 名前付き引数を使う
HttpClientHandler handler = new() { AllowAutoRedirect = false };
var result2 = Process(handler, new CancellationTokenSource(TimeSpan.FromSeconds(30)));

// int? x = new(); は 0 を返す（null ではない！）
int? x = new();
Console.WriteLine(x.HasValue); // true
Console.WriteLine(x.Value);    // 0

// null にしたいなら
int? y = null;
int? z = default; // これも null（Nullable<int> の default は null）

// new() が default と異なる動作をするのは struct の場合
// 参照型では new() は常にインスタンス生成、default は null

// オーバーロードがある場合、new() は解決ができないことがある
public static void Print(StringBuilder sb) => Console.WriteLine(sb);
public static void Print(StringWriter sw) => Console.WriteLine(sw);

// Print(new());  // CS0121: 曖昧
Print(new StringBuilder());  // OK: 型を明示

// → new() はオーバーロード解決に型情報を提供しないため、
//    呼び出し先が一意に決まらないと曖昧エラーになる