【C#】抽象クラスのコンストラクタ完全解説｜呼び出し順序・baseの使い方・静的初期化まで

abstract class Animal
{
    public abstract void MakeSound();
}

// Animal animal = new Animal(); // コンパイルエラー

abstract class Animal
{
    public string Name { get; set; }
    public Animal(string name)
    {
        Name = name;
    }
    public void DisplayName()
    {
        Console.WriteLine($"動物の名前は {Name} です。");
    }
    public abstract void MakeSound();
}

using System;
abstract class Animal
{
    public string Name { get; }
    // 抽象クラスのコンストラクタ
    protected Animal(string name)
    {
        Name = name;
        Console.WriteLine("Animalのコンストラクタが呼ばれました。");
    }
    public abstract void MakeSound();
}
class Dog : Animal
{
    public Dog(string name) : base(name)
    {
        Console.WriteLine("Dogのコンストラクタが呼ばれました。");
    }
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン！");
    }
}
class Program
{
    static void Main()
    {
        Dog dog = new Dog("ポチ");
        dog.MakeSound();
        Console.WriteLine($"名前: {dog.Name}");
    }
}

Animalのコンストラクタが呼ばれました。
Dogのコンストラクタが呼ばれました。
ワンワン！
名前: ポチ

protected Animal(string name)
{
    Name = name;
}

abstract class Shape
{
    protected Shape()
    {
        Console.WriteLine("Shapeのコンストラクタ");
    }
}
class Circle : Shape
{
    public Circle() : base()
    {
        Console.WriteLine("Circleのコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        // Shape shape = new Shape(); // コンパイルエラー
        Circle circle = new Circle();
    }
}

Shapeのコンストラクタ
Circleのコンストラクタ

abstract class BaseClass
{
    protected BaseClass()
    {
        Console.WriteLine("BaseClassのコンストラクタ");
    }
}
class UnrelatedClass
{
    public void CreateBase()
    {
        // BaseClass baseObj = new BaseClass(); // コンパイルエラー
    }
}

public abstract class InternalBase
{
    internal InternalBase()
    {
        Console.WriteLine("InternalBaseのコンストラクタ");
    }
}
internal class InternalDerived : InternalBase
{
    public InternalDerived() : base()
    {
        Console.WriteLine("InternalDerivedのコンストラクタ");
    }
}

[assembly: InternalsVisibleTo("MyProject.Tests")]
public abstract class ServiceBase
{
    internal ServiceBase()
    {
        Console.WriteLine("ServiceBaseのコンストラクタ");
    }
}

abstract class AbstractExample
{
    public AbstractExample()
    {
        Console.WriteLine("AbstractExampleのコンストラクタ");
    }
}

abstract class Product
{
    public Product()
    {
        Console.WriteLine("Productのコンストラクタ");
    }
}
class ConcreteProduct : Product
{
    public ConcreteProduct() : base()
    {
        Console.WriteLine("ConcreteProductのコンストラクタ");
    }
}
class ProductFactory
{
    public static Product Create()
    {
        return new ConcreteProduct();
    }
}
class Program
{
    static void Main()
    {
        Product product = ProductFactory.Create();
    }
}

Productのコンストラクタ
ConcreteProductのコンストラクタ

class Sample
{
    private int number = 10;
    private string message = GetMessage();
    public Sample()
    {
        Console.WriteLine($"number = {number}");
        Console.WriteLine($"message = {message}");
    }
    private static string GetMessage()
    {
        return "フィールド初期化子によるメッセージ";
    }
}
class Program
{
    static void Main()
    {
        var sample = new Sample();
    }
}

number = 10
message = フィールド初期化子によるメッセージ

using System;
class BaseClass
{
    public BaseClass()
    {
        Console.WriteLine("BaseClassのコンストラクタ");
    }
}
class DerivedClass : BaseClass
{
    public DerivedClass()
    {
        Console.WriteLine("DerivedClassのコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        var obj = new DerivedClass();
    }
}

BaseClassのコンストラクタ
DerivedClassのコンストラクタ

using System;
class BaseClass
{
    public BaseClass()
    {
        Console.WriteLine("BaseClassのコンストラクタ");
        PrintMessage();
    }
    public virtual void PrintMessage()
    {
        Console.WriteLine("BaseClassのメッセージ");
    }
}
class DerivedClass : BaseClass
{
    private string message = "派生クラスのメッセージ";
    public DerivedClass()
    {
        Console.WriteLine("DerivedClassのコンストラクタ");
    }
    public override void PrintMessage()
    {
        Console.WriteLine(message);
    }
}
class Program
{
    static void Main()
    {
        var obj = new DerivedClass();
    }
}

BaseClassのコンストラクタ
DerivedClassのコンストラクタ

using System;
class GrandParent
{
    public GrandParent()
    {
        Console.WriteLine("GrandParentのコンストラクタ");
    }
}
class Parent : GrandParent
{
    public Parent()
    {
        Console.WriteLine("Parentのコンストラクタ");
    }
}
class Child : Parent
{
    public Child()
    {
        Console.WriteLine("Childのコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        var obj = new Child();
    }
}

GrandParentのコンストラクタ
Parentのコンストラクタ
Childのコンストラクタ

using System;
abstract class Person
{
    public string Name { get; }
    public int Age { get; }
    protected Person(string name, int age)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("名前は必須です。", nameof(name));
        if (age < 0)
            throw new ArgumentOutOfRangeException(nameof(age), "年齢は0以上でなければなりません。");
        Name = name;
        Age = age;
        Console.WriteLine("Personのコンストラクタ");
    }
}
class Employee : Person
{
    public string Position { get; }
    public Employee(string name, int age, string position) : base(name, age)
    {
        if (string.IsNullOrWhiteSpace(position))
            throw new ArgumentException("役職は必須です。", nameof(position));
        Position = position;
        Console.WriteLine("Employeeのコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        var employee = new Employee("山田太郎", 30, "エンジニア");
        Console.WriteLine($"名前: {employee.Name}, 年齢: {employee.Age}, 役職: {employee.Position}");
    }
}

Personのコンストラクタ
Employeeのコンストラクタ
名前: 山田太郎, 年齢: 30, 役職: エンジニア

using System;
abstract class Vehicle
{
    public string Model { get; }
    public int Year { get; }
    protected Vehicle(string model) : this(model, 0)
    {
        Console.WriteLine("Vehicle(string) コンストラクタ");
    }
    protected Vehicle(string model, int year)
    {
        Model = model;
        Year = year;
        Console.WriteLine("Vehicle(string, int) コンストラクタ");
    }
}
class Car : Vehicle
{
    public Car(string model) : base(model)
    {
        Console.WriteLine("Car(string) コンストラクタ");
    }
    public Car(string model, int year) : base(model, year)
    {
        Console.WriteLine("Car(string, int) コンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        var car1 = new Car("トヨタ");
        var car2 = new Car("ホンダ", 2020);
    }
}

Vehicle(string, int) コンストラクタ
Vehicle(string) コンストラクタ
Car(string) コンストラクタ
Vehicle(string, int) コンストラクタ
Car(string, int) コンストラクタ

using System;
class BaseClass
{
    public BaseClass(int value)
    {
        Console.WriteLine($"BaseClassのコンストラクタ: {value}");
    }
}
class DerivedClass : BaseClass
{
    public DerivedClass()
    {
        Console.WriteLine("DerivedClassのコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        // var obj = new DerivedClass(); // コンパイルエラー
    }
}

public DerivedClass() : base(10)
{
    Console.WriteLine("DerivedClassのコンストラクタ");
}

using System;
abstract class Account
{
    public string Owner { get; }
    public decimal Balance { get; }
    protected Account(string owner, decimal balance)
    {
        Owner = owner;
        Balance = balance;
        Console.WriteLine("Accountのコンストラクタ");
    }
}
class SavingsAccount : Account
{
    public decimal InterestRate { get; }
    public SavingsAccount(string owner) : this(owner, 0m, 0.01m)
    {
        Console.WriteLine("SavingsAccount(string) コンストラクタ");
    }
    public SavingsAccount(string owner, decimal balance) : this(owner, balance, 0.01m)
    {
        Console.WriteLine("SavingsAccount(string, decimal) コンストラクタ");
    }
    public SavingsAccount(string owner, decimal balance, decimal interestRate) : base(owner, balance)
    {
        InterestRate = interestRate;
        Console.WriteLine("SavingsAccount(string, decimal, decimal) コンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        var account1 = new SavingsAccount("佐藤");
        var account2 = new SavingsAccount("鈴木", 10000m);
        var account3 = new SavingsAccount("高橋", 20000m, 0.02m);
    }
}

Accountのコンストラクタ
SavingsAccount(string, decimal, decimal) コンストラクタ
SavingsAccount(string) コンストラクタ
Accountのコンストラクタ
SavingsAccount(string, decimal, decimal) コンストラクタ
SavingsAccount(string, decimal) コンストラクタ
Accountのコンストラクタ
SavingsAccount(string, decimal, decimal) コンストラクタ

class Product
{
    public string Name { get; }
    public decimal Price { get; }
    public string Category { get; }
    public Product(string name, decimal price, string category = "未分類")
    {
        Name = name;
        Price = price;
        Category = category;
        Console.WriteLine($"Productコンストラクタ: Name={Name}, Price={Price}, Category={Category}");
    }
}
class Program
{
    static void Main()
    {
        var p1 = new Product("ノートパソコン", 150000m);
        var p2 = new Product("スマートフォン", 80000m, "電子機器");
    }
}

Productコンストラクタ: Name=ノートパソコン, Price=150000, Category=未分類
Productコンストラクタ: Name=スマートフォン, Price=80000, Category=電子機器

class User
{
    public string Username { get; private set; }
    public string Email { get; private set; }
    public int Age { get; private set; }
    public User(string username)
    {
        Initialize(username, null, 0);
        Console.WriteLine("User(string) コンストラクタ");
    }
    public User(string username, string email)
    {
        Initialize(username, email, 0);
        Console.WriteLine("User(string, string) コンストラクタ");
    }
    public User(string username, string email, int age)
    {
        Initialize(username, email, age);
        Console.WriteLine("User(string, string, int) コンストラクタ");
    }
    private void Initialize(string username, string email, int age)
    {
        if (string.IsNullOrWhiteSpace(username))
            throw new ArgumentException("ユーザー名は必須です。", nameof(username));
        Username = username;
        Email = email ?? "未登録";
        Age = age;
    }
}
class Program
{
    static void Main()
    {
        var user1 = new User("taro");
        var user2 = new User("hanako", "hanako@example.com");
        var user3 = new User("jiro", "jiro@example.com", 25);
    }
}

User(string) コンストラクタ
User(string, string) コンストラクタ
User(string, string, int) コンストラクタ

class Sample
{
    public Sample(int x)
    {
        Console.WriteLine("int パラメーターのコンストラクタ");
    }
    public Sample(double x)
    {
        Console.WriteLine("double パラメーターのコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        Sample s1 = new Sample(10);    // intが優先される
        Sample s2 = new Sample(10.5);  // doubleが優先される
        Sample s3 = new Sample(10f);   // floatはintにもdoubleにも暗黙変換可能で曖昧
    }
}

class Example
{
    public Example(int x, int y = 0)
    {
        Console.WriteLine("int, int? コンストラクタ");
    }
    public Example(int x)
    {
        Console.WriteLine("int コンストラクタ");
    }
}

using System;
class Configuration
{
    // Lazy<T>で遅延初期化
    private static readonly Lazy<Configuration> _instance = new Lazy<Configuration>(() =>
    {
        Console.WriteLine("Configurationの初期化処理を実行中...");
        return new Configuration();
    });
    public static Configuration Instance => _instance.Value;
    public string Setting { get; }
    private Configuration()
    {
        Setting = "初期設定値";
    }
}
class Program
{
    static void Main()
    {
        Console.WriteLine("プログラム開始");
        // Configuration.Instanceに初めてアクセスしたタイミングで初期化される
        Console.WriteLine($"設定値: {Configuration.Instance.Setting}");
        // 2回目以降は初期化処理は実行されない
        Console.WriteLine($"設定値: {Configuration.Instance.Setting}");
    }
}

プログラム開始
Configurationの初期化処理を実行中...
設定値: 初期設定値
設定値: 初期設定値

using System;
using System.Threading.Tasks;
class Logger
{
    static Logger()
    {
        Console.WriteLine("Loggerの静的コンストラクタが呼ばれました。");
    }
    public static void Log(string message)
    {
        Console.WriteLine($"Log: {message}");
    }
}
class Program
{
    static void Main()
    {
        Parallel.Invoke(
            () => Logger.Log("メッセージ1"),
            () => Logger.Log("メッセージ2"),
            () => Logger.Log("メッセージ3")
        );
    }
}

Loggerの静的コンストラクタが呼ばれました。
Log: メッセージ1
Log: メッセージ2
Log: メッセージ3

class A
{
    public static readonly string Value = B.Value + " from A";
}
class B
{
    public static readonly string Value = A.Value + " from B";
}
class Program
{
    static void Main()
    {
        Console.WriteLine(A.Value);
    }
}

class Sample
{
    private int count = 10;
    private string message = "初期メッセージ";
    public Sample()
    {
        Console.WriteLine($"count = {count}, message = {message}");
    }
}

class Sample
{
    private int count;
    private string message;
    public Sample(int initialCount)
    {
        count = initialCount;
        message = $"カウントは {count} です。";
        Console.WriteLine(message);
    }
}

class Config
{
    private readonly string connectionString;
    public Config()
    {
        connectionString = "Server=localhost;Database=Test;";
    }
    public Config(string connStr)
    {
        connectionString = connStr;
    }
    public void Print()
    {
        Console.WriteLine(connectionString);
    }
}

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}
class Service
{
    private readonly ILogger logger;
    // 依存オブジェクトはコンストラクタで注入される
    public Service(ILogger logger)
    {
        this.logger = logger;
    }
    public void Execute()
    {
        logger.Log("処理を実行しました。");
    }
}
class Program
{
    static void Main()
    {
        // DIコンテナの代わりに手動で注入
        ILogger logger = new ConsoleLogger();
        var service = new Service(logger);
        service.Execute();
    }
}

処理を実行しました。

class A
{
    private readonly Lazy<B> b;
    public A()
    {
        b = new Lazy<B>(() => new B(this));
    }
    public void UseB()
    {
        b.Value.DoSomething();
    }
}
class B
{
    private readonly A a;
    public B(A a)
    {
        this.a = a;
    }
    public void DoSomething()
    {
        Console.WriteLine("Bの処理");
    }
}

using System;
using System.IO;
class FileProcessor
{
    private FileStream fileStream;
    public FileProcessor(string filePath)
    {
        try
        {
            fileStream = new FileStream(filePath, FileMode.Open);
            // ファイル読み込み処理など
            throw new InvalidOperationException("処理中にエラーが発生しました。");
        }
        catch
        {
            // 例外発生時にリソースを解放
            fileStream?.Dispose();
            throw; // 例外を再スロー
        }
    }
}

using System;
using System.IO;
class ResourceHolder : IDisposable
{
    private FileStream fileStream;
    private bool disposed = false;
    public ResourceHolder(string filePath)
    {
        try
        {
            fileStream = new FileStream(filePath, FileMode.Open);
            // 何らかの処理
            throw new Exception("初期化中に例外が発生");
        }
        finally
        {
            if (disposed == false)
            {
                Dispose();
            }
        }
    }
    public void Dispose()
    {
        if (!disposed)
        {
            fileStream?.Dispose();
            disposed = true;
            Console.WriteLine("リソースを解放しました。");
        }
    }
}
class Program
{
    static void Main()
    {
        try
        {
            var holder = new ResourceHolder("test.txt");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"例外キャッチ: {ex.Message}");
        }
    }
}

リソースを解放しました。
例外キャッチ: 初期化中に例外が発生

using System;
class User
{
    public string Username { get; }
    public User(string username)
    {
        if (string.IsNullOrWhiteSpace(username))
            throw new ArgumentException("ユーザー名は空白またはnullにできません。", nameof(username));
        Username = username;
    }
}
class Program
{
    static void Main()
    {
        try
        {
            var user = new User("");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"例外発生: {ex.Message}");
        }
    }
}

例外発生: ユーザー名は空白またはnullにできません。

using System;
class Publisher
{
    public event EventHandler OnChange;
    public void Raise()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
    }
}
class Subscriber
{
    private Publisher publisher;
    public Subscriber(Publisher pub)
    {
        publisher = pub;
        publisher.OnChange += HandleChange;
        // 例外発生
        throw new Exception("初期化失敗");
    }
    private void HandleChange(object sender, EventArgs e)
    {
        Console.WriteLine("イベントを受信しました。");
    }
    ~Subscriber()
    {
        Console.WriteLine("Subscriberのデストラクタ呼び出し");
    }
}
class Program
{
    static void Main()
    {
        var pub = new Publisher();
        try
        {
            var sub = new Subscriber(pub);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"例外: {ex.Message}");
        }
        GC.Collect();
        GC.WaitForPendingFinalizers();
        pub.Raise();
    }
}

例外: 初期化失敗
イベントを受信しました。

abstract class ServiceBase
{
    protected ServiceBase(string config)
    {
        if (string.IsNullOrEmpty(config))
            throw new ArgumentException("設定が必要です。", nameof(config));
        // 複雑な初期化処理
    }
    public abstract void Execute();
}

using System;
using System.Collections.Generic;
class PooledObject
{
    public int Value { get; set; }
    public void Reset()
    {
        Value = 0;
    }
}
class ObjectPool
{
    private readonly Stack<PooledObject> pool = new Stack<PooledObject>();
    public PooledObject Get()
    {
        if (pool.Count > 0)
        {
            return pool.Pop();
        }
        else
        {
            return new PooledObject();
        }
    }
    public void Return(PooledObject obj)
    {
        obj.Reset();
        pool.Push(obj);
    }
}
class Program
{
    static void Main()
    {
        var pool = new ObjectPool();
        var obj1 = pool.Get();
        obj1.Value = 42;
        Console.WriteLine($"obj1.Value = {obj1.Value}");
        pool.Return(obj1);
        var obj2 = pool.Get();
        Console.WriteLine($"obj2.Value = {obj2.Value}"); // 0にリセットされている
    }
}

obj1.Value = 42
obj2.Value = 0