[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M79WWRRESMB2ER8YQ7KSDTPF":3,"skill-same:01M79WWRRESMB2ER8YQ7KSDTPF":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M79WWRRESMB2ER8YQ7KSDTPF","process-api-net11",null,"Provides guidance on the new System.Diagnostics.Process APIs introduced in .NET 11: Process.Run, Process.RunAndCaptureText, Process.StartAndForget, Process.ReadAllText\u002FBytes\u002FLines, KillOnParentExit, InheritedHandles, and StartDetached. USE FOR: starting, orchestrating, or capturing output from external processes in applications targeting net11.0 or later. DO NOT USE FOR: applications targeting .NET 10 or earlier, or basic pre-.NET 11 Process.Start usage without new APIs.","Blind-Striker\u002Fagent-skills-and-plugins","Blind-Striker","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F1965259?v=4","01M79WFXTE5PH0C1VB7B54ANMN","Deniz İrgin","01M79WFXV5KZ5GST1K8G035DM5",1,"MIT","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fcodex\u002Fdeniz-dotnet-general\u002Fskills\u002Fprocess-api-net11\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: process-api-net11\ndescription: >\n  Provides guidance on the new System.Diagnostics.Process APIs introduced in\n  .NET 11: Process.Run, Process.RunAndCaptureText, Process.StartAndForget,\n  Process.ReadAllText\u002FBytes\u002FLines, KillOnParentExit, InheritedHandles, and\n  StartDetached. USE FOR: starting, orchestrating, or capturing output from\n  external processes in applications targeting net11.0 or later. DO NOT USE FOR:\n  applications targeting .NET 10 or earlier, or basic pre-.NET 11 Process.Start\n  usage without new APIs.\nlicense: MIT\n---\n\n# Process API Improvements — .NET 11\n\nNew APIs added to `System.Diagnostics.Process` in .NET 11 simplify process management, eliminate boilerplate, and prevent common deadlock patterns when capturing output in .NET 11 or later applications.\n\n## When to Use\n\n- Running or orchestrating external processes in a .NET 11 (or later) project.\n- Needing to start a process, wait for it to exit, and capture its output\u002Ferror streams without risking deadlocks (`Process.RunAndCaptureText[Async]`).\n- Wanting to ensure child processes are automatically terminated when the parent process exits (`KillOnParentExit`).\n- Requiring lightweight, low-overhead process creation via `SafeProcessHandle` on supported platforms.\n- Requiring fine-grained control over handle inheritance (`InheritedHandles`) or starting detached processes (`StartDetached`).\n\n## When Not to Use\n\n- The project targets .NET 10 or earlier — these APIs are not available before .NET 11.\n- The default `Process.Start()` is sufficient and does not require output capturing or advanced lifecycle rules.\n\n## Target Framework\n\n```xml\n\u003CTargetFramework>net11.0\u003C\u002FTargetFramework>\n```\n\n## New APIs\n\n### Types\n\nBefore using the new convenience methods, note the following types. Use the framework types directly:\n\n| Type | Kind | Read-only properties |\n|------|------|----------------------|\n| `ProcessExitStatus` | Sealed class | `int ExitCode`, `bool Canceled`, `PosixSignal? Signal` |\n| `ProcessTextOutput` | Sealed class | `ProcessExitStatus ExitStatus`, `string StandardOutput`, `string StandardError`, `int ProcessId` |\n| `ProcessOutputLine` | Readonly struct | `string Content`, `bool StandardError` |\n\n`ProcessExitStatus` describes the outcome of a completed process. Interpret `ExitCode` using the external command's contract; there is no universal `Success` property. `ProcessTextOutput` contains the exit status, captured output and error text, and process ID. `ProcessOutputLine` identifies one output line and whether it came from standard error.\n\n### High-Level Convenience APIs\n\n#### Static Methods\n\nThe `ProcessStartInfo` overloads below require `UseShellExecute = false`, which is the default for .NET.\n\n##### `Process.Run` \u002F `Process.RunAsync`\nStarts a process and waits for it to exit, returning the exit status. Does not capture standard output or error. Passing `silent: true` discards standard output and error by internally redirecting standard handles to the `NUL` device. On timeout or cancellation, the process is killed.\n```csharp\npublic static ProcessExitStatus Run(string fileName, IEnumerable\u003Cstring>? arguments = null, bool silent = false, TimeSpan? timeout = null)\npublic static Task\u003CProcessExitStatus> RunAsync(string fileName, IEnumerable\u003Cstring>? arguments = null, bool silent = false, CancellationToken cancellationToken = default)\npublic static ProcessExitStatus Run(ProcessStartInfo startInfo, TimeSpan? timeout = null)\npublic static Task\u003CProcessExitStatus> RunAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default)\n```\n\n##### `Process.RunAndCaptureText` \u002F `Process.RunAndCaptureTextAsync`\nStarts a process, captures both standard output and error, and waits for it to exit. Extremely useful for avoiding deadlocks on stream redirection. On timeout or cancellation, the process is killed.\n\nWhen using the `ProcessStartInfo` overloads, the caller is responsible for setting `RedirectStandardOutput = true` and `RedirectStandardError = true` on `ProcessStartInfo` (because BCL APIs cannot modify the input arguments they were given).\n```csharp\npublic static ProcessTextOutput RunAndCaptureText(string fileName, IEnumerable\u003Cstring>? arguments = null, TimeSpan? timeout = null)\npublic static Task\u003CProcessTextOutput> RunAndCaptureTextAsync(string fileName, IEnumerable\u003Cstring>? arguments = null, CancellationToken cancellationToken = default)\npublic static ProcessTextOutput RunAndCaptureText(ProcessStartInfo startInfo, TimeSpan? timeout = null)\npublic static Task\u003CProcessTextOutput> RunAndCaptureTextAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default)\n```\n\n##### `Process.StartAndForget`\nThere is a common misconception that when a process is disposed, it's also being killed. This is not the case, as `Process.Dispose` only releases the resources associated with the process, but does not kill it.\n\nTo make it easier to start a process without the need to worry about disposing it, `Process.StartAndForget` was introduced. The method starts an executable, returns its ID, and immediately releases all handle resources associated with it. Standard handles not supplied through `StandardInputHandle`, `StandardOutputHandle`, or `StandardErrorHandle` go to the null device by default.\n\n`StartAndForget` throws `InvalidOperationException` if `UseShellExecute` or any `RedirectStandardInput`, `RedirectStandardOutput`, or `RedirectStandardError` flag is true. Use a capture or streaming API if output needs to be read.\n```csharp\npublic static int StartAndForget(string fileName, IEnumerable\u003Cstring>? arguments = null)\npublic static int StartAndForget(ProcessStartInfo startInfo)\n```\n\n#### Instance Methods\nThese methods are called on a `Process` instance to directly read stdout and stderr, guaranteeing no OS pipe buffer overflow deadlocks.\n\n*Note: Calling these methods requires `RedirectStandardOutput = true` and `RedirectStandardError = true` on the `ProcessStartInfo` passed to `Process.Start`.*\n\n```csharp\npublic (string StandardOutput, string StandardError) ReadAllText(TimeSpan? timeout = null)\npublic Task\u003C(string StandardOutput, string StandardError)> ReadAllTextAsync(CancellationToken cancellationToken = default)\npublic (byte[] StandardOutput, byte[] StandardError) ReadAllBytes(TimeSpan? timeout = null)\npublic Task\u003C(byte[] StandardOutput, byte[] StandardError)> ReadAllBytesAsync(CancellationToken cancellationToken = default)\npublic IEnumerable\u003CProcessOutputLine> ReadAllLines(TimeSpan? timeout = null)\npublic IAsyncEnumerable\u003CProcessOutputLine> ReadAllLinesAsync(CancellationToken cancellationToken = default)\n```\n\nExample of deconstructing the tuple return:\n```csharp\nvar (stdout, stderr) = await process.ReadAllTextAsync();\n```\n\n### ProcessStartInfo Properties\n\n#### `KillOnParentExit`\nEnsures that the spawned child process is terminated when the current (parent) process exits (including fatal crash and being force killed). Works across Windows, Linux, and Android.\n```csharp\npublic bool KillOnParentExit { get; set; }\n```\n\nIn cross-platform code, guard the property assignment with a supported-platform check, not only the assigned value. If automatic teardown is required, fail explicitly on an unsupported platform instead of starting an unprotected child process.\n`KillOnParentExit` requires `UseShellExecute = false`.\n\n#### `InheritedHandles`\nProvides precise control over which handles (file descriptors) are inherited by the child process, preventing accidental resource leaks.\n- Standard handles (`stdin`, `stdout`, `stderr`) are always included (no need to add them to the list).\n- Setting the list to an empty list means only standard handles get inherited.\n- Only `SafeFileHandle` and `SafePipeHandle` instances are allowed as of today.\n- No global lock is used when spawning new processes on Windows (important for tuning projects that spawn multiple processes in parallel).\n- Concurrent process starts must not pass the same handle in `InheritedHandles`: the runtime temporarily changes its inheritance flags. Serialize starts that share a handle, or use separate handles for each concurrent start.\n- Do not enable inheritance on the handles before passing them; other process-start APIs could then inherit them unintentionally.\n- On Unix systems without native handle-inheritance control, setting this property can severely reduce process-start performance.\n- A non-null list requires `UseShellExecute = false` and cannot be combined with a non-empty `UserName`.\n```csharp\npublic IList\u003CSafeHandle>? InheritedHandles { get; set; }\n```\n\n#### `StartDetached`\nStarts the process detached from the parent's terminal or job session, ensuring it survives the parent's exit.\n```csharp\npublic bool StartDetached { get; set; }\n```\n\n`StartDetached` requires `UseShellExecute = false`.\n\n---\n\n## Examples\n\n### 1. One-Line Run and Capture Output\n\nRun a process and safely read all output text without stream deadlock risks. For simple CLI operations that don't need cancellation or async scalability, prefer the synchronous overload:\n\n```csharp\nusing System;\nusing System.Diagnostics;\n\n\u002F\u002F Run 'git status' and capture output\nProcessTextOutput result = Process.RunAndCaptureText(\"git\", [\"status\"]);\n\nif (result.ExitStatus.ExitCode == 0)\n{\n    Console.WriteLine($\"Git Output: {result.StandardOutput}\");\n}\nelse\n{\n    Console.WriteLine($\"Failed with exit code: {result.ExitStatus.ExitCode}\");\n    Console.WriteLine($\"Error: {result.StandardError}\");\n}\n```\n\n### 2. Auto-Killing Child Processes on Parent Exit\n\nOn Windows, Linux, and Android, ensure a long-running background worker process is killed when the main application terminates. On other platforms, this example stops before starting the child process:\n\n```csharp\nusing System;\nusing System.Diagnostics;\n\nProcessStartInfo startInfo = new(\"dotnet\", [\"run\", \"--project\", \"BackgroundWorker.csproj\"]);\n\nif (OperatingSystem.IsWindows() || OperatingSystem.IsLinux() || OperatingSystem.IsAndroid())\n{\n    startInfo.KillOnParentExit = true;\n}\nelse\n{\n    throw new PlatformNotSupportedException(\"This example requires Windows, Linux, or Android.\");\n}\n\nusing Process process = Process.Start(startInfo)!;\n\u002F\u002F The background worker is now tied to this process's lifecycle\n```\n\n### 3. Read All Lines From Output\n\nStart a process and read its output lines safely:\n\n```csharp\nusing System;\nusing System.Diagnostics;\nusing System.Threading.Tasks;\n\nProcessStartInfo startInfo = new(\"ping\", [\"127.0.0.1\"])\n{\n    RedirectStandardOutput = true,\n    RedirectStandardError = true\n};\n\nusing Process process = Process.Start(startInfo)!;\n\u002F\u002F Read all output lines safely and asynchronously\nawait foreach (ProcessOutputLine line in process.ReadAllLinesAsync())\n{\n    string prefix = line.StandardError ? \"[Err]\" : \"[Out]\";\n    Console.WriteLine($\"{prefix} > {line.Content}\");\n}\n```\n\n### 4. Read Entire Output Deadlock-Free (Tuple Return)\n\nStart a process with custom `ProcessStartInfo` and read both stdout and stderr into a deconstructed tuple without buffer deadlocks:\n\n```csharp\nusing System;\nusing System.Diagnostics;\nusing System.Threading.Tasks;\n\nProcessStartInfo startInfo = new(\"git\", [\"diff\"])\n{\n    RedirectStandardOutput = true,\n    RedirectStandardError = true\n};\n\nusing Process process = Process.Start(startInfo)!;\nvar (stdout, stderr) = await process.ReadAllTextAsync();\n\nConsole.WriteLine($\"Diff output: {stdout}\");\n```\n\n### 5. Start and Forget (Fire & Forget)\n\nLaunch a helper executable without holding onto system handle structures:\n\n```csharp\nusing System;\nusing System.Diagnostics;\n\n\u002F\u002F Fire and forget, getting back only the process ID\nint pid = Process.StartAndForget(\"notepad.exe\");\nConsole.WriteLine($\"Notepad started with PID: {pid}\");\n```\n","# Process API Improvements — .NET 11\n\nNew APIs added to `System.Diagnostics.Process` in .NET 11 simplify process management, eliminate boilerplate, and prevent common deadlock patterns when capturing output in .NET 11 or later applications.\n\n## When to Use\n\n- Running or orchestrating external processes in a .NET 11 (or later) project.\n- Needing to start a process, wait for it to exit, and capture its output\u002Ferror streams without risking deadlocks (`Process.RunAndCaptureText[Async]`).\n- Wanting to ensure child processes are automatically terminated when the parent process exits (`KillOnParentExit`).\n- Requiring lightweight, low-overhead process creation via `SafeProcessHandle` on supported platforms.\n- Requiring fine-grained control over handle inheritance (`InheritedHandles`) or starting detached processes (`StartDetached`).\n\n## When Not to Use\n\n- The project targets .NET 10 or earlier — these APIs are not available before .NET 11.\n- The default `Process.Start()` is sufficient and does not require output capturing or advanced lifecycle rules.\n\n## Target Framework\n\n```xml\n\u003CTargetFramework>net11.0\u003C\u002FTargetFramework>\n```\n\n## New APIs\n\n### Types\n\nBefore using the new convenience methods, note the following types. Use the framework types directly:\n\n| Type | Kind | Read-only properties |\n|------|------|----------------------|\n| `ProcessExitStatus` | Sealed class | `int ExitCode`, `bool Canceled`, `PosixSignal? Signal` |\n| `ProcessTextOutput` | Sealed class | `ProcessExitStatus ExitStatus`, `string StandardOutput`, `string StandardError`, `int ProcessId` |\n| `ProcessOutputLine` | Readonly struct | `string Content`, `bool StandardError` |\n\n`ProcessExitStatus` describes the outcome of a completed process. Interpret `ExitCode` using the external command's contract; there is no universal `Success` property. `ProcessTextOutput` contains the exit status, captured output and error text, and process ID. `ProcessOutputLine` identifies one output line and whether it came from standard error.\n\n### High-Level Convenience APIs\n\n#### Static Methods\n\nThe `ProcessStartInfo` overloads below require `UseShellExecute = false`, which is the default for .NET.\n\n##### `Process.Run` \u002F `Process.RunAsync`\nStarts a process and waits for it to exit, returning the exit status. Does not capture standard output or error. Passing `silent: true` discards standard output and error by internally redirecting standard handles to the `NUL` device. On timeout or cancellation, the process is killed.\n```csharp\npublic static ProcessExitStatus Run(string fileName, IEnumerable\u003Cstring>? arguments = null, bool silent = false, TimeSpan? timeout = null)\npublic static Task\u003CProcessExitStatus> RunAsync(string fileName, IEnumerable\u003Cstring>? arguments = null, bool silent = false, CancellationToken cancellationToken = default)\npublic static ProcessExitStatus Run(ProcessStartInfo startInfo, TimeSpan? timeout = null)\npublic static Task\u003CProcessExitStatus> RunAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default)\n```\n\n##### `Process.RunAndCaptureText` \u002F `Process.RunAndCaptureTextAsync`\nStarts a process, captures both standard output and error, and waits for it to exit. Extremely useful for avoiding deadlocks on stream redirection. On timeout or cancellation, the process is killed.\n\nWhen using the `ProcessStartInfo` overloads, the caller is responsible for setting `RedirectStandardOutput = true` and `RedirectStandardError = true` on `ProcessStartInfo` (because BCL APIs cannot modify the input arguments they were given).\n```csharp\npublic static ProcessTextOutput RunAndCaptureText(string fileName, IEnumerable\u003Cstring>? arguments = null, TimeSpan? timeout = null)\npublic static Task\u003CProcessTextOutput> RunAndCaptureTextAsync(string fileName, IEnumerable\u003Cstring>? arguments = null, CancellationToken cancellationToken = default)\npublic static ProcessTextOutput RunAndCaptureText(ProcessStartInfo startInfo, TimeSpan? timeout = null)\npublic static Task\u003CProcessTextOutput> RunAndCaptureTextAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default)\n```\n\n##### `Process.StartAndForget`\nThere is a common misconception that when a process is disposed, it's also being killed. This is not the case, as `Process.Dispose` only releases the resources associated with the process, but does not kill it.\n\nTo make it easier to start a process without the need to worry about disposing it, `Process.StartAndForget` was introduced. The method starts an executable, returns its ID, and immediately releases all handle resources associated with it. Standard handles not supplied through `StandardInputHandle`, `StandardOutputHandle`, or `StandardErrorHandle` go to the null device by default.\n\n`StartAndForget` throws `InvalidOperationException` if `UseShellExecute` or any `RedirectStandardInput`, `RedirectStandardOutput`, or `RedirectStandardError` flag is true. Use a capture or streaming API if output needs to be read.\n```csharp\npublic static int StartAndForget(string fileName, IEnumerable\u003Cstring>? arguments = null)\npublic static int StartAndForget(ProcessStartInfo startInfo)\n```\n\n#### Instance Methods\nThese methods are called on a `Process` instance to directly read stdout and stderr, guaranteeing no OS pipe buffer overflow deadlocks.\n\n*Note: Calling these methods requires `RedirectStandardOutput = true` and `RedirectStandardError = true` on the `ProcessStartInfo` passed to `Process.Start`.*\n\n```csharp\npublic (string StandardOutput, string StandardError) ReadAllText(TimeSpan? timeout = null)\npublic Task\u003C(string StandardOutput, string StandardError)> ReadAllTextAsync(CancellationToken cancellationToken = default)\npublic (byte[] StandardOutput, byte[] StandardError) ReadAllBytes(TimeSpan? timeout = null)\npublic Task\u003C(byte[] StandardOutput, byte[] StandardError)> ReadAllBytesAsync(CancellationToken cancellationToken = default)\npublic IEnumerable\u003CProcessOutputLine> ReadAllLines(TimeSpan? timeout = null)\npublic IAsyncEnumerable\u003CProcessOutputLine> ReadAllLinesAsync(CancellationToken cancellationToken = default)\n```\n\nExample of deconstructing the tuple return:\n```csharp\nvar (stdout, stderr) = await process.ReadAllTextAsync();\n```\n\n### ProcessStartInfo Properties\n\n#### `KillOnParentExit`\nEnsures that the spawned child process is terminated when the current (parent) process exits (including fatal crash and being force killed). Works across Windows, Linux, and Android.\n```csharp\npublic bool KillOnParentExit { get; set; }\n```\n\nIn cross-platform code, guard the property assignment with a supported-platform check, not only the assigned value. If automatic teardown is required, fail explicitly on an unsupported platform instead of starting an unprotected child process.\n`KillOnParentExit` requires `UseShellExecute = false`.\n\n#### `InheritedHandles`\nProvides precise control over which handles (file descriptors) are inherited by the child process, preventing accidental resource leaks.\n- Standard handles (`stdin`, `stdout`, `stderr`) are always included (no need to add them to the list).\n- Setting the list to an empty list means only standard handles get inherited.\n- Only `SafeFileHandle` and `SafePipeHandle` instances are allowed as of today.\n- No global lock is used when spawning new processes on Windows (important for tuning projects that spawn multiple processes in parallel).\n- Concurrent process starts must not pass the same handle in `InheritedHandles`: the runtime temporarily changes its inheritance flags. Serialize starts that share a handle, or use separate handles for each concurrent start.\n- Do not enable inheritance on the handles before passing them; other process-start APIs could then inherit them unintentionally.\n- On Unix systems without native handle-inheritance control, setting this property can severely reduce process-start performance.\n- A non-null list requires `UseShellExecute = false` and cannot be combined with a non-empty `UserName`.\n```csharp\npublic IList\u003CSafeHandle>? InheritedHandles { get; set; }\n```\n\n#### `StartDetached`\nStarts the process detached from the parent's terminal or job session, ensuring it survives the parent's exit.\n```csharp\npublic bool StartDetached { get; set; }\n```\n\n`StartDetached` requires `UseShellExecute = false`.\n\n---\n\n## Examples\n\n### 1. One-Line Run and Capture Output\n\nRun a process and safely read all output text without stream deadlock risks. For simple CLI operations that don't need cancellation or async scalability, prefer the synchronous overload:\n\n```csharp\nusing System;\nusing System.Diagnostics;\n\n\u002F\u002F Run 'git status' and capture output\nProcessTextOutput result = Process.RunAndCaptureText(\"git\", [\"status\"]);\n\nif (result.ExitStatus.ExitCode == 0)\n{\n    Console.WriteLine($\"Git Output: {result.StandardOutput}\");\n}\nelse\n{\n    Console.WriteLine($\"Failed with exit code: {result.ExitStatus.ExitCode}\");\n    Console.WriteLine($\"Error: {result.StandardError}\");\n}\n```\n\n### 2. Auto-Killing Child Processes on Parent Exit\n\nOn Windows, Linux, and Android, ensure a long-running background worker process is killed when the main application terminates. On other platforms, this example stops before starting the child process:\n\n```csharp\nusing System;\nusing System.Diagnostics;\n\nProcessStartInfo startInfo = new(\"dotnet\", [\"run\", \"--project\", \"BackgroundWorker.csproj\"]);\n\nif (OperatingSystem.IsWindows() || OperatingSystem.IsLinux() || OperatingSystem.IsAndroid())\n{\n    startInfo.KillOnParentExit = true;\n}\nelse\n{\n    throw new PlatformNotSupportedException(\"This example requires Windows, Linux, or Android.\");\n}\n\nusing Process process = Process.Start(startInfo)!;\n\u002F\u002F The background worker is now tied to this process's lifecycle\n```\n\n### 3. Read All Lines From Output\n\nStart a process and read its output lines safely:\n\n```csharp\nusing System;\nusing System.Diagnostics;\nusing System.Threading.Tasks;\n\nProcessStartInfo startInfo = new(\"ping\", [\"127.0.0.1\"])\n{\n    RedirectStandardOutput = true,\n    RedirectStandardError = true\n};\n\nusing Process process = Process.Start(startInfo)!;\n\u002F\u002F Read all output lines safely and asynchronously\nawait foreach (ProcessOutputLine line in process.ReadAllLinesAsync())\n{\n    string prefix = line.StandardError ? \"[Err]\" : \"[Out]\";\n    Console.WriteLine($\"{prefix} > {line.Content}\");\n}\n```\n\n### 4. Read Entire Output Deadlock-Free (Tuple Return)\n\nStart a process with custom `ProcessStartInfo` and read both stdout and stderr into a deconstructed tuple without buffer deadlocks:\n\n```csharp\nusing System;\nusing System.Diagnostics;\nusing System.Threading.Tasks;\n\nProcessStartInfo startInfo = new(\"git\", [\"diff\"])\n{\n    RedirectStandardOutput = true,\n    RedirectStandardError = true\n};\n\nusing Process process = Process.Start(startInfo)!;\nvar (stdout, stderr) = await process.ReadAllTextAsync();\n\nConsole.WriteLine($\"Diff output: {stdout}\");\n```\n\n### 5. Start and Forget (Fire & Forget)\n\nLaunch a helper executable without holding onto system handle structures:\n\n```csharp\nusing System;\nusing System.Diagnostics;\n\n\u002F\u002F Fire and forget, getting back only the process ID\nint pid = Process.StartAndForget(\"notepad.exe\");\nConsole.WriteLine($\"Notepad started with PID: {pid}\");\n```\n",{"name":5,"license":15,"description":24},"Provides guidance on the new System.Diagnostics.Process APIs introduced in .NET 11: Process.Run, Process.RunAndCaptureText, Process.StartAndForget, Process.ReadAllText\u002FBytes\u002FLines, KillOnParentExit, InheritedHandles, and StartDetached. USE FOR: starting, orchestrating, or capturing output from external processes in applications targeting net11.0 or later. DO NOT USE FOR: applications targeting .NET 10 or earlier, or basic pre-.NET 11 Process.Start usage without new APIs.\n","master","b30b1c1908dbc56a8184128f18803053d762ccb5","codex\u002Fdeniz-dotnet-general\u002Fskills\u002Fprocess-api-net11",0,"https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins","https:\u002F\u002Fgithub.com\u002FBlind-Striker","denizirgin.com","VP of Engineering - \r\n@armutcom @homeruntech @prontopro\r\n |  Speaker \r\n@CodeFiction\r\n, http:\u002F\u002Fcodefiction.tech | Developer, gamer, blogger, maiden iron fan","2026-11-13 00:23:18",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add Blind-Striker\u002Fagent-skills-and-plugins --skill process-api-net11",{"tool":40,"command":41},"bunx","bunx skills add Blind-Striker\u002Fagent-skills-and-plugins --skill process-api-net11",{"tool":43,"command":44},"pnpm","pnpm dlx skills add Blind-Striker\u002Fagent-skills-and-plugins --skill process-api-net11","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fcodex\u002Fdeniz-dotnet-general\u002Fskills\u002Fprocess-api-net11\u002FSKILL.md",true,[],[49,56,63,70,77,84],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M79YGWBJ52PHMSTKJ3RJ3AWR","writing-tunit-tests","Write tests in TUnit — the attributes, the async assertion model, data-driven cases, lifecycle hooks, and the parallelism rules. USE FOR writing or fixing a test in a TUnit project, translating a test idea into TUnit syntax, or reviewing TUnit test code for API mistakes. DO NOT USE FOR deciding what to test, judging whether a test is any good, or running tests.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-dotnet-general\u002Fwriting-tunit-tests\u002FSKILL.md",[],[],{"skillNo":57,"name":58,"nameZh":6,"description":59,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":60,"categories":61,"keywords":62,"publishedAt":19},"01M79YGR3Y9RCRS6TD71D0KKP8","dotnet-walls","Walls for a .NET change in a repository without its own quality gates — pinned, ephemeral analyzer, format, clone and scanner commands for the verify step, their identity ratchet, and the build traps. Use during a walls preflight, or when a worker's verify step needs .NET quality gates.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-dotnet-general\u002Fdotnet-walls\u002FSKILL.md",[],[],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":19},"01M79YGFNJBST7D803NQW3SBYM","csharp-15","Write, review and modernize C# 15 (.NET 11) code correctly. Covers every C# 15 feature - collection expression arguments (`[with(...), ...]`), union types (`union`, `[Union]`, `IUnion`, custom unions), closed class hierarchies (`closed`), extension indexers, labeled `break`\u002F`continue`, non-virtual static interface members on runtimes without default interface methods, and the preview memory-safety model (`unsafe(expr)`, `safe`, requires-unsafe members). Use when code targets net11.0 or LangVersion 15\u002Fpreview, when the user mentions any of these features, when replacing marker interfaces, OneOf-style results, `goto`\u002Fflag loop exits or capacity\u002Fcomparer boilerplate, or when the build reports CS8121, CS8509, CS8655, CS8510, CS0121\u002FCS0411 on a `with(...)` element, CS9370, CS9380 or CS9363.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-dotnet-general\u002Fcsharp-15\u002FSKILL.md",[],[],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M79YGAV031473HSX6FN87ENH","verified-waves","Run one task as verified multi-agent waves. Plans the fan-out, sends findings to fresh skeptics, keeps a ledger, and reports N of M done; small tasks stay solo.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-coordination\u002Fverified-waves\u002FSKILL.md",[],[],{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":19},"01M79YG6QXNND4WRPP3GATSY8J","harness","The bundled dispatch harness, which runs a task file on worker models through OpenCode or Codex, fences their writes, escalates their asks to the operator, settles each result from git and its verify commands, and records every step in a ledger. Its commands, task file, modes and write fence, configuration, runs and their recovery, ledger and exit codes.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-coordination\u002Fharness\u002FSKILL.md",[],[],{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":19},"01M79YG2P5S91SDTA5912XJ4FV","delegating-to-worker-models","Use when you hand off implementation, a plan, research a decision will rely on, or a review, and you brief the worker and check what comes back. A subagent that searches, reads in parallel, or keeps your context small is ordinary tool use. Covers what stays with you, the mechanism, assigning work by strength, the walls preflight, prompts without contradictions, the worker contract and model profiles, evidence from your own run, review, and the fix-up loop.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-coordination\u002Fdelegating-to-worker-models\u002FSKILL.md",[],[]]