C#初心者必見！コンストラクタとオーバーロードの基本を完全マスター

public class Player
{
    public string Name;
    public int Hp;
    public int Mp;

    // これがコンストラクタです
    public Player(string name, int initialHp, int initialMp)
    {
        Name = name;
        Hp = initialHp;
        Mp = initialMp;
        Console.WriteLine($"プレイヤー「{Name}」が生成されました。(HP: {Hp}, MP: {Mp})");
    }
}

public class Game
{
    public static void Main(string[] args)
    {
        // new演算子でPlayerオブジェクトを生成する際にコンストラクタが呼び出される
        Player hero = new Player("勇者", 100, 50);
        Player wizard = new Player("魔法使い", 70, 120);
    }
}

public class Book
{
    public string Title;
    public string Author;
    public int PageCount;

    // 引数を持つコンストラクタ
    public Book(string title, string author, int pageCount)
    {
        Title = title;
        Author = author;
        PageCount = pageCount;
    }

    // 引数を持たないコンストラクタ（デフォルトコンストラクタとも呼ばれる）
    public Book()
    {
        Title = "タイトル未設定";
        Author = "著者不明";
        PageCount = 0;
    }
}

public class Library
{
    public static void Main(string[] args)
    {
        // 引数ありコンストラクタで初期化
        Book book1 = new Book("C#入門", "山田太郎", 300);
        Console.WriteLine($"タイトル: {book1.Title}, 著者: {book1.Author}, ページ数: {book1.PageCount}");

        // 引数なしコンストラクタで初期化
        Book book2 = new Book();
        Console.WriteLine($"タイトル: {book2.Title}, 著者: {book2.Author}, ページ数: {book2.PageCount}");
    }
}

public class Item
{
    public string Name;
    public int Price;

    // コンストラクタを何も定義していない
}

public class Shop
{
    public static void Main(string[] args)
    {
        // Itemクラスにはコンストラクタを定義していないが、
        // デフォルトコンストラクタが自動生成されるため、
        // new Item() のように引数なしでインスタンス化できる。
        Item apple = new Item();
        apple.Name = "りんご";
        apple.Price = 100;

        Console.WriteLine($"商品名: {apple.Name}, 価格: {apple.Price}円");
    }
}

// コンパイラが自動生成するデフォルトコンストラクタ（イメージ）
// public Item()
// {
// }

public class Product
{
    public string Code;

    // 引数ありのコンストラクタを定義
    public Product(string code)
    {
        Code = code;
    }
}

public class Store
{
    public static void Main(string[] args)
    {
        // Product p1 = new Product(); // これはコンパイルエラーになる！
                                   // なぜなら、引数ありコンストラクタを定義したため、
                                   // デフォルトコンストラクタは自動生成されないから。

        Product p2 = new Product("XYZ123"); // こちらはOK
        Console.WriteLine($"商品コード: {p2.Code}");
    }
}

public class Rectangle
{
    public int Width;
    public int Height;
    public string Color;

    // メインとなるコンストラクタ (3つの引数を取る)
    public Rectangle(int width, int height, string color)
    {
        Width = width;
        Height = height;
        Color = color;
        Console.WriteLine($"幅:{Width}, 高さ:{Height}, 色:{Color} の長方形を作成");
    }

    // 2つの引数を取るコンストラクタ (色はデフォルトで "白" とする)
    // this(...) を使って上記の3引数コンストラクタを呼び出す
    public Rectangle(int width, int height) : this(width, height, "白")
    {
        Console.WriteLine("2引数コンストラクタ経由");
        // ここでは追加の初期化処理などを行える
    }

    // 1つの引数を取るコンストラクタ (正方形として扱い、色はデフォルトで "黒" とする)
    public Rectangle(int sideLength) : this(sideLength, sideLength, "黒")
    {
        Console.WriteLine("1引数コンストラクタ経由 (正方形)");
    }
}

public class DrawingApp
{
    public static void Main(string[] args)
    {
        Rectangle r1 = new Rectangle(10, 5, "赤");
        // 出力: 幅:10, 高さ:5, 色:赤 の長方形を作成

        Console.WriteLine("---");

        Rectangle r2 = new Rectangle(7, 3);
        // 出力:
        // 幅:7, 高さ:3, 色:白 の長方形を作成
        // 2引数コンストラクタ経由

        Console.WriteLine("---");

        Rectangle r3 = new Rectangle(4);
        // 出力:
        // 幅:4, 高さ:4, 色:黒 の長方形を作成
        // 1引数コンストラクタ経由 (正方形)
    }
}

public class Calculator
{
    // int型の2数を加算するメソッド
    public int Add(int a, int b)
    {
        Console.WriteLine("int Add(int, int) が呼ばれました");
        return a + b;
    }

    // double型の2数を加算するメソッド (オーバーロード)
    public double Add(double a, double b)
    {
        Console.WriteLine("double Add(double, double) が呼ばれました");
        return a + b;
    }

    // int型の3数を加算するメソッド (オーバーロード)
    public int Add(int a, int b, int c)
    {
        Console.WriteLine("int Add(int, int, int) が呼ばれました");
        return a + b + c;
    }
}

public class TestCalculator
{
    public static void Main(string[] args)
    {
        Calculator calc = new Calculator();

        Console.WriteLine(calc.Add(10, 20));         // int Add(int, int) が呼ばれる
        Console.WriteLine(calc.Add(3.14, 2.71));     // double Add(double, double) が呼ばれる
        Console.WriteLine(calc.Add(1, 2, 3));        // int Add(int, int, int) が呼ばれる
    }
}

public class User
{
    public string UserId { get; private set; }
    public string Name { get; private set; }
    public string Email { get; private set; }

    // コンストラクタ 1: UserIdとNameで初期化
    public User(string userId, string name) : this(userId, name, "N/A") // Emailはデフォルト値
    {
        Console.WriteLine("User(string, string) コンストラクタが呼ばれました。");
    }

    // コンストラクタ 2: UserId, Name, Emailで初期化 (メインのコンストラクタ)
    public User(string userId, string name, string email)
    {
        Console.WriteLine("User(string, string, string) コンストラクタが呼ばれました。");
        if (string.IsNullOrWhiteSpace(userId))
            throw new ArgumentException("UserIdは必須です。", nameof(userId));
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("Nameは必須です。", nameof(name));

        UserId = userId;
        Name = name;
        Email = email;
    }

    // コンストラクタ 3: 引数なし (ゲストユーザーとして初期化)
    public User() : this("guest", "Guest User", "guest@example.com")
    {
        Console.WriteLine("User() コンストラクタが呼ばれました。");
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"ID: {UserId}, Name: {Name}, Email: {Email}");
    }
}

public class UserManagement
{
    public static void Main(string[] args)
    {
        User user1 = new User("taro123", "山田太郎");
        user1.DisplayInfo();
        // User(string, string, string) コンストラクタが呼ばれました。
        // User(string, string) コンストラクタが呼ばれました。
        // ID: taro123, Name: 山田太郎, Email: N/A

        Console.WriteLine("---");

        User user2 = new User("hanako456", "鈴木花子", "hanako@example.com");
        user2.DisplayInfo();
        // User(string, string, string) コンストラクタが呼ばれました。
        // ID: hanako456, Name: 鈴木花子, Email: hanako@example.com

        Console.WriteLine("---");

        User guestUser = new User();
        guestUser.DisplayInfo();
        // User(string, string, string) コンストラクタが呼ばれました。
        // User() コンストラクタが呼ばれました。
        // ID: guest, Name: Guest User, Email: guest@example.com
    }
}

// 基底クラス
public class Vehicle
{
    public string RegistrationNumber { get; private set; }

    // 基底クラスのコンストラクタ 1
    public Vehicle(string regNum)
    {
        Console.WriteLine("Vehicle(string) コンストラクタが呼ばれました。");
        RegistrationNumber = regNum;
    }

    // 基底クラスのコンストラクタ 2 (オーバーロード)
    public Vehicle()
    {
        Console.WriteLine("Vehicle() コンストラクタが呼ばれました。");
        RegistrationNumber = "未登録";
    }
}

// 派生クラス
public class Car : Vehicle // Vehicleクラスを継承
{
    public string ModelName { get; private set; }

    // 派生クラスのコンストラクタ 1
    // base(regNum) で基底クラスの Vehicle(string) を呼び出す
    public Car(string regNum, string model) : base(regNum)
    {
        Console.WriteLine("Car(string, string) コンストラクタが呼ばれました。");
        ModelName = model;
    }

    // 派生クラスのコンストラクタ 2
    // base() で基底クラスの Vehicle() を呼び出す
    public Car(string model) : base() // もしくは : base("一時登録") のように特定の値を渡すことも可能
    {
        Console.WriteLine("Car(string) コンストラクタが呼ばれました。");
        ModelName = model;
    }

    // 派生クラスのコンストラクタ 3
    // 明示的にbaseを指定しない場合、基底クラスの引数なしコンストラクタ (Vehicle()) が暗黙的に呼ばれる
    // もし基底クラスに引数なしコンストラクタが存在しない場合はコンパイルエラー
    public Car() // : base() と同じ意味
    {
        Console.WriteLine("Car() コンストラクタが呼ばれました。");
        ModelName = "車種不明";
    }
}

public class Showroom
{
    public static void Main(string[] args)
    {
        Console.WriteLine("--- Car 1 ---");
        Car car1 = new Car("XYZ 123", "SedanX");
        Console.WriteLine($"登録番号: {car1.RegistrationNumber}, モデル名: {car1.ModelName}");
        // 出力:
        // --- Car 1 ---
        // Vehicle(string) コンストラクタが呼ばれました。
        // Car(string, string) コンストラクタが呼ばれました。
        // 登録番号: XYZ 123, モデル名: SedanX

        Console.WriteLine("\n--- Car 2 ---");
        Car car2 = new Car("HatchY");
        Console.WriteLine($"登録番号: {car2.RegistrationNumber}, モデル名: {car2.ModelName}");
        // 出力:
        // --- Car 2 ---
        // Vehicle() コンストラクタが呼ばれました。
        // Car(string) コンストラクタが呼ばれました。
        // 登録番号: 未登録, モデル名: HatchY

        Console.WriteLine("\n--- Car 3 ---");
        Car car3 = new Car();
        Console.WriteLine($"登録番号: {car3.RegistrationNumber}, モデル名: {car3.ModelName}");
        // 出力:
        // --- Car 3 ---
        // Vehicle() コンストラクタが呼ばれました。
        // Car() コンストラクタが呼ばれました。
        // 登録番号: 未登録, モデル名: 車種不明
    }
}

public class Animal
{
    public string Species { get; protected set; }

    public Animal(string species)
    {
        Species = species;
        Console.WriteLine($"Animalコンストラクタ実行: {Species} が生成されようとしています。");
    }
}

public class Dog : Animal
{
    public string Name { get; private set; }

    // base(species) で Animal(string) を呼び出す
    public Dog(string name, string species) : base(species)
    {
        Name = name;
        Console.WriteLine($"Dogコンストラクタ実行: 名前は {Name} です。");
    }
}

public class PetShop
{
    public static void Main(string[] args)
    {
        Dog myDog = new Dog("ポチ", "柴犬");
        // 出力結果:
        // Animalコンストラクタ実行: 柴犬 が生成されようとしています。
        // Dogコンストラクタ実行: 名前は ポチ です。

        Console.WriteLine($"私のペットは {myDog.Species} の {myDog.Name} です。");
        // 私のペットは 柴犬 の ポチ です。
    }
}

public class A
{
    // 引数ありコンストラクタのみ定義
    public A(string message)
    {
        Console.WriteLine($"A: {message}");
    }
}

public class B : A
{
    // base() を暗黙的に呼び出そうとするが、Aには引数なしコンストラクタがないためエラー
    /*
    public B() // コンパイルエラー！
    {
        Console.WriteLine("B");
    }
    */

    // 正しくは、Aの引数ありコンストラクタを明示的に呼び出す必要がある
    public B(string msgForA) : base(msgForA)
    {
        Console.WriteLine("B");
    }
}

MyClass obj = new MyClass(); // new MyClass() がコンストラクタ呼び出し
                             // obj には MyClass の新しいインスタンスへの参照が代入される

public class FileManager
{
    private IntPtr fileHandle; // アンマネージドリソースの例 (IntPtrはポインタやハンドルを扱う型)
    private bool disposed = false;

    public FileManager(string filePath)
    {
        // ここでファイルを開き、fileHandle を取得する処理 (仮)
        Console.WriteLine($"ファイル「{filePath}」を開いています... (仮のハンドル取得)");
        fileHandle = new IntPtr(12345); // 仮のハンドル
    }

    // これがデストラクタ（ファイナライザ）
    ~FileManager()
    {
        Console.WriteLine("FileManagerのデストラクタが呼ばれました。");
        CleanUp(false); // ファイナライザからの呼び出し
    }

    // リソース解放のためのメソッド (IDisposableパターンでよく使われる)
    public void Dispose()
    {
        CleanUp(true);
        GC.SuppressFinalize(this); // ファイナライザを呼び出さないようにする
    }

    protected virtual void CleanUp(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // マネージドリソースの解放 (もしあれば)
                Console.WriteLine("マネージドリソースを解放中...");
            }

            // アンマネージドリソースの解放
            if (fileHandle != IntPtr.Zero)
            {
                Console.WriteLine($"アンマネージドリソース (ハンドル: {fileHandle}) を解放中...");
                // ここで実際に fileHandle を解放するOSのAPIなどを呼び出す
                fileHandle = IntPtr.Zero;
            }
            disposed = true;
        }
    }
}

public class ResourceDemo
{
    public static void Main(string[] args)
    {
        CreateAndReleaseManager();
        Console.WriteLine("CreateAndReleaseManagerメソッドの実行が完了しました。");
        Console.WriteLine("ガベージコレクションを強制実行します (通常は非推奨)。");
        GC.Collect();
        GC.WaitForPendingFinalizers(); // ファイナライザの完了を待つ
        Console.WriteLine("プログラム終了。");
    }

    static void CreateAndReleaseManager()
    {
        FileManager fm = new FileManager("sample.txt");
        // fm.Dispose(); // 本来はここでDisposeを呼ぶべき
        Console.WriteLine("FileManagerオブジェクトはスコープを抜けました。");
        // fm はここでスコープを抜けるが、すぐにデストラクタが呼ばれるとは限らない
    }
}

public class SafeFileManager : IDisposable
{
    private IntPtr fileHandle;
    private bool disposed = false;

    public SafeFileManager(string filePath)
    {
        Console.WriteLine($"[Safe] ファイル「{filePath}」を開いています...");
        fileHandle = new IntPtr(67890); // 仮のハンドル
    }

    public void DoSomething()
    {
        if (disposed) throw new ObjectDisposedException(nameof(SafeFileManager));
        Console.WriteLine("[Safe] ファイル操作を実行中...");
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // ファイナライザの呼び出しを抑制
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // マネージドリソースの解放 (もしあれば)
                Console.WriteLine("[Safe] マネージドリソースを解放。");
            }

            // アンマネージドリソースの解放
            if (fileHandle != IntPtr.Zero)
            {
                Console.WriteLine($"[Safe] アンマネージドリソース (ハンドル: {fileHandle}) を解放。");
                fileHandle = IntPtr.Zero;
            }
            disposed = true;
        }
    }

    // 念のためファイナライザも実装 (Disposeが呼ばれなかった場合のセーフティネット)
    ~SafeFileManager()
    {
        Console.WriteLine("[Safe] ファイナライザが呼ばれました。");
        Dispose(false);
    }
}

public class SafeResourceDemo
{
    public static void Main(string[] args)
    {
        using (SafeFileManager sfm = new SafeFileManager("important.dat"))
        {
            sfm.DoSomething();
        } // usingブロックを抜ける際に、sfm.Dispose() が自動的に呼び出される

        Console.WriteLine("--- usingブロックの後 ---");
        // ガベージコレクションを強制実行しても、既にDisposeされているのでファイナライザは通常呼ばれない
        // (GC.SuppressFinalize(this) の効果)
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine("プログラム終了。");
    }
}