@k2works/claude-code-booster 4.13.0 → 4.14.0

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

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

@@ -1,166 +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 チェーンによるパイプライン処理と不変データの考え方を学びます。
+# 第 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 チェーンによるパイプライン処理と不変データの考え方を学びます。