[C#] クラスの初期化方法とその重要性

// クラスの定義
public class Car
{
    // フィールド
    private string color;
    private int speed;
    // メソッド
    public void Drive()
    {
        Console.WriteLine("車が走っています。");
    }
}

// オブジェクトの生成と初期化
Car myCar = new Car();
myCar.Drive();

// コンストラクタの定義
public class Car
{
    private string color;
    private int speed;
    // コンストラクタ
    public Car(string color, int speed)
    {
        this.color = color;
        this.speed = speed;
    }
    public void Drive()
    {
        Console.WriteLine($"車の色は{color}で、速度は{speed}です。");
    }
}
// オブジェクトの生成と初期化
Car myCar = new Car("赤", 100);
myCar.Drive();

車の色は赤で、速度は100です。

// デフォルトコンストラクタの例
public class Car
{
    private string color;
    private int speed;
    // デフォルトコンストラクタ
    public Car()
    {
        color = "白";
        speed = 0;
    }
    public void Drive()
    {
        Console.WriteLine($"車の色は{color}で、速度は{speed}です。");
    }
}
// オブジェクトの生成と初期化
Car myCar = new Car();
myCar.Drive();

車の色は白で、速度は0です。

// パラメータ付きコンストラクタの例
public class Car
{
    private string color;
    private int speed;
    // パラメータ付きコンストラクタ
    public Car(string color, int speed)
    {
        this.color = color;
        this.speed = speed;
    }
    public void Drive()
    {
        Console.WriteLine($"車の色は{color}で、速度は{speed}です。");
    }
}
// オブジェクトの生成と初期化
Car myCar = new Car("青", 120);
myCar.Drive();

車の色は青で、速度は120です。

// 静的コンストラクタの例
public class Car
{
    private static int totalCars;
    private string color;
    private int speed;
    // 静的コンストラクタ
    static Car()
    {
        totalCars = 0;
        Console.WriteLine("静的コンストラクタが呼び出されました。");
    }
    // パラメータ付きコンストラクタ
    public Car(string color, int speed)
    {
        this.color = color;
        this.speed = speed;
        totalCars++;
    }
    public void Drive()
    {
        Console.WriteLine($"車の色は{color}で、速度は{speed}です。");
    }
    public static void ShowTotalCars()
    {
        Console.WriteLine($"総車数: {totalCars}");
    }
}
// オブジェクトの生成と初期化
Car myCar1 = new Car("赤", 100);
Car myCar2 = new Car("緑", 80);
Car.ShowTotalCars();

静的コンストラクタが呼び出されました。
車の色は赤で、速度は100です。
車の色は緑で、速度は80です。
総車数: 2

// コピーコンストラクタの例
public class Car
{
    private string color;
    private int speed;
    // パラメータ付きコンストラクタ
    public Car(string color, int speed)
    {
        this.color = color;
        this.speed = speed;
    }
    // コピーコンストラクタ
    public Car(Car existingCar)
    {
        this.color = existingCar.color;
        this.speed = existingCar.speed;
    }
    public void Drive()
    {
        Console.WriteLine($"車の色は{color}で、速度は{speed}です。");
    }
}
// オブジェクトの生成と初期化
Car originalCar = new Car("黄", 90);
Car copiedCar = new Car(originalCar);
copiedCar.Drive();

車の色は黄で、速度は90です。

// 一貫したオブジェクト状態の保証
public class BankAccount
{
    private decimal balance;
    // コンストラクタで初期化
    public BankAccount(decimal initialBalance)
    {
        if (initialBalance < 0)
        {
            throw new ArgumentException("初期残高は0以上でなければなりません。");
        }
        balance = initialBalance;
    }
    public void DisplayBalance()
    {
        Console.WriteLine($"現在の残高は{balance}円です。");
    }
}
// オブジェクトの生成と初期化
try
{
    BankAccount account = new BankAccount(1000);
    account.DisplayBalance();
}
catch (ArgumentException e)
{
    Console.WriteLine(e.Message);
}

現在の残高は1000円です。

// エラー防止のための初期化
public class TemperatureSensor
{
    private double temperature;
    // コンストラクタで初期化
    public TemperatureSensor(double initialTemperature)
    {
        if (initialTemperature < -273.15)
        {
            throw new ArgumentOutOfRangeException("温度は絶対零度以上でなければなりません。");
        }
        temperature = initialTemperature;
    }
    public void DisplayTemperature()
    {
        Console.WriteLine($"現在の温度は{temperature}度です。");
    }
}
// オブジェクトの生成と初期化
try
{
    TemperatureSensor sensor = new TemperatureSensor(25.0);
    sensor.DisplayTemperature();
}
catch (ArgumentOutOfRangeException e)
{
    Console.WriteLine(e.Message);
}

現在の温度は25度です。

// 依存関係の管理
public class Engine
{
    public void Start()
    {
        Console.WriteLine("エンジンが始動しました。");
    }
}
public class Car
{
    private Engine engine;
    // コンストラクタで依存関係を注入
    public Car(Engine engine)
    {
        this.engine = engine ?? throw new ArgumentNullException(nameof(engine), "エンジンは必須です。");
    }
    public void StartCar()
    {
        engine.Start();
        Console.WriteLine("車が走り始めました。");
    }
}
// オブジェクトの生成と初期化
try
{
    Engine engine = new Engine();
    Car myCar = new Car(engine);
    myCar.StartCar();
}
catch (ArgumentNullException e)
{
    Console.WriteLine(e.Message);
}

エンジンが始動しました。
車が走り始めました。

// デフォルト値の設定
public class UserProfile
{
    private string username;
    private int age;
    // コンストラクタでデフォルト値を設定
    public UserProfile()
    {
        username = "ゲスト";
        age = 18;
    }
    public void DisplayProfile()
    {
        Console.WriteLine($"ユーザー名: {username}, 年齢: {age}");
    }
}
// オブジェクトの生成と初期化
UserProfile user = new UserProfile();
user.DisplayProfile();

ユーザー名: ゲスト, 年齢: 18

// 不変オブジェクトの作成
public class ImmutablePoint
{
    public int X { get; }
    public int Y { get; }
    // コンストラクタで初期化
    public ImmutablePoint(int x, int y)
    {
        X = x;
        Y = y;
    }
    public void DisplayPoint()
    {
        Console.WriteLine($"座標: ({X}, {Y})");
    }
}
// オブジェクトの生成と初期化
ImmutablePoint point = new ImmutablePoint(5, 10);
point.DisplayPoint();

座標: (5, 10)

// 例外処理の実装
public class Product
{
    private string name;
    private decimal price;
    // コンストラクタで例外処理を実装
    public Product(string name, decimal price)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("商品名は必須です。");
        }
        if (price < 0)
        {
            throw new ArgumentOutOfRangeException("価格は0以上でなければなりません。");
        }
        this.name = name;
        this.price = price;
    }
    public void DisplayProduct()
    {
        Console.WriteLine($"商品名: {name}, 価格: {price}円");
    }
}
// オブジェクトの生成と初期化
try
{
    Product product = new Product("ノートパソコン", 150000);
    product.DisplayProduct();
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
}

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

// ビルダーパターンの例
public class Computer
{
    public string CPU { get; private set; }
    public string RAM { get; private set; }
    public string Storage { get; private set; }
    private Computer() { }
    public class Builder
    {
        private Computer computer = new Computer();
        public Builder SetCPU(string cpu)
        {
            computer.CPU = cpu;
            return this;
        }
        public Builder SetRAM(string ram)
        {
            computer.RAM = ram;
            return this;
        }
        public Builder SetStorage(string storage)
        {
            computer.Storage = storage;
            return this;
        }
        public Computer Build()
        {
            return computer;
        }
    }
}
// オブジェクトの生成と初期化
Computer myComputer = new Computer.Builder()
    .SetCPU("Intel i7")
    .SetRAM("16GB")
    .SetStorage("512GB SSD")
    .Build();
Console.WriteLine($"CPU: {myComputer.CPU}, RAM: {myComputer.RAM}, Storage: {myComputer.Storage}");

CPU: Intel i7, RAM: 16GB, Storage: 512GB SSD

// 依存性注入の例
public interface ILogger
{
    void Log(string message);
}
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"ログ: {message}");
    }
}
public class Application
{
    private readonly ILogger logger;
    // コンストラクタで依存性を注入
    public Application(ILogger logger)
    {
        this.logger = logger;
    }
    public void Run()
    {
        logger.Log("アプリケーションが開始されました。");
    }
}
// オブジェクトの生成と初期化
ILogger logger = new ConsoleLogger();
Application app = new Application(logger);
app.Run();

ログ: アプリケーションが開始されました。

// シングルトンパターンの例
public class Singleton
{
    private static Singleton instance;
    private static readonly object lockObject = new object();
    // プライベートコンストラクタ
    private Singleton() { }
    public static Singleton Instance
    {
        get
        {
            lock (lockObject)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
    public void ShowMessage()
    {
        Console.WriteLine("シングルトンインスタンスが使用されています。");
    }
}
// オブジェクトの生成と初期化
Singleton singleton = Singleton.Instance;
singleton.ShowMessage();

シングルトンインスタンスが使用されています。

// ファクトリーパターンの例
public interface IProduct
{
    void Display();
}
public class ConcreteProductA : IProduct
{
    public void Display()
    {
        Console.WriteLine("ConcreteProductAが生成されました。");
    }
}
public class ConcreteProductB : IProduct
{
    public void Display()
    {
        Console.WriteLine("ConcreteProductBが生成されました。");
    }
}
public class ProductFactory
{
    public static IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("無効な製品タイプです。");
        }
    }
}
// オブジェクトの生成と初期化
IProduct productA = ProductFactory.CreateProduct("A");
productA.Display();
IProduct productB = ProductFactory.CreateProduct("B");
productB.Display();

ConcreteProductAが生成されました。
ConcreteProductBが生成されました。