演算子

【C#】newキーワードで学ぶオブジェクト生成の基本と応用テクニック

2025-05-21更新日: 2025-05-21

C#のnewはオブジェクト生成と初期化を一手に担い、メモリ確保とコンストラクター呼び出しを自動で行います。

クラス、構造体、配列、匿名型、ジェネリックコレクションなどを簡潔に作成でき、型安全に扱いを開始できます。

生成した参照を失えばガベージコレクションが回収し、IDisposable実装型はusingで明示的に破棄すると安全です。

目次から探す

newキーワードの基礎理解
基本構文と代表的な使い方
コンストラクターとnewの関係性
ジェネリック型とnew()制約
匿名型・タプル・レコードの生成
コレクションおよび特殊メモリ領域での生成
動的オブジェクト生成テクニック
- Activator.CreateInstanceの使いどころ
- リフレクションのパフォーマンス最適化
new修飾子によるメンバー隠蔽
メモリ効率を意識した生成戦略
ヌル許容参照型との連携
- 非null初期化のベストパターン
- null抑制演算子とnew()初期化子の使い分け
例外・リソース管理とnew
- コンストラクター内での例外ハンドリング
- using宣言とIDisposable型生成
まとめ

newキーワードの基礎理解

C#におけるnewキーワードは、オブジェクト指向プログラミングの基本であるインスタンス生成を行うための重要な構文です。

ここでは、new式がどのような処理を行っているのか、参照型と値型でのメモリ配置の違い、そしてヒープ確保とガベージコレクションの関係について詳しく解説いたします。

new式で行われる処理フロー

new式は、単にオブジェクトを作るだけでなく、複数の処理を連続して行っています。

具体的には以下のような流れで処理が進みます。

メモリの確保

newキーワードを使うと、まずオブジェクトのサイズに応じたメモリ領域が確保されます。

参照型の場合はヒープ領域に、値型の場合はスタックやヒープに割り当てられます。

コンストラクターの呼び出し

確保されたメモリ領域に対して、指定されたコンストラクターが呼び出されます。

コンストラクターはオブジェクトの初期化を担当し、フィールドやプロパティに初期値をセットします。

参照の返却

参照型の場合は、確保されたヒープ上のオブジェクトのアドレスを指す参照が返されます。

値型の場合は、値そのものが返されます。

変数への代入

返された参照や値が変数に代入され、以降その変数を通じてオブジェクトにアクセスできるようになります。

以下のサンプルコードは、new式の基本的な使い方を示しています。

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}
class Program
{
    static void Main()
    {
        // new式でPersonクラスのインスタンスを生成し、変数personに代入
        Person person = new Person("Alice", 30);
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
    }
}

Name: Alice, Age: 30

このコードでは、new Person("Alice", 30)が呼ばれると、ヒープにメモリが確保され、Personのコンストラクターが呼ばれて初期化されます。

最後に、その参照がperson変数に代入されます。

参照型と値型のメモリ配置の差異

C#の型は大きく分けて「参照型」と「値型」に分類されます。

newキーワードを使ったインスタンス生成時のメモリ配置は、この分類によって異なります。

型の種類	メモリ配置場所	変数に格納される内容	例
参照型	ヒープ	オブジェクトのアドレス(参照)	クラス、配列、文字列など
値型	スタックまたはヒープ(ボックス化時)	実際の値	構造体、列挙型、プリミティブ型(int, boolなど)

参照型の場合

参照型は、new式でヒープ領域にオブジェクトの実体が作られます。

変数にはそのオブジェクトのメモリアドレスが格納され、変数を通じてオブジェクトのメンバーにアクセスします。

複数の変数が同じオブジェクトを参照することも可能です。

値型の場合

値型は通常、変数が直接値を保持します。

newキーワードを使って構造体を生成すると、スタック上にその値が割り当てられます。

ただし、値型を参照型として扱う場合(ボクシング)には、ヒープにコピーが作られます。

以下のサンプルコードで、参照型と値型の違いを確認してみましょう。

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}
public struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}
class Program
{
    static void Main()
    {
        // 参照型の例
        Person person1 = new Person("Bob", 25);
        Person person2 = person1; // person2はperson1と同じオブジェクトを参照
        person2.Name = "Charlie";
        Console.WriteLine($"person1.Name: {person1.Name}"); // "Charlie"になる
        // 値型の例
        Point p1 = new Point(10, 20);
        Point p2 = p1; // p2はp1の値をコピー
        p2.X = 30;
        Console.WriteLine($"p1.X: {p1.X}"); // 10のまま変わらない
    }
}

person1.Name: Charlie
p1.X: 10

この例では、person2がperson1と同じオブジェクトを参照しているため、person2.Nameを変更するとperson1.Nameも変わります。

一方、Point構造体は値型なので、p2はp1のコピーであり、p2.Xを変更してもp1.Xは変わりません。

ヒープ確保とガベージコレクションの関係

newキーワードで参照型のオブジェクトを生成すると、メモリはヒープ領域に確保されます。

ヒープは動的にメモリを割り当てる領域で、プログラムの実行中にサイズが変動します。

ヒープに確保されたオブジェクトは、不要になったときに自動的に解放される仕組みが必要です。

これを担うのがC#のガベージコレクション(GC)です。

ヒープ確保の特徴

ヒープは大きなメモリ領域で、複数のオブジェクトが格納されます
new式で生成されたオブジェクトはヒープに配置され、変数はそのオブジェクトの参照を保持します
ヒープ上のオブジェクトは、プログラムのどこからでも参照可能です

ガベージコレクションの役割

ガベージコレクターは、ヒープ上のオブジェクトの参照状況を監視します
どの変数やオブジェクトからも参照されていないオブジェクトは「不要」と判断され、メモリが解放されます
開発者が明示的にメモリ解放を行う必要がなく、メモリ管理の負担を軽減します

GCの動作イメージ

プログラムがnewでオブジェクトを生成し、ヒープに配置。
変数や他のオブジェクトがそのオブジェクトを参照。
参照がなくなったオブジェクトはGCの対象となります。
GCが不要なオブジェクトのメモリを回収し、ヒープの空き領域を増やす。

以下のコードは、newで生成したオブジェクトがGCの対象になる例です。

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}
class Program
{
    static void Main()
    {
        CreatePerson();
        GC.Collect(); // 明示的にGCを呼び出す(通常は不要)
        Console.WriteLine("GCが実行されました。");
    }
    static void CreatePerson()
    {
        Person tempPerson = new Person("Dave", 40);
        Console.WriteLine($"Created: {tempPerson.Name}");
        // tempPersonのスコープが終了すると参照がなくなる
    }
}

Created: Dave
GCが実行されました。

この例では、CreatePersonメソッド内でPersonオブジェクトを生成しています。

メソッド終了後、tempPersonの参照はスコープ外となり、GCの対象になります。

GC.Collect()は明示的にガベージコレクションを呼び出していますが、通常はランタイムが自動で管理します。

注意点

ガベージコレクションは便利ですが、頻繁に発生するとパフォーマンスに影響を与えます
大量のオブジェクトをnewで生成する場合は、オブジェクトプールなどの再利用技術を検討すると良いでしょう

このように、newキーワードは単なるインスタンス生成のための構文ではなく、メモリ確保や初期化、参照管理と密接に関わっています。

これらの基礎を理解することで、C#のオブジェクト生成の仕組みをより深く把握でき、効率的なプログラム設計に役立てられます。

基本構文と代表的な使い方

クラスインスタンス生成の書式

クラスのインスタンスを生成する際は、newキーワードを使ってコンストラクターを呼び出します。

基本的な書式は以下の通りです。

ClassName variableName = new ClassName(arguments);

ここで、ClassNameはクラス名、variableNameは変数名、argumentsはコンストラクターに渡す引数です。

引数がない場合は空の括弧()を付けます。

以下は、Carクラスのインスタンスを生成する例です。

public class Car
{
    public string Model { get; set; }
    public int Year { get; set; }
    public Car(string model, int year)
    {
        Model = model;
        Year = year;
    }
}
class Program
{
    static void Main()
    {
        Car myCar = new Car("Toyota", 2020);
        Console.WriteLine($"Model: {myCar.Model}, Year: {myCar.Year}");
    }
}

Model: Toyota, Year: 2020

この例では、new Car("Toyota", 2020)でCarクラスのコンストラクターが呼ばれ、myCarにインスタンスが代入されます。

構造体インスタンス生成のポイント

構造体は値型であり、newキーワードを使ってインスタンスを生成すると、フィールドが初期化されます。

構造体はパラメーターなしのコンストラクターを持てないため、newを使わずに宣言した場合はフィールドが未初期化のままになります。

public struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}
class Program
{
    static void Main()
    {
        // newを使わずに宣言(フィールドは未初期化)
        Point p1;
        p1.X = 10;
        p1.Y = 20;
        Console.WriteLine($"p1: X={p1.X}, Y={p1.Y}");
        // newを使って生成(フィールドはコンストラクターで初期化)
        Point p2 = new Point(30, 40);
        Console.WriteLine($"p2: X={p2.X}, Y={p2.Y}");
    }
}

p1: X=10, Y=20
p2: X=30, Y=40

newを使うとコンストラクターが呼ばれ、すべてのフィールドが初期化されます。

newを使わずに宣言した場合は、すべてのフィールドに値を代入しないとコンパイルエラーになることがあります。

オブジェクト初期化子によるプロパティ設定

newキーワードとともにオブジェクト初期化子を使うと、コンストラクター呼び出し後にプロパティやフィールドをまとめて初期化できます。

これによりコードが簡潔になり、可読性が向上します。

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
}
class Program
{
    static void Main()
    {
        Book book = new Book
        {
            Title = "C#入門",
            Author = "山田太郎"
        };
        Console.WriteLine($"Title: {book.Title}, Author: {book.Author}");
    }
}

Title: C#入門, Author: 山田太郎

この例では、new Bookの後に中括弧{}内でプロパティを初期化しています。

コンストラクターの引数を使わずに初期化できるため、引数が多い場合や省略可能なプロパティがある場合に便利です。

コンストラクター併用時の優先順序

オブジェクト初期化子はコンストラクター呼び出しの後に実行されます。

つまり、コンストラクターで設定した値はオブジェクト初期化子で上書きされる可能性があります。

public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Employee()
    {
        Name = "未設定";
        Age = 0;
    }
}
class Program
{
    static void Main()
    {
        Employee emp = new Employee
        {
            Name = "佐藤花子",
            Age = 28
        };
        Console.WriteLine($"Name: {emp.Name}, Age: {emp.Age}");
    }
}

Name: 佐藤花子, Age: 28

この例では、EmployeeのコンストラクターでNameとAgeに初期値を設定していますが、オブジェクト初期化子で上書きされているため、最終的な値は佐藤花子と28になります。

配列生成と初期化パターン

配列の生成にもnewキーワードを使います。

配列のサイズを指定して生成する方法と、初期値を指定して生成する方法があります。

class Program
{
    static void Main()
    {
        // サイズ指定で配列を生成(要素はデフォルト値で初期化)
        int[] numbers = new int[5];
        Console.WriteLine("numbersの初期値:");
        foreach (var num in numbers)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
        // 初期値を指定して配列を生成
        string[] fruits = new string[] { "りんご", "みかん", "バナナ" };
        Console.WriteLine("fruitsの内容:");
        foreach (var fruit in fruits)
        {
            Console.Write(fruit + " ");
        }
        Console.WriteLine();
        // varを使った配列初期化
        var colors = new[] { "赤", "青", "緑" };
        Console.WriteLine("colorsの内容:");
        foreach (var color in colors)
        {
            Console.Write(color + " ");
        }
        Console.WriteLine();
    }
}

numbersの初期値:
0 0 0 0 0
fruitsの内容:
りんご みかん バナナ
colorsの内容:
赤 青 緑

new int[5]は5つの整数要素を持つ配列を生成し、すべての要素は0で初期化されます
new string[] { ... }は指定した初期値で配列を生成します
varとnew[]を組み合わせると、型推論で配列の型が決まります

コレクション初期化子の活用

newキーワードとコレクション初期化子を使うと、リストや辞書などのコレクションに要素を簡潔に追加できます。

これにより、要素の追加コードを省略でき、読みやすいコードになります。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // List<T>の初期化
        List<string> cities = new List<string>
        {
            "東京",
            "大阪",
            "名古屋"
        };
        Console.WriteLine("都市リスト:");
        foreach (var city in cities)
        {
            Console.WriteLine(city);
        }
        // Dictionary<TKey, TValue>の初期化
        Dictionary<int, string> errorCodes = new Dictionary<int, string>
        {
            { 404, "Not Found" },
            { 500, "Internal Server Error" },
            { 403, "Forbidden" }
        };
        Console.WriteLine("エラーコード一覧:");
        foreach (var kvp in errorCodes)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

都市リスト:
東京
大阪
名古屋
エラーコード一覧:
404: Not Found
500: Internal Server Error
403: Forbidden

List<string>は中括弧内に要素を列挙するだけで初期化できます
Dictionary<int, string>は中括弧内で{キー, 値}の形式で要素を追加します

コレクション初期化子は、Addメソッドを呼び出すコードを自動生成しているため、手動でAddを呼ぶよりも簡潔に記述できます。

コンストラクターとnewの関係性

既定コンストラクターの自動生成ルール

C#では、クラスや構造体にコンストラクターを明示的に定義しない場合、コンパイラーが自動的に既定コンストラクター(パラメーターなしのコンストラクター)を生成します。

この既定コンストラクターは、フィールドやプロパティをデフォルト値で初期化する役割を持ちます。

ただし、以下の条件で自動生成されるかどうかが変わります。

クラスの場合

クラスに一つもコンストラクターが定義されていなければ、既定コンストラクターが自動生成されます。

逆に、パラメーター付きコンストラクターを定義すると、既定コンストラクターは自動生成されません。

必要なら自分で明示的に定義する必要があります。

構造体の場合

構造体は常にパラメーターなしの既定コンストラクターが存在し、すべてのフィールドはデフォルト値で初期化されます。

ただし、構造体は自分でパラメーターなしコンストラクターを定義できません(C# 10以前)。

C# 10以降は定義可能ですが、まだ制限があります。

以下の例で確認しましょう。

public class SampleClass
{
    public int Value;
    // パラメーター付きコンストラクターを定義
    public SampleClass(int value)
    {
        Value = value;
    }
}
class Program
{
    static void Main()
    {
        // SampleClass obj1 = new SampleClass(); // コンパイルエラーになる
        SampleClass obj2 = new SampleClass(10);
        Console.WriteLine($"Value: {obj2.Value}");
    }
}

Value: 10

この例では、SampleClassにパラメーター付きコンストラクターがあるため、既定コンストラクターは自動生成されません。

new SampleClass()はコンパイルエラーになります。

パラメーター付きコンストラクターの呼び出し

newキーワードを使うとき、パラメーター付きコンストラクターを呼び出すことができます。

コンストラクターの引数に適切な値を渡すことで、オブジェクトの初期化を柔軟に行えます。

public class Product
{
    public string Name { get; }
    public decimal Price { get; }
    public Product(string name, decimal price)
    {
        Name = name;
        Price = price;
    }
}
class Program
{
    static void Main()
    {
        Product product = new Product("ノートパソコン", 150000m);
        Console.WriteLine($"商品名: {product.Name}, 価格: {product.Price}円");
    }
}

商品名: ノートパソコン, 価格: 150000円

この例では、new Product("ノートパソコン", 150000m)でパラメーター付きコンストラクターが呼ばれ、NameとPriceが初期化されています。

staticコンストラクターの実行タイミング

staticコンストラクターは、クラスの静的メンバーを初期化するための特別なコンストラクターです。

newキーワードでインスタンスを生成する際に、最初のインスタンス生成前に一度だけ自動的に実行されます。

引数を持たず、アクセス修飾子も指定できません
明示的に呼び出すことはできません
静的メンバーにアクセスした場合も実行されます

以下の例で動作を確認します。

public class Logger
{
    public static int InstanceCount;
    static Logger()
    {
        Console.WriteLine("staticコンストラクターが呼ばれました");
        InstanceCount = 0;
    }
    public Logger()
    {
        InstanceCount++;
        Console.WriteLine("インスタンスコンストラクターが呼ばれました");
    }
}
class Program
{
    static void Main()
    {
        Console.WriteLine("プログラム開始");
        Logger logger1 = new Logger();
        Logger logger2 = new Logger();
        Console.WriteLine($"生成されたインスタンス数: {Logger.InstanceCount}");
    }
}

プログラム開始
staticコンストラクターが呼ばれました
インスタンスコンストラクターが呼ばれました
インスタンスコンストラクターが呼ばれました
生成されたインスタンス数: 2

この例では、Loggerクラスの最初のインスタンス生成時にstaticコンストラクターが一度だけ呼ばれ、その後インスタンスコンストラクターが呼ばれています。

privateコンストラクターとSingleton実装

privateコンストラクターは、クラスの外部からインスタンス生成を禁止するために使います。

これを利用して、Singletonパターンを実装できます。

Singletonは、アプリケーション内でただ一つのインスタンスだけを持つことを保証するデザインパターンです。

public class Singleton
{
    private static readonly Singleton instance = new Singleton();
    // privateコンストラクターで外部からのインスタンス生成を禁止
    private Singleton()
    {
        Console.WriteLine("Singletonインスタンスが生成されました");
    }
    public static Singleton Instance
    {
        get { return instance; }
    }
    public void ShowMessage()
    {
        Console.WriteLine("Singletonのメソッドが呼ばれました");
    }
}
class Program
{
    static void Main()
    {
        // Singleton s = new Singleton(); // コンパイルエラーになる
        Singleton s1 = Singleton.Instance;
        Singleton s2 = Singleton.Instance;
        s1.ShowMessage();
        Console.WriteLine($"s1とs2は同じインスタンスか？ {ReferenceEquals(s1, s2)}");
    }
}

Singletonインスタンスが生成されました
Singletonのメソッドが呼ばれました
s1とs2は同じインスタンスか？ True

この例では、privateコンストラクターにより外部からのnewによるインスタンス生成が禁止され、Instanceプロパティを通じて唯一のインスタンスを取得しています。

s1とs2は同じインスタンスであることが確認できます。

レコード型のプライマリコンストラクター

C# 9.0から導入されたレコード型は、イミュータブルなデータを簡潔に表現できる型です。

レコード型では、プライマリコンストラクターを使ってプロパティを一括で定義・初期化できます。

public record Person(string Name, int Age);
class Program
{
    static void Main()
    {
        Person p = new Person("山田花子", 35);
        Console.WriteLine($"名前: {p.Name}, 年齢: {p.Age}");
        // with式でコピーを作成し、一部の値を変更可能
        Person p2 = p with { Age = 36 };
        Console.WriteLine($"名前: {p2.Name}, 年齢: {p2.Age}");
    }
}

名前: 山田花子, 年齢: 35
名前: 山田花子, 年齢: 36

プライマリコンストラクターは、レコードの宣言時に丸括弧内でパラメーターを指定し、そのままプロパティとして公開します。

newキーワードでインスタンスを生成すると、プライマリコンストラクターが呼ばれて初期化されます。

また、レコードはwith式を使って既存のインスタンスを元に新しいインスタンスを作成し、一部のプロパティだけを変更することができます。

これによりイミュータブルなデータ操作が簡単になります。

ジェネリック型とnew()制約

new()制約が必要になるケース

ジェネリッククラスやメソッドで型パラメーターを使う場合、型が何であるかはコンパイル時にはわかりません。

そのため、型パラメーターの型に対してインスタンスを生成したい場合、パラメーターなしのコンストラクターを持つ型に限定する必要があります。

これを指定するのがnew()制約です。

new()制約を付けることで、型パラメーターがパラメーターなしのコンストラクターを持つ型であることを保証し、new T()のようにインスタンス生成が可能になります。

型パラメーターのインスタンス生成例

以下の例では、new()制約を付けたジェネリッククラスで、型パラメーターTのインスタンスを生成しています。

public class Factory<T> where T : new()
{
    public T CreateInstance()
    {
        // new()制約があるため、パラメーターなしコンストラクターを呼べる
        return new T();
    }
}
public class Sample
{
    public int Value { get; set; } = 42;
}
class Program
{
    static void Main()
    {
        Factory<Sample> factory = new Factory<Sample>();
        Sample instance = factory.CreateInstance();
        Console.WriteLine($"Value: {instance.Value}");
    }
}

Value: 42

この例では、Factory<T>にwhere T : new()制約があるため、new T()が可能です。

Sampleクラスはパラメーターなしのコンストラクターを持つため、問題なくインスタンスが生成されます。

もしnew()制約がなければ、new T()はコンパイルエラーになります。

Activator.CreateInstanceとの差異

Activator.CreateInstanceはリフレクションを使って動的に型のインスタンスを生成するメソッドです。

ジェネリック型のインスタンス生成において、new()制約を使わずに動的生成したい場合に利用されます。

public class FactoryWithoutNew<T>
{
    public T CreateInstance()
    {
        // Activator.CreateInstanceはパラメーターなしコンストラクターを呼ぶ
        return (T)Activator.CreateInstance(typeof(T));
    }
}
public class SampleWithParam
{
    public int Value { get; set; }
    public SampleWithParam(int value)
    {
        Value = value;
    }
}
class Program
{
    static void Main()
    {
        FactoryWithoutNew<SampleWithParam> factory = new FactoryWithoutNew<SampleWithParam>();
        try
        {
            SampleWithParam instance = factory.CreateInstance();
            Console.WriteLine($"Value: {instance.Value}");
        }
        catch (MissingMethodException ex)
        {
            Console.WriteLine("パラメーターなしコンストラクターが存在しないため生成できません。");
        }
    }
}

パラメーターなしコンストラクターが存在しないため生成できません。

主な違い

項目	new()制約を使った`new T()`	`Activator.CreateInstance`
コンパイル時チェック	あり(パラメーターなしコンストラクター必須)	なし(実行時に例外が発生する可能性あり)
パフォーマンス	高速(直接呼び出し)	遅い(リフレクションを使用)
利用可能なコンストラクター	パラメーターなしのみ	パラメーター付きも指定可能(オーバーロードあり)
型安全性	高い	低い

new()制約はコンパイル時に安全性を保証し、パフォーマンスも良いため、可能な限りこちらを使うことが推奨されます。

Activator.CreateInstanceは柔軟ですが、実行時例外やパフォーマンス低下のリスクがあります。

構造体を型引数に持つ際の注意事項

構造体は値型であり、パラメーターなしのコンストラクターを持つため、new()制約を満たします。

しかし、構造体をジェネリックの型引数に使う場合、いくつか注意点があります。

new T()はデフォルト値の生成と同義

構造体のnew T()は、すべてのフィールドがデフォルト値(0やnull)で初期化されたインスタンスを返します。

構造体にパラメーター付きコンストラクターがあっても、new T()はそれを呼びません。

パラメーター付きコンストラクターは呼べない

ジェネリック型のnew()制約はパラメーターなしコンストラクターのみを要求するため、パラメーター付きコンストラクターを持つ構造体でもnew T()はパラメーターなしの初期化しかできません。

ボクシングに注意

構造体をobject型やインターフェイス型にキャストするとボクシングが発生し、パフォーマンスに影響します。

ジェネリックコード内で構造体を扱う際は、ボクシングを避ける工夫が必要です。

以下の例で確認します。

public struct MyStruct
{
    public int X;
    public int Y;
    public MyStruct(int x, int y)
    {
        X = x;
        Y = y;
    }
}
public class StructFactory<T> where T : struct
{
    public T CreateInstance()
    {
        // new T()はパラメーターなしの初期化を行う
        return new T();
    }
}
class Program
{
    static void Main()
    {
        StructFactory<MyStruct> factory = new StructFactory<MyStruct>();
        MyStruct instance = factory.CreateInstance();
        Console.WriteLine($"X: {instance.X}, Y: {instance.Y}"); // 0,0が出力される
    }
}

X: 0, Y: 0

この例では、MyStructにパラメーター付きコンストラクターがありますが、new T()は呼ばれず、すべてのフィールドがデフォルト値で初期化されたインスタンスが生成されます。

構造体を型引数に持つ場合は、この挙動を理解した上で設計することが重要です。

匿名型・タプル・レコードの生成

匿名型の特徴とスコープ制限

匿名型は、名前のない型を簡単に作成できるC#の機能で、主に一時的なデータの格納やLINQクエリの結果などで利用されます。

newキーワードとオブジェクト初期化子のような構文で作成し、プロパティ名と値を指定します。

class Program
{
    static void Main()
    {
        var person = new { Name = "田中太郎", Age = 28 };
        Console.WriteLine($"名前: {person.Name}, 年齢: {person.Age}");
    }
}

名前: 田中太郎, 年齢: 28

匿名型の特徴は以下の通りです。

型名がないため、varキーワードで型推論を使って変数を宣言します
プロパティは読み取り専用(getのみ)で、不変(イミュータブル)です
同じプロパティ名と型の匿名型はコンパイラーが同一の型として扱います
スコープが限定されるため、メソッドの外やクラスのメンバーとしては使えません。主にローカル変数やメソッドの戻り値として利用されます
EqualsやGetHashCode、ToStringが自動的にオーバーライドされており、値の比較が可能です

匿名型は一時的なデータ構造として便利ですが、型名がないため、メソッドの引数や戻り値の型として使いづらい点があります。

ValueTupleとの機能比較

C# 7.0以降で導入されたValueTupleは、複数の値をまとめて返したり扱ったりするための構造体です。

匿名型と似ていますが、いくつかの違いがあります。

class Program
{
    static void Main()
    {
        (string Name, int Age) person = ("佐藤花子", 32);
        Console.WriteLine($"名前: {person.Name}, 年齢: {person.Age}");
    }
}

名前: 佐藤花子, 年齢: 32

項目	匿名型	ValueTuple
型の名前	なし(コンパイラー生成)	明示的に定義された構造体
可変性	イミュータブル(読み取り専用)	ミュータブル(値の変更可能)
メモリ配置	参照型(ヒープ上)	値型(スタック上)
比較	値の比較が可能	値の比較は可能(`Equals`実装)
使用用途	一時的なデータの集約	複数の値の返却や簡易データ構造
スコープ制限	ローカルスコープ限定	スコープ制限なし

ValueTupleは構造体なので、パフォーマンス面で有利な場合があります。

また、名前付き要素を持てるため、コードの可読性も高いです。

一方、匿名型はイミュータブルで安全に使えるため、変更不要な一時データに適しています。

record型とwith式によるコピー生成

C# 9.0で導入されたrecord型は、イミュータブルなデータを表現するための参照型で、値の比較やコピー生成が簡単に行えます。

recordはnewキーワードでインスタンスを生成し、with式を使って既存のインスタンスから一部の値を変更したコピーを作成できます。

public record Person(string Name, int Age);
class Program
{
    static void Main()
    {
        Person p1 = new Person("鈴木一郎", 45);
        Console.WriteLine($"名前: {p1.Name}, 年齢: {p1.Age}");
        // with式でコピーを作成し、Ageだけ変更
        Person p2 = p1 with { Age = 46 };
        Console.WriteLine($"名前: {p2.Name}, 年齢: {p2.Age}");
        // 値の比較
        Console.WriteLine($"p1とp2は等しいか？ {p1 == p2}");
    }
}

名前: 鈴木一郎, 年齢: 45
名前: 鈴木一郎, 年齢: 46
p1とp2は等しいか？ False

record型の特徴は以下の通りです。

イミュータブルなプロパティを持つことが多い(initアクセサーを使うことも可能)
EqualsやGetHashCodeが値ベースで自動的に実装されるため、内容が同じなら等しいと判定されます
with式で簡単にコピーを作成し、一部のプロパティだけを変更できます
クラスであるため、参照型の特徴を持ちつつ値のように扱えます

recordは、データの不変性を保ちつつ、柔軟にコピーや比較を行いたい場合に非常に便利です。

匿名型やValueTupleと比べて、より明示的に型を定義でき、メソッドの引数や戻り値としても使いやすい点がメリットです。

コレクションおよび特殊メモリ領域での生成

List<T>・Dictionary<TKey,TValue>の典型例

C#で最もよく使われるコレクションの一つがList<T>とDictionary<TKey, TValue>です。

これらはnewキーワードを使ってインスタンスを生成し、要素の追加や管理を行います。

List<T>の生成例

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // int型のListを生成し、初期要素を追加
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // 要素の追加
        numbers.Add(6);
        Console.WriteLine("Listの要素:");
        foreach (var num in numbers)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}

Listの要素:
1 2 3 4 5 6

List<T>は内部的に配列を使って要素を管理し、必要に応じて自動的にサイズを拡張します。

new List<int>()で空のリストを生成し、初期化子で要素を指定することも可能です。

Dictionary<TKey, TValue>の生成例

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // Dictionaryを生成し、キーと値のペアを初期化
        Dictionary<string, int> ages = new Dictionary<string, int>
        {
            { "Alice", 30 },
            { "Bob", 25 },
            { "Charlie", 35 }
        };
        // 要素の追加
        ages["Diana"] = 28;
        Console.WriteLine("Dictionaryの内容:");
        foreach (var kvp in ages)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Dictionaryの内容:
Alice: 30
Bob: 25
Charlie: 35
Diana: 28

Dictionary<TKey, TValue>はキーと値のペアを高速に検索・追加・削除できるコレクションです。

newキーワードで生成し、初期化子で複数のペアをまとめて追加できます。

ImmutableCollectionの生成負荷

ImmutableCollectionは、変更不可(イミュータブル)なコレクションを提供するためのクラス群で、スレッドセーフな設計や不変性を保証したい場合に使われます。

代表的なものにImmutableList<T>やImmutableDictionary<TKey, TValue>があります。

using System;
using System.Collections.Immutable;
class Program
{
    static void Main()
    {
        // ImmutableListの生成
        var immutableList = ImmutableList.Create<int>(1, 2, 3);
        // 新しい要素を追加した新しいリストを生成(元のリストは変更されない)
        var newList = immutableList.Add(4);
        Console.WriteLine("元のリスト:");
        foreach (var item in immutableList)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
        Console.WriteLine("新しいリスト:");
        foreach (var item in newList)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
    }
}

元のリスト:
1 2 3
新しいリスト:
1 2 3 4

生成負荷のポイント

ImmutableCollectionは変更操作のたびに新しいインスタンスを生成します。これにより不変性が保たれますが、頻繁な生成はパフォーマンスやメモリ使用量に影響を与えます
内部的には構造共有(構造体の一部を共有)を行い、効率化を図っていますが、完全にコピーを避けることはできません
大量の要素を頻繁に追加・削除する用途には向かず、変更が少ない場合やスレッドセーフが必要な場合に適しています

Span<T>とstackallocを組み合わせた高速化

Span<T>は、C# 7.2以降で導入された構造体で、連続したメモリ領域を安全かつ効率的に扱うための型です。

stackallocと組み合わせることで、スタック上に一時的な配列を確保し、ヒープ割り当てを回避して高速な処理が可能になります。

using System;
class Program
{
    static void Main()
    {
        // stackallocでスタック上にint配列を確保し、Spanでラップ
        Span<int> numbers = stackalloc int[5] { 10, 20, 30, 40, 50 };
        Console.WriteLine("Spanの要素:");
        for (int i = 0; i < numbers.Length; i++)
        {
            Console.Write(numbers[i] + " ");
        }
        Console.WriteLine();
        // Spanはスライスや部分操作も可能
        Span<int> slice = numbers.Slice(1, 3);
        Console.WriteLine("スライスの要素:");
        foreach (var num in slice)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}

Spanの要素:
10 20 30 40 50
スライスの要素:
20 30 40

高速化の理由

stackallocはスタック領域にメモリを確保するため、ヒープ割り当てやGCの負荷がありません
Span<T>は構造体であり、ヒープ割り当てなしにメモリ領域を参照できるため、パフォーマンスが向上します
一時的なバッファや高速なデータ処理に適しており、特に文字列処理やバイナリデータの操作で効果を発揮します

注意点

stackallocで確保できるメモリサイズはスタックの制限に依存し、大きな配列には向きません
Span<T>は参照型のメンバーを持てないため、クラスのフィールドとしては使えません。メソッド内のローカル変数として使うのが一般的です

これらのコレクションや特殊メモリ領域の生成方法を理解し、用途に応じて使い分けることで、効率的でパフォーマンスの高いC#プログラムを作成できます。

動的オブジェクト生成テクニック

Activator.CreateInstanceの使いどころ

Activator.CreateInstanceは、型情報が実行時にしかわからない場合にオブジェクトを動的に生成するためのメソッドです。

リフレクションを利用してインスタンスを作成するため、コンパイル時に型が決まっていないシナリオで特に有用です。

例えば、プラグインシステムや依存性注入のフレームワーク、設定ファイルから型を読み込んでインスタンス化する場合などに使われます。

using System;
public class Person
{
    public string Name { get; }
    public int Age { get; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}
class Program
{
    static void Main()
    {
        Type type = typeof(Person);
        // Activator.CreateInstanceで動的にインスタンス生成
        object obj = Activator.CreateInstance(type, "山田太郎", 30);
        Person person = obj as Person;
        if (person != null)
        {
            Console.WriteLine(person);
        }
    }
}

Name: 山田太郎, Age: 30

この例では、Person型の情報をTypeオブジェクトとして取得し、Activator.CreateInstanceにコンストラクター引数を渡してインスタンスを生成しています。

型が事前にわからない場合でも柔軟に対応可能です。

ただし、Activator.CreateInstanceはリフレクションを使うため、パフォーマンスが低下しやすい点に注意が必要です。

頻繁に呼び出す処理には向きません。

リフレクションのパフォーマンス最適化

リフレクションは強力ですが、実行時の型情報の探索やメソッド呼び出しはオーバーヘッドが大きく、パフォーマンスに影響します。

特に大量のオブジェクト生成や頻繁なメソッド呼び出しがある場合は、最適化が必要です。

代表的な最適化手法としては、Expression Treeを使った高速ファクトリの実装があります。

Expression Treeを使うと、リフレクションで得たコンストラクター情報を元に、コンパイル済みのデリゲートを生成し、通常のメソッド呼び出しに近い速度でインスタンス生成が可能になります。

Expression Treeによる高速ファクトリ実装

以下は、Expression Treeを使って任意の型のパラメーター付きコンストラクターを呼び出す高速ファクトリを実装した例です。

using System;
using System.Linq.Expressions;
using System.Reflection;
public static class Factory<T>
{
    private static readonly Func<object[], T> _creator;
    static Factory()
    {
        ConstructorInfo ctor = typeof(T).GetConstructors()[0];
        ParameterInfo[] paramsInfo = ctor.GetParameters();
        // パラメーター配列を受け取るパラメーター式
        ParameterExpression param = Expression.Parameter(typeof(object[]), "args");
        Expression[] argsExp = new Expression[paramsInfo.Length];
        for (int i = 0; i < paramsInfo.Length; i++)
        {
            // object[]から各パラメーターを取り出し、適切な型にキャスト
            Expression index = Expression.Constant(i);
            Expression paramAccessorExp = Expression.ArrayIndex(param, index);
            Expression paramCastExp = Expression.Convert(paramAccessorExp, paramsInfo[i].ParameterType);
            argsExp[i] = paramCastExp;
        }
        // new T(args) の式を作成
        NewExpression newExp = Expression.New(ctor, argsExp);
        // Func<object[], T>のラムダ式を作成
        var lambda = Expression.Lambda<Func<object[], T>>(newExp, param);
        // コンパイルしてデリゲートを生成
        _creator = lambda.Compile();
    }
    public static T Create(params object[] args)
    {
        return _creator(args);
    }
}
public class Person
{
    public string Name { get; }
    public int Age { get; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}
class Program
{
    static void Main()
    {
        Person p = Factory<Person>.Create("佐藤花子", 28);
        Console.WriteLine(p);
    }
}

Name: 佐藤花子, Age: 28

この実装のポイントは以下の通りです。

静的コンストラクターで一度だけExpression Treeを構築し、コンパイル済みのデリゲートを生成します
Createメソッドはobject[]の引数を受け取り、デリゲートを呼び出して高速にインスタンスを生成します
リフレクションのオーバーヘッドは初回のデリゲート生成時のみで、その後は高速な呼び出しが可能です

この方法は、動的に型が決まるがパフォーマンスも重視したい場合に非常に有効です。

大量のオブジェクト生成や頻繁な呼び出しがあるシステムで活用できます。

new修飾子によるメンバー隠蔽

継承階層での非virtual隠蔽パターン

C#のnew修飾子は、クラスの継承階層において、基底クラスのメンバーと同名のメンバーを派生クラスで再定義(隠蔽)する際に使います。

これは、基底クラスのメンバーがvirtualでない場合に特に用いられます。

例えば、基底クラスにvirtualでないメソッドがあり、派生クラスで同名のメソッドを定義したい場合、newキーワードを付けることで基底クラスのメソッドを隠蔽(シャドウイング)します。

using System;
public class BaseClass
{
    public void Show()
    {
        Console.WriteLine("BaseClassのShowメソッド");
    }
}
public class DerivedClass : BaseClass
{
    public new void Show()
    {
        Console.WriteLine("DerivedClassのShowメソッド");
    }
}
class Program
{
    static void Main()
    {
        BaseClass baseObj = new BaseClass();
        baseObj.Show();  // BaseClassのShowメソッド
        DerivedClass derivedObj = new DerivedClass();
        derivedObj.Show();  // DerivedClassのShowメソッド
        BaseClass baseRefDerived = new DerivedClass();
        baseRefDerived.Show();  // BaseClassのShowメソッド(隠蔽のため基底クラスのメソッドが呼ばれる)
    }
}

BaseClassのShowメソッド
DerivedClassのShowメソッド
BaseClassのShowメソッド

この例では、DerivedClassのShowメソッドはnew修飾子で基底クラスのShowを隠蔽しています。

DerivedClassのインスタンスをDerivedClass型で呼ぶと派生クラスのメソッドが呼ばれますが、基底クラス型の変数で参照すると基底クラスのメソッドが呼ばれます。

このように、newによる隠蔽はメソッドの呼び出し時の型によって挙動が変わるため、注意が必要です。

overrideとの動作比較

overrideは、基底クラスのvirtualまたはabstractメソッドを派生クラスでオーバーライド(上書き)するためのキーワードです。

overrideを使うと、基底クラスのメソッド呼び出しが派生クラスの実装に動的にバインドされます。

以下の例でoverrideとの違いを比較します。

using System;
public class BaseClass
{
    public virtual void Show()
    {
        Console.WriteLine("BaseClassのShowメソッド");
    }
}
public class DerivedClass : BaseClass
{
    public override void Show()
    {
        Console.WriteLine("DerivedClassのShowメソッド");
    }
}
class Program
{
    static void Main()
    {
        BaseClass baseObj = new BaseClass();
        baseObj.Show();  // BaseClassのShowメソッド
        DerivedClass derivedObj = new DerivedClass();
        derivedObj.Show();  // DerivedClassのShowメソッド
        BaseClass baseRefDerived = new DerivedClass();
        baseRefDerived.Show();  // DerivedClassのShowメソッド(動的バインディング)
    }
}

BaseClassのShowメソッド
DerivedClassのShowメソッド
DerivedClassのShowメソッド

overrideを使うと、基底クラス型の変数であっても、実際のインスタンスの型に応じて派生クラスのメソッドが呼ばれます。

これが動的ポリモーフィズムの基本です。

項目	`new`修飾子による隠蔽	`override`によるオーバーライド
基底クラスのメソッド	`virtual`でなくてもよい	`virtual`または`abstract`である必要がある
呼び出し時の挙動	変数の型に依存(静的バインディング)	実際のオブジェクトの型に依存(動的バインディング)
メソッドの置き換え	隠蔽(シャドウイング)	完全な置き換え
コンパイラー警告	基底メンバーと同名で`new`を付けないと警告	なし

コード規約と可読性の観点

new修飾子を使ったメンバー隠蔽は、意図的に基底クラスのメンバーを隠す場合にのみ使うべきです。

無意識に同名メンバーを定義すると、予期せぬ動作やバグの原因になるため注意が必要です。

コード規約のポイント

newを使う場合は必ず明示的に付ける

コンパイラーは、基底クラスのメンバーと同名のメンバーを派生クラスで定義すると警告を出します。

これを抑制するためにnewを付けることで、隠蔽が意図的であることを明示します。

可能な限りvirtual/overrideを使う

多態性を活かした設計が望ましい場合は、virtualとoverrideを使い、動的バインディングを利用したほうが可読性と保守性が高まります。

隠蔽は限定的に使う

newによる隠蔽は、基底クラスのメンバーを意図的に隠したい特殊なケースに限定し、一般的な継承設計では避けることが推奨されます。

可読性の観点

newを使うと、呼び出し元の変数の型によって呼ばれるメソッドが変わるため、コードの挙動が直感的でなくなることがあります
チーム開発では、newを使った隠蔽が多いとコードの理解が難しくなり、バグの温床になる可能性があります
ドキュメントやコメントで隠蔽の意図を明確にし、コードレビューで注意を促すことが重要です

このように、new修飾子は基底クラスの非virtualメンバーを隠蔽するための機能ですが、動的ポリモーフィズムを活かすoverrideとは挙動が大きく異なります。

設計方針や可読性を考慮し、適切に使い分けることが重要です。

メモリ効率を意識した生成戦略

Object Poolによる再利用

オブジェクトの生成と破棄はメモリの割り当てやガベージコレクション(GC)を引き起こし、パフォーマンスに影響を与えることがあります。

特に大量のオブジェクトを頻繁に生成する場合は、Object Pool(オブジェクトプール)を活用してオブジェクトの再利用を行うことで、メモリ効率とパフォーマンスを改善できます。

Object Poolは、使い終わったオブジェクトを破棄せずにプールに戻し、再度必要になったときにプールから取得して使い回す仕組みです。

これにより、newによる頻繁なインスタンス生成を回避できます。

.NETではSystem.Buffers.ObjectPool<T>やMicrosoft.Extensions.ObjectPoolなどのライブラリが提供されています。

以下は簡単な自作のObject Poolの例です。

using System;
using System.Collections.Generic;
public class SimpleObjectPool<T> where T : new()
{
    private readonly Stack<T> _pool = new Stack<T>();
    public T Get()
    {
        if (_pool.Count > 0)
        {
            return _pool.Pop();
        }
        else
        {
            return new T();
        }
    }
    public void Return(T obj)
    {
        _pool.Push(obj);
    }
}
public class MyClass
{
    public int Value { get; set; }
}
class Program
{
    static void Main()
    {
        var pool = new SimpleObjectPool<MyClass>();
        // オブジェクトをプールから取得
        MyClass obj1 = pool.Get();
        obj1.Value = 100;
        Console.WriteLine($"obj1.Value: {obj1.Value}");
        // オブジェクトをプールに返却
        pool.Return(obj1);
        // 再度オブジェクトを取得(同じインスタンスが返る可能性がある)
        MyClass obj2 = pool.Get();
        Console.WriteLine($"obj2.Value: {obj2.Value}"); // 100が出力される可能性あり
        // 状態をリセットして使うのが望ましい
        obj2.Value = 0;
    }
}

obj1.Value: 100
obj2.Value: 100

この例では、SimpleObjectPool<T>がオブジェクトの再利用を管理しています。

newによる生成はプールが空の場合のみ行われ、頻繁な生成を抑制できます。

ただし、プールから返却されたオブジェクトの状態はリセットしないと予期せぬ動作になるため、利用時に初期化が必要です。

new回避とボクシング削減

C#では、値型(構造体)を参照型として扱う際にボクシングが発生します。

ボクシングは値型をヒープ上のオブジェクトに変換する処理で、newキーワードを使ったインスタンス生成とは別に、パフォーマンスやメモリ効率に悪影響を与えます。

ボクシングは例えば、値型をobject型やインターフェイス型に代入するときに発生します。

int x = 10;
object obj = x; // ボクシング発生

ボクシングを減らすためには、以下のような対策が有効です。

ジェネリックを活用する

ジェネリック型は値型をボクシングせずに扱えるため、List<int>のように使うとボクシングを回避できます。

newを使わずに値型を初期化する

値型はnewを使わなくても宣言だけで初期化可能です。

newを使うとパフォーマンスに大きな差はありませんが、ボクシングとは無関係です。

インターフェイスの使用を控える

値型にインターフェイスを実装させている場合、インターフェイス型に代入するとボクシングが発生します。

必要に応じて抽象クラスやジェネリック制約を検討します。

以下はボクシングを避けるジェネリックの例です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int>();
        numbers.Add(1);
        numbers.Add(2);
        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

1
2

この例では、List<int>は値型のintをボクシングせずに格納できるため、効率的です。

構造体ファクトリメソッドの利点

構造体(値型)はnewキーワードを使って生成すると、すべてのフィールドがデフォルト値で初期化されますが、パラメーター付きコンストラクターを定義している場合はそれを使って初期化できます。

しかし、構造体はパラメーターなしのコンストラクターを自分で定義できない(C# 10以前)ため、ファクトリメソッドを使って初期化をカプセル化するパターンがよく使われます。

ファクトリメソッドは静的メソッドとして定義し、構造体の生成と初期化をまとめて行います。

これにより、newを使わずに効率的に構造体を生成でき、コードの可読性も向上します。

public struct Point
{
    public int X { get; }
    public int Y { get; }
    private Point(int x, int y)
    {
        X = x;
        Y = y;
    }
    // ファクトリメソッド
    public static Point Create(int x, int y)
    {
        return new Point(x, y);
    }
}
class Program
{
    static void Main()
    {
        Point p = Point.Create(10, 20);
        Console.WriteLine($"X: {p.X}, Y: {p.Y}");
    }
}

X: 10, Y: 20

この例では、Point.Createメソッドが構造体の生成と初期化を担い、newキーワードは構造体内部でのみ使われています。

外部からはnewを使わずに初期化できるため、コードの一貫性と安全性が高まります。

ファクトリメソッドの利点は以下の通りです。

初期化ロジックを一箇所にまとめられます
不変構造体の生成を簡潔にできます
将来的に生成方法を変更しやすい

これらのメモリ効率を意識した生成戦略を活用することで、C#プログラムのパフォーマンスとメモリ使用量を最適化できます。

特に大量のオブジェクト生成やリアルタイム処理が求められる場面で効果的です。

ヌル許容参照型との連携

非null初期化のベストパターン

C# 8.0以降で導入されたヌル許容参照型(Nullable Reference Types)は、参照型変数がnullを許容するかどうかを型システムで明示的に区別できる機能です。

これにより、null参照例外(NullReferenceException)の発生をコンパイル時に防ぎやすくなりました。

非nullの参照型を安全に初期化するためには、非null初期化のパターンを適切に使うことが重要です。

以下に代表的なベストパターンを示します。

コンストラクターでの初期化

最も基本的で推奨される方法は、コンストラクターで必須の参照型プロパティやフィールドを初期化することです。

これにより、インスタンス生成時に必ず非nullの状態が保証されます。

#nullable enable
public class User
{
    public string Name { get; }
    public string Email { get; }
    public User(string name, string email)
    {
        Name = name ?? throw new ArgumentNullException(nameof(name));
        Email = email ?? throw new ArgumentNullException(nameof(email));
    }
}
class Program
{
    static void Main()
    {
        User user = new User("山田太郎", "yamada@example.com");
        Console.WriteLine($"Name: {user.Name}, Email: {user.Email}");
    }
}

Name: 山田太郎, Email: yamada@example.com

この例では、NameとEmailはコンストラクターで必ず非nullに初期化されるため、以降のコードでnullチェックが不要になります。

オブジェクト初期化子とrequiredキーワードの併用(C# 11以降)

C# 11からはrequiredキーワードを使い、オブジェクト初期化子で必須のプロパティを指定できます。

これにより、コンストラクターを使わずに非null初期化を強制できます。

#nullable enable
public class Product
{
    public required string Name { get; init; }
    public required decimal Price { get; init; }
}
class Program
{
    static void Main()
    {
        Product product = new Product
        {
            Name = "ノートパソコン",
            Price = 150000m
        };
        Console.WriteLine($"Name: {product.Name}, Price: {product.Price}");
    }
}

Name: ノートパソコン, Price: 150000

requiredプロパティはオブジェクト初期化子で必ず設定しなければコンパイルエラーになるため、非null初期化が保証されます。

非nullフィールドの遅延初期化とnull!抑制演算子

どうしてもコンストラクターで初期化できない場合は、フィールドやプロパティにnull!(null抑制演算子)を使ってコンパイラーの警告を抑制し、後で必ず初期化することを明示します。

#nullable enable
public class Config
{
    public string ConnectionString { get; set; } = null!;
    public void Initialize(string connStr)
    {
        ConnectionString = connStr;
    }
}

ただし、この方法は開発者の責任で必ず初期化を行う必要があり、誤用すると実行時例外の原因になるため注意が必要です。

null抑制演算子とnew()初期化子の使い分け

ヌル許容参照型のコードで、null抑制演算子!とnew()初期化子はどちらも非nullを保証するために使われますが、使い分けが重要です。

null抑制演算子(!)

!はコンパイラーに「この変数はnullではないと信じてほしい」という意味で、実際の初期化は開発者が責任を持つ必要があります。

主に以下のようなケースで使います。

コンストラクターで初期化できないが、後で必ず初期化するフィールドやプロパティ
DI(依存性注入)フレームワークなどで外部から値がセットされる場合

public class Service
{
    public ILogger Logger { get; set; } = null!; // 後で必ずセットされる想定
}

この場合、初期化漏れがあると実行時にNullReferenceExceptionが発生するリスクがあります。

new()初期化子

C# 11から導入されたnew()初期化子は、プロパティの宣言時にデフォルトの非nullインスタンスを生成して初期化する方法です。

これにより、初期化漏れを防ぎ、実行時の安全性が高まります。

public class Order
{
    public List<string> Items { get; set; } = new();
}

この例では、Itemsは空のリストで初期化されているため、nullチェック不要で安全に使えます。

使い分けのポイント

ポイント	null抑制演算子`!`	new()初期化子
初期化のタイミング	後で必ず初期化する必要がある	宣言時に初期化済み
実行時の安全性	初期化漏れで例外が発生するリスクあり	初期化済みなので安全
適用対象	外部からセットされるプロパティやフィールド	コレクションやオブジェクトの初期化
コードの明確さ	初期化責任が曖昧になりやすい	初期化が明示的でわかりやすい

これらの機能を適切に使い分けることで、ヌル許容参照型の恩恵を最大限に活かし、安全で堅牢なコードを書くことができます。

特に大規模プロジェクトやチーム開発では、非null初期化のルールを統一することが重要です。

例外・リソース管理とnew

コンストラクター内での例外ハンドリング

newキーワードを使ってオブジェクトを生成すると、そのクラスのコンストラクターが呼び出されます。

コンストラクター内で例外が発生すると、オブジェクトの生成は失敗し、例外は呼び出し元に伝播します。

これにより、生成途中の不完全なオブジェクトが存在しない状態が保証されます。

コンストラクター内で例外が発生する可能性がある場合は、適切に例外処理を行うか、呼び出し元で例外をキャッチして対処する必要があります。

以下は、コンストラクター内で例外をスローし、呼び出し元でキャッチする例です。

using System;
public class FileProcessor
{
    private string _filePath;
    public FileProcessor(string filePath)
    {
        if (string.IsNullOrWhiteSpace(filePath))
        {
            throw new ArgumentException("ファイルパスは空白またはnullにできません。", nameof(filePath));
        }
        _filePath = filePath;
        // ここでファイルの存在チェックなどを行い、例外をスローすることも可能
        if (!System.IO.File.Exists(_filePath))
        {
            throw new System.IO.FileNotFoundException("指定されたファイルが存在しません。", _filePath);
        }
    }
    public void Process()
    {
        Console.WriteLine($"ファイル {_filePath} を処理中...");
        // 処理内容
    }
}
class Program
{
    static void Main()
    {
        try
        {
            FileProcessor processor = new FileProcessor(""); // 空文字で例外発生
            processor.Process();
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"引数エラー: {ex.Message}");
        }
        catch (System.IO.FileNotFoundException ex)
        {
            Console.WriteLine($"ファイルエラー: {ex.Message}");
        }
    }
}

引数エラー: ファイルパスは空白またはnullにできません。

この例では、FileProcessorのコンストラクターで引数の検証を行い、不正な値の場合は例外をスローしています。

呼び出し元のMainメソッドで例外をキャッチし、適切にエラーメッセージを表示しています。

コンストラクター内で例外が発生すると、オブジェクトは生成されず、メモリリークの心配はありません。

ただし、例外処理の設計は慎重に行い、必要に応じてリソースの解放やログ出力を行うことが望ましいです。

using宣言とIDisposable型生成

C#では、IDisposableインターフェイスを実装した型は、リソースの解放を明示的に行う必要があります。

newキーワードでIDisposable型のオブジェクトを生成した場合、使用後にDisposeメソッドを呼び出してリソースを解放しなければなりません。

これを簡潔に書くために、using宣言やusingステートメントが用意されています。

usingを使うと、スコープを抜ける際に自動的にDisposeが呼ばれ、リソースリークを防止できます。

usingステートメントの例

using System;
using System.IO;
class Program
{
    static void Main()
    {
        // usingステートメントでFileStreamを生成し、スコープ終了時にDisposeが呼ばれる
        using (FileStream fs = new FileStream("sample.txt", FileMode.OpenOrCreate))
        {
            byte[] data = System.Text.Encoding.UTF8.GetBytes("Hello, world!");
            fs.Write(data, 0, data.Length);
            Console.WriteLine("ファイルに書き込みました。");
        } // ここでfs.Dispose()が自動的に呼ばれる
    }
}

ファイルに書き込みました。

using宣言(C# 8.0以降)の例

C# 8.0以降では、using宣言を使うことで、変数宣言の直後にusingを付けてスコープ終了時に自動的にDisposeを呼び出せます。

using System;
using System.IO;
class Program
{
    static void Main()
    {
        using FileStream fs = new FileStream("sample.txt", FileMode.OpenOrCreate);
        byte[] data = System.Text.Encoding.UTF8.GetBytes("こんにちは！");
        fs.Write(data, 0, data.Length);
        Console.WriteLine("ファイルに書き込みました。");
    } // ここでfs.Dispose()が自動的に呼ばれる
}

ファイルに書き込みました。

ポイント

newで生成したIDisposable型のオブジェクトは、必ずDisposeを呼び出してリソースを解放する必要があります
usingステートメントやusing宣言を使うことで、コードが簡潔になり、リソースリークのリスクを減らせます
コンストラクター内でIDisposableオブジェクトを生成する場合は、例外発生時のリソース解放も考慮し、try-catch-finallyやusingを適切に使うことが重要です

このように、newキーワードで生成されるオブジェクトの例外処理やリソース管理は、堅牢で安全なプログラムを書く上で欠かせない要素です。

適切な例外ハンドリングとIDisposableの利用を心がけましょう。

まとめ

この記事では、C#のnewキーワードを中心に、オブジェクト生成の基本から応用テクニックまで幅広く解説しました。

new式の処理フローや参照型・値型のメモリ配置、コンストラクターとの関係性、ジェネリック型での制約、匿名型やレコードの生成方法、コレクションや特殊メモリ領域の活用法、動的生成の最適化、メンバー隠蔽の使い分け、メモリ効率を意識した生成戦略、ヌル許容参照型との連携、そして例外処理やリソース管理まで、実践的な知識を網羅しています。

これにより、効率的で安全なC#プログラムの設計・実装が可能になります。