【C#】インターフェースと抽象クラス完全ガイド｜違い・使い分け・デフォルト実装・明示的実装・設計パターンまで

// インターフェース: 命名規則は先頭に "I" を付ける
interface ILogger
{
    void Log(string message);
    void LogError(string message, Exception? ex = null);
}

// 実装クラス① : コンソール出力
class ConsoleLogger : ILogger
{
    public void Log(string message)
        => Console.WriteLine($"[INFO]  {message}");

    public void LogError(string message, Exception? ex = null)
        => Console.WriteLine($"[ERROR] {message}{(ex is null ? "" : $": {ex.Message}")}");
}

// 実装クラス② : ファイル出力（同じインターフェースを別実装）
class FileLogger : ILogger
{
    private readonly string _path;
    public FileLogger(string path) => _path = path;

    public void Log(string message)
        => File.AppendAllText(_path, $"[INFO]  {message}
");

    public void LogError(string message, Exception? ex = null)
        => File.AppendAllText(_path, $"[ERROR] {message}
");
}

// 利用側はインターフェース型で受け取る → 実装に依存しない
void RunApp(ILogger logger)
{
    logger.Log("アプリ起動");
    logger.Log("処理完了");
}

RunApp(new ConsoleLogger());
RunApp(new FileLogger("app.log"));

interface IReadable   { string Read();           }
interface IWritable   { void   Write(string data); }
interface ICloseable  { void   Close();            }

// 3つのインターフェースを同時に実装
class FileStream2 : IReadable, IWritable, ICloseable
{
    private readonly string _path;
    public FileStream2(string path) => _path = path;

    public string Read()           => File.ReadAllText(_path);
    public void   Write(string d)  => File.WriteAllText(_path, d);
    public void   Close()          => Console.WriteLine("ファイルを閉じました");
}

// 必要な能力だけを受け取るメソッドが書ける
void SaveData(IWritable w, string data) => w.Write(data);
void Cleanup(ICloseable c)              => c.Close();

var fs = new FileStream2("data.txt");
SaveData(fs, "Hello, World!");
Cleanup(fs);

interface IShape
{
    double Area();
    double Perimeter();

    // デフォルト実装: 実装クラスがオーバーライドしなくてもコンパイルできる
    string Describe()
        => $"面積: {Area():F2}、周囲: {Perimeter():F2}";
}

class Circle2 : IShape
{
    public double Radius { get; }
    public Circle2(double r) => Radius = r;

    public double Area()      => Math.PI * Radius * Radius;
    public double Perimeter() => 2 * Math.PI * Radius;
    // Describe() は実装しない → デフォルト実装が使われる
}

class Square3 : IShape
{
    public double Side { get; }
    public Square3(double s) => Side = s;

    public double Area()      => Side * Side;
    public double Perimeter() => 4 * Side;

    // オーバーライドして独自の説明にする
    public string Describe() => $"正方形（一辺: {Side}）";
}

IShape c = new Circle2(5);
IShape s = new Square3(4);

Console.WriteLine(c.Describe()); // 面積: 78.54、周囲: 31.42（デフォルト）
Console.WriteLine(s.Describe()); // 正方形（一辺: 4）（オーバーライド）

// 数値型の加算を抽象化する例
interface IAddable<T> where T : IAddable<T>
{
    static abstract T operator +(T a, T b);
    static abstract T Zero { get; }
}

struct Meters : IAddable<Meters>
{
    public double Value { get; }
    public Meters(double v) => Value = v;

    public static Meters operator +(Meters a, Meters b) => new(a.Value + b.Value);
    public static Meters Zero => new(0);

    public override string ToString() => $"{Value}m";
}

// ジェネリクスで任意の IAddable<T> 型の合計を計算できる
static T Sum<T>(IEnumerable<T> items) where T : IAddable<T>
    => items.Aggregate(T.Zero, (acc, x) => acc + x);

var distances = new[] { new Meters(1.5), new Meters(2.3), new Meters(0.8) };
Console.WriteLine(Sum(distances)); // 4.6m

interface IPrintable  { void Print(); }
interface IDisplayable { void Print(); }  // 同名メソッド

class Document : IPrintable, IDisplayable
{
    // 通常の実装（クラス型からも呼べる）
    public void Print()
        => Console.WriteLine("[Document] 通常の Print()");

    // 明示的実装（IPrintable 型からのみ呼べる）
    void IPrintable.Print()
        => Console.WriteLine("[IPrintable] 印刷用の Print()");

    // 明示的実装（IDisplayable 型からのみ呼べる）
    void IDisplayable.Print()
        => Console.WriteLine("[IDisplayable] 表示用の Print()");
}

var doc = new Document();
doc.Print();                          // [Document] 通常の Print()

IPrintable  printable  = doc;
IDisplayable displayable = doc;

printable.Print();   // [IPrintable] 印刷用の Print()
displayable.Print(); // [IDisplayable] 表示用の Print()

// IDisposable の Dispose() を明示的に実装して
// 「使う人が直接 Dispose() を呼ぶ」より「using で使う」設計を促す例
class ResourceHolder : IDisposable
{
    private bool _disposed;

    // 明示的実装: 直接 .Dispose() は呼ばせず using を促す
    void IDisposable.Dispose()
    {
        if (!_disposed)
        {
            Console.WriteLine("リソースを解放しました");
            _disposed = true;
        }
    }

    public void DoWork()
        => Console.WriteLine("処理中…");
}

using (IDisposable r = new ResourceHolder())
{
    ((ResourceHolder)r).DoWork(); // using で自動解放
} // Dispose() が呼ばれる

// 抽象クラス: 直接 new はできない
abstract class DataExporter
{
    // フィールド・コンストラクタを持てる（インターフェースにはない）
    protected string _outputPath;

    protected DataExporter(string outputPath)
    {
        _outputPath = outputPath;
    }

    // 通常メソッド（共通処理。子クラスで呼べる）
    protected void LogExport(int count)
        => Console.WriteLine($"{count} 件を {_outputPath} にエクスポートしました");

    // abstract メソッド（子クラスが必ず override する）
    public abstract void Export(IEnumerable<string> data);

    // virtual メソッド（デフォルト実装あり・子クラスが任意で上書き可）
    public virtual string GetFormat() => "CSV";
}

class CsvExporter : DataExporter
{
    public CsvExporter(string path) : base(path) { }

    public override void Export(IEnumerable<string> data)
    {
        var lines = data.ToArray();
        File.WriteAllLines(_outputPath, lines);
        LogExport(lines.Length); // 親クラスの protected メソッドを使える
    }
}

class JsonExporter : DataExporter
{
    public JsonExporter(string path) : base(path) { }

    public override void Export(IEnumerable<string> data)
    {
        var json = System.Text.Json.JsonSerializer.Serialize(data.ToArray());
        File.WriteAllText(_outputPath, json);
        LogExport(data.Count());
    }

    public override string GetFormat() => "JSON"; // virtual をオーバーライド
}

DataExporter exporter = new CsvExporter("output.csv");
exporter.Export(new[] { "Alice,25", "Bob,30" });
// 2 件を output.csv にエクスポートしました

abstract class ReportGenerator
{
    // テンプレートメソッド: 処理の骨格を定義（final 相当として sealed を付ける）
    public sealed string Generate(DateTime reportDate)
    {
        var header  = BuildHeader(reportDate);   // ①ヘッダー生成（子クラスが実装）
        var body    = BuildBody();               // ②本文生成（子クラスが実装）
        var footer  = BuildFooter();             // ③フッター生成（共通処理）
        return $"{header}
{body}
{footer}";
    }

    // 子クラスが実装するステップ
    protected abstract string BuildHeader(DateTime date);
    protected abstract string BuildBody();

    // 共通のフッター（子クラスが任意でオーバーライド可）
    protected virtual string BuildFooter()
        => $"--- 生成日時: {DateTime.Now:yyyy-MM-dd HH:mm} ---";
}

class MonthlySalesReport : ReportGenerator
{
    private readonly decimal _total;
    public MonthlySalesReport(decimal total) => _total = total;

    protected override string BuildHeader(DateTime date)
        => $"【月次売上レポート】{date:yyyy年M月}";

    protected override string BuildBody()
        => $"売上合計: {_total:C}";
}

class InventoryReport2 : ReportGenerator
{
    private readonly int _count;
    public InventoryReport2(int count) => _count = count;

    protected override string BuildHeader(DateTime date)
        => $"【在庫レポート】{date:yyyy-MM-dd}";

    protected override string BuildBody()
        => $"在庫アイテム: {_count:N0} 件";

    protected override string BuildFooter()
        => "=== 在庫管理システム ==="; // フッターをカスタマイズ
}

var sales = new MonthlySalesReport(1_250_000);
Console.WriteLine(sales.Generate(new DateTime(2024, 5, 1)));
// 【月次売上レポート】2024年5月
// 売上合計: ¥1,250,000
// --- 生成日時: 2024-05-01 10:30 ---

var inv = new InventoryReport2(3842);
Console.WriteLine(inv.Generate(DateTime.Today));
// 【在庫レポート】2024-05-01
// 在庫アイテム: 3,842 件
// === 在庫管理システム ===

/*
① 状態（フィールド）やコンストラクタが必要か？
   → YES: 抽象クラス一択（インターフェースはフィールドを持てない）

② 複数の「能力・ロール」を1つのクラスに持たせたいか？
   → YES: インターフェース（多重実装が必要）

③ 処理の骨格（ステップの順序）を固定したいか？
   → YES: 抽象クラス（テンプレートメソッドパターン）

④ 異なる継承ツリーのクラス（Car と Dog など）に同じ契約を課したいか？
   → YES: インターフェース

⑤ DI コンテナやモックで差し替えたいか？
   → YES: インターフェース（コンストラクタインジェクションの標準的な手法）

迷ったら → インターフェース（後から抽象クラスにするより変更が少ない）
*/