@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokking-concurrency/csharp/index.md

@@ -0,0 +1,101 @@
+---
+title: C# で学ぶ並行処理プログラミング
+description: Grokking Concurrency C# 版
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# C# で学ぶ並行処理プログラミング
+
+## 概要
+
+このセクションでは、Grokking Concurrency の内容を **C# 12 / .NET 8** で実装しながら学びます。TDD（テスト駆動開発）で実装されたコード例と、詳細なドキュメントを通じて、並行処理の基礎から応用までを理解できます。
+
+---
+
+## 目次
+
+### Part I: 並行処理の基礎
+
+逐次処理の特徴と限界を理解し、なぜ並行処理が必要かを学びます。
+
+- [Part I - 並行処理の基礎](part-1.md)
+
+### Part II: プロセスとスレッド
+
+OS レベルの並行処理の基本単位であるプロセスとスレッドを学びます。
+
+- [Part II - プロセスとスレッド](part-2.md)
+
+### Part III: マルチタスキング
+
+OS がどのようにタスクを切り替えるか、タイムシェアリングの仕組みを学びます。
+
+- [Part III - マルチタスキングとスケジューリング](part-3.md)
+
+### Part IV: タスク分解と並列パターン
+
+Fork/Join パターンとパイプラインパターンを学びます。
+
+- [Part IV - タスク分解と並列パターン](part-4.md)
+
+### Part V: 同期と排他制御
+
+Lock、Monitor、デッドロックについて学びます。
+
+- [Part V - 同期と排他制御](part-5.md)
+
+### Part VI: ノンブロッキング I/O
+
+async/await を使ったノンブロッキング I/O を学びます。
+
+- [Part VI - ノンブロッキング I/O](part-6.md)
+
+### Part VII: 非同期プログラミング
+
+Task と async/await を学びます。
+
+- [Part VII - 非同期プログラミング](part-7.md)
+
+### Part VIII: 分散並列処理
+
+MapReduce パターンと PLINQ を学びます。
+
+- [Part VIII - 分散並列処理](part-8.md)
+
+---
+
+## 技術スタック
+
+- **C# 12** (Primary Constructor, Collection Expressions)
+- **.NET 8** (ランタイム)
+- **xUnit** (テストフレームワーク)
+
+---
+
+## 実行方法
+
+### テストの実行
+
+```bash
+cd apps/csharp
+dotnet test
+```
+
+### サンプルコードの実行
+
+```bash
+cd apps/csharp
+dotnet run --project src
+```
+
+---
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著
+- [C# in Depth](https://csharpindepth.com/) - C# 深掘り
+- [.NET 8 Documentation](https://docs.microsoft.com/ja-jp/dotnet/)

package/lib/assets/docs/article/grokking-concurrency/csharp/part-1.md

@@ -0,0 +1,97 @@
+---
+title: Part I - 並行処理の基礎
+description: 逐次処理の基本と並行処理の必要性を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, sequential, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part I: 並行処理の基礎
+
+## 概要
+
+本章では、逐次処理の基本概念を理解し、なぜ並行処理が必要になるのかを学びます。パスワードクラッカーの例を通じて、逐次処理の限界を体験します。
+
+---
+
+## 逐次処理の例: パスワードクラッカー
+
+### SHA-256 ハッシュの計算
+
+```csharp
+public static string GetCryptoHash(string password)
+{
+    var bytes = Encoding.UTF8.GetBytes(password);
+    var hash = SHA256.HashData(bytes);
+    return Convert.ToHexString(hash).ToLowerInvariant();
+}
+```
+
+### パスワード候補の生成
+
+```csharp
+public static List<string> GetCombinations(int length, int minNumber, int maxNumber)
+{
+    var combinations = new List<string>();
+    var format = new string('0', length);
+
+    for (var i = minNumber; i <= maxNumber; i++)
+    {
+        combinations.Add(i.ToString(format));
+    }
+
+    return combinations;
+}
+```
+
+### ブルートフォース探索
+
+```csharp
+public static string? CrackPassword(string cryptoHash, int length)
+{
+    int maxNumber = (int)Math.Pow(10, length) - 1;
+    var combinations = GetCombinations(length, 0, maxNumber);
+
+    foreach (var combination in combinations)
+    {
+        if (CheckPassword(cryptoHash, combination))
+        {
+            return combination;
+        }
+    }
+
+    return null;
+}
+```
+
+---
+
+## 逐次処理の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| 予測可能性 | 実行順序が明確 |
+| デバッグ容易 | 問題の特定が簡単 |
+| リソース効率 | オーバーヘッドなし |
+
+---
+
+## 逐次処理の限界
+
+- CPU バウンドタスクでは 1 コアしか使用できない
+- I/O 待機中に CPU がアイドル状態になる
+- 大規模データ処理に時間がかかる
+
+---
+
+## 次のステップ
+
+Part II では、スレッドを使った並列処理を学び、パスワードクラッカーを高速化します。
+
+---
+
+## 参考資料
+
+- [System.Security.Cryptography](https://docs.microsoft.com/ja-jp/dotnet/api/system.security.cryptography)

package/lib/assets/docs/article/grokking-concurrency/csharp/part-2.md

@@ -0,0 +1,123 @@
+---
+title: Part II - プロセスとスレッド
+description: プロセスとスレッドの基本を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, thread, process, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、OS レベルの並行処理の基本単位であるプロセスとスレッドを学びます。C# の `Thread` クラスと `Task` を使った並列処理を実装します。
+
+---
+
+## スレッドの基本操作
+
+### スレッドの作成
+
+```csharp
+public static Thread CreateWorkerThread(Action task)
+{
+    return new Thread(() => task());
+}
+```
+
+### 複数スレッドの作成
+
+```csharp
+public static List<Thread> CreateMultipleWorkers(int count, Action<int> task)
+{
+    var threads = new List<Thread>();
+    for (var i = 0; i < count; i++)
+    {
+        var index = i;
+        var thread = new Thread(() => task(index))
+        {
+            Name = $"Worker-{index}"
+        };
+        threads.Add(thread);
+    }
+    return threads;
+}
+```
+
+---
+
+## 並列パスワードクラッカー
+
+### チャンク分割
+
+```csharp
+public record ChunkRange(int Start, int End);
+
+public static List<ChunkRange> GetChunks(int numChunks, int length)
+{
+    var maxNumber = (int)Math.Pow(10, length) - 1;
+    var chunkSize = (maxNumber + 1) / numChunks;
+
+    var chunks = new List<ChunkRange>();
+    for (var i = 0; i < numChunks; i++)
+    {
+        var start = i * chunkSize;
+        var end = i == numChunks - 1 ? maxNumber : start + chunkSize - 1;
+        chunks.Add(new ChunkRange(start, end));
+    }
+    return chunks;
+}
+```
+
+### 並列処理
+
+```csharp
+public static string? CrackPasswordParallel(string cryptoHash, int length)
+{
+    var numCores = Environment.ProcessorCount;
+    var chunks = GetChunks(numCores, length);
+
+    using var cts = new CancellationTokenSource();
+    var tasks = chunks.Select(chunk =>
+        Task.Run(() => CrackChunk(cryptoHash, length, chunk.Start, chunk.End), cts.Token)
+    ).ToArray();
+
+    // 最初に見つかった結果を返す
+    while (tasks.Any(t => !t.IsCompleted))
+    {
+        var completedTask = Task.WhenAny(tasks).Result;
+        if (completedTask.Result != null)
+        {
+            cts.Cancel();
+            return completedTask.Result;
+        }
+    }
+    return null;
+}
+```
+
+---
+
+## プロセスとスレッドの違い
+
+| 特性 | プロセス | スレッド |
+|------|----------|----------|
+| メモリ空間 | 独立 | 共有 |
+| 作成コスト | 高い | 低い |
+| 通信 | IPC 必要 | 直接共有 |
+| 分離性 | 高い | 低い |
+
+---
+
+## 次のステップ
+
+Part III では、マルチタスキングとスケジューリングを学びます。
+
+---
+
+## 参考資料
+
+- [System.Threading.Thread](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.thread)
+- [Task Parallel Library](https://docs.microsoft.com/ja-jp/dotnet/standard/parallel-programming/task-parallel-library-tpl)

package/lib/assets/docs/article/grokking-concurrency/csharp/part-3.md

@@ -0,0 +1,101 @@
+---
+title: Part III - マルチタスキングとスケジューリング
+description: マルチタスキングの仕組みを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, multitasking, scheduling, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、OS がどのようにタスクを切り替えるか、タイムシェアリングの仕組みを学びます。ゲームループの例を通じて、マルチタスキングを理解します。
+
+---
+
+## ゲームループの例
+
+### タスクの定義
+
+```csharp
+public record GameTask(string Name, Action Action)
+{
+    public void Run() => Action();
+}
+```
+
+### イベントによる調整
+
+```csharp
+public class ProcessorFreeEvent
+{
+    private readonly object _lock = new();
+    private bool _signaled;
+
+    public void WaitForSignal()
+    {
+        lock (_lock)
+        {
+            while (!_signaled)
+            {
+                Monitor.Wait(_lock);
+            }
+            _signaled = false;
+        }
+    }
+
+    public void Signal()
+    {
+        lock (_lock)
+        {
+            _signaled = true;
+            Monitor.Pulse(_lock);
+        }
+    }
+}
+```
+
+### ゲームループ
+
+```csharp
+public class GameLoop(
+    Action inputTask,
+    Action computeTask,
+    Action renderTask,
+    Func<bool> continueCondition)
+{
+    public void Run()
+    {
+        while (continueCondition())
+        {
+            inputTask();
+            computeTask();
+            renderTask();
+        }
+    }
+}
+```
+
+---
+
+## スケジューリング方式
+
+| 方式 | 説明 |
+|------|------|
+| 協調的 | タスクが自発的に制御を譲る |
+| 先制的 | OS がタイムスライスで切り替え |
+
+---
+
+## 次のステップ
+
+Part IV では、Fork/Join パターンとパイプラインパターンを学びます。
+
+---
+
+## 参考資料
+
+- [System.Threading.Monitor](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.monitor)

package/lib/assets/docs/article/grokking-concurrency/csharp/part-4.md

@@ -0,0 +1,112 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: Fork/Join パターンとパイプラインパターンを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, fork-join, pipeline, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、Fork/Join パターンとパイプラインパターンを学びます。投票集計とパイプライン処理の例を通じて、並列パターンを理解します。
+
+---
+
+## Fork/Join パターン: 投票集計
+
+### 逐次処理
+
+```csharp
+public static Dictionary<int, int> CountVotes(List<int> votes)
+{
+    var result = new Dictionary<int, int>();
+    foreach (var vote in votes)
+    {
+        if (result.ContainsKey(vote))
+            result[vote]++;
+        else
+            result[vote] = 1;
+    }
+    return result;
+}
+```
+
+### 並列処理
+
+```csharp
+public static Dictionary<int, int> CountVotesParallel(List<int> votes, int numWorkers)
+{
+    var chunkSize = (int)Math.Ceiling((double)votes.Count / numWorkers);
+    var chunks = new List<List<int>>();
+
+    for (var i = 0; i < votes.Count; i += chunkSize)
+    {
+        chunks.Add(votes.GetRange(i, Math.Min(chunkSize, votes.Count - i)));
+    }
+
+    // Fork
+    var tasks = chunks.Select(chunk =>
+        Task.Run(() => CountVotes(chunk))
+    ).ToArray();
+
+    // Join
+    Task.WaitAll(tasks);
+    return tasks.Aggregate(new Dictionary<int, int>(),
+        (acc, t) => MergeResults(acc, t.Result));
+}
+```
+
+---
+
+## パイプラインパターン
+
+### ステージワーカー
+
+```csharp
+public class Pipeline<T>
+{
+    public void AddStage(string name, Func<object, object> processor) { ... }
+    public void Start() { ... }
+    public void Submit(T item) { ... }
+    public void Stop() { ... }
+}
+```
+
+### 使用例
+
+```csharp
+var pipeline = new Pipeline<string>();
+pipeline.AddStage("wash", item => "washed:" + item);
+pipeline.AddStage("dry", item => "dried:" + item);
+pipeline.AddStage("fold", item => "folded:" + item);
+
+pipeline.Start();
+pipeline.Submit("load1");
+pipeline.Stop();
+```
+
+---
+
+## パターンの比較
+
+| パターン | 用途 |
+|----------|------|
+| Fork/Join | データ並列処理 |
+| Pipeline | ステージ並列処理 |
+
+---
+
+## 次のステップ
+
+Part V では、同期と排他制御を学びます。
+
+---
+
+## 参考資料
+
+- [Task Parallel Library](https://docs.microsoft.com/ja-jp/dotnet/standard/parallel-programming/)
+- [BlockingCollection](https://docs.microsoft.com/ja-jp/dotnet/api/system.collections.concurrent.blockingcollection-1)

package/lib/assets/docs/article/grokking-concurrency/csharp/part-5.md

@@ -0,0 +1,99 @@
+---
+title: Part V - 同期と排他制御
+description: Lock と Monitor を使った同期を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, lock, synchronization, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、Lock と Monitor を使った同期を学びます。銀行口座の例を通じて、スレッドセーフな実装とデッドロック回避を理解します。
+
+---
+
+## 銀行口座の例
+
+### lock を使った実装
+
+```csharp
+public class BankAccount
+{
+    private readonly object _lock = new();
+    private int _balance;
+
+    public void Deposit(int amount)
+    {
+        lock (_lock)
+        {
+            _balance += amount;
+        }
+    }
+
+    public bool Withdraw(int amount)
+    {
+        lock (_lock)
+        {
+            if (_balance >= amount)
+            {
+                _balance -= amount;
+                return true;
+            }
+            return false;
+        }
+    }
+}
+```
+
+### デッドロック回避
+
+```csharp
+public static bool Transfer(BankAccount from, BankAccount to, int amount)
+{
+    // 常に同じ順序でロックを取得
+    var first = RuntimeHelpers.GetHashCode(from) < RuntimeHelpers.GetHashCode(to) ? from : to;
+    var second = first == from ? to : from;
+
+    lock (first._lock)
+    {
+        lock (second._lock)
+        {
+            if (from._balance >= amount)
+            {
+                from._balance -= amount;
+                to._balance += amount;
+                return true;
+            }
+            return false;
+        }
+    }
+}
+```
+
+---
+
+## 同期プリミティブ
+
+| プリミティブ | 用途 |
+|-------------|------|
+| `lock` | 排他制御 |
+| `Monitor` | 条件変数 |
+| `SemaphoreSlim` | リソース数制限 |
+| `ReaderWriterLockSlim` | 読み書きロック |
+
+---
+
+## 次のステップ
+
+Part VI では、ノンブロッキング I/O を学びます。
+
+---
+
+## 参考資料
+
+- [lock ステートメント](https://docs.microsoft.com/ja-jp/dotnet/csharp/language-reference/statements/lock)
+- [System.Threading.Monitor](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.monitor)

package/lib/assets/docs/article/grokking-concurrency/csharp/part-6.md

@@ -0,0 +1,61 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: async/await を使ったノンブロッキング I/O を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, async, non-blocking, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、C# の async/await を使ったノンブロッキング I/O を学びます。
+
+---
+
+## async/await の基本
+
+### 非同期メソッド
+
+```csharp
+public async Task<string> FetchDataAsync(string url)
+{
+    using var client = new HttpClient();
+    return await client.GetStringAsync(url);
+}
+```
+
+### 複数の非同期操作
+
+```csharp
+public async Task<string[]> FetchMultipleAsync(string[] urls)
+{
+    var tasks = urls.Select(url => FetchDataAsync(url));
+    return await Task.WhenAll(tasks);
+}
+```
+
+---
+
+## 同期 vs 非同期
+
+| 特性 | 同期 | 非同期 |
+|------|------|--------|
+| スレッド | ブロック | 解放 |
+| スケーラビリティ | 低 | 高 |
+| コード複雑度 | 低 | やや高 |
+
+---
+
+## 次のステップ
+
+Part VII では、Task と非同期プログラミングを深く学びます。
+
+---
+
+## 参考資料
+
+- [async/await](https://docs.microsoft.com/ja-jp/dotnet/csharp/programming-guide/concepts/async/)