@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,174 @@
+# 第 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、デリゲート、パターンマッチ）を活用します。

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

@@ -0,0 +1,166 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+C# は LINQ やラムダ式を通じて関数型プログラミングの機能を豊富にサポートしています。この章では **デリゲート** と **LINQ** を中心に、高階関数と関数合成の考え方を学びます。
+
+## 10.2 デリゲートとラムダ式
+
+C# のデリゲートは関数を値として扱うための仕組みです。`Func<T, TResult>` と `Action<T>` が代表的なデリゲート型です。
+
+```csharp
+// Func: 戻り値を持つ関数
+Func<int, int, int> add = (a, b) => a + b;
+Assert.Equal(5, add(2, 3));
+
+// Action: 戻り値を持たない関数
+Action<string> print = message => Console.WriteLine(message);
+
+// Predicate: bool を返す関数（Func<T, bool> のエイリアス）
+Predicate<int> isEven = n => n % 2 == 0;
+Assert.True(isEven(4));
+```
+
+Rust のクロージャ `|x| x * 2` に相当するのが C# のラムダ式 `x => x * 2` です。Rust のように所有権の概念はありませんが、キャプチャした変数の参照を保持する点は共通です。
+
+### 環境のキャプチャ
+
+```csharp
+int factor = 3;
+Func<int, bool> isMultiple = n => n % factor == 0;
+Assert.True(isMultiple(9));
+Assert.False(isMultiple(7));
+```
+
+## 10.3 LINQ と高階関数
+
+### Select — 要素の変換
+
+`Select` は各要素に関数を適用して変換します。Rust の `.map()` に相当します。
+
+```csharp
+var values = list.Values
+    .Select(v => v.Value)
+    .ToList();
+```
+
+### Where — 要素の選別
+
+`Where` は条件に一致する要素だけを残します。Rust の `.filter()` に相当します。
+
+```csharp
+var fizzValues = list.Values
+    .Where(v => v.Value == "Fizz")
+    .ToList();
+```
+
+### FirstOrDefault — 最初の一致要素
+
+`FirstOrDefault` は条件に一致する最初の要素を返します。Rust の `.find()` に相当します。
+
+```csharp
+var firstBuzz = list.Values
+    .FirstOrDefault(v => v.Value == "Buzz");
+```
+
+### Any / All — 条件判定
+
+```csharp
+bool hasFizzBuzz = list.Values
+    .Any(v => v.Value == "FizzBuzz");
+
+bool allNonEmpty = list.Values
+    .All(v => !string.IsNullOrEmpty(v.Value));
+```
+
+## 10.4 FizzBuzzList への関数型メソッド追加
+
+```csharp
+public class FizzBuzzList
+{
+    // ...既存のコード
+
+    public FizzBuzzList Filter(Func<FizzBuzzValue, bool> predicate)
+    {
+        return new FizzBuzzList(_values.Where(predicate).ToList());
+    }
+
+    public FizzBuzzValue? FindFirst(Func<FizzBuzzValue, bool> predicate)
+    {
+        return _values.FirstOrDefault(predicate);
+    }
+
+    public List<string> ToStringValues()
+    {
+        return _values.Select(v => v.Value).ToList();
+    }
+
+    public Dictionary<string, int> CountByValue()
+    {
+        return _values
+            .GroupBy(v => v.Value)
+            .ToDictionary(g => g.Key, g => g.Count());
+    }
+}
+```
+
+### テストの作成
+
+```csharp
+[Fact]
+public void フィルタリングできる()
+{
+    var list = new FizzBuzzList(new List<FizzBuzzValue>
+    {
+        new FizzBuzzValue(1, "1"),
+        new FizzBuzzValue(3, "Fizz"),
+        new FizzBuzzValue(5, "Buzz"),
+        new FizzBuzzValue(15, "FizzBuzz")
+    });
+    var filtered = list.Filter(v => v.Value == "Fizz");
+    Assert.Equal(1, filtered.Count);
+    Assert.Equal("Fizz", filtered.Get(0).Value);
+}
+
+[Fact]
+public void 最初の一致する値を取得できる()
+{
+    var list = new FizzBuzzList(new List<FizzBuzzValue>
+    {
+        new FizzBuzzValue(1, "1"),
+        new FizzBuzzValue(3, "Fizz"),
+        new FizzBuzzValue(6, "Fizz")
+    });
+    var found = list.FindFirst(v => v.Value == "Fizz");
+    Assert.NotNull(found);
+    Assert.Equal(3, found.Number);
+}
+
+[Fact]
+public void 値ごとにカウントできる()
+{
+    var list = new FizzBuzzList(new List<FizzBuzzValue>
+    {
+        new FizzBuzzValue(1, "1"),
+        new FizzBuzzValue(3, "Fizz"),
+        new FizzBuzzValue(6, "Fizz"),
+        new FizzBuzzValue(5, "Buzz")
+    });
+    var counts = list.CountByValue();
+    Assert.Equal(1, counts["1"]);
+    Assert.Equal(2, counts["Fizz"]);
+    Assert.Equal(1, counts["Buzz"]);
+}
+```
+
+## 10.5 まとめ
+
+| 概念 | C# | Rust | Java |
+|------|------|------|------|
+| クロージャ | `x => x * 2` | `\|x\| x * 2` | `x -> x * 2` |
+| map | `.Select(f)` | `.iter().map(f).collect()` | `.stream().map(f)` |
+| filter | `.Where(f)` | `.iter().filter(f).collect()` | `.stream().filter(f)` |
+| find | `.FirstOrDefault(f)` | `.iter().find(f)` → `Option` | `.stream().findFirst()` |
+| デリゲート | `Func<T, TResult>` | `Fn(T) -> TResult` | `Function<T, R>` |
+
+次章では、LINQ チェーンによるパイプライン処理と不変データの考え方を学びます。

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

@@ -0,0 +1,192 @@
+# 第 11 章: 不変データとパイプライン処理
+
+## 11.1 はじめに
+
+前章ではデリゲートと LINQ を使った高階関数を学びました。この章では **LINQ チェーン** によるパイプライン処理と **不変データ** の考え方を深めます。
+
+## 11.2 C# の不変性
+
+C# では `readonly` キーワードと読み取り専用プロパティで不変性を実現します。
+
+```csharp
+// 読み取り専用フィールド
+private readonly List<FizzBuzzValue> _values;
+
+// 読み取り専用プロパティ（get のみ）
+public int Number { get; }
+public string Value { get; }
+```
+
+`FizzBuzzValue` はコンストラクタで値を設定した後は変更できません。Rust がデフォルトで不変（`let`）であるのに対し、C# では明示的に `readonly` や get のみのプロパティで不変性を宣言します。
+
+### イミュータブルな Add 操作
+
+`FizzBuzzList` の `Add` メソッドは、元のリストを変更せず新しいリストを返します。
+
+```csharp
+public FizzBuzzList Add(FizzBuzzValue value)
+{
+    var newValues = new List<FizzBuzzValue>(_values) { value };
+    return new FizzBuzzList(newValues);
+}
+```
+
+```csharp
+[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); // 元のリストは変更されない
+}
+```
+
+## 11.3 LINQ チェーン（パイプライン）
+
+C# の LINQ はメソッドチェーンで連結でき、パイプライン処理を実現します。
+
+```csharp
+// パイプライン: Where → Select → ToList
+var fizzNumbers = list.Values
+    .Where(v => v.Value == "Fizz")
+    .Select(v => v.Number)
+    .ToList();
+```
+
+### Aggregate（集約）
+
+Rust の `.fold()` に相当する `Aggregate` で値を集約します。
+
+```csharp
+// 全 FizzBuzz 値を改行区切りで連結
+var joined = list.Values
+    .Select(v => v.Value)
+    .Aggregate((acc, v) => $"{acc}\n{v}");
+```
+
+### Take（先頭 N 件）
+
+```csharp
+var firstFive = list.Values
+    .Take(5)
+    .Select(v => v.Value)
+    .ToList();
+```
+
+### GroupBy（グループ化）
+
+Rust では `HashMap` を手動で構築する必要がありますが、C# では `GroupBy` が標準で提供されています。
+
+```csharp
+public Dictionary<string, int> CountByValue()
+{
+    return _values
+        .GroupBy(v => v.Value)
+        .ToDictionary(g => g.Key, g => g.Count());
+}
+```
+
+## 11.4 ImmutableList の活用
+
+`System.Collections.Immutable` パッケージを使うと、よりイミュータブルなコレクションを利用できます。
+
+```bash
+$ dotnet add package System.Collections.Immutable
+```
+
+```csharp
+using System.Collections.Immutable;
+
+// ImmutableList の使用例
+var immutableList = ImmutableList<FizzBuzzValue>.Empty;
+var newList = immutableList.Add(new FizzBuzzValue(1, "1"));
+
+// 元のリストは空のまま
+Assert.Equal(0, immutableList.Count);
+Assert.Equal(1, newList.Count);
+```
+
+`ImmutableList` は `Add` で常に新しいリストを返し、元のリストは変更されません。内部的にはバランス木を使って効率的に実装されています。
+
+## 11.5 FizzBuzzList のパイプライン操作
+
+```csharp
+public class FizzBuzzList
+{
+    // ...既存のコード
+
+    public FizzBuzzList AddRange(IEnumerable<FizzBuzzValue> values)
+    {
+        var newValues = new List<FizzBuzzValue>(_values);
+        newValues.AddRange(values);
+        return new FizzBuzzList(newValues);
+    }
+
+    public override string ToString()
+    {
+        return string.Join(", ", _values.Select(v => v.ToString()));
+    }
+
+    public bool Equals(FizzBuzzList? other)
+    {
+        if (other is null) return false;
+        if (ReferenceEquals(this, other)) return true;
+        return _values.SequenceEqual(other._values);
+    }
+
+    public override bool Equals(object? obj) => Equals(obj as FizzBuzzList);
+
+    public override int GetHashCode()
+    {
+        var hash = new HashCode();
+        foreach (var value in _values)
+            hash.Add(value);
+        return hash.ToHashCode();
+    }
+}
+```
+
+### テストの作成
+
+```csharp
+[Fact]
+public void AddRangeで複数の値を追加できる()
+{
+    var list = new FizzBuzzList();
+    var newList = list.AddRange(new List<FizzBuzzValue>
+    {
+        new FizzBuzzValue(1, "1"),
+        new FizzBuzzValue(2, "2")
+    });
+    Assert.Equal(2, newList.Count);
+}
+
+[Fact]
+public void 同じ内容のリストは等しい()
+{
+    var list1 = new FizzBuzzList(new List<FizzBuzzValue>
+    {
+        new FizzBuzzValue(1, "1"),
+        new FizzBuzzValue(3, "Fizz")
+    });
+    var list2 = new FizzBuzzList(new List<FizzBuzzValue>
+    {
+        new FizzBuzzValue(1, "1"),
+        new FizzBuzzValue(3, "Fizz")
+    });
+    Assert.Equal(list1, list2);
+}
+```
+
+## 11.6 まとめ
+
+| 概念 | C# | Rust | Java |
+|------|------|------|------|
+| 不変フィールド | `readonly` / get のみプロパティ | `let`（デフォルト不変） | `final` |
+| パイプライン | `.Where().Select().ToList()` | `.iter().filter().map().collect()` | `.stream().filter().map().collect()` |
+| 集約 | `.Aggregate(f)` | `.fold(init, f)` | `.reduce(f)` |
+| イミュータブルコレクション | `ImmutableList<T>` | `Vec<T>`（所有権で制御） | `List.of()` |
+| グループ化 | `.GroupBy(f).ToDictionary()` | `HashMap` 手動構築 | `.collect(groupingBy())` |
+
+次章では、Nullable 参照型とパターンマッチングを使ったエラーハンドリングと型安全性を学びます。