@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/getting-start-tdd/csharp/chapter07.md

@@ -1,223 +0,0 @@
----
-type: Article
-title: "第 7 章: カプセル化とポリモーフィズム"
-description: "第 1 部では手続き型の FizzBuzz プログラムを TDD で構築しました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 7 章: カプセル化とポリモーフィズム
-
-## 7.1 はじめに
-
-第 1 部では手続き型の FizzBuzz プログラムを TDD で構築しました。この章からは **オブジェクト指向プログラミング** の要素を C# で実現していきます。まず **カプセル化** と **ポリモーフィズム** を導入し、手続き型コードを構造化された設計に進化させます。
-
-## 7.2 手続き型コードの課題
-
-第 1 部で作成した `Generate` メソッドは手続き型プログラミングの典型例です。
-
-```csharp
-public static string Generate(int number)
-{
-    if (number % 3 == 0 && number % 5 == 0) return "FizzBuzz";
-    if (number % 3 == 0) return "Fizz";
-    if (number % 5 == 0) return "Buzz";
-    return number.ToString();
-}
-```
-
-この設計の課題は、新しい FizzBuzz タイプ（数値のみ返す、FizzBuzz のみ返す等）を追加する場合に、既存のメソッドを直接修正する必要があることです。
-
-## 7.3 カプセル化 — 値オブジェクトの導入
-
-### FizzBuzzValue クラス
-
-数値と FizzBuzz の結果をまとめた値オブジェクトを作成します。
-
-```csharp
-namespace FizzBuzz.Domain.Model;
-
-public class FizzBuzzValue : IEquatable<FizzBuzzValue>
-{
-    public int Number { get; }
-    public string Value { get; }
-
-    public FizzBuzzValue(int number, string value)
-    {
-        Number = number;
-        Value = value;
-    }
-
-    public override string ToString() => $"{Number}:{Value}";
-
-    public bool Equals(FizzBuzzValue? other)
-    {
-        if (other is null) return false;
-        if (ReferenceEquals(this, other)) return true;
-        return Number == other.Number && Value == other.Value;
-    }
-
-    public override bool Equals(object? obj) => Equals(obj as FizzBuzzValue);
-    public override int GetHashCode() => HashCode.Combine(Number, Value);
-}
-```
-
-C# ではプロパティ（`{ get; }` のみの読み取り専用プロパティ）でフィールドをカプセル化します。`IEquatable<T>` インターフェースを実装して値の等価性を保証します。Rust の `#[derive(PartialEq)]` に相当する機能ですが、C# では手動で実装する必要があります。
-
-### テストの作成
-
-```csharp
-public class FizzBuzzValueTest
-{
-    [Fact]
-    public void 値を保持する()
-    {
-        var value = new FizzBuzzValue(1, "1");
-        Assert.Equal(1, value.Number);
-        Assert.Equal("1", value.Value);
-    }
-
-    [Fact]
-    public void 同じ値のオブジェクトは等しい()
-    {
-        var value1 = new FizzBuzzValue(1, "1");
-        var value2 = new FizzBuzzValue(1, "1");
-        Assert.Equal(value1, value2);
-    }
-}
-```
-
-## 7.4 ポリモーフィズム — interface の導入
-
-### IFizzBuzzType インターフェース
-
-FizzBuzz のタイプを抽象化するインターフェースを定義します。
-
-```csharp
-namespace FizzBuzz.Domain.Type;
-
-using FizzBuzz.Domain.Model;
-
-public interface IFizzBuzzType
-{
-    FizzBuzzValue Generate(int number);
-}
-```
-
-C# の `interface` は Rust の `trait` や Java の `interface` に相当します。実装クラスは明示的に `: IFizzBuzzType` と宣言してインターフェースを実装します。
-
-### 3 つの実装
-
-```csharp
-// タイプ 1: 通常の FizzBuzz
-public class FizzBuzzType01 : IFizzBuzzType
-{
-    private const int FizzNumber = 3;
-    private const int BuzzNumber = 5;
-
-    public FizzBuzzValue Generate(int number)
-    {
-        string value;
-        if (IsFizzBuzz(number)) value = "FizzBuzz";
-        else if (IsFizz(number)) value = "Fizz";
-        else if (IsBuzz(number)) value = "Buzz";
-        else value = number.ToString();
-
-        return new FizzBuzzValue(number, value);
-    }
-
-    private static bool IsFizz(int number) => number % FizzNumber == 0;
-    private static bool IsBuzz(int number) => number % BuzzNumber == 0;
-    private static bool IsFizzBuzz(int number) => IsFizz(number) && IsBuzz(number);
-}
-
-// タイプ 2: 数値のみ
-public class FizzBuzzType02 : IFizzBuzzType
-{
-    public FizzBuzzValue Generate(int number)
-    {
-        return new FizzBuzzValue(number, number.ToString());
-    }
-}
-
-// タイプ 3: 15 の倍数のみ FizzBuzz
-public class FizzBuzzType03 : IFizzBuzzType
-{
-    private const int FizzBuzzNumber = 15;
-
-    public FizzBuzzValue Generate(int number)
-    {
-        var value = number % FizzBuzzNumber == 0 ? "FizzBuzz" : number.ToString();
-        return new FizzBuzzValue(number, value);
-    }
-}
-```
-
-### テストの作成
-
-```csharp
-public class FizzBuzzType01Test
-{
-    private readonly IFizzBuzzType _type = new FizzBuzzType01();
-
-    [Fact]
-    public void 数を文字列にして返す()
-    {
-        Assert.Equal("1", _type.Generate(1).Value);
-    }
-
-    [Fact]
-    public void 三の倍数のときはFizzを返す()
-    {
-        Assert.Equal("Fizz", _type.Generate(3).Value);
-    }
-
-    [Fact]
-    public void 五の倍数のときはBuzzを返す()
-    {
-        Assert.Equal("Buzz", _type.Generate(5).Value);
-    }
-
-    [Fact]
-    public void 三と五の倍数のときはFizzBuzzを返す()
-    {
-        Assert.Equal("FizzBuzz", _type.Generate(15).Value);
-    }
-}
-```
-
-## 7.5 ファクトリメソッド
-
-タイプ番号から適切な実装を返すファクトリメソッドを作成します。
-
-```csharp
-public static class FizzBuzzTypeFactory
-{
-    public static IFizzBuzzType Create(int type)
-    {
-        return type switch
-        {
-            1 => new FizzBuzzType01(),
-            2 => new FizzBuzzType02(),
-            3 => new FizzBuzzType03(),
-            _ => throw new ArgumentException($"Invalid FizzBuzz type: {type}")
-        };
-    }
-}
-```
-
-C# の `switch` 式は Rust の `match` 式に近い構文で、値を返す式として使えます。`_` はデフォルトケースで、Rust のワイルドカードパターンと同じです。不正なタイプ番号の場合は `ArgumentException` をスローします。
-
-## 7.6 まとめ
-
-この章では以下を学びました。
-
-| 概念 | C# の実現方法 | 他言語の対応 |
-|------|-------------|-------------|
-| カプセル化 | `class` + 読み取り専用プロパティ | Rust: struct + 非公開フィールド |
-| ポリモーフィズム | `interface` + 明示的実装 | Rust: trait + impl |
-| 値オブジェクト | `IEquatable<T>` + `GetHashCode` | Rust: `#[derive(PartialEq)]` |
-| ファクトリ | `switch` 式 + `ArgumentException` | Rust: `match` + `Result` |
-
-次章では、デザインパターン（Command、First-Class Collection）を適用していきます。

package/lib/assets/docs/article/getting-start-tdd/csharp/chapter08.md

@@ -1,258 +0,0 @@
----
-type: Article
-title: "第 8 章: デザインパターンの適用"
-description: "前章では class と interface を使ってカプセル化とポリモーフィズムを実現しました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 8 章: デザインパターンの適用
-
-## 8.1 はじめに
-
-前章では class と interface を使ってカプセル化とポリモーフィズムを実現しました。この章では **デザインパターン** を適用して、設計をさらに改善します。
-
-## 8.2 Value Object パターン
-
-### FizzBuzzValue の強化
-
-前章で作成した `FizzBuzzValue` は既に Value Object パターンを実現しています。
-
-```csharp
-public class FizzBuzzValue : IEquatable<FizzBuzzValue>
-{
-    public int Number { get; }
-    public string Value { get; }
-
-    public FizzBuzzValue(int number, string value)
-    {
-        Number = number;
-        Value = value;
-    }
-
-    public override string ToString() => $"{Number}:{Value}";
-
-    public bool Equals(FizzBuzzValue? other)
-    {
-        if (other is null) return false;
-        if (ReferenceEquals(this, other)) return true;
-        return Number == other.Number && Value == other.Value;
-    }
-
-    public override bool Equals(object? obj) => Equals(obj as FizzBuzzValue);
-    public override int GetHashCode() => HashCode.Combine(Number, Value);
-}
-```
-
-`IEquatable<T>` の実装により、2 つの `FizzBuzzValue` を値で比較できます。読み取り専用プロパティにより不変性が保証されます。Rust の `#[derive(PartialEq, Clone)]` に対し、C# では `IEquatable<T>` と `GetHashCode` を明示的に実装します。
-
-## 8.3 First-Class Collection パターン
-
-### FizzBuzzList クラス
-
-FizzBuzzValue のコレクションを専用の型でラップします。
-
-```csharp
-namespace FizzBuzz.Domain.Model;
-
-public class FizzBuzzList : IEquatable<FizzBuzzList>
-{
-    private readonly List<FizzBuzzValue> _values;
-
-    public IReadOnlyList<FizzBuzzValue> Values => _values.AsReadOnly();
-
-    public FizzBuzzList()
-    {
-        _values = new List<FizzBuzzValue>();
-    }
-
-    public FizzBuzzList(List<FizzBuzzValue> values)
-    {
-        _values = new List<FizzBuzzValue>(values);
-    }
-
-    public FizzBuzzValue Get(int index) => _values[index];
-    public int Count => _values.Count;
-
-    public FizzBuzzList Add(FizzBuzzValue value)
-    {
-        var newValues = new List<FizzBuzzValue>(_values) { value };
-        return new FizzBuzzList(newValues);
-    }
-
-    public List<string> ToStringValues()
-    {
-        return _values.Select(v => v.Value).ToList();
-    }
-
-    // ...等価性の実装
-}
-```
-
-First-Class Collection パターンにより、コレクション操作の責務を `FizzBuzzList` に集約できます。`Add` メソッドは新しいリストを返すイミュータブルな設計です。`IReadOnlyList<T>` で公開することで外部からの変更を防ぎます。
-
-### テストの作成
-
-```csharp
-public class FizzBuzzListTest
-{
-    [Fact]
-    public void 空のリストを作成できる()
-    {
-        var list = new FizzBuzzList();
-        Assert.Equal(0, list.Count);
-    }
-
-    [Fact]
-    public void 値を追加できる()
-    {
-        var list = new FizzBuzzList();
-        var newList = list.Add(new FizzBuzzValue(1, "1"));
-        Assert.Equal(1, newList.Count);
-        Assert.Equal(0, list.Count); // 元のリストは変更されない
-    }
-
-    [Fact]
-    public void 文字列リストに変換できる()
-    {
-        var list = new FizzBuzzList(new List<FizzBuzzValue>
-        {
-            new FizzBuzzValue(1, "1"),
-            new FizzBuzzValue(3, "Fizz"),
-            new FizzBuzzValue(5, "Buzz")
-        });
-        var strings = list.ToStringValues();
-        Assert.Equal(new List<string> { "1", "Fizz", "Buzz" }, strings);
-    }
-}
-```
-
-## 8.4 Command パターン
-
-### IFizzBuzzCommand インターフェース
-
-FizzBuzz の操作をコマンドとして抽象化します。
-
-```csharp
-namespace FizzBuzz.Application;
-
-using FizzBuzz.Domain.Model;
-
-public interface IFizzBuzzCommand
-{
-    FizzBuzzValue ExecuteValue(int number);
-    FizzBuzzList ExecuteList(int count);
-}
-```
-
-### 単一値コマンド
-
-```csharp
-public class FizzBuzzValueCommand : IFizzBuzzCommand
-{
-    private readonly IFizzBuzzType _type;
-
-    public FizzBuzzValueCommand(IFizzBuzzType type)
-    {
-        _type = type;
-    }
-
-    public FizzBuzzValue ExecuteValue(int number)
-    {
-        return _type.Generate(number);
-    }
-
-    public FizzBuzzList ExecuteList(int count)
-    {
-        throw new NotSupportedException(
-            "FizzBuzzValueCommand does not support list execution.");
-    }
-}
-```
-
-### リストコマンド
-
-```csharp
-public class FizzBuzzListCommand : IFizzBuzzCommand
-{
-    private readonly IFizzBuzzType _type;
-
-    public FizzBuzzListCommand(IFizzBuzzType type)
-    {
-        _type = type;
-    }
-
-    public FizzBuzzValue ExecuteValue(int number)
-    {
-        throw new NotSupportedException(
-            "FizzBuzzListCommand does not support single value execution.");
-    }
-
-    public FizzBuzzList ExecuteList(int count)
-    {
-        var values = Enumerable.Range(1, count)
-            .Select(i => _type.Generate(i))
-            .ToList();
-        return new FizzBuzzList(values);
-    }
-}
-```
-
-コンストラクタインジェクションで `IFizzBuzzType` を受け取ることで、具体的なタイプに依存しない設計を実現しています。
-
-### テストの作成
-
-```csharp
-public class FizzBuzzCommandTest
-{
-    [Fact]
-    public void ValueCommandで単一値を取得できる()
-    {
-        var command = new FizzBuzzValueCommand(
-            FizzBuzzTypeFactory.Create(FizzBuzzTypeName.Standard));
-        var result = command.ExecuteValue(3);
-        Assert.Equal("Fizz", result.Value);
-    }
-
-    [Fact]
-    public void ListCommandでリストを生成できる()
-    {
-        var command = new FizzBuzzListCommand(
-            FizzBuzzTypeFactory.Create(FizzBuzzTypeName.Standard));
-        var result = command.ExecuteList(100);
-        Assert.Equal(100, result.Count);
-    }
-}
-```
-
-## 8.5 Strategy パターン
-
-`IFizzBuzzType` インターフェースと 3 つの実装クラス（`FizzBuzzType01`, `FizzBuzzType02`, `FizzBuzzType03`）は、Strategy パターンを実現しています。コマンドのコンストラクタに異なる `IFizzBuzzType` を渡すことで、同じインターフェースで異なる振る舞いを切り替えられます。
-
-### Factory Method パターン
-
-`FizzBuzzTypeFactory.Create` メソッドは Factory Method パターンです。
-
-```csharp
-public static IFizzBuzzType Create(FizzBuzzTypeName name)
-{
-    return Create((int)name);
-}
-```
-
-`FizzBuzzTypeName` enum を使うことで、型安全なファクトリ呼び出しが可能です。
-
-## 8.6 まとめ
-
-この章では以下のデザインパターンを適用しました。
-
-| パターン | 目的 | C# の実現方法 |
-|---------|------|-------------|
-| Value Object | 値の等価性保証 | `IEquatable<T>` + 読み取り専用プロパティ |
-| First-Class Collection | コレクション操作の集約 | `class` + `List<T>` + `IReadOnlyList<T>` |
-| Command | 操作の抽象化と遅延実行 | `interface` + コンストラクタインジェクション |
-| Strategy | アルゴリズムの交換可能性 | `interface` + 複数の実装クラス |
-| Factory Method | タイプ番号による生成 | `switch` 式 + `static` メソッド |
-
-次章では SOLID 原則の観点から設計を評価し、モジュール分割を行います。

package/lib/assets/docs/article/getting-start-tdd/csharp/chapter09.md

@@ -1,183 +0,0 @@
----
-type: Article
-title: "第 9 章: SOLID 原則とモジュール設計"
-description: "前章ではデザインパターンを適用して設計を改善しました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 9 章: SOLID 原則とモジュール設計
-
-## 9.1 はじめに
-
-前章ではデザインパターンを適用して設計を改善しました。この章では **SOLID 原則** の観点から設計を評価し、**namespace によるモジュール分割** でコードの責務を明確にします。
-
-## 9.2 SOLID 原則の適用
-
-### 単一責任の原則（SRP）
-
-| namespace | 責務 |
-|-----------|------|
-| `FizzBuzz.Domain.Type` | FizzBuzz タイプの定義と生成ルール |
-| `FizzBuzz.Domain.Model` | 値オブジェクトとコレクション |
-| `FizzBuzz.Application` | コマンドの実行と結果の出力 |
-
-各クラスが単一の責任を持つように設計されています。`FizzBuzzType01` は通常の FizzBuzz ロジックのみ、`FizzBuzzValue` は値の保持と等価性のみを担当します。
-
-### 開放閉鎖の原則（OCP）
-
-`IFizzBuzzType` インターフェースを実装する新しいクラスを追加するだけで、既存のコードを変更せずに新しいタイプを追加できます。
-
-```csharp
-// 既存コードを変更せずに新しいタイプを追加
-public class FizzBuzzType04 : IFizzBuzzType
-{
-    public FizzBuzzValue Generate(int number)
-    {
-        // 新しいルールの実装
-        return new FizzBuzzValue(number, number.ToString());
-    }
-}
-```
-
-### リスコフの置換の原則（LSP）
-
-`IFizzBuzzType` を実装するすべてのクラスは、`IFizzBuzzType` 型として交換可能です。
-
-```csharp
-IFizzBuzzType type = new FizzBuzzType01(); // どの実装でも動作する
-IFizzBuzzType type = new FizzBuzzType02(); // 交換可能
-```
-
-### インターフェース分離の原則（ISP）
-
-`IFizzBuzzType` インターフェースは `Generate` メソッドのみを定義しており、不必要なメソッドを強制しません。
-
-```csharp
-public interface IFizzBuzzType
-{
-    FizzBuzzValue Generate(int number); // 必要最小限のメソッド
-}
-```
-
-### 依存性逆転の原則（DIP）
-
-`FizzBuzzListCommand` は具体的な `FizzBuzzType01` ではなく `IFizzBuzzType` インターフェースに依存しています。
-
-```csharp
-public class FizzBuzzListCommand : IFizzBuzzCommand
-{
-    private readonly IFizzBuzzType _type; // 抽象に依存
-
-    public FizzBuzzListCommand(IFizzBuzzType type) // コンストラクタインジェクション
-    {
-        _type = type;
-    }
-}
-```
-
-## 9.3 モジュール分割
-
-### ディレクトリ構成
-
-```
-FizzBuzz/
-├── FizzBuzz.cs                       (公開 API)
-├── FizzBuzz.csproj
-├── Application/
-│   ├── IFizzBuzzCommand.cs
-│   ├── FizzBuzzValueCommand.cs
-│   └── FizzBuzzListCommand.cs
-└── Domain/
-    ├── Model/
-    │   ├── FizzBuzzValue.cs
-    │   └── FizzBuzzList.cs
-    └── Type/
-        ├── IFizzBuzzType.cs
-        ├── FizzBuzzType01.cs
-        ├── FizzBuzzType02.cs
-        ├── FizzBuzzType03.cs
-        ├── FizzBuzzTypeName.cs
-        └── FizzBuzzTypeFactory.cs
-```
-
-### C# の namespace システム
-
-C# の `namespace` はモジュールを論理的にグループ化し、`using` で参照します。
-
-```csharp
-// FizzBuzz/Domain/Type/IFizzBuzzType.cs
-namespace FizzBuzz.Domain.Type;
-
-using FizzBuzz.Domain.Model;
-
-public interface IFizzBuzzType
-{
-    FizzBuzzValue Generate(int number);
-}
-```
-
-```csharp
-// FizzBuzz/Application/FizzBuzzListCommand.cs
-namespace FizzBuzz.Application;
-
-using FizzBuzz.Domain.Model;
-using FizzBuzz.Domain.Type;
-
-public class FizzBuzzListCommand : IFizzBuzzCommand
-{
-    // ...
-}
-```
-
-Rust の `mod` + `pub` によるモジュールシステムに対して、C# では `namespace` + `using` でモジュール間の依存関係を表現します。Java の `package` + `import` に近い感覚です。
-
-### FizzBuzzTypeName enum
-
-タイプの名前を enum で型安全に定義します。
-
-```csharp
-namespace FizzBuzz.Domain.Type;
-
-public enum FizzBuzzTypeName
-{
-    Standard = 1,
-    NumberOnly = 2,
-    FizzBuzzOnly = 3
-}
-```
-
-C# の `enum` は整数値に紐づく列挙型です。Rust の `enum` ほど強力ではありませんが、`switch` 式と組み合わせることで型安全なディスパッチが可能です。
-
-## 9.4 依存関係
-
-```
-Application → Domain.Type
-Application → Domain.Model
-Domain.Type → Domain.Model
-```
-
-- `Application` は `Domain` に依存
-- `Domain.Type` は `Domain.Model` に依存（`FizzBuzzValue` を生成）
-- 逆方向の依存は存在しない（単方向依存）
-
-## 9.5 まとめ
-
-この章では以下を実現しました。
-
-| 原則 | 適用内容 |
-|------|---------|
-| SRP | Type / Model / Application の責務分離 |
-| OCP | interface による拡張ポイント |
-| LSP | IFizzBuzzType による交換可能性 |
-| ISP | 最小限のインターフェース定義 |
-| DIP | コンストラクタインジェクションによる依存の抽象化 |
-
-| namespace | 責務 | 含まれる型 |
-|-----------|------|-----------|
-| `Domain.Type` | FizzBuzz 生成ルール | IFizzBuzzType, Type01-03, Factory, TypeName |
-| `Domain.Model` | 値オブジェクト | FizzBuzzValue, FizzBuzzList |
-| `Application` | コマンド実行 | IFizzBuzzCommand, ValueCommand, ListCommand |
-
-第 3 部を通じて、C# の interface、class、namespace を使ったオブジェクト指向的な設計を学びました。次の第 4 部では、C# の関数型プログラミング機能（LINQ、デリゲート、パターンマッチ）を活用します。