【C#】クラスをわかりやすく入門！基本構文からコンストラクター・継承まで

public class Car
{
    public string Color;
    public int Year;
    public Car(string color, int year)
    {
        Color = color;
        Year = year;
    }
    public void Start()
    {
        Console.WriteLine("車が始動しました。");
    }
}
class Program
{
    static void Main()
    {
        // Carクラスのインスタンスを作成(インスタンス化)
        Car myCar = new Car("赤", 2020);
        myCar.Start();  // メソッドの呼び出し
    }
}

車が始動しました。

class Person
{
    public string Name;
    public int Age;
}
class Program
{
    static void Main()
    {
        Person p = new Person();
        p.Name = "太郎";
        p.Age = 30;
        Console.WriteLine($"{p.Name}さんは{p.Age}歳です。");
    }
}

太郎さんは30歳です。

namespace VehicleApp
{
    public class Car
    {
        public string Color;
        public int Year;
    }
}

public class Car
{
    public string Color;  // 車の色を表すフィールド
    private int year;     // 製造年を表すプライベートフィールド
}

public class Car
{
    private int year;
    public int Year
    {
        get { return year; }
        set
        {
            if (value > 1885)  // 自動車の発明年以降のみ許可
            {
                year = value;
            }
        }
    }
}

public class Car
{
    public string Color { get; set; }  // 自動実装プロパティ
}

public class Car
{
    public string Color { get; set; }
    public int Year { get; set; }
    // メソッドの定義
    public void Start()
    {
        Console.WriteLine("車が始動しました。");
    }
    // 引数と戻り値のあるメソッド
    public string GetDescription()
    {
        return $"この車は{Color}色で、製造年は{Year}年です。";
    }
}

public class Car
{
    public string Color;          // どこからでもアクセス可能
    private int year;             // クラス内のみアクセス可能
    protected int speed;          // 派生クラスからアクセス可能
    internal string modelName;    // 同一アセンブリ内でアクセス可能
    public void Start()
    {
        Console.WriteLine("車が始動しました。");
    }
}

public class Car
{
    public string Color;
    public int Year;
    // デフォルトコンストラクター
    public Car()
    {
        Color = "白";  // デフォルトの色を白に設定
        Year = 2020;   // デフォルトの製造年を2020年に設定
    }
    public void ShowInfo()
    {
        Console.WriteLine($"色: {Color}, 製造年: {Year}");
    }
}
class Program
{
    static void Main()
    {
        Car myCar = new Car();  // デフォルトコンストラクターが呼ばれる
        myCar.ShowInfo();
    }
}

色: 白, 製造年: 2020

public class Car
{
    public string Color;
    public int Year;
    // 引数付きコンストラクター
    public Car(string color, int year)
    {
        Color = color;
        Year = year;
    }
    public void ShowInfo()
    {
        Console.WriteLine($"色: {Color}, 製造年: {Year}");
    }
}
class Program
{
    static void Main()
    {
        Car myCar = new Car("赤", 2021);  // 引数付きコンストラクターが呼ばれる
        myCar.ShowInfo();
    }
}

色: 赤, 製造年: 2021

public class Car
{
    public string Color;
    public int Year;
    // デフォルトコンストラクター
    public Car()
    {
        Color = "白";
        Year = 2020;
    }
    // 引数付きコンストラクター(色のみ)
    public Car(string color)
    {
        Color = color;
        Year = 2020;
    }
    // 引数付きコンストラクター(色と年)
    public Car(string color, int year)
    {
        Color = color;
        Year = year;
    }
    public void ShowInfo()
    {
        Console.WriteLine($"色: {Color}, 製造年: {Year}");
    }
}
class Program
{
    static void Main()
    {
        Car car1 = new Car();
        Car car2 = new Car("青");
        Car car3 = new Car("黒", 2019);
        car1.ShowInfo();
        car2.ShowInfo();
        car3.ShowInfo();
    }
}

色: 白, 製造年: 2020
色: 青, 製造年: 2020
色: 黒, 製造年: 2019

public class Car
{
    public string Color;
    public int Year;
    public Car() : this("白", 2020)  // 引数付きコンストラクターを呼び出す
    {
    }
    public Car(string color, int year)
    {
        Color = color;
        Year = year;
    }
    public void ShowInfo()
    {
        Console.WriteLine($"色: {Color}, 製造年: {Year}");
    }
}
class Program
{
    static void Main()
    {
        Car myCar = new Car();  // デフォルトコンストラクターが呼ばれ、内部で引数付きコンストラクターを呼ぶ
        myCar.ShowInfo();
    }
}

色: 白, 製造年: 2020

public class Car
{
    public string Color;
    public int Year;
    public Car(string color, int year)
    {
        Color = color;
        Year = year;
    }
}
public class ElectricCar : Car
{
    public int BatteryLevel;
    public ElectricCar(string color, int year, int batteryLevel)
        : base(color, year)  // 基底クラスのコンストラクターを呼び出す
    {
        BatteryLevel = batteryLevel;
    }
    public void ShowInfo()
    {
        Console.WriteLine($"色: {Color}, 製造年: {Year}, バッテリー残量: {BatteryLevel}%");
    }
}
class Program
{
    static void Main()
    {
        ElectricCar myElectricCar = new ElectricCar("青", 2022, 85);
        myElectricCar.ShowInfo();
    }
}

色: 青, 製造年: 2022, バッテリー残量: 85%

public class Person
{
    private string name;  // フィールド(データの実体)
    public string Name    // プロパティ
    {
        get
        {
            return name;  // 値を返す
        }
        set
        {
            name = value; // 値を設定する
        }
    }
}

public class Person
{
    private int age;
    public int Age
    {
        get
        {
            return age;
        }
        set
        {
            if (value >= 0)  // 年齢は0以上であることを保証
            {
                age = value;
            }
            else
            {
                Console.WriteLine("年齢は0以上でなければなりません。");
            }
        }
    }
}

public class Person
{
    public string Name { get; set; }  // 自動実装プロパティ
    public int Age { get; set; }
}

public class Person
{
    public string Name { get; }  // 読み取り専用プロパティ
    public Person(string name)
    {
        Name = name;  // コンストラクター内でのみ設定可能
    }
}

public class Person
{
    private int age;
    public int Age
    {
        get { return age; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "年齢は0以上でなければなりません。");
            }
            age = value;
        }
    }
}
class Program
{
    static void Main()
    {
        Person p = new Person();
        try
        {
            p.Age = 25;
            Console.WriteLine($"年齢: {p.Age}");
            p.Age = -5;  // 例外が発生する
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"エラー: {ex.Message}");
        }
    }
}

年齢: 25
エラー: 年齢は0以上でなければなりません。

public class Car
{
    public string Color;  // フィールド(クラスのメンバー変数)
    public void ShowColor()
    {
        string message = "車の色は";  // ローカル変数(メソッド内の変数)
        Console.WriteLine(message + Color);
    }
}

public class MathConstants
{
    public const double Pi = 3.14159;  // コンパイル時定数
    public void ShowPi()
    {
        Console.WriteLine($"円周率: {Pi}");
    }
}

public class Car
{
    public readonly int MaxSpeed;
    public Car(int maxSpeed)
    {
        MaxSpeed = maxSpeed;  // コンストラクター内で初期化可能
    }
    public void ShowMaxSpeed()
    {
        Console.WriteLine($"最大速度: {MaxSpeed} km/h");
    }
}
class Program
{
    static void Main()
    {
        Car car = new Car(180);
        car.ShowMaxSpeed();
        // car.MaxSpeed = 200;  // コンパイルエラー: readonlyフィールドは変更不可
    }
}

public class Calculator
{
    // 引数2つを受け取り、合計を返すメソッド
    public int Add(int a, int b)
    {
        return a + b;
    }
}

public void PrintMessage(string message)
{
    Console.WriteLine(message);
}

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
    public double Add(double a, double b)
    {
        return a + b;
    }
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
}

// 使い分け例
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(1, 2));       // 3
Console.WriteLine(calc.Add(1.5, 2.5));   // 4.0
Console.WriteLine(calc.Add(1, 2, 3));    // 6

public void Greet(string name, string greeting = "こんにちは")
{
    Console.WriteLine($"{greeting}, {name}さん！");
}

Greet("太郎");               // こんにちは, 太郎さん！
Greet("花子", "おはよう");   // おはよう, 花子さん！

public class Car
{
    public string Color;
    public void ShowColor()
    {
        Console.WriteLine($"車の色は{Color}です。");
    }
}
class Program
{
    static void Main()
    {
        Car myCar = new Car();
        myCar.Color = "赤";
        myCar.ShowColor();  // インスタンスメソッドの呼び出し
    }
}

車の色は赤です。

public class MathUtil
{
    public static int Square(int x)
    {
        return x * x;
    }
}
class Program
{
    static void Main()
    {
        int result = MathUtil.Square(5);  // 静的メソッドの呼び出し
        Console.WriteLine(result);
    }
}

25

public class Counter
{
    // staticフィールド：全インスタンスで共有されるカウント値
    private static int count = 0;
    // staticプロパティ：外部からアクセス可能なカウント値
    public static int Count
    {
        get { return count; }
    }
    public Counter()
    {
        count++;  // インスタンスが作られるたびにカウントアップ
    }
}
class Program
{
    static void Main()
    {
        Console.WriteLine($"初期カウント: {Counter.Count}");  // 0
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Console.WriteLine($"カウント: {Counter.Count}");  // 2
    }
}

初期カウント: 0
カウント: 2

public class Logger
{
    public static readonly DateTime StartTime;
    // staticコンストラクター
    static Logger()
    {
        StartTime = DateTime.Now;
        Console.WriteLine("Loggerのstaticコンストラクターが呼ばれました。");
    }
    public static void Log(string message)
    {
        Console.WriteLine($"[{DateTime.Now}] {message}");
    }
}
class Program
{
    static void Main()
    {
        Console.WriteLine($"開始時刻: {Logger.StartTime}");
        Logger.Log("処理を開始します。");
    }
}

Loggerのstaticコンストラクターが呼ばれました。
開始時刻: 2024/06/XX XX:XX:XX
[2024/06/XX XX:XX:XX] 処理を開始します。

public class Singleton
{
    // 唯一のインスタンスを保持するstaticフィールド
    private static readonly Singleton instance;
    // staticコンストラクターでインスタンスを初期化
    static Singleton()
    {
        instance = new Singleton();
    }
    // コンストラクターはprivateにして外部からの生成を禁止
    private Singleton()
    {
    }
    // インスタンスを取得するためのpublicなstaticプロパティ
    public static Singleton Instance
    {
        get { return instance; }
    }
    public void ShowMessage()
    {
        Console.WriteLine("シングルトンのインスタンスが呼ばれました。");
    }
}
class Program
{
    static void Main()
    {
        Singleton s1 = Singleton.Instance;
        Singleton s2 = Singleton.Instance;
        s1.ShowMessage();
        Console.WriteLine($"s1とs2は同じインスタンスですか？ {ReferenceEquals(s1, s2)}");
    }
}

シングルトンのインスタンスが呼ばれました。
s1とs2は同じインスタンスですか？ True

// 基底クラス
public class Animal
{
    public string Name;
    public void Eat()
    {
        Console.WriteLine($"{Name}は食事をしています。");
    }
}
// 派生クラス
public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name}は吠えています。");
    }
}
class Program
{
    static void Main()
    {
        Dog dog = new Dog();
        dog.Name = "ポチ";
        dog.Eat();   // 基底クラスのメソッドを呼び出し
        dog.Bark();  // 派生クラス独自のメソッドを呼び出し
    }
}

ポチは食事をしています。
ポチは吠えています。

public class Animal
{
    public string Name;
    public virtual void Speak()
    {
        Console.WriteLine($"{Name}は何かを話しています。");
    }
}
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine($"{Name}はワンワンと吠えています。");
    }
}
class Program
{
    static void Main()
    {
        Animal animal = new Animal { Name = "動物" };
        animal.Speak();
        Dog dog = new Dog { Name = "ポチ" };
        dog.Speak();
    }
}

動物は何かを話しています。
ポチはワンワンと吠えています。

public sealed class FinalClass
{
    public void Show()
    {
        Console.WriteLine("このクラスは継承できません。");
    }
}
// 以下はコンパイルエラーになる
// public class DerivedClass : FinalClass { }

public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("BaseClassのDisplay");
    }
}
public class DerivedClass : BaseClass
{
    public sealed override void Display()
    {
        Console.WriteLine("DerivedClassのDisplay(これ以上オーバーライド不可)");
    }
}
public class FurtherDerivedClass : DerivedClass
{
    // 以下はコンパイルエラーになる
    // public override void Display() { }
}

Animal animal = new Dog();
if (animal is Dog)
{
    Console.WriteLine("animalはDog型です。");
}
else
{
    Console.WriteLine("animalはDog型ではありません。");
}

animalはDog型です。

Animal animal = new Dog();
Dog dog = animal as Dog;
if (dog != null)
{
    dog.Bark();
}
else
{
    Console.WriteLine("キャストに失敗しました。");
}

ポチは吠えています。

public abstract class Animal
{
    public string Name { get; set; }
    // 共通のメソッド(実装あり)
    public void Eat()
    {
        Console.WriteLine($"{Name}は食事をしています。");
    }
    // 抽象メソッド(実装なし、派生クラスで必須実装)
    public abstract void Speak();
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine($"{Name}はワンワンと吠えています。");
    }
}
class Program
{
    static void Main()
    {
        Dog dog = new Dog { Name = "ポチ" };
        dog.Eat();    // 基底クラスの共通メソッド
        dog.Speak();  // 派生クラスで実装した抽象メソッド
    }
}

ポチは食事をしています。
ポチはワンワンと吠えています。

public interface IFlyable
{
    void Fly();
}
public interface ISwimmable
{
    void Swim();
}
public class Bird : IFlyable
{
    public void Fly()
    {
        Console.WriteLine("鳥が飛んでいます。");
    }
}
public class Duck : IFlyable, ISwimmable
{
    public void Fly()
    {
        Console.WriteLine("アヒルが飛んでいます。");
    }
    public void Swim()
    {
        Console.WriteLine("アヒルが泳いでいます。");
    }
}

public interface IPrinter
{
    void Print();
}
public interface IScanner
{
    void Print();
}
public class MultiFunctionDevice : IPrinter, IScanner
{
    // IPrinterのPrint実装
    void IPrinter.Print()
    {
        Console.WriteLine("プリンターで印刷しています。");
    }
    // IScannerのPrint実装
    void IScanner.Print()
    {
        Console.WriteLine("スキャナーでスキャンしています。");
    }
    // クラス独自のメソッド
    public void Print()
    {
        Console.WriteLine("MultiFunctionDeviceの通常のPrintメソッド");
    }
}
class Program
{
    static void Main()
    {
        MultiFunctionDevice device = new MultiFunctionDevice();
        // クラスのメソッド呼び出し
        device.Print();
        // 明示的インターフェース実装の呼び出し
        ((IPrinter)device).Print();
        ((IScanner)device).Print();
    }
}

MultiFunctionDeviceの通常のPrintメソッド
プリンターで印刷しています。
スキャナーでスキャンしています。

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("動物が鳴いています。");
    }
}
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("ワンワン");
    }
}
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("ニャー");
    }
}
class Program
{
    static void Main()
    {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.Speak();  // DogのSpeakが呼ばれる
        animal2.Speak();  // CatのSpeakが呼ばれる
    }
}

ワンワン
ニャー

public class BaseClass
{
    public virtual void Show()
    {
        Console.WriteLine("BaseClassのShow");
    }
}
public class DerivedOverride : BaseClass
{
    public override void Show()
    {
        Console.WriteLine("DerivedOverrideのShow");
    }
}
public class DerivedNew : BaseClass
{
    public new void Show()
    {
        Console.WriteLine("DerivedNewのShow");
    }
}
class Program
{
    static void Main()
    {
        BaseClass baseRef1 = new DerivedOverride();
        BaseClass baseRef2 = new DerivedNew();
        baseRef1.Show();  // DerivedOverrideのShowが呼ばれる
        baseRef2.Show();  // BaseClassのShowが呼ばれる
        DerivedNew derivedNew = new DerivedNew();
        derivedNew.Show();  // DerivedNewのShowが呼ばれる
    }
}

DerivedOverrideのShow
BaseClassのShow
DerivedNewのShow

public class Duck
{
    public void Quack()
    {
        Console.WriteLine("ガーガー");
    }
}
public class Person
{
    public void Quack()
    {
        Console.WriteLine("私はアヒルの真似をします。");
    }
}
class Program
{
    static void MakeQuack(dynamic obj)
    {
        obj.Quack();
    }
    static void Main()
    {
        Duck duck = new Duck();
        Person person = new Person();
        MakeQuack(duck);    // ガーガー
        MakeQuack(person);  // 私はアヒルの真似をします。
    }
}

ガーガー
私はアヒルの真似をします。

public interface IQuackable
{
    void Quack();
}
public class Duck : IQuackable
{
    public void Quack()
    {
        Console.WriteLine("ガーガー");
    }
}
public class Person : IQuackable
{
    public void Quack()
    {
        Console.WriteLine("私はアヒルの真似をします。");
    }
}
class Program
{
    static void MakeQuack(IQuackable obj)
    {
        obj.Quack();
    }
    static void Main()
    {
        Duck duck = new Duck();
        Person person = new Person();
        MakeQuack(duck);    // ガーガー
        MakeQuack(person);  // 私はアヒルの真似をします。
    }
}

ガーガー
私はアヒルの真似をします。

public class Box<T>
{
    private T content;
    public void SetContent(T value)
    {
        content = value;
    }
    public T GetContent()
    {
        return content;
    }
}
class Program
{
    static void Main()
    {
        Box<int> intBox = new Box<int>();
        intBox.SetContent(123);
        Console.WriteLine(intBox.GetContent());  // 123
        Box<string> strBox = new Box<string>();
        strBox.SetContent("こんにちは");
        Console.WriteLine(strBox.GetContent());  // こんにちは
    }
}

123
こんにちは

public class Repository<T> where T : class, new()
{
    public T CreateInstance()
    {
        return new T();  // new()制約があるため引数なしコンストラクターが使える
    }
}
class Program
{
    static void Main()
    {
        Repository<StringBuilder> repo = new Repository<StringBuilder>();
        StringBuilder sb = repo.CreateInstance();
        sb.Append("ジェネリック制約の例");
        Console.WriteLine(sb.ToString());
    }
}

ジェネリック制約の例

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3 };
        numbers.Add(4);
        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
        Dictionary<string, int> ages = new Dictionary<string, int>();
        ages["太郎"] = 30;
        ages["花子"] = 25;
        Console.WriteLine($"太郎の年齢は{ages["太郎"]}歳です。");
    }
}

1
2
3
4
太郎の年齢は30歳です。

public class Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
    // + 演算子のオーバーロード
    public static Point operator +(Point a, Point b)
    {
        return new Point(a.X + b.X, a.Y + b.Y);
    }
    // - 演算子のオーバーロード
    public static Point operator -(Point a, Point b)
    {
        return new Point(a.X - b.X, a.Y - b.Y);
    }
    // == 演算子のオーバーロード
    public static bool operator ==(Point a, Point b)
    {
        if (ReferenceEquals(a, b)) return true;
        if (a is null || b is null) return false;
        return a.X == b.X && a.Y == b.Y;
    }
    // != 演算子のオーバーロード
    public static bool operator !=(Point a, Point b)
    {
        return !(a == b);
    }
    // Equalsメソッドのオーバーライド(後述)
    public override bool Equals(object obj)
    {
        if (obj is Point p)
        {
            return this == p;
        }
        return false;
    }
    // GetHashCodeメソッドのオーバーライド(後述)
    public override int GetHashCode()
    {
        return HashCode.Combine(X, Y);
    }
}
class Program
{
    static void Main()
    {
        Point p1 = new Point(2, 3);
        Point p2 = new Point(4, 5);
        Point p3 = p1 + p2;
        Point p4 = p2 - p1;
        Console.WriteLine($"p3: ({p3.X}, {p3.Y})");  // (6, 8)
        Console.WriteLine($"p4: ({p4.X}, {p4.Y})");  // (2, 2)
        Console.WriteLine($"p1 == p2? {p1 == p2}");  // False
        Console.WriteLine($"p1 != p2? {p1 != p2}");  // True
        Point p5 = new Point(2, 3);
        Console.WriteLine($"p1 == p5? {p1 == p5}");  // True
    }
}

p3: (6, 8)
p4: (2, 2)
p1 == p2? False
p1 != p2? True
p1 == p5? True

public override bool Equals(object obj)
{
    if (obj is Point p)
    {
        return this.X == p.X && this.Y == p.Y;
    }
    return false;
}
public static bool operator ==(Point a, Point b)
{
    if (ReferenceEquals(a, b)) return true;
    if (a is null || b is null) return false;
    return a.Equals(b);
}
public static bool operator !=(Point a, Point b)
{
    return !(a == b);
}

public override int GetHashCode()
{
    return HashCode.Combine(X, Y);
}

// クラスの例
public class PersonClass
{
    public string Name { get; set; }
    public int Age { get; set; }
}
// レコードの例
public record PersonRecord(string Name, int Age);

PersonClass c1 = new PersonClass { Name = "太郎", Age = 30 };
PersonClass c2 = new PersonClass { Name = "太郎", Age = 30 };
Console.WriteLine(c1 == c2);  // False(参照比較)
PersonRecord r1 = new PersonRecord("太郎", 30);
PersonRecord r2 = new PersonRecord("太郎", 30);
Console.WriteLine(r1 == r2);  // True(値比較)

public record PersonRecord
{
    public string Name { get; init; }
    public int Age { get; init; }
}
class Program
{
    static void Main()
    {
        var person = new PersonRecord { Name = "花子", Age = 25 };
        Console.WriteLine($"{person.Name} は {person.Age} 歳です。");
        // person.Age = 26;  // コンパイルエラー：init-onlyプロパティは変更不可
    }
}

var person1 = new PersonRecord("太郎", 30);
var person2 = person1 with { Age = 31 };
Console.WriteLine(person1);  // PersonRecord { Name = 太郎, Age = 30 }
Console.WriteLine(person2);  // PersonRecord { Name = 太郎, Age = 31 }

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    // ToStringのオーバーライドで文字列表現をカスタマイズ
    public override string ToString()
    {
        return $"名前: {Name}, 年齢: {Age}歳";
    }
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "太郎", Age = 30 };
        Console.WriteLine(person.ToString());
    }
}

名前: 太郎, 年齢: 30歳

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public override string ToString()
    {
        // 文字列補間を使って見やすく整形
        return $"商品名: {Name}, 価格: {Price:C}";
    }
}
class Program
{
    static void Main()
    {
        Product product = new Product { Name = "ノートパソコン", Price = 123456.78m };
        Console.WriteLine(product.ToString());
    }
}

商品名: ノートパソコン, 価格: ¥123,456.78

public override string ToString()
{
    return $@"商品情報:
  名前: {Name}
  価格: {Price:C}";
}

public class ResourceHolder : IDisposable
{
    private bool disposed = false;
    // 外部リソースの例(ファイルやネットワークなど)
    // ここでは簡略化のため省略
    public void UseResource()
    {
        if (disposed)
            throw new ObjectDisposedException("ResourceHolder");
        Console.WriteLine("リソースを使用中...");
    }
    // IDisposableの実装
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);  // ガベージコレクターにファイナライザーの呼び出し不要を通知
    }
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // マネージリソースの解放(例：他のIDisposableオブジェクトのDispose呼び出し)
                Console.WriteLine("マネージリソースを解放しています。");
            }
            // アンマネージリソースの解放(例：ファイルハンドルなど)
            Console.WriteLine("アンマネージリソースを解放しています。");
            disposed = true;
        }
    }
    ~ResourceHolder()
    {
        Dispose(false);
    }
}
class Program
{
    static void Main()
    {
        using (var resource = new ResourceHolder())
        {
            resource.UseResource();
        }  // usingブロック終了時にDisposeが自動的に呼ばれる
    }
}

リソースを使用中...
マネージリソースを解放しています。
アンマネージリソースを解放しています。

public class SampleClass
{
    ~SampleClass()
    {
        Console.WriteLine("デストラクターが呼ばれました。");
    }
}

public class Button
{
    // イベントフィールドの宣言(標準のEventHandlerを使用)
    public event EventHandler Clicked;
    // イベントを発生させるメソッド
    public void OnClick()
    {
        // イベントが登録されていれば呼び出す
        Clicked?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        Button button = new Button();
        // イベント購読(イベントハンドラーの登録)
        button.Clicked += Button_Clicked;
        // ボタンをクリック(イベント発生)
        button.OnClick();
    }
    // イベントハンドラー(イベント発生時に呼ばれるメソッド)
    private static void Button_Clicked(object sender, EventArgs e)
    {
        Console.WriteLine("ボタンがクリックされました。");
    }
}

ボタンがクリックされました。

public class Timer
{
    // 引数なしのActionデリゲートをイベントとして宣言
    public event Action Tick;
    public void OnTick()
    {
        Tick?.Invoke();
    }
}
class Program
{
    static void Main()
    {
        Timer timer = new Timer();
        // ラムダ式でイベント購読
        timer.Tick += () => Console.WriteLine("タイマーが動作しました。");
        timer.OnTick();
    }
}

タイマーが動作しました。

public class Calculator
{
    public event Func<int, int, int> Calculate;
    public int OnCalculate(int a, int b)
    {
        if (Calculate != null)
        {
            return Calculate.Invoke(a, b);
        }
        return 0;
    }
}
class Program
{
    static void Main()
    {
        Calculator calc = new Calculator();
        // 足し算の処理を登録
        calc.Calculate += (x, y) => x + y;
        int result = calc.OnCalculate(3, 4);
        Console.WriteLine($"計算結果: {result}");
    }
}

計算結果: 7

// ファイル1: Person.Part1.cs
public partial class Person
{
    public string Name { get; set; }
    public void SayHello()
    {
        Console.WriteLine($"こんにちは、{Name}です。");
    }
}
// ファイル2: Person.Part2.cs
public partial class Person
{
    public int Age { get; set; }
    public void ShowAge()
    {
        Console.WriteLine($"{Name}の年齢は{Age}歳です。");
    }
}

class Program
{
    static void Main()
    {
        Person p = new Person { Name = "太郎", Age = 30 };
        p.SayHello();
        p.ShowAge();
    }
}

こんにちは、太郎です。
太郎の年齢は30歳です。

public class OuterClass
{
    private int outerValue = 10;
    // ネストクラスの定義
    public class NestedClass
    {
        public void ShowMessage()
        {
            Console.WriteLine("ネストクラスのメソッドです。");
            // outerValueには直接アクセスできない(非staticの場合)
        }
    }
    // ネストクラスのインスタンスを使うメソッド
    public void UseNested()
    {
        NestedClass nested = new NestedClass();
        nested.ShowMessage();
    }
}

class Program
{
    static void Main()
    {
        OuterClass outer = new OuterClass();
        outer.UseNested();
        // 外部からネストクラスのインスタンスを作成することも可能
        OuterClass.NestedClass nested = new OuterClass.NestedClass();
        nested.ShowMessage();
    }
}

ネストクラスのメソッドです。
ネストクラスのメソッドです。

public class BaseClass
{
    public int PublicValue = 1;
    private int PrivateValue = 2;
    protected int ProtectedValue = 3;
    public void ShowValues()
    {
        Console.WriteLine($"Public: {PublicValue}, Private: {PrivateValue}, Protected: {ProtectedValue}");
    }
}
public class DerivedClass : BaseClass
{
    public void ShowProtected()
    {
        // PublicValueはアクセス可能
        Console.WriteLine($"PublicValue: {PublicValue}");
        // PrivateValueはアクセス不可(コンパイルエラー)
        // Console.WriteLine($"PrivateValue: {PrivateValue}");
        // ProtectedValueはアクセス可能
        Console.WriteLine($"ProtectedValue: {ProtectedValue}");
    }
}
class Program
{
    static void Main()
    {
        BaseClass baseObj = new BaseClass();
        Console.WriteLine(baseObj.PublicValue);  // OK
        // Console.WriteLine(baseObj.PrivateValue);  // エラー
        // Console.WriteLine(baseObj.ProtectedValue);  // エラー
        DerivedClass derivedObj = new DerivedClass();
        derivedObj.ShowProtected();
    }
}

Public: 1, Private: 2, Protected: 3
PublicValue: 1
ProtectedValue: 3

public class Sample
{
    internal int InternalValue = 10;
    protected internal int ProtectedInternalValue = 20;
}
class Program
{
    static void Main()
    {
        Sample sample = new Sample();
        Console.WriteLine(sample.InternalValue);           // 同一アセンブリ内なのでアクセス可能
        Console.WriteLine(sample.ProtectedInternalValue);  // 同一アセンブリ内なのでアクセス可能
    }
}

public class BaseClass
{
    private protected int PrivateProtectedValue = 100;
}
public class DerivedClass : BaseClass
{
    public void ShowValue()
    {
        Console.WriteLine($"PrivateProtectedValue: {PrivateProtectedValue}");  // アクセス可能
    }
}
class Program
{
    static void Main()
    {
        DerivedClass derived = new DerivedClass();
        derived.ShowValue();
        BaseClass baseObj = new BaseClass();
        // Console.WriteLine(baseObj.PrivateProtectedValue);  // エラー：同一アセンブリ内でも非派生クラスからは不可
    }
}

// 依存するインターフェース
public interface IMessageService
{
    void SendMessage(string message);
}
// 依存オブジェクトの実装
public class EmailService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine($"メール送信: {message}");
    }
}
// 依存性注入を受けるクラス
public class Notification
{
    private readonly IMessageService _messageService;
    // コンストラクターで依存オブジェクトを注入
    public Notification(IMessageService messageService)
    {
        _messageService = messageService;
    }
    public void Notify(string message)
    {
        _messageService.SendMessage(message);
    }
}
class Program
{
    static void Main()
    {
        IMessageService emailService = new EmailService();
        Notification notification = new Notification(emailService);
        notification.Notify("テストメッセージ");
    }
}

メール送信: テストメッセージ

// テスト用モック実装
public class MockMessageService : IMessageService
{
    public string LastMessage { get; private set; }
    public void SendMessage(string message)
    {
        LastMessage = message;  // メッセージを記録するだけ
    }
}
class Program
{
    static void Main()
    {
        var mockService = new MockMessageService();
        var notification = new Notification(mockService);
        notification.Notify("テストメッセージ");
        // モックに記録されたメッセージを検証
        Console.WriteLine(mockService.LastMessage == "テストメッセージ"
            ? "テスト成功"
            : "テスト失敗");
    }
}