[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6DYRY58JJADNSQFSFRWXYM8":3,"skill-same:01M6DYRY58JJADNSQFSFRWXYM8":80},{"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":44,"linkOnly":45,"markdownContent":46,"markdownBody":47,"frontMatter":48,"refName":50,"commitSha":51,"skillDirectory":52,"forksCount":53,"repositoryHtmlUrl":54,"repositoryHomepageUrl":55,"ownerHtmlUrl":56,"ownerBlogUrl":57,"ownerDescription":58,"updatedAt":59,"install":60,"resources":73},"01M6DYRY58JJADNSQFSFRWXYM8","system-text-json-net11",null,"Imperative guidance for the System.Text.Json APIs added in .NET 11: the built-in `JsonNamingPolicy.PascalCase` naming policy, and the strongly-typed generic `JsonSerializerOptions.GetTypeInfo` and `JsonSerializerOptions.TryGetTypeInfo` metadata accessors (generic overloads that return a typed `JsonTypeInfo`). USE ONLY when the user is targeting net11.0 or later and needs PascalCase JSON property or dictionary-key names without writing a custom naming policy, a strongly-typed generic `JsonTypeInfo` instead of the non-generic `JsonTypeInfo`, or a no-throw way to probe whether a type's serialization metadata is resolved. DO NOT USE when the target is earlier than net11.0, the requested behavior uses an established pre-net11 naming policy, or the user explicitly selected another JSON library.","managedcode\u002Fdotnet-skills","managedcode","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F78253589?v=4","01M6DYDJR3EG8KB5G4PC65XCTT","Managed Code","01M6DYDJX0ZT432N04NYJW89DN",512,"MIT","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fcatalog\u002FPlatform\u002FOfficial-DotNet-Dotnet11\u002Fskills\u002Fsystem-text-json-net11\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43],"system","json","text","system text json net11","probe","when","generic","custom","for","targeting","naming","dictionary","type","do","later","guidance","writing","only","use","user","behavior","serialization","library","metadata","policy","2026-11-10 10:12:30",false,"---\nname: system-text-json-net11\ndescription: >\n  Imperative guidance for the System.Text.Json APIs added in .NET 11: the built-in\n  `JsonNamingPolicy.PascalCase` naming policy, and the strongly-typed generic\n  `JsonSerializerOptions.GetTypeInfo` and `JsonSerializerOptions.TryGetTypeInfo`\n  metadata accessors (generic overloads that return a typed `JsonTypeInfo`).\n  USE ONLY when the user is targeting net11.0 or later and needs\n  PascalCase JSON property or dictionary-key names without writing a custom naming policy, a strongly-typed\n  generic `JsonTypeInfo` instead of the non-generic `JsonTypeInfo`, or a no-throw way to probe\n  whether a type's serialization metadata is resolved.\n  DO NOT USE when the target is earlier than net11.0, the requested behavior uses an\n  established pre-net11 naming policy, or the user explicitly selected another JSON library.\nlicense: MIT\n---\n\n# System.Text.Json — .NET 11\n\nThree APIs were added to `System.Text.Json` in .NET 11. This skill tells you exactly\nwhen to reach for each one, what to write, what **not** to write, and how to prove the\nresult runs. Do not describe these APIs to the user — apply them, then run the code and\nshow the output.\n\n| API | Replaces the pre-.NET-11 workaround of... |\n| --- | --- |\n| `JsonNamingPolicy.PascalCase` (static property) | writing a custom `JsonNamingPolicy` subclass or hand-annotating every member with `[JsonPropertyName]` |\n| `JsonSerializerOptions.GetTypeInfo\u003CT>()` | calling non-generic `GetTypeInfo(typeof(T))` and casting to `JsonTypeInfo\u003CT>` |\n| `JsonSerializerOptions.TryGetTypeInfo\u003CT>(out JsonTypeInfo\u003CT>? info)` | wrapping `GetTypeInfo` in `try`\u002F`catch` to probe availability |\n\n## Step 0 — Make the requested `net11.0` validation possible\n\nThese APIs only exist in the .NET 11 base class library. Before writing code:\n\n1. Run `dotnet --list-sdks` and confirm an SDK that can target `net11.0` is present — an\n   `11.x` SDK, or a later SDK with the `net11.0` targeting pack.\n2. If the user explicitly asks you to run the sample and no suitable SDK is installed,\n   use the official `dotnet-install` script to install the current .NET 11 SDK into a\n   temporary or project-local directory. Prefer the GA channel build. Use a preview only\n   when GA is not yet available or the user explicitly requested a preview. Do not require\n   administrator access, change the machine-wide `PATH`, or replace an installed SDK.\n3. Run the sample with that local `dotnet` executable. If download or execution is blocked,\n   still provide the complete `net11.0` program and report that it was **not run**. Never\n   substitute `net10.0`, a custom naming policy, or a different API and present that as\n   validation of the .NET 11 feature.\n\nUse the channel, not a guessed version. Try the GA channel first:\n\n```powershell\n$installScript = Join-Path $env:TEMP \"dotnet-install-$([guid]::NewGuid()).ps1\"\ntry {\n    Invoke-WebRequest -Uri 'https:\u002F\u002Fdot.net\u002Fv1\u002Fdotnet-install.ps1' -OutFile $installScript\n    & $installScript -Channel 11.0 -InstallDir .\\.dotnet\n    & .\\.dotnet\\dotnet.exe run --project \u003CPATH_TO_NET11_PROJECT>\n}\nfinally {\n    Remove-Item -LiteralPath $installScript -Force -ErrorAction SilentlyContinue\n}\n```\n\n```bash\ninstall_script=\"$(mktemp \"${TMPDIR:-\u002Ftmp}\u002Fdotnet-install.XXXXXX\")\"\ntrap 'rm -f \"$install_script\"' EXIT\ncurl -fsSL https:\u002F\u002Fdot.net\u002Fv1\u002Fdotnet-install.sh -o \"$install_script\"\nbash \"$install_script\" --channel 11.0 --install-dir .\u002F.dotnet\n.\u002F.dotnet\u002Fdotnet run --project \u003CPATH_TO_NET11_PROJECT>\n```\n\nBefore .NET 11 GA, retry the install with `-Quality preview` (PowerShell) or\n`--quality preview` (shell).\n\n## Decision table — symptom → do this → never do this\n\nMatch the user's request to a row, apply the **Do this** cell verbatim, and confirm the\n**Verify** column before you are done.\n\n| User asks for… | Do this (on `net11.0`) | Never do this | Verify |\n| --- | --- | --- | --- |\n| PascalCase JSON property names | `options.PropertyNamingPolicy = JsonNamingPolicy.PascalCase;` | define `class …: JsonNamingPolicy`; add per-member `[JsonPropertyName]`; string-case the names yourself | output JSON keys are PascalCase — e.g. `\"Name\"`, `\"Age\"` |\n| PascalCase dictionary keys | `options.DictionaryKeyPolicy = JsonNamingPolicy.PascalCase;` | set only `PropertyNamingPolicy`; pre-transform the dictionary; define a custom policy | dictionary keys such as `pendingOrders` become `\"PendingOrders\"` |\n| Strongly-typed metadata `JsonTypeInfo\u003CT>` | set `TypeInfoResolver = new DefaultJsonTypeInfoResolver()`, then `JsonTypeInfo\u003CT> ti = options.GetTypeInfo\u003CT>();` | `(JsonTypeInfo\u003CT>)options.GetTypeInfo(typeof(T))` | variable is typed `JsonTypeInfo\u003CT>`, no cast |\n| Probe whether metadata is resolved | `if (options.TryGetTypeInfo\u003CT>(out var ti)) { … } else { … }` | `try { options.GetTypeInfo\u003CT>(); } catch (…) { … }` | no `try`\u002F`catch`; both branches handled |\n\n## Rule 1 — PascalCase property names\n\n**When** the user wants JSON output whose property names are PascalCase (`Name`, `Age`)\nand asks for the built-in \u002F framework-provided way:\n\n1. Create or reuse a `JsonSerializerOptions` and set\n   `PropertyNamingPolicy = JsonNamingPolicy.PascalCase`.\n2. Serialize with those options.\n\nDo **not** write a `JsonNamingPolicy` subclass, do **not** add `[JsonPropertyName(\"…\")]`\nattributes to force casing, and do **not** upper-case the first letter of each name by\nhand. `JsonNamingPolicy.PascalCase` is the single correct answer on .NET 11.\n\n```csharp\n\u002F\u002F Console project (reflection enabled by default). To run this as a file-based app\n\u002F\u002F (dotnet run app.cs), also set TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n\u002F\u002F — see \"Producing runnable output\" below.\nusing System.Text.Json;\n\nvar options = new JsonSerializerOptions\n{\n    PropertyNamingPolicy = JsonNamingPolicy.PascalCase\n};\nstring json = JsonSerializer.Serialize(new { name = \"Jane\", age = 30 }, options);\nConsole.WriteLine(json);\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n```\n\n### Dictionary keys are a separate setting\n\n`PropertyNamingPolicy` does not transform `Dictionary\u003Cstring, TValue>` keys. For that\nrequest, set `DictionaryKeyPolicy`:\n\n```csharp\nvar options = new JsonSerializerOptions\n{\n    DictionaryKeyPolicy = JsonNamingPolicy.PascalCase\n};\nvar values = new Dictionary\u003Cstring, int>\n{\n    [\"pendingOrders\"] = 2,\n    [\"activeUsers\"] = 5\n};\nConsole.WriteLine(JsonSerializer.Serialize(values, options));\n\u002F\u002F {\"PendingOrders\":2,\"ActiveUsers\":5}\n```\n\n## Rule 2 — Strongly-typed `JsonTypeInfo\u003CT>`\n\n**When** the user wants type metadata back as `JsonTypeInfo\u003CT>` (not the non-generic\n`JsonTypeInfo` that needs a cast):\n\n1. Call `options.GetTypeInfo\u003CT>()` — it returns `JsonTypeInfo\u003CT>` directly.\n2. Assign it to a `JsonTypeInfo\u003CT>` variable and use it (e.g. pass it to\n   `JsonSerializer.Serialize`\u002F`Deserialize`).\n\nDo **not** call the non-generic `GetTypeInfo(Type)` overload and cast the result.\n\n> **Requires a resolver.** `GetTypeInfo\u003CT>()` throws `NotSupportedException`\n> (`NoMetadataForType`) unless the options have a `TypeInfoResolver` — set\n> `TypeInfoResolver = new DefaultJsonTypeInfoResolver()` for reflection-based apps, or use\n> a source-generated `JsonSerializerContext` for trimmed\u002FAOT apps.\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\nvar options = new JsonSerializerOptions\n{\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\n\nJsonTypeInfo\u003CPerson> typeInfo = options.GetTypeInfo\u003CPerson>();\nConsole.WriteLine(typeInfo.Type.Name); \u002F\u002F Person\n\nrecord Person(string Name, int Age);\n```\n\n## Rule 3 — Probe metadata without throwing\n\n**When** the user wants to check whether metadata for `T` is available and branch on it —\n*without* an exception being thrown when it is not:\n\n1. Call `options.TryGetTypeInfo\u003CT>(out var info)`.\n2. Handle the `true` branch (metadata resolved, use `info`) and the `false` branch\n   (not resolved) explicitly.\n\nDo **not** wrap `GetTypeInfo\u003CT>()` in `try`\u002F`catch` to detect the missing case — that is\nexactly the anti-pattern this API removes. `TryGetTypeInfo\u003CT>` returns `false` (instead of\nthrowing) when no resolver can produce metadata for `T`, which is precisely the case you\nwant to branch on.\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\n\u002F\u002F Configured with a resolver → metadata is available.\nvar configured = new JsonSerializerOptions\n{\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\nif (configured.TryGetTypeInfo\u003CPerson>(out JsonTypeInfo\u003CPerson>? info) && info is not null)\n{\n    Console.WriteLine($\"Resolved: {info.Type.Name}\"); \u002F\u002F Resolved: Person\n}\nelse\n{\n    Console.WriteLine(\"Type info not available\");\n}\n\n\u002F\u002F No resolver → TryGetTypeInfo returns false instead of throwing.\nvar empty = new JsonSerializerOptions();\nConsole.WriteLine(empty.TryGetTypeInfo\u003CPerson>(out _)); \u002F\u002F False\n\nrecord Person(string Name, int Age);\n```\n\n## Producing runnable output on `net11.0`\n\nThe task is not done until the program runs on `net11.0` and prints its JSON. Prefer a\nconsole **project** — reflection-based serialization works there out of the box. A\nfile-based app also works but has one important caveat (below).\n\nWhen the installed SDK cannot target `net11.0` and execution was requested, install an\nSDK locally with the official script and invoke it by full path. The install script is\nnon-administrative and does not persistently alter `PATH`.\n\n### Option A — console project (recommended)\n\nCreate a project whose `.csproj` contains `\u003CTargetFramework>net11.0\u003C\u002FTargetFramework>`,\nput the code in `Program.cs`, then run `dotnet run`. Confirm the process exits with code 0\nand prints the expected JSON.\n\n```csharp\nusing System.Text.Json;\n\nvar options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.PascalCase };\nConsole.WriteLine(JsonSerializer.Serialize(new { name = \"Jane\", age = 30 }, options));\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n```\n\n### Option B — file-based app (quickest, one caveat)\n\nSave as `app.cs`, then run `dotnet run app.cs`; the first directive pins the framework.\n\n> **Caveat — file-based apps disable System.Text.Json reflection.** In a `dotnet run app.cs`\n> file-based app, `JsonSerializer.IsReflectionEnabledByDefault` is `false`, so plain\n> reflection serialization throws `NotSupportedException` (`NoMetadataForType`). Set an\n> explicit `TypeInfoResolver = new DefaultJsonTypeInfoResolver()` on the options (as below),\n> or use a source-generated `JsonSerializerContext`. A regular project does **not** need this.\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\nvar options = new JsonSerializerOptions\n{\n    PropertyNamingPolicy = JsonNamingPolicy.PascalCase,\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\nConsole.WriteLine(JsonSerializer.Serialize(new { name = \"Jane\", age = 30 }, options));\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n```\n\n## Worked example — serialize with typed metadata + PascalCase\n\nThe record below uses lowercase member names on purpose, so the PascalCase policy\nvisibly rewrites them in the output:\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\nvar options = new JsonSerializerOptions\n{\n    PropertyNamingPolicy = JsonNamingPolicy.PascalCase,\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\n\nJsonTypeInfo\u003CPerson> typeInfo = options.GetTypeInfo\u003CPerson>();\nstring json = JsonSerializer.Serialize(new Person(\"Jane\", 30), typeInfo);\nConsole.WriteLine(json);\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n\nrecord Person(string name, int age);\n```\n\n## Validation checklist\n\nBefore reporting success, confirm every applicable box:\n\n- [ ] The project or file-based app targets `net11.0` (visible in the `.csproj` or the\n      `#:property TargetFramework=net11.0` directive).\n- [ ] PascalCase requests use `JsonNamingPolicy.PascalCase` — no custom `JsonNamingPolicy`\n      subclass and no per-member `[JsonPropertyName]` attributes just to change casing.\n- [ ] Dictionary-key requests set `DictionaryKeyPolicy`, not only `PropertyNamingPolicy`.\n- [ ] Typed-metadata requests use the generic `GetTypeInfo\u003CT>()` — no cast of a\n      non-generic `JsonTypeInfo` — and the options set a `TypeInfoResolver` (e.g.\n      `DefaultJsonTypeInfoResolver`) so the call doesn't throw `NoMetadataForType`.\n- [ ] Probing requests use `TryGetTypeInfo\u003CT>(out …)` — no `try`\u002F`catch` around\n      `GetTypeInfo`.\n- [ ] The program was actually run (`dotnet run …`), exited 0, and its printed JSON shows\n      the expected property names (e.g. `\"Name\"`, `\"Age\"`).\n- [ ] If a **file-based app** (`dotnet run app.cs`) is used, every `JsonSerializerOptions`\n      sets a `TypeInfoResolver` — file-based apps disable reflection so plain serialization\n      throws `NoMetadataForType` without one.\n\n## Common pitfalls\n\n| Pitfall | Fix |\n| --- | --- |\n| Hand-rolling a `class … : JsonNamingPolicy` for PascalCase | Delete it; set `PropertyNamingPolicy = JsonNamingPolicy.PascalCase`. |\n| Adding `[JsonPropertyName(\"Name\")]` to every member to force casing | Remove the attributes; the naming policy handles all members at once. |\n| Casting `(JsonTypeInfo\u003CT>)options.GetTypeInfo(typeof(T))` | Call the generic `options.GetTypeInfo\u003CT>()`; no cast needed. |\n| `try { options.GetTypeInfo\u003CT>(); } catch (…) { … }` to test availability | Replace with `if (options.TryGetTypeInfo\u003CT>(out var info)) { … }`. |\n| `NotSupportedException` \u002F `NoMetadataForType` from `GetTypeInfo\u003CT>()` | The options have no resolver. Set `TypeInfoResolver = new DefaultJsonTypeInfoResolver()` (reflection) or a source-generated `JsonSerializerContext` (trim\u002FAOT). |\n| `NoMetadataForType` even for a plain `Serialize` in a `dotnet run app.cs` file-based app | File-based apps disable STJ reflection. Add `TypeInfoResolver = new DefaultJsonTypeInfoResolver()`, or run it as a normal project instead. |\n| Leaving the app on the SDK's default TFM | Pin `net11.0` explicitly so the .NET 11 APIs resolve and the output shows the target. |\n| Claiming success without running | Run `dotnet run` and paste the actual JSON output; the target is a working, executed program. |\n\n## More info\n\n- [JsonNamingPolicy class](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.jsonnamingpolicy) — built-in naming policies including `PascalCase`\n- [JsonSerializerOptions.GetTypeInfo](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.jsonserializeroptions.gettypeinfo) — typed and non-typed metadata access\n- [JsonTypeInfo\\\u003CT\\>](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.serialization.metadata.jsontypeinfo-1) — strongly-typed serialization metadata\n- [DefaultJsonTypeInfoResolver](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.serialization.metadata.defaultjsontypeinforesolver) — reflection-based resolver required by `GetTypeInfo`\u002F`TryGetTypeInfo`\n- [File-based apps](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fcore\u002Fsdk\u002Ffile-based-apps) — `dotnet run app.cs` and the `#:property` directive\n","# System.Text.Json — .NET 11\n\nThree APIs were added to `System.Text.Json` in .NET 11. This skill tells you exactly\nwhen to reach for each one, what to write, what **not** to write, and how to prove the\nresult runs. Do not describe these APIs to the user — apply them, then run the code and\nshow the output.\n\n| API | Replaces the pre-.NET-11 workaround of... |\n| --- | --- |\n| `JsonNamingPolicy.PascalCase` (static property) | writing a custom `JsonNamingPolicy` subclass or hand-annotating every member with `[JsonPropertyName]` |\n| `JsonSerializerOptions.GetTypeInfo\u003CT>()` | calling non-generic `GetTypeInfo(typeof(T))` and casting to `JsonTypeInfo\u003CT>` |\n| `JsonSerializerOptions.TryGetTypeInfo\u003CT>(out JsonTypeInfo\u003CT>? info)` | wrapping `GetTypeInfo` in `try`\u002F`catch` to probe availability |\n\n## Step 0 — Make the requested `net11.0` validation possible\n\nThese APIs only exist in the .NET 11 base class library. Before writing code:\n\n1. Run `dotnet --list-sdks` and confirm an SDK that can target `net11.0` is present — an\n   `11.x` SDK, or a later SDK with the `net11.0` targeting pack.\n2. If the user explicitly asks you to run the sample and no suitable SDK is installed,\n   use the official `dotnet-install` script to install the current .NET 11 SDK into a\n   temporary or project-local directory. Prefer the GA channel build. Use a preview only\n   when GA is not yet available or the user explicitly requested a preview. Do not require\n   administrator access, change the machine-wide `PATH`, or replace an installed SDK.\n3. Run the sample with that local `dotnet` executable. If download or execution is blocked,\n   still provide the complete `net11.0` program and report that it was **not run**. Never\n   substitute `net10.0`, a custom naming policy, or a different API and present that as\n   validation of the .NET 11 feature.\n\nUse the channel, not a guessed version. Try the GA channel first:\n\n```powershell\n$installScript = Join-Path $env:TEMP \"dotnet-install-$([guid]::NewGuid()).ps1\"\ntry {\n    Invoke-WebRequest -Uri 'https:\u002F\u002Fdot.net\u002Fv1\u002Fdotnet-install.ps1' -OutFile $installScript\n    & $installScript -Channel 11.0 -InstallDir .\\.dotnet\n    & .\\.dotnet\\dotnet.exe run --project \u003CPATH_TO_NET11_PROJECT>\n}\nfinally {\n    Remove-Item -LiteralPath $installScript -Force -ErrorAction SilentlyContinue\n}\n```\n\n```bash\ninstall_script=\"$(mktemp \"${TMPDIR:-\u002Ftmp}\u002Fdotnet-install.XXXXXX\")\"\ntrap 'rm -f \"$install_script\"' EXIT\ncurl -fsSL https:\u002F\u002Fdot.net\u002Fv1\u002Fdotnet-install.sh -o \"$install_script\"\nbash \"$install_script\" --channel 11.0 --install-dir .\u002F.dotnet\n.\u002F.dotnet\u002Fdotnet run --project \u003CPATH_TO_NET11_PROJECT>\n```\n\nBefore .NET 11 GA, retry the install with `-Quality preview` (PowerShell) or\n`--quality preview` (shell).\n\n## Decision table — symptom → do this → never do this\n\nMatch the user's request to a row, apply the **Do this** cell verbatim, and confirm the\n**Verify** column before you are done.\n\n| User asks for… | Do this (on `net11.0`) | Never do this | Verify |\n| --- | --- | --- | --- |\n| PascalCase JSON property names | `options.PropertyNamingPolicy = JsonNamingPolicy.PascalCase;` | define `class …: JsonNamingPolicy`; add per-member `[JsonPropertyName]`; string-case the names yourself | output JSON keys are PascalCase — e.g. `\"Name\"`, `\"Age\"` |\n| PascalCase dictionary keys | `options.DictionaryKeyPolicy = JsonNamingPolicy.PascalCase;` | set only `PropertyNamingPolicy`; pre-transform the dictionary; define a custom policy | dictionary keys such as `pendingOrders` become `\"PendingOrders\"` |\n| Strongly-typed metadata `JsonTypeInfo\u003CT>` | set `TypeInfoResolver = new DefaultJsonTypeInfoResolver()`, then `JsonTypeInfo\u003CT> ti = options.GetTypeInfo\u003CT>();` | `(JsonTypeInfo\u003CT>)options.GetTypeInfo(typeof(T))` | variable is typed `JsonTypeInfo\u003CT>`, no cast |\n| Probe whether metadata is resolved | `if (options.TryGetTypeInfo\u003CT>(out var ti)) { … } else { … }` | `try { options.GetTypeInfo\u003CT>(); } catch (…) { … }` | no `try`\u002F`catch`; both branches handled |\n\n## Rule 1 — PascalCase property names\n\n**When** the user wants JSON output whose property names are PascalCase (`Name`, `Age`)\nand asks for the built-in \u002F framework-provided way:\n\n1. Create or reuse a `JsonSerializerOptions` and set\n   `PropertyNamingPolicy = JsonNamingPolicy.PascalCase`.\n2. Serialize with those options.\n\nDo **not** write a `JsonNamingPolicy` subclass, do **not** add `[JsonPropertyName(\"…\")]`\nattributes to force casing, and do **not** upper-case the first letter of each name by\nhand. `JsonNamingPolicy.PascalCase` is the single correct answer on .NET 11.\n\n```csharp\n\u002F\u002F Console project (reflection enabled by default). To run this as a file-based app\n\u002F\u002F (dotnet run app.cs), also set TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n\u002F\u002F — see \"Producing runnable output\" below.\nusing System.Text.Json;\n\nvar options = new JsonSerializerOptions\n{\n    PropertyNamingPolicy = JsonNamingPolicy.PascalCase\n};\nstring json = JsonSerializer.Serialize(new { name = \"Jane\", age = 30 }, options);\nConsole.WriteLine(json);\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n```\n\n### Dictionary keys are a separate setting\n\n`PropertyNamingPolicy` does not transform `Dictionary\u003Cstring, TValue>` keys. For that\nrequest, set `DictionaryKeyPolicy`:\n\n```csharp\nvar options = new JsonSerializerOptions\n{\n    DictionaryKeyPolicy = JsonNamingPolicy.PascalCase\n};\nvar values = new Dictionary\u003Cstring, int>\n{\n    [\"pendingOrders\"] = 2,\n    [\"activeUsers\"] = 5\n};\nConsole.WriteLine(JsonSerializer.Serialize(values, options));\n\u002F\u002F {\"PendingOrders\":2,\"ActiveUsers\":5}\n```\n\n## Rule 2 — Strongly-typed `JsonTypeInfo\u003CT>`\n\n**When** the user wants type metadata back as `JsonTypeInfo\u003CT>` (not the non-generic\n`JsonTypeInfo` that needs a cast):\n\n1. Call `options.GetTypeInfo\u003CT>()` — it returns `JsonTypeInfo\u003CT>` directly.\n2. Assign it to a `JsonTypeInfo\u003CT>` variable and use it (e.g. pass it to\n   `JsonSerializer.Serialize`\u002F`Deserialize`).\n\nDo **not** call the non-generic `GetTypeInfo(Type)` overload and cast the result.\n\n> **Requires a resolver.** `GetTypeInfo\u003CT>()` throws `NotSupportedException`\n> (`NoMetadataForType`) unless the options have a `TypeInfoResolver` — set\n> `TypeInfoResolver = new DefaultJsonTypeInfoResolver()` for reflection-based apps, or use\n> a source-generated `JsonSerializerContext` for trimmed\u002FAOT apps.\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\nvar options = new JsonSerializerOptions\n{\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\n\nJsonTypeInfo\u003CPerson> typeInfo = options.GetTypeInfo\u003CPerson>();\nConsole.WriteLine(typeInfo.Type.Name); \u002F\u002F Person\n\nrecord Person(string Name, int Age);\n```\n\n## Rule 3 — Probe metadata without throwing\n\n**When** the user wants to check whether metadata for `T` is available and branch on it —\n*without* an exception being thrown when it is not:\n\n1. Call `options.TryGetTypeInfo\u003CT>(out var info)`.\n2. Handle the `true` branch (metadata resolved, use `info`) and the `false` branch\n   (not resolved) explicitly.\n\nDo **not** wrap `GetTypeInfo\u003CT>()` in `try`\u002F`catch` to detect the missing case — that is\nexactly the anti-pattern this API removes. `TryGetTypeInfo\u003CT>` returns `false` (instead of\nthrowing) when no resolver can produce metadata for `T`, which is precisely the case you\nwant to branch on.\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\n\u002F\u002F Configured with a resolver → metadata is available.\nvar configured = new JsonSerializerOptions\n{\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\nif (configured.TryGetTypeInfo\u003CPerson>(out JsonTypeInfo\u003CPerson>? info) && info is not null)\n{\n    Console.WriteLine($\"Resolved: {info.Type.Name}\"); \u002F\u002F Resolved: Person\n}\nelse\n{\n    Console.WriteLine(\"Type info not available\");\n}\n\n\u002F\u002F No resolver → TryGetTypeInfo returns false instead of throwing.\nvar empty = new JsonSerializerOptions();\nConsole.WriteLine(empty.TryGetTypeInfo\u003CPerson>(out _)); \u002F\u002F False\n\nrecord Person(string Name, int Age);\n```\n\n## Producing runnable output on `net11.0`\n\nThe task is not done until the program runs on `net11.0` and prints its JSON. Prefer a\nconsole **project** — reflection-based serialization works there out of the box. A\nfile-based app also works but has one important caveat (below).\n\nWhen the installed SDK cannot target `net11.0` and execution was requested, install an\nSDK locally with the official script and invoke it by full path. The install script is\nnon-administrative and does not persistently alter `PATH`.\n\n### Option A — console project (recommended)\n\nCreate a project whose `.csproj` contains `\u003CTargetFramework>net11.0\u003C\u002FTargetFramework>`,\nput the code in `Program.cs`, then run `dotnet run`. Confirm the process exits with code 0\nand prints the expected JSON.\n\n```csharp\nusing System.Text.Json;\n\nvar options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.PascalCase };\nConsole.WriteLine(JsonSerializer.Serialize(new { name = \"Jane\", age = 30 }, options));\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n```\n\n### Option B — file-based app (quickest, one caveat)\n\nSave as `app.cs`, then run `dotnet run app.cs`; the first directive pins the framework.\n\n> **Caveat — file-based apps disable System.Text.Json reflection.** In a `dotnet run app.cs`\n> file-based app, `JsonSerializer.IsReflectionEnabledByDefault` is `false`, so plain\n> reflection serialization throws `NotSupportedException` (`NoMetadataForType`). Set an\n> explicit `TypeInfoResolver = new DefaultJsonTypeInfoResolver()` on the options (as below),\n> or use a source-generated `JsonSerializerContext`. A regular project does **not** need this.\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\nvar options = new JsonSerializerOptions\n{\n    PropertyNamingPolicy = JsonNamingPolicy.PascalCase,\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\nConsole.WriteLine(JsonSerializer.Serialize(new { name = \"Jane\", age = 30 }, options));\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n```\n\n## Worked example — serialize with typed metadata + PascalCase\n\nThe record below uses lowercase member names on purpose, so the PascalCase policy\nvisibly rewrites them in the output:\n\n```csharp\n\u002F\u002F File-based app (run: dotnet run app.cs). In a .csproj project, remove this line and\n\u002F\u002F set \u003CTargetFramework>net11.0\u003C\u002FTargetFramework> in the project file instead.\n#:property TargetFramework=net11.0\n\nusing System.Text.Json;\nusing System.Text.Json.Serialization.Metadata;\n\nvar options = new JsonSerializerOptions\n{\n    PropertyNamingPolicy = JsonNamingPolicy.PascalCase,\n    TypeInfoResolver = new DefaultJsonTypeInfoResolver()\n};\n\nJsonTypeInfo\u003CPerson> typeInfo = options.GetTypeInfo\u003CPerson>();\nstring json = JsonSerializer.Serialize(new Person(\"Jane\", 30), typeInfo);\nConsole.WriteLine(json);\n\u002F\u002F {\"Name\":\"Jane\",\"Age\":30}\n\nrecord Person(string name, int age);\n```\n\n## Validation checklist\n\nBefore reporting success, confirm every applicable box:\n\n- [ ] The project or file-based app targets `net11.0` (visible in the `.csproj` or the\n      `#:property TargetFramework=net11.0` directive).\n- [ ] PascalCase requests use `JsonNamingPolicy.PascalCase` — no custom `JsonNamingPolicy`\n      subclass and no per-member `[JsonPropertyName]` attributes just to change casing.\n- [ ] Dictionary-key requests set `DictionaryKeyPolicy`, not only `PropertyNamingPolicy`.\n- [ ] Typed-metadata requests use the generic `GetTypeInfo\u003CT>()` — no cast of a\n      non-generic `JsonTypeInfo` — and the options set a `TypeInfoResolver` (e.g.\n      `DefaultJsonTypeInfoResolver`) so the call doesn't throw `NoMetadataForType`.\n- [ ] Probing requests use `TryGetTypeInfo\u003CT>(out …)` — no `try`\u002F`catch` around\n      `GetTypeInfo`.\n- [ ] The program was actually run (`dotnet run …`), exited 0, and its printed JSON shows\n      the expected property names (e.g. `\"Name\"`, `\"Age\"`).\n- [ ] If a **file-based app** (`dotnet run app.cs`) is used, every `JsonSerializerOptions`\n      sets a `TypeInfoResolver` — file-based apps disable reflection so plain serialization\n      throws `NoMetadataForType` without one.\n\n## Common pitfalls\n\n| Pitfall | Fix |\n| --- | --- |\n| Hand-rolling a `class … : JsonNamingPolicy` for PascalCase | Delete it; set `PropertyNamingPolicy = JsonNamingPolicy.PascalCase`. |\n| Adding `[JsonPropertyName(\"Name\")]` to every member to force casing | Remove the attributes; the naming policy handles all members at once. |\n| Casting `(JsonTypeInfo\u003CT>)options.GetTypeInfo(typeof(T))` | Call the generic `options.GetTypeInfo\u003CT>()`; no cast needed. |\n| `try { options.GetTypeInfo\u003CT>(); } catch (…) { … }` to test availability | Replace with `if (options.TryGetTypeInfo\u003CT>(out var info)) { … }`. |\n| `NotSupportedException` \u002F `NoMetadataForType` from `GetTypeInfo\u003CT>()` | The options have no resolver. Set `TypeInfoResolver = new DefaultJsonTypeInfoResolver()` (reflection) or a source-generated `JsonSerializerContext` (trim\u002FAOT). |\n| `NoMetadataForType` even for a plain `Serialize` in a `dotnet run app.cs` file-based app | File-based apps disable STJ reflection. Add `TypeInfoResolver = new DefaultJsonTypeInfoResolver()`, or run it as a normal project instead. |\n| Leaving the app on the SDK's default TFM | Pin `net11.0` explicitly so the .NET 11 APIs resolve and the output shows the target. |\n| Claiming success without running | Run `dotnet run` and paste the actual JSON output; the target is a working, executed program. |\n\n## More info\n\n- [JsonNamingPolicy class](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.jsonnamingpolicy) — built-in naming policies including `PascalCase`\n- [JsonSerializerOptions.GetTypeInfo](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.jsonserializeroptions.gettypeinfo) — typed and non-typed metadata access\n- [JsonTypeInfo\\\u003CT\\>](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.serialization.metadata.jsontypeinfo-1) — strongly-typed serialization metadata\n- [DefaultJsonTypeInfoResolver](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fapi\u002Fsystem.text.json.serialization.metadata.defaultjsontypeinforesolver) — reflection-based resolver required by `GetTypeInfo`\u002F`TryGetTypeInfo`\n- [File-based apps](https:\u002F\u002Flearn.microsoft.com\u002Fdotnet\u002Fcore\u002Fsdk\u002Ffile-based-apps) — `dotnet run app.cs` and the `#:property` directive\n",{"name":5,"license":15,"description":49},"Imperative guidance for the System.Text.Json APIs added in .NET 11: the built-in `JsonNamingPolicy.PascalCase` naming policy, and the strongly-typed generic `JsonSerializerOptions.GetTypeInfo` and `JsonSerializerOptions.TryGetTypeInfo` metadata accessors (generic overloads that return a typed `JsonTypeInfo`). USE ONLY when the user is targeting net11.0 or later and needs PascalCase JSON property or dictionary-key names without writing a custom naming policy, a strongly-typed generic `JsonTypeInfo` instead of the non-generic `JsonTypeInfo`, or a no-throw way to probe whether a type's serialization metadata is resolved. DO NOT USE when the target is earlier than net11.0, the requested behavior uses an established pre-net11 naming policy, or the user explicitly selected another JSON library.\n","main","497cc9aba79a931ac6fb8d36a48cc22fe3d6d74b","catalog\u002FPlatform\u002FOfficial-DotNet-Dotnet11\u002Fskills\u002Fsystem-text-json-net11",41,"https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills","https:\u002F\u002Fskills.managed-code.com","https:\u002F\u002Fgithub.com\u002Fmanagedcode","https:\u002F\u002Fwww.managed-code.com","Open Source Community for .NET Developers: Reliable, Actively Maintained, and Community-Driven. Made in Ukraine 🇺🇦 with ❤️","2026-11-11 19:34:28",{"source":8,"skillName":5,"commands":61,"prompt":71,"zipAvailable":72},[62,65,68],{"tool":63,"command":64},"npx","npx skills add managedcode\u002Fdotnet-skills --skill system-text-json-net11",{"tool":66,"command":67},"bunx","bunx skills add managedcode\u002Fdotnet-skills --skill system-text-json-net11",{"tool":69,"command":70},"pnpm","pnpm dlx skills add managedcode\u002Fdotnet-skills --skill system-text-json-net11","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fcatalog\u002FPlatform\u002FOfficial-DotNet-Dotnet11\u002Fskills\u002Fsystem-text-json-net11\u002FSKILL.md",true,[74],{"path":75,"resourceType":76,"resourceTypeDesc":77,"sizeBytes":78,"sourceHtmlUrl":79},"manifest.json","REFERENCE","参考文档",109,"https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fcatalog\u002FPlatform\u002FOfficial-DotNet-Dotnet11\u002Fskills\u002Fsystem-text-json-net11\u002Fmanifest.json",[81,118,141,170,180,185],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":97,"publishedAt":44},"01M6DYQE1Y9FHAQHEDTVFQ3447","xtwitter-scraper","Use XTwitterScraper when a .NET application needs typed access to Xquik's X automation REST API for tweet search, user lookup, posting workflows, extraction jobs, monitors, webhooks, or giveaway draws. USE FOR: integrating the XTwitterScraper NuGet package; reviewing Xquik API client usage; modeling API-key configuration, pagination, binary exports, raw responses, retries, and webhook\u002Fevent flows in .NET. DO NOT USE FOR: unrelated stacks; direct browser automation; generic social-media strategy; or code that does not call Xquik. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fcatalog\u002FLibraries\u002FXTwitterScraper\u002Fskills\u002Fxtwitter-scraper\u002FSKILL.md",[87,92],{"categoryNo":88,"categoryName":89,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000010","后端与接口","SCENARIO","使用场景",{"categoryNo":93,"categoryName":94,"taxonomyType":95,"taxonomyTypeDesc":96},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",[98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117],"xtwitter scraper","browser automation","workflows","run","code","browser","search","repository","api","Media","api client","access","edit","unrelated","webhooks","files","social","commands","modeling","webhook",{"skillNo":119,"name":120,"nameZh":6,"description":121,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":122,"categories":123,"keywords":130,"publishedAt":44},"01M6DYQ9S4PE1H6G8MCH9T21HR","sep","Use Sep for high-performance separated-value parsing and writing in .NET, including delimiter inference, explicit parser\u002Fwriter options, and low-allocation row\u002Fcolumn workflows. USE FOR: delimited data needs are performance-sensitive and allocation-aware; project needs explicit control over separator inference, escaping, trimming, and header behavior;. DO NOT USE FOR: unrelated stacks; generic tasks that do not need this specific guidance. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fcatalog\u002FLibraries\u002FSep\u002Fskills\u002Fsep\u002FSKILL.md",[124,127],{"categoryNo":125,"categoryName":126,"taxonomyType":90,"taxonomyTypeDesc":91},"01JBSEEDCAT000000000000018","写作与文案",{"categoryNo":128,"categoryName":129,"taxonomyType":95,"taxonomyTypeDesc":96},"01JBSEEDCAT000000000000036","内容创作者",[120,35,131,100,132,101,105,133,134,135,110,136,111,113,32,137,138,139,115,140],"performance","tasks","data","parsing","parser","context","writer","options","project","high-performance",{"skillNo":142,"name":143,"nameZh":6,"description":144,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":145,"categories":146,"keywords":147,"publishedAt":44},"01M6DZS2DNEPXCGGF6SSCW6G5V","webgpu-threejs-tsl","Comprehensive guide for developing WebGPU-enabled Three.js applications using TSL (Three.js Shading Language). Covers WebGPU renderer setup, TSL syntax and node materials, compute shaders, post-processing effects, and WGSL integration. Use this skill when working with Three.js WebGPU, TSL shaders, node materials, or GPU compute in Three.js.","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fexternal-sources\u002Fupstreams\u002Fwebgpu-claude-skill\u002Fskills\u002Fwebgpu-threejs-tsl\u002FSKILL.md",[],[148,149,150,151,152,153,154,155,156,157,158,159,37,160,161,162,163,164,165,166,27,167,168,169,24],"webgpu","threejs","webgpu threejs tsl","setup","shaders","gpu","integration","applications","js","node","syntax","guide","language","three","compute","post","processing","with","renderer","materials","wgsl","effects",{"skillNo":171,"name":172,"nameZh":6,"description":173,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":174,"categories":175,"keywords":176,"publishedAt":44},"01M6DZS0BQXW2B56A289XF1X76","roslynk","Use Roslynk for semantic inspection and edits of *.cs, *.razor and *.cshtml solution files.","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fexternal-sources\u002Fupstreams\u002Froslynk\u002Fskills\u002Froslynk\u002FSKILL.md",[],[172,37,113,177,178,27,179],"semantic","razor","inspection",{"skillNo":181,"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":182,"categories":183,"keywords":184,"publishedAt":44},"01M6DZRW6MEJCVW80K3S4XV60K","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fexternal-sources\u002Fupstreams\u002Fdotnet-skills\u002Fplugins\u002Fdotnet11\u002Fskills\u002Fsystem-text-json-net11\u002FSKILL.md",[],[19,20,21,22,35,43,42,41,40,39,38,37,36,23,34,33,32,31,30,29,28,27,26,25,24],{"skillNo":186,"name":187,"nameZh":6,"description":188,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":189,"categories":190,"keywords":193,"publishedAt":44},"01M6DZRRJP3S662NFSG1RSPQQ7","process-api-net11","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.","https:\u002F\u002Fgithub.com\u002Fmanagedcode\u002Fdotnet-skills\u002Fblob\u002Fmain\u002Fexternal-sources\u002Fupstreams\u002Fdotnet-skills\u002Fplugins\u002Fdotnet11\u002Fskills\u002Fprocess-api-net11\u002FSKILL.md",[191,192],{"categoryNo":88,"categoryName":89,"taxonomyType":90,"taxonomyTypeDesc":91},{"categoryNo":93,"categoryName":94,"taxonomyType":95,"taxonomyTypeDesc":96},[106,194,195,196,101,197,155,19,37,34,33,32,198,199,200,201,28,27,202],"process","process api net11","diagnostics","start","basic","processes","output","usage","new"]