@codingame/monaco-editor-wrapper 4.0.0-next.3 → 4.0.0

package/dist/assets/ms-dotnettools.csharp-2.16.24.vsix/package.nls.cs.json

@@ -0,0 +1,203 @@
+{
+  "command.csharp.attachToProcess": "Připojení k procesu .NET 5+ nebo .NET Core",
+  "command.csharp.downloadDebugger": "Stáhnout ladicí program .NET Core",
+  "command.csharp.listProcess": "Vypsat proces pro připojení",
+  "command.csharp.listRemoteDockerProcess": "Výpis procesů v připojení Dockeru",
+  "command.csharp.listRemoteProcess": "Vypsat procesy pro připojení na vzdáleném připojení",
+  "command.csharp.reportIssue": "Nahlásit problém",
+  "command.csharp.showDecompilationTerms": "Zobrazit smlouvu o podmínkách dekompilátoru",
+  "command.dotnet.generateAssets.currentProject": "Generovat prostředky pro sestavení a ladění",
+  "command.dotnet.openSolution": "Otevřít řešení",
+  "command.dotnet.restartServer": "Restartovat jazykový server",
+  "command.dotnet.restore.all": "Obnovit všechny projekty",
+  "command.dotnet.restore.project": "Obnovit projekt",
+  "command.dotnet.test.debugTestsInContext": "Ladit testy v Context",
+  "command.dotnet.test.runTestsInContext": "Spustit testy v Context",
+  "command.extension.showRazorCSharpWindow": "Zobrazit Razor CSharp",
+  "command.extension.showRazorHtmlWindow": "Zobrazit Razor Html",
+  "command.o.fixAll.document": "Oprava všech výskytů problému s kódem v dokumentu",
+  "command.o.fixAll.project": "Opravit všechny výskyty problému s kódem v projektu",
+  "command.o.fixAll.solution": "Opravit všechny výskyty problému s kódem v rámci řešení",
+  "command.o.pickProjectAndStart": "Vybrat projekt",
+  "command.o.reanalyze.allProjects": "Analyzovat všechny projekty",
+  "command.o.reanalyze.currentProject": "Analyzovat aktuální projekt",
+  "command.o.restart": "Restartovat OmniSharp",
+  "command.razor.reportIssue": "Nahlásit problém s Razorem",
+  "configuration.csharp.inlayHints.enableInlayHintsForImplicitObjectCreation": "Zobrazit tipy pro implicitní vytvoření objektu",
+  "configuration.csharp.inlayHints.enableInlayHintsForImplicitVariableTypes": "Zobrazit nápovědy pro proměnné s odvozenými typy",
+  "configuration.csharp.inlayHints.enableInlayHintsForIndexerParameters": "Zobrazit tipy pro indexery",
+  "configuration.csharp.inlayHints.enableInlayHintsForLambdaParameterTypes": "Zobrazit nápovědy pro typy parametrů lambda",
+  "configuration.csharp.inlayHints.enableInlayHintsForTypes": "Zobrazovat vložené nápovědy k typům",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope": "Spustit analýzu kódu na pozadí pro: (Dříve omnisharp.enableRoslynAnalyzers)",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope.fullSolution": "Celé řešení",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope.none": "Žádné",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope.openFiles": "Otevřené dokumenty",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope": "Zobrazit chyby a upozornění kompilátoru pro:",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope.fullSolution": "Celé řešení",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope.none": "Žádné",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope.openFiles": "Otevřené dokumenty",
+  "configuration.dotnet.codeLens.enableReferencesCodeLens": "Určuje, zda mají být zobrazeny odkazy CodeLens. (Dříve csharp.referencesCodeLens.enabled)",
+  "configuration.dotnet.codeLens.enableTestsCodeLens": "Určuje, jestli se má zobrazit CodeLens testu spuštění a ladění. (Dříve csharp.testsCodeLens.enabled)",
+  "configuration.dotnet.completion.provideRegexCompletions": "Umožňuje zobrazit regulární výrazy v seznamu dokončení.",
+  "configuration.dotnet.completion.showCompletionItemsFromUnimportedNamespaces": "Povolí podporu zobrazení neimportovaných typů a neimportovaných metod rozšíření v seznamech dokončení. Při potvrzení se na začátek aktuálního souboru přidá příslušná direktiva použití. (Dříve omnisharp.enableImportCompletion)",
+  "configuration.dotnet.completion.showNameCompletionSuggestions": "Pro členy, které jste nedávno vybrali, proveďte automatické dokončování názvů objektů.",
+  "configuration.dotnet.defaultSolution.description": "Cesta výchozího řešení, které se má otevřít v pracovním prostoru. Můžete přeskočit nastavením na „zakázat“. (Dříve omnisharp.defaultLaunchSolution)",
+  "configuration.dotnet.dotnetPath": "Zadává cestu k adresáři instalace dotnet, která se má použít místo výchozí systémové instalace. To má vliv pouze na instalaci dotnet, která se má použít k hostování samotného jazykového serveru. Příklad: /home/username/mycustomdotnetdirectory",
+  "configuration.dotnet.highlighting.highlightRelatedJsonComponents": "Zvýrazněte související komponenty JSON pod kurzorem.",
+  "configuration.dotnet.highlighting.highlightRelatedRegexComponents": "Zvýraznit související komponenty regulárního výrazu pod kurzorem.",
+  "configuration.dotnet.implementType.insertionBehavior": "Umístění vložení vlastností, událostí a metod při implementaci rozhraní nebo abstraktní třídy.",
+  "configuration.dotnet.implementType.insertionBehavior.atTheEnd": "Umístit je na konec.",
+  "configuration.dotnet.implementType.insertionBehavior.withOtherMembersOfTheSameKind": "Umístěte je s ostatními členy stejného druhu.",
+  "configuration.dotnet.implementType.propertyGenerationBehavior": "Chování generování vlastností při implementaci rozhraní nebo abstraktní třídy.",
+  "configuration.dotnet.implementType.propertyGenerationBehavior.preferAutoProperties": "Upřednostňovat automatické vlastnosti.",
+  "configuration.dotnet.implementType.propertyGenerationBehavior.preferThrowingProperties": "Upřednostňovat vyvolávání vlastností.",
+  "configuration.dotnet.inlayHints.enableInlayHintsForLiteralParameters": "Zobrazit nápovědy pro literály",
+  "configuration.dotnet.inlayHints.enableInlayHintsForObjectCreationParameters": "Zobrazit nápovědy pro výrazy new",
+  "configuration.dotnet.inlayHints.enableInlayHintsForOtherParameters": "Zobrazit nápovědy pro všechno ostatní",
+  "configuration.dotnet.inlayHints.enableInlayHintsForParameters": "Zobrazit tipy k názvům vložených parametrů",
+  "configuration.dotnet.inlayHints.suppressInlayHintsForParametersThatDifferOnlyBySuffix": "Potlačit nápovědy, když se název parametru liší jen předponou",
+  "configuration.dotnet.inlayHints.suppressInlayHintsForParametersThatMatchArgumentName": "Potlačit nápovědy, když argument odpovídá názvu parametru",
+  "configuration.dotnet.inlayHints.suppressInlayHintsForParametersThatMatchMethodIntent": "Potlačit nápovědy, když název parametru odpovídá záměru metody",
+  "configuration.dotnet.navigation.navigateToDecompiledSources": "Povolit navigaci na dekompilované zdroje.",
+  "configuration.dotnet.preferCSharpExtension": "Vynutí načtení projektů pouze s rozšířením jazyka C#.  To může být užitečné při použití starších typů projektů, které jazyk C# Dev Kit nepodporuje. (Vyžaduje opětovné načtení okna)",
+  "configuration.dotnet.projects.enableAutomaticRestore": "Povolí automatické obnovení balíčku NuGet, pokud rozšíření zjistí, že chybí prostředky.",
+  "configuration.dotnet.quickInfo.showRemarksInQuickInfo": "Zobrazit informace o poznámkách při zobrazení symbolu.",
+  "configuration.dotnet.server.crashDumpPath": "Nastaví cestu ke složce, do které se zapisují výpisy stavu systému, pokud dojde k chybovému ukončení jazykového serveru.  Musí být zapisovatelný uživatelem.",
+  "configuration.dotnet.server.extensionPaths": "Přepsat pro cestu k jazykovému serveru -- argumenty rozšíření",
+  "configuration.dotnet.server.path": "Určuje absolutní cestu ke spustitelnému souboru serveru (LSP nebo O#). Ponechání prázdné vede k použití verze připnuté k rozšíření C#. (Dříve omnisharp.path)",
+  "configuration.dotnet.server.startTimeout": "Určuje časový limit (v ms), aby se klient úspěšně spustil a připojil k jazykovému serveru.",
+  "configuration.dotnet.server.trace": "Nastaví úroveň protokolování pro jazykový server",
+  "configuration.dotnet.server.waitForDebugger": "Při spuštění serveru předá příznak --debug, aby bylo možné připojit ladicí program. (Dříve omnisharp.waitForDebugger)",
+  "configuration.dotnet.symbolSearch.searchReferenceAssemblies": "Hledat symboly v referenčních sestaveních Ovlivňuje funkce, které vyžadují vyhledávání symbolů, například přidání importů.",
+  "configuration.dotnet.unitTestDebuggingOptions": "Možnosti, které se mají použít s ladicím programem při spouštění pro ladění testů jednotek. (Dříve csharp.unitTestDebuggingOptions)",
+  "configuration.razor.languageServer.debug": "Určuje, jestli se má při spouštění jazykového serveru čekat na připojení ladění.",
+  "configuration.razor.languageServer.directory": "Přepíše cestu k adresáři jazykového serveru Razor.",
+  "configuration.razor.trace": "Určuje, jestli se mají vypisovat všechny zprávy [Verbose], některé zprávy [Messages] nebo vůbec [Off].",
+  "configuration.razor.trace.messages": "Zaznamená jenom některé zprávy z rozšíření Razor",
+  "configuration.razor.trace.off": "Nezaznamenává zprávy z rozšíření Razor",
+  "configuration.razor.trace.verbose": "Zaznamenává zprávy z rozšíření Razor",
+  "debuggers.coreclr.configurationSnippets.description.attach": "Připojte ladicí program .NET (coreclr) ke spuštěným procesům. Můžete to provést také pomocí příkazu „Připojit k procesu .NET 5+ nebo .NET Core“.",
+  "debuggers.coreclr.configurationSnippets.description.blazor-hosted": "Tento fragment kódu se používá ke spuštění nového procesu v ladicím programu Blazor WebAssembly (blazorwasm), který určuje cestu ke spustitelnému souboru, který se má spustit. Ve většině případů je „.NET: Spustit projekt jazyka C#“ fragment kódu lepší volbou, ale tento fragment kódu lze použít k úplné kontrole nad všemi možnostmi spuštění. Tento fragment kódu je pro hostované projekty Blazor, což je projekt, který má back-endovou aplikaci ASP.NET Core pro obsluhu svých souborů.",
+  "debuggers.coreclr.configurationSnippets.description.blazor-standalone": "Tento fragment kódu slouží ke spuštění nového procesu v ladicím programu Blazor WebAssembly (blazorwasm). Ve většině případů je „.NET: Spustit projekt jazyka C#“ fragment kódu lepší volbou, ale tento fragment kódu lze použít k úplné kontrole nad všemi možnostmi spuštění. Tento fragment kódu je pro samostatné projekty Blazor, což je projekt, který nemá back-endovou aplikaci ASP.NET Core pro obsluhu svých souborů.",
+  "debuggers.coreclr.configurationSnippets.description.console-local": "Tento fragment kódu slouží ke spuštění nového procesu v ladicím programu .NET (coreclr) a určuje cestu ke spustitelnému souboru, který se má spustit. Ve většině případů je „.NET: Spustit projekt jazyka C#“ “ fragment kódu lepší volbou. Tento fragment kódu je užitečný, když byl projekt sestaven mimo tuto instanci VS Code nebo když chcete hostovat kód .NET ve vlastním spustitelném souboru, například konkrétní verzi dotnet.exe/dotnet nebo pokud je kód .NET hostovaný nativní aplikací. Tento fragment kódu je pro konzolové aplikace.",
+  "debuggers.coreclr.configurationSnippets.description.remote": "Tento fragment kódu ukazuje, jak vzdáleně ladit kód .NET **bez** vzdálené komunikace VS Code. Měl by se používat v případech, kdy chcete projekt sestavit místně, ale spustit ho na jiném počítači.",
+  "debuggers.coreclr.configurationSnippets.description.web-local": "Tento fragment kódu slouží ke spuštění nového procesu v ladicím programu .NET (coreclr) a určuje cestu ke spustitelnému souboru, který se má spustit. Ve většině případů je „.NET: Spustit projekt jazyka C#“ “ fragment kódu lepší volbou. Tento fragment kódu je užitečný, když byl projekt sestaven mimo tuto instanci VS Code nebo když chcete hostovat kód .NET ve vlastním spustitelném souboru, například konkrétní verzi dotnet.exe/dotnet nebo pokud je kód .NET hostovaný nativní aplikací. Tento fragment kódu je pro webové aplikace (ASP.NET Core).",
+  "debuggers.coreclr.configurationSnippets.label.attach-local": ".NET: Připojení k procesu .NET",
+  "debuggers.coreclr.configurationSnippets.label.attach-remote": ".NET: Vzdálené ladění – připojení k procesu .NET",
+  "debuggers.coreclr.configurationSnippets.label.blazor-hosted": ".NET: Webové sestavení – spuštění hostovaného projektu Blazor",
+  "debuggers.coreclr.configurationSnippets.label.blazor-standalone": ".NET: Webové sestavení – spuštění samostatného projektu Blazor",
+  "debuggers.coreclr.configurationSnippets.label.console-local": ".NET: Spustit spustitelný soubor (konzola)",
+  "debuggers.coreclr.configurationSnippets.label.console-remote": ".NET: Vzdálené ladění – spustitelný soubor (konzola)",
+  "debuggers.coreclr.configurationSnippets.label.web-local": ".NET: Spustit spustitelný soubor (web)",
+  "debuggers.dotnet.configurationSnippets.description": "Tento fragment kódu konfiguruje VS Code pro ladění projektu jazyka C#. Možnosti ladění (příklad: argumenty spustitelného souboru) se dají nakonfigurovat prostřednictvím souboru „<project-directory>/Properties/launchSettings.json“.",
+  "debuggers.dotnet.configurationSnippets.label": ".NET: Spustit projekt C#",
+  "debuggers.dotnet.launch.launchConfigurationId.description": "ID konfigurace spuštění, které se má použít. Pokud je řetězec prázdný, použije se aktuální aktivní konfigurace.",
+  "debuggers.dotnet.launch.projectPath.description": "Cesta k souboru .csproj.",
+  "generateOptionsSchema.allowFastEvaluate.description": "Při hodnotě true (výchozí stav) se ladicí program pokusí o rychlejší vyhodnocení tím, že provede simulaci provádění jednoduchých vlastností a metod.",
+  "generateOptionsSchema.args.0.description": "Argumenty příkazového řádku, které se předávají do programu",
+  "generateOptionsSchema.args.1.description": "Řetězcová verze argumentů příkazového řádku, které se předávají do programu.",
+  "generateOptionsSchema.checkForDevCert.description": "Pokud spouštíte webový projekt ve Windows nebo macOS a tato možnost je povolená, ladicí program zkontroluje, jestli má počítač certifikát HTTPS podepsaný svým držitelem, který se používá k vývoji webových serverů běžících na koncových bodech HTTPS. Pokud není tato možnost zadaná, použije se při nastaveném serverReadyAction výchozí hodnota true. Tato možnost neprovádí nic v linuxových scénářích, scénářích se vzdáleným VS Code a scénářích s webovým uživatelským rozhraním VS Code. Pokud se certifikát HTTPS nenajde nebo není důvěryhodný, zobrazí se uživateli výzva k jeho instalaci nebo k důvěřování.",
+  "generateOptionsSchema.console.externalTerminal.enumDescription": "Cílový proces bude spuštěn v rámci vlastního externího terminálu. Při použití tohoto režimu bude nutné přepnout fokus mezi Visual Studio Code a oknem externího terminálu.",
+  "generateOptionsSchema.console.integratedTerminal.enumDescription": "Cílový proces bude spuštěn v integrovaném terminálu VS Code.",
+  "generateOptionsSchema.console.internalConsole.enumDescription": "Vstup (stdin) a výstup (stdout/stderr) konzoly cílového procesu se směrují přes konzolu ladění VS Code.",
+  "generateOptionsSchema.console.markdownDescription": "Označuje, do které konzoly se má cílový program spustit. Další informace najdete tady: https://aka.ms/VSCode-CS-LaunchJson-Console.",
+  "generateOptionsSchema.console.settingsDescription": "**Poznámka:** _Tato možnost se používá jenom pro projekty konzoly spuštěné s konfigurací ladění typu dotnet_.\r\n\r\nOznačuje, do které konzoly se má cílový program spustit. Další informace najdete tady: https://aka.ms/VSCode-CS-LaunchJson-Console.",
+  "generateOptionsSchema.cwd.description": "Cesta k pracovnímu adresáři laděného programu. Výchozí hodnota je aktuální pracovní prostor.",
+  "generateOptionsSchema.enableStepFiltering.markdownDescription": "Příznakem povolíte krokování nad vlastnostmi a operátory. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.env.description": "Proměnné prostředí se předaly programu.",
+  "generateOptionsSchema.envFile.markdownDescription": "Proměnné prostředí předané do programu souborem. Příklad: ${workspaceFolder}/.env",
+  "generateOptionsSchema.externalConsole.markdownDescription": "Atribut externalConsole je zastaralý.Použijte místo něj argument console. Výchozí hodnota této možnosti je false.",
+  "generateOptionsSchema.justMyCode.markdownDescription": "Pokud je tato možnost povolená (výchozí), ladicí program zobrazí a vkročí do uživatelského kódu (Můj kód), přičemž ignoruje systémový kód a další kód, který je optimalizovaný nebo který nemá symboly ladění. [Další informace](https://aka.ms/VSCode-CS-LaunchJson-JustMyCode)",
+  "generateOptionsSchema.launchBrowser.args.description": "Argumenty, které se mají předat příkazu pro otevření prohlížeče. Používá se jenom v případě, že element specifický pro platformu (osx, linux nebo windows) neurčuje hodnotu pro args. Pomocí ${auto-detect-url} můžete automaticky použít adresu, na které server naslouchá.",
+  "generateOptionsSchema.launchBrowser.description": "Popisuje možnosti spuštění webového prohlížeče v rámci spuštění.",
+  "generateOptionsSchema.launchBrowser.enabled.description": "Určuje, jestli je povolené spuštění webového prohlížeče. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.launchBrowser.linux.args.description": "Argumenty, které se mají předat příkazu pro otevření prohlížeče. Pomocí ${auto-detect-url} můžete automaticky použít adresu, na které server naslouchá.",
+  "generateOptionsSchema.launchBrowser.linux.command.description": "Spustitelný soubor, který spustí webový prohlížeč.",
+  "generateOptionsSchema.launchBrowser.linux.description": "Možnosti konfigurace spouštění webu specifické pro Linux. Ve výchozím nastavení se spustí prohlížeč pomocí příkazu xdg-open.",
+  "generateOptionsSchema.launchBrowser.osx.args.description": "Argumenty, které se mají předat příkazu pro otevření prohlížeče. Pomocí ${auto-detect-url} můžete automaticky použít adresu, na které server naslouchá.",
+  "generateOptionsSchema.launchBrowser.osx.command.description": "Spustitelný soubor, který spustí webový prohlížeč.",
+  "generateOptionsSchema.launchBrowser.osx.description": "Možnosti konfigurace spouštění webu specifické pro OSX. Ve výchozím nastavení se spustí prohlížeč pomocí příkazu open.",
+  "generateOptionsSchema.launchBrowser.windows.args.description": "Argumenty, které se mají předat příkazu pro otevření prohlížeče. Pomocí ${auto-detect-url} můžete automaticky použít adresu, na které server naslouchá.",
+  "generateOptionsSchema.launchBrowser.windows.command.description": "Spustitelný soubor, který spustí webový prohlížeč.",
+  "generateOptionsSchema.launchBrowser.windows.description": "Možnosti konfigurace spouštění webu specifické pro Windows. Ve výchozím nastavení se spustí prohlížeč pomocí příkazu cmd /c start.",
+  "generateOptionsSchema.launchSettingsFilePath.markdownDescription": "Cesta k souboru launchSettings.json. Pokud tato možnost není nastavená, ladicí program bude hledat v souboru {cwd}/Properties/launchSettings.json.",
+  "generateOptionsSchema.launchSettingsProfile.description": "Pokud je tato hodnota zadaná, označuje název profilu v souboru launchSettings.json, který se má použít. Ignoruje se, pokud se soubor launchSettings.json nenajde. Soubor launchSettings.json se bude číst ze zadané cesty, která by měla být vlastností launchSettingsFilePath, nebo {cwd}/Properties/launchSettings.json, pokud není nastavená. Pokud je tato hodnota nastavená na null nebo prázdný řetězec, soubor launchSettings.json se ignoruje. Pokud tato hodnota není zadaná, použije se první profil Project.",
+  "generateOptionsSchema.logging.browserStdOut.markdownDescription": "Příznak určující, jestli se má text stdout ze spuštění webového prohlížeče protokolovat do okna výstupu. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.logging.consoleUsageMessage.description": "Určuje, jestli se má protokolovat zpráva, když cílový proces volá rozhraní API Console.Read* a stdin se přesměruje na konzolu.",
+  "generateOptionsSchema.logging.description": "Příznaky určující, jaké typy zpráv se mají protokolovat do okna výstupu.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.all.enumDescription": "Vytisknout všechna volání rozhraní API ladicího programu. Toto je velmi podrobné.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.error.enumDescription": "Selhání tisku z volání rozhraní API ladicího programu.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.markdownDescription": "Určuje, jestli se má do výstupního okna vytisknout volání rozhraní API do Microsoft.VisualStudio.Debugger.Engine/vsdebugeng.h. Výchozí hodnota této možnosti se vrací na „none“.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.none.enumDescription": "Zakázat trasování volání rozhraní API",
+  "generateOptionsSchema.logging.diagnosticsLog.debugRuntimeEventTracing.markdownDescription": "Označit příznakem určujícím, zda má být povoleno podrobné trasování událostí vyvolaných základním modulem runtime. Výchozí hodnota této možnosti se vrací na „false“.",
+  "generateOptionsSchema.logging.diagnosticsLog.description": "Nastavení řídící to, které zprávy se vytisknou do okna výstupu z diagnostického protokolu ladicího programu. Účelem tohoto protokolu je pomoci při řešení problémů s ladicím programem.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.error.enumDescription": "Umožňuje vytisknout diagnostické zprávy na úrovni chyb.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.important.enumDescription": "Vytisknout důležité diagnostické zprávy.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.markdownDescription": "Určuje, které zprávy se vytisknou do okna výstupu z dispečera ladicího programu. Pokud se nezadá, použije se výchozí hodnota none, pokud není povolené jedno z podrobných nastavení protokolu („debugEngineAPITracing“, „debugRuntimeEventTracing“, „expressionEvaluationTracing“ nebo „startDebuggingTracing“), v takovém případě se výchozí hodnota změní na „normal“.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.none.enumDescription": "Netisknout další diagnostické zprávy.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.normal.enumDescription": "Vytisknout všechny nepodrobné diagnostické zprávy.",
+  "generateOptionsSchema.logging.diagnosticsLog.expressionEvaluationTracing.markdownDescription": "Příznak určující, zda má být povoleno podrobné trasování pro vyhodnocení výrazu. Výchozí hodnota této možnosti se vrací na „false“.",
+  "generateOptionsSchema.logging.diagnosticsLog.protocolMessages.markdownDescription": "Označit příznakem určujícím, jestli se mají zprávy protokolu DAP vyměňované mezi ladicím programem jazyka C# a uživatelským rozhraním protokolovat do okna výstupu. Výchozí hodnota této možnosti se vrací na „false“.",
+  "generateOptionsSchema.logging.diagnosticsLog.startDebuggingTracing.markdownDescription": "Příznak určující, jestli se má povolit podrobné trasování pro spuštění ladění. Výchozí hodnota této možnosti se vrací na „false“.",
+  "generateOptionsSchema.logging.elapsedTiming.markdownDescription": "Pokud je hodnota true, protokolování zpráv protokolu bude obsahovat vlastnosti „adapterElapsedTime“ a „engineElapsedTime“, které označují dobu v mikrosekundách, po kterou požadavek trval. Výchozí hodnota této možnosti se vrací na „false“.",
+  "generateOptionsSchema.logging.engineLogging.deprecationMessage": "Nastavení „logging.engineLogging“ je zastaralé a místo toho se použije „logging.diagnosticsLog.protocolMessages“.",
+  "generateOptionsSchema.logging.exceptions.markdownDescription": "Příznak určující, jestli se do okna výstupu mají protokolovat zprávy výjimek. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.logging.moduleLoad.markdownDescription": "Příznak určující, jestli se do okna výstupu mají protokolovat události načtení modulu. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.logging.processExit.markdownDescription": "Určuje, jestli se při ukončení cílového procesu nebo zastavení ladění zaprotokoluje zpráva. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.logging.programOutput.markdownDescription": "Příznak určující, jestli se má výstup programu protokolovat do okna výstupu, když nepoužíváte externí konzolu. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.logging.threadExit.markdownDescription": "Určuje, jestli se zpráva zaprotokoluje, když se ukončí vlákno v cílovém procesu. Výchozí hodnota této možnosti je false.",
+  "generateOptionsSchema.pipeTransport.debuggerPath.description": "Úplná cesta k ladicímu programu na cílovém počítači.",
+  "generateOptionsSchema.pipeTransport.description": "Pokud je k dispozici, předá ladicímu programu informaci, aby se připojil ke vzdálenému počítači pomocí dalšího spustitelného souboru jako kanál, který bude přenášet standardní vstup a výstup mezi nástrojem VS Code a spustitelným souborem back-endu ladicího programu s .NET Core (vsdbg).",
+  "generateOptionsSchema.pipeTransport.linux.description": "Možnosti konfigurace spuštění kanálu specifické pro Linux",
+  "generateOptionsSchema.pipeTransport.linux.pipeArgs.0.description": "Argumenty příkazového řádku předané programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.linux.pipeArgs.1.description": "Řetězcová verze argumentů příkazového řádku předaná programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.linux.pipeCwd.description": "Plně kvalifikovaná cesta k pracovnímu adresáři pro cílový program",
+  "generateOptionsSchema.pipeTransport.linux.pipeEnv.description": "Proměnné prostředí, které se předávají do cílového programu",
+  "generateOptionsSchema.pipeTransport.linux.pipeProgram.description": "Plně kvalifikovaný příkaz kanálu, který se má provést",
+  "generateOptionsSchema.pipeTransport.linux.quoteArgs.description": "Mají být argumenty obsahující znaky, které je třeba uvést v uvozovkách (například mezery), v uvozovkách? Výchozí hodnota je true. Pokud je nastavená hodnota false, příkaz ladicího programu už nebude automaticky v uvozovkách.",
+  "generateOptionsSchema.pipeTransport.osx.description": "Možnosti konfigurace spuštění kanálu specifické pro OSX",
+  "generateOptionsSchema.pipeTransport.osx.pipeArgs.0.description": "Argumenty příkazového řádku předané programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.osx.pipeArgs.1.description": "Řetězcová verze argumentů příkazového řádku předaná programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.osx.pipeCwd.description": "Plně kvalifikovaná cesta k pracovnímu adresáři pro cílový program",
+  "generateOptionsSchema.pipeTransport.osx.pipeEnv.description": "Proměnné prostředí, které se předávají do cílového programu",
+  "generateOptionsSchema.pipeTransport.osx.pipeProgram.description": "Plně kvalifikovaný příkaz kanálu, který se má provést",
+  "generateOptionsSchema.pipeTransport.osx.quoteArgs.description": "Mají být argumenty obsahující znaky, které je třeba uvést v uvozovkách (například mezery), v uvozovkách? Výchozí hodnota je true. Pokud je nastavená hodnota false, příkaz ladicího programu už nebude automaticky v uvozovkách.",
+  "generateOptionsSchema.pipeTransport.pipeArgs.0.description": "Argumenty příkazového řádku předané programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.pipeArgs.1.description": "Řetězcová verze argumentů příkazového řádku předaná programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.pipeCwd.description": "Plně kvalifikovaná cesta k pracovnímu adresáři pro cílový program",
+  "generateOptionsSchema.pipeTransport.pipeEnv.description": "Proměnné prostředí, které se předávají do cílového programu",
+  "generateOptionsSchema.pipeTransport.pipeProgram.description": "Plně kvalifikovaný příkaz kanálu, který se má provést",
+  "generateOptionsSchema.pipeTransport.quoteArgs.description": "Mají být argumenty obsahující znaky, které je třeba uvést v uvozovkách (například mezery), v uvozovkách? Výchozí hodnota je true. Pokud je nastavená hodnota false, příkaz ladicího programu už nebude automaticky v uvozovkách.",
+  "generateOptionsSchema.pipeTransport.windows.description": "Možnosti konfigurace spuštění kanálu specifické pro Windows",
+  "generateOptionsSchema.pipeTransport.windows.pipeArgs.0.description": "Argumenty příkazového řádku předané programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.windows.pipeArgs.1.description": "Řetězcová verze argumentů příkazového řádku předaná programu kanálu. Token ${debuggerCommand} v pipeArgs se nahradí úplným příkazem ladicího programu. Tento token je možné zadat jako vložený s jinými argumenty. Pokud se v žádném argumentu nepoužije ${debuggerCommand}, přidá se na konec seznamu argumentů úplný příkaz ladicího programu.",
+  "generateOptionsSchema.pipeTransport.windows.pipeCwd.description": "Plně kvalifikovaná cesta k pracovnímu adresáři pro cílový program",
+  "generateOptionsSchema.pipeTransport.windows.pipeEnv.description": "Proměnné prostředí, které se předávají do cílového programu",
+  "generateOptionsSchema.pipeTransport.windows.pipeProgram.description": "Plně kvalifikovaný příkaz kanálu, který se má provést",
+  "generateOptionsSchema.pipeTransport.windows.quoteArgs.description": "Mají být argumenty obsahující znaky, které je třeba uvést v uvozovkách (například mezery), v uvozovkách? Výchozí hodnota je true. Pokud je nastavená hodnota false, příkaz ladicího programu už nebude automaticky v uvozovkách.",
+  "generateOptionsSchema.processId.0.markdownDescription": "ID procesu, ke kterému má proběhnout připojení. Pomocí \"\" získáte seznam spuštěných procesů, ke kterým se dá připojit. Pokud se použije processId, nemělo by se používat processName.",
+  "generateOptionsSchema.processId.1.markdownDescription": "ID procesu, ke kterému má proběhnout připojení. Pomocí \"\" získáte seznam spuštěných procesů, ke kterým se dá připojit. Pokud se použije processId, nemělo by se používat processName.",
+  "generateOptionsSchema.processName.markdownDescription": "Název procesu, ke kterému má proběhnout připojení. Pokud se používá tato hodnota, nemělo by se používat processId.",
+  "generateOptionsSchema.program.markdownDescription": "Cesta ke spustitelnému souboru knihovny .DLL aplikace nebo hostitele .NET Core, který se má spustit.\r\nTato vlastnost má obvykle tvar: ${workspaceFolder}/bin/Debug/(target-framework)/(project-name.dll)\r\n\r\nPříklad: ${workspaceFolder}/bin/Debug/netcoreapp1.1/MyProject.dll\r\n\r\nKde:\r\n(target-framework) je architektura, pro kterou se laděný projekt sestavuje. Obvykle se v souboru projektu nachází jako vlastnost TargetFramework.\r\n\r\n(project-name.dll) je název výstupní knihovny .DLL sestavení laděného projektu. Obvykle je stejný jako název souboru projektu, ale s příponou .dll.",
+  "generateOptionsSchema.requireExactSource.markdownDescription": "Příznak, který vyžaduje, aby aktuální zdrojový kód odpovídal souboru pdb. Výchozí hodnota této možnosti je true.",
+  "generateOptionsSchema.sourceFileMap.markdownDescription": "Mapuje cesty k místním zdrojovým umístěním v době sestavení (build-time). Všechny instance cesty v době sestavení budou nahrazeny místní zdrojovou cestou.\r\n\r\nPříklad:\r\n\r\n{\"<build-path>\":\"<local-source-path>\"}",
+  "generateOptionsSchema.sourceLinkOptions.additionalItems.enabled.markdownDescription": "Je pro tuto adresu URL povolený nástroj Source Link? Pokud je tato možnost nezadaná, výchozí hodnota je true.",
+  "generateOptionsSchema.sourceLinkOptions.markdownDescription": "Možnosti řízení způsobu připojení Source Link k webovým serverům. [Další informace](https://aka.ms/VSCode-DotNet-SourceLink)",
+  "generateOptionsSchema.stopAtEntry.markdownDescription": "Při hodnotě true by se ladicí program měl zastavit na vstupním bodu cíle. Výchozí hodnota této možnosti je false.",
+  "generateOptionsSchema.suppressJITOptimizations.markdownDescription": "Pokud je hodnota nastavená na true, při načtení optimalizovaného modulu (.dll zkompilovaného v konfiguraci verze) v cílovém procesu ladicí program požádá kompilátor JIT o vygenerování kódu se zakázanými optimalizacemi. [Další informace](https://aka.ms/VSCode-CS-LaunchJson-SuppressJITOptimizations)",
+  "generateOptionsSchema.symbolOptions.cachePath.description": "Adresář, do kterého by se měly ukládat symboly stažené ze serverů se symboly. Pokud není zadaný, bude výchozí ladicí program systému Windows %TEMP% \\SymbolCache a systémů Linux a macOS ~/.dotnet/symbolcache.",
+  "generateOptionsSchema.symbolOptions.description": "Možnosti kontroly způsobu, jakým se hledají a načítají symboly (soubory .pdb).",
+  "generateOptionsSchema.symbolOptions.moduleFilter.description": "Poskytuje možnosti pro kontrolu, pro které moduly (soubory DLL) se ladicí program pokusí načíst symboly (soubory. pdb).",
+  "generateOptionsSchema.symbolOptions.moduleFilter.excludedModules.description": "Pole modulů, pro které by ladicí program neměl načítat symboly. Zástupné znaky (například: MyCompany. *.DLL) jsou podporovány.\r\n\r\nTato vlastnost je ignorována, pokud není „mode“ nastaven na hodnotu „loadAllButExcluded“.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.includeSymbolsNextToModules.description": "Pokud má hodnotu true, u libovolného modulu, který není v poli „includedModules“, bude ladicí program stále provádět kontrolu vedle samotného modulu a spouštěcího souboru, ale nebude kontrolovat cesty v seznamu hledání symbolů. Tato možnost je standardně nastavena na hodnotu true.\r\n\r\nTato vlastnost je ignorována, pokud není „mode“ nastaven na hodnotu „loadOnlyIncluded“.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.includedModules.description": "Pole modulů, pro které má ladicí program načíst symboly. Zástupné znaky (například: MyCompany. *.DLL) jsou podporovány.\r\n\r\nTato vlastnost je ignorována, pokud není „mode“ nastaven na hodnotu „loadOnlyIncluded“.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.mode.description": "Určuje, v jakém ze dvou základních operačních režimů pracuje filtr modulu.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.mode.loadAllButExcluded.enumDescription": "Načte symboly pro všechny moduly, pokud není modul v poli „excludedModules“.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.mode.loadOnlyIncluded.enumDescription": "Nepokoušejte se načíst symboly pro ŽÁDNÝ modul, pokud není v poli „includedModules“, nebo je součástí nastavení „includeSymbolsNextToModules“.",
+  "generateOptionsSchema.symbolOptions.searchMicrosoftSymbolServer.description": "Pokud je hodnota true, přidá se do cesty pro hledání symbolů server symbolů pro produkty Microsoft (https​://msdl.microsoft.com​/download/symbols). Pokud tato možnost není zadaná, výchozí hodnota je false.",
+  "generateOptionsSchema.symbolOptions.searchNuGetOrgSymbolServer.description": "Pokud je hodnota true, přidá se do cesty pro hledání symbolů server symbolů pro NuGet.org (https​://symbols.nuget.org​/download/symbols). Pokud tato možnost není zadaná, výchozí hodnota je false.",
+  "generateOptionsSchema.symbolOptions.searchPaths.description": "Pole adres URL serveru symbolů (například: http​://MyExampleSymbolServer) nebo adresářů (příklad: /build/symbols) k vyhledávání souborů .pdb. Tyto adresáře budou prohledány spolu s výchozími umístěními – vedle modulu a cesty, kam byl soubor pdb původně přemístěn.",
+  "generateOptionsSchema.targetArchitecture.markdownDescription": "[Podporováno pouze v místním ladění macOS]\r\n\r\nArchitektura laděného procesu. Tato chyba se automaticky zjistí, pokud není tento parametr nastavený. Povolené hodnoty jsou x86_64 nebo arm64.",
+  "generateOptionsSchema.targetOutputLogPath.description": "Při nastavení této možnosti se text, který cílová aplikace zapisuje do stdout a stderr (např. Console.WriteLine), uloží do zadaného souboru. Tato možnost se bude ignorovat, pokud je konzola nastavená na jinou hodnotu než internalConsole. Příklad: ${workspaceFolder}/out.txt",
+  "viewsWelcome.debug.contents": "[Generování prostředků jazyka C# pro sestavení a ladění](command:dotnet.generateAssets)\r\n\r\nDalší informace o souboru launch.json najdete v tématu [Konfigurace souboru launch.json pro ladění v jazyce C#](https://aka.ms/VSCode-CS-LaunchJson)."
+}

package/dist/assets/ms-dotnettools.csharp-2.16.24.vsix/package.nls.de.json

@@ -0,0 +1,203 @@
+{
+  "command.csharp.attachToProcess": "An einen .NET 5+ oder .NET Core-Prozess anfügen",
+  "command.csharp.downloadDebugger": ".NET Core-Debugger herunterladen",
+  "command.csharp.listProcess": "Prozess zum Anfügen auflisten",
+  "command.csharp.listRemoteDockerProcess": "Prozesse für Docker-Verbindung auflisten",
+  "command.csharp.listRemoteProcess": "Prozesse für Remoteverbindung zum Anfügen auflisten",
+  "command.csharp.reportIssue": "Ein Problem melden",
+  "command.csharp.showDecompilationTerms": "Vereinbarung zu den Decompilerbedingungen anzeigen",
+  "command.dotnet.generateAssets.currentProject": "Ressourcen für Build und Debuggen generieren",
+  "command.dotnet.openSolution": "Projektmappe öffnen",
+  "command.dotnet.restartServer": "Sprachserver neu starten",
+  "command.dotnet.restore.all": "Alle Projekte wiederherstellen",
+  "command.dotnet.restore.project": "Projekt wiederherstellen",
+  "command.dotnet.test.debugTestsInContext": "Tests im Kontext debuggen",
+  "command.dotnet.test.runTestsInContext": "Tests im Kontext ausführen",
+  "command.extension.showRazorCSharpWindow": "Razor CSharp anzeigen",
+  "command.extension.showRazorHtmlWindow": "Razor-HTML anzeigen",
+  "command.o.fixAll.document": "Alle Vorkommen eines Codeproblems innerhalb des Dokuments beheben",
+  "command.o.fixAll.project": "Alle Vorkommen eines Codeproblems innerhalb des Projekts beheben",
+  "command.o.fixAll.solution": "Alle Vorkommen eines Codeproblems innerhalb der Projektmappe beheben",
+  "command.o.pickProjectAndStart": "Projekt auswählen",
+  "command.o.reanalyze.allProjects": "Alle Projekte analysieren",
+  "command.o.reanalyze.currentProject": "Aktuelles Projekt analysieren",
+  "command.o.restart": "OmniSharp neu starten",
+  "command.razor.reportIssue": "Razor-Problem melden",
+  "configuration.csharp.inlayHints.enableInlayHintsForImplicitObjectCreation": "Hinweise für die implizite Objekterstellung anzeigen",
+  "configuration.csharp.inlayHints.enableInlayHintsForImplicitVariableTypes": "Hinweise für Variablen mit abgeleiteten Typen anzeigen",
+  "configuration.csharp.inlayHints.enableInlayHintsForIndexerParameters": "Hinweise für Indexer anzeigen",
+  "configuration.csharp.inlayHints.enableInlayHintsForLambdaParameterTypes": "Hinweise für Lambda-Parametertypen anzeigen",
+  "configuration.csharp.inlayHints.enableInlayHintsForTypes": "Inlinetyphinweise anzeigen",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope": "Ausführen der Hintergrundcodeanalyse für: (Zuvor \"omnisharp.enableRoslynAnalyzers\")",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope.fullSolution": "Gesamte Projektmappe",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope.none": "Keine",
+  "configuration.dotnet.backgroundAnalysis.analyzerDiagnosticsScope.openFiles": "Geöffnete Dokumente",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope": "Compilerfehler und -warnungen anzeigen für:",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope.fullSolution": "Gesamte Projektmappe",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope.none": "Keine",
+  "configuration.dotnet.backgroundAnalysis.compilerDiagnosticsScope.openFiles": "Geöffnete Dokumente",
+  "configuration.dotnet.codeLens.enableReferencesCodeLens": "Gibt an, ob die Verweise auf CodeLens angezeigt werden sollen. (Zuvor \"csharp.referencesCodeLens.enabled\")",
+  "configuration.dotnet.codeLens.enableTestsCodeLens": "Gibt an, ob der CodeLens-Test zum Ausführen und Debuggen angezeigt werden soll. (Zuvor \"csharp.testsCodeLens.enabled\")",
+  "configuration.dotnet.completion.provideRegexCompletions": "Reguläre Ausdrücke in der Vervollständigungsliste anzeigen.",
+  "configuration.dotnet.completion.showCompletionItemsFromUnimportedNamespaces": "Ermöglicht die Anzeige nicht importierter Typen und nicht importierter Erweiterungsmethoden in Vervollständigungslisten. Wenn ein Commit ausgeführt wird, wird die entsprechende using-Direktive am Anfang der aktuellen Datei hinzugefügt. (Zuvor \"omnisharp.enableImportCompletion\")",
+  "configuration.dotnet.completion.showNameCompletionSuggestions": "Führen Sie die automatische Vervollständigung des Objektnamens für die Elemente aus, die Sie kürzlich ausgewählt haben.",
+  "configuration.dotnet.defaultSolution.description": "Der Pfad der Standardlösung, die im Arbeitsbereich geöffnet werden soll, oder auf \"deaktivieren\" festlegen, um sie zu überspringen. (Zuvor \"omnisharp.defaultLaunchSolution\")",
+  "configuration.dotnet.dotnetPath": "Gibt den Pfad zu einem dotnet-Installationsverzeichnis an, das anstelle des Standardsystems verwendet werden soll. Dies wirkt sich nur auf die dotnet-Installation aus, die zum Hosten des Sprachservers selbst verwendet werden soll. Beispiel: \"/home/username/mycustomdotnetdirectory\".",
+  "configuration.dotnet.highlighting.highlightRelatedJsonComponents": "Zugehörige JSON-Komponenten unter dem Cursor markieren.",
+  "configuration.dotnet.highlighting.highlightRelatedRegexComponents": "Zugehörige Komponenten regulärer Ausdrücke unter dem Cursor markieren.",
+  "configuration.dotnet.implementType.insertionBehavior": "Die Einfügeposition von Eigenschaften, Ereignissen und Methoden beim Implementieren der Schnittstelle oder abstrakten Klasse.",
+  "configuration.dotnet.implementType.insertionBehavior.atTheEnd": "Platzieren Sie sie am Ende.",
+  "configuration.dotnet.implementType.insertionBehavior.withOtherMembersOfTheSameKind": "Platzieren Sie sie mit anderen Mitgliedern derselben Art.",
+  "configuration.dotnet.implementType.propertyGenerationBehavior": "Generierungsverhalten von Eigenschaften beim Implementieren einer Schnittstelle oder einer abstrakten Klasse.",
+  "configuration.dotnet.implementType.propertyGenerationBehavior.preferAutoProperties": "Automatische Eigenschaften bevorzugen.",
+  "configuration.dotnet.implementType.propertyGenerationBehavior.preferThrowingProperties": "Ausgelöste Eigenschaften bevorzugen.",
+  "configuration.dotnet.inlayHints.enableInlayHintsForLiteralParameters": "Hinweise für Literale anzeigen",
+  "configuration.dotnet.inlayHints.enableInlayHintsForObjectCreationParameters": "Hinweise für new-Ausdrücke anzeigen",
+  "configuration.dotnet.inlayHints.enableInlayHintsForOtherParameters": "Hinweise für alles andere anzeigen",
+  "configuration.dotnet.inlayHints.enableInlayHintsForParameters": "Hinweise zu Inlineparameternamen anzeigen",
+  "configuration.dotnet.inlayHints.suppressInlayHintsForParametersThatDifferOnlyBySuffix": "Hinweise unterdrücken, wenn sich Parameternamen nur durch das Suffix unterscheiden",
+  "configuration.dotnet.inlayHints.suppressInlayHintsForParametersThatMatchArgumentName": "Hinweise unterdrücken, wenn das Argument mit dem Namen des Parameters übereinstimmt",
+  "configuration.dotnet.inlayHints.suppressInlayHintsForParametersThatMatchMethodIntent": "Hinweise unterdrücken, wenn der Parametername mit der Methodenabsicht übereinstimmt",
+  "configuration.dotnet.navigation.navigateToDecompiledSources": "Aktivieren der Navigation zu dekompilierten Quellen.",
+  "configuration.dotnet.preferCSharpExtension": "Erzwingt, dass Projekte nur mit der C#-Erweiterung geladen werden.  Dies kann nützlich sein, wenn Legacy-Projekttypen verwendet werden, die vom C# Dev Kit nicht unterstützt werden. (Erfordert erneutes Laden des Fensters)",
+  "configuration.dotnet.projects.enableAutomaticRestore": "Aktiviert die automatische NuGet-Wiederherstellung, wenn die Erweiterung erkennt, dass Ressourcen fehlen.",
+  "configuration.dotnet.quickInfo.showRemarksInQuickInfo": "Beschreibungsinformationen beim Anzeigen des Symbols anzeigen.",
+  "configuration.dotnet.server.crashDumpPath": "Legt einen Ordnerpfad fest, in den Absturzabbilder geschrieben werden, wenn der Sprachserver abstürzt.  Muss vom Benutzer beschreibbar sein.",
+  "configuration.dotnet.server.extensionPaths": "Außerkraftsetzung für Pfad zu Sprachserver --extension-Argumenten",
+  "configuration.dotnet.server.path": "Gibt den absoluten Pfad zur ausführbaren Serverdatei (LSP oder O#) an. Wenn sie leer gelassen wird, wird die an die C#-Erweiterung angeheftete Version verwendet. (Zuvor \"omnisharp.path\")",
+  "configuration.dotnet.server.startTimeout": "Gibt ein Timeout (in ms) an, mit dem der Client erfolgreich gestartet und eine Verbindung mit dem Sprachserver hergestellt werden kann.",
+  "configuration.dotnet.server.trace": "Legt den Protokolliergrad für den Sprachserver fest.",
+  "configuration.dotnet.server.waitForDebugger": "Übergibt das Flag \"--debug\" beim Starten des Servers, damit ein Debugger angefügt werden kann. (Zuvor \"omnisharp.waitForDebugger\")",
+  "configuration.dotnet.symbolSearch.searchReferenceAssemblies": "Symbole in Verweisassemblys suchen. Dies wirkt sich auf Features aus, die eine Symbolsuche erfordern, z. B. Importe hinzufügen.",
+  "configuration.dotnet.unitTestDebuggingOptions": "Optionen, die mit dem Debugger beim Starten des Komponententestdebuggings verwendet werden können. (Zuvor \"csharp.unitTestDebuggingOptions\")",
+  "configuration.razor.languageServer.debug": "Gibt an, ob beim Starten des Sprachservers auf die Debuganfügung gewartet werden soll.",
+  "configuration.razor.languageServer.directory": "Überschreibt den Pfad zum Razor-Sprachserver-Verzeichnis.",
+  "configuration.razor.trace": "Gibt an, ob alle Nachrichten [Verbose], einige Nachrichten [Messages] oder gar nicht [Off] ausgegeben werden sollen.",
+  "configuration.razor.trace.messages": "Protokolliert nur einige Nachrichten von der Razor-Erweiterung.",
+  "configuration.razor.trace.off": "Protokolliert keine Nachrichten von der Razor-Erweiterung.",
+  "configuration.razor.trace.verbose": "Protokolliert alle Nachrichten aus der Razor-Erweiterung.",
+  "debuggers.coreclr.configurationSnippets.description.attach": "Fügen Sie den .NET-Debugger (coreclr) an einen laufenden Prozess an. Dies kann auch mit dem Befehl \"An einen .NET 5+- oder .NET Core-Prozess anfügen\" erfolgen.",
+  "debuggers.coreclr.configurationSnippets.description.blazor-hosted": "Dieser Codeschnipsel wird verwendet, um einen neuen Prozess unter dem Blazor WebAssembly-Debugger (blazorwasm) zu starten. Dabei wird der Pfad zu der ausführbaren Datei angegeben, die gestartet werden soll. In den meisten Fällen ist der Codeschnipsel \".NET: C#-Projekt starten\" die bessere Wahl. Dieser Codeschnipsel kann jedoch verwendet werden, um Vollzugriff auf alle Startoptionen zu erhalten. Dieser Codeschnipsel ist für gehostete Blazor-Projekte vorgesehen. Dabei handelt es sich um ein Projekt, das im Back-End über eine ASP.NET Core-App zum Verarbeiten der Dateien verfügt.",
+  "debuggers.coreclr.configurationSnippets.description.blazor-standalone": "Dieser Codeschnipsel wird verwendet, um einen neuen Prozess unter dem Blazor WebAssembly-Debugger (blazorwasm) zu starten. In den meisten Fällen ist der Codeschnipsel \".NET: C#-Projekt starten\" die bessere Wahl. Dieser Codeschnipsel kann jedoch verwendet werden, um Vollzugriff auf alle Startoptionen zu erhalten. Dieser Codeschnipsel ist für eigenständige Blazor-Projekte vorgesehen. Dabei handelt es sich um ein Projekt, das im Back-End über keine ASP.NET Core-App zum Verarbeiten der Dateien verfügt.",
+  "debuggers.coreclr.configurationSnippets.description.console-local": "Dieser Codeschnipsel wird verwendet, um einen neuen Prozess unter dem .NET-Debugger (coreclr) zu starten. Dabei wird der Pfad zu der ausführbaren Datei angegeben, die gestartet werden soll. In den meisten Fällen ist der Codeschnipsel \".NET: C#-Projekt starten\" die bessere Wahl. Dieser Codeschnipsel ist nützlich, wenn das Projekt außerhalb dieser VS Code-Instanz erstellt wurde, wenn Sie Ihren .NET-Code in einer benutzerdefinierten ausführbaren Datei (z. B. in einer bestimmten Version von \"dotnet.exe\"/\"dotnet\") hosten möchten oder wenn der .NET-Code von einer nativen Anwendung gehostet wird. Dieser Codeschnipsel ist für Konsolenanwendungen vorgesehen.",
+  "debuggers.coreclr.configurationSnippets.description.remote": "Dieser Codeschnipsel zeigt, wie Sie ein Remotedebuggen von .NET Code **ohne** die Remotefunktion von VS Code durchführen. Dies sollte in Fällen verwendet werden, in denen Sie Ihr Projekt lokal erstellen, aber auf einem anderen Computer ausführen möchten.",
+  "debuggers.coreclr.configurationSnippets.description.web-local": "Dieser Codeschnipsel wird verwendet, um einen neuen Prozess unter dem .NET-Debugger (coreclr) zu starten. Dabei wird der Pfad zu der ausführbaren Datei angegeben, die gestartet werden soll. In den meisten Fällen ist der Codeschnipsel \".NET: C#-Projekt starten\" die bessere Wahl. Dieser Codeschnipsel ist nützlich, wenn das Projekt außerhalb dieser VS Code-Instanz erstellt wurde, wenn Sie Ihren .NET-Code in einer benutzerdefinierten ausführbaren Datei (z. B. in einer bestimmten Version von \"dotnet.exe\"/\"dotnet\") hosten möchten oder wenn der .NET-Code von einer nativen Anwendung gehostet wird. Dieser Codeschnipsel ist für Webanwendungen (ASP.NET Core) geeignet.",
+  "debuggers.coreclr.configurationSnippets.label.attach-local": ".NET: An einen .NET-Prozess anfügen",
+  "debuggers.coreclr.configurationSnippets.label.attach-remote": ".NET: Remotedebuggen – An .NET-Prozess anfügen",
+  "debuggers.coreclr.configurationSnippets.label.blazor-hosted": ".NET: Webassembly – Gehostetes Blazor-Projekt starten",
+  "debuggers.coreclr.configurationSnippets.label.blazor-standalone": ".NET: Webassembly – Eigenständiges Blazor-Projekt starten",
+  "debuggers.coreclr.configurationSnippets.label.console-local": ".NET: Ausführbare Datei starten (Konsole)",
+  "debuggers.coreclr.configurationSnippets.label.console-remote": ".NET: Remotedebuggen – Ausführbare Datei starten (Konsole)",
+  "debuggers.coreclr.configurationSnippets.label.web-local": ".NET: Ausführbare Datei starten (Web)",
+  "debuggers.dotnet.configurationSnippets.description": "Dieser Codeschnipsel konfiguriert VS Code für das Debuggen eines C#-Projekts. Debugoptionen (zum Beispiel Argumente für die ausführbare Datei) können über die Datei '<project-directory>/Properties/launchSettings.json' konfiguriert werden.",
+  "debuggers.dotnet.configurationSnippets.label": ".NET: C#-Projekt starten",
+  "debuggers.dotnet.launch.launchConfigurationId.description": "Die zu verwendende Startkonfigurations-ID. Eine leere Zeichenfolge verwendet die aktuelle aktive Konfiguration.",
+  "debuggers.dotnet.launch.projectPath.description": "Pfad zur CSPROJ-Datei.",
+  "generateOptionsSchema.allowFastEvaluate.description": "Bei \"true\" (Standardzustand) versucht der Debugger eine schnellere Auswertung, indem er die Ausführung einfacher Eigenschaften und Methoden simuliert.",
+  "generateOptionsSchema.args.0.description": "Befehlszeilenargumente, die an das Programm übergeben werden.",
+  "generateOptionsSchema.args.1.description": "An das Programm übergebene Zeichenfolgenversion von Befehlszeilenargumenten.",
+  "generateOptionsSchema.checkForDevCert.description": "Wenn Sie ein Webprojekt unter Windows oder macOS starten und dies aktiviert ist, überprüft der Debugger, ob der Computer über ein selbstsigniertes HTTPS-Zertifikat verfügt, das zum Entwickeln von Webservern verwendet wird, die auf HTTPS-Endpunkten ausgeführt werden. Wenn nicht angegeben, wird standardmäßig \"true\" verwendet, wenn \"serverReadyAction\" festgelegt ist. Mit dieser Option werden keine Linux-, VS Code-Remote- und VS Code-Webbenutzeroberflächenszenarien ausgeführt. Wenn das HTTPS-Zertifikat nicht gefunden wird oder nicht vertrauenswürdig ist, wird der Benutzer aufgefordert, es zu installieren bzw. ihm zu vertrauen.",
+  "generateOptionsSchema.console.externalTerminal.enumDescription": "Der Zielprozess wird in einem eigenen externen Terminal ausgeführt. Wenn Sie diesen Modus verwenden, müssen Sie den Fokus zwischen Visual Studio Code und dem externen Terminalfenster wechseln.",
+  "generateOptionsSchema.console.integratedTerminal.enumDescription": "Der Zielprozess wird im integrierten Terminal VS Code ausgeführt.",
+  "generateOptionsSchema.console.internalConsole.enumDescription": "Die Konsoleneingabe (stdin) und die Ausgabe (stdout/stderr) des Zielprozesses werden über die VS Code Debugging-Konsole weitergeleitet.",
+  "generateOptionsSchema.console.markdownDescription": "Gibt an, in welcher Konsole das Zielprogramm gestartet werden soll. Weitere Informationen finden Sie unter „https://aka.ms/VSCode-CS-LaunchJson-Console“.",
+  "generateOptionsSchema.console.settingsDescription": "**Hinweis:** _Diese Option wird nur für Konsolenprojekte verwendet, die mit der Debugkonfiguration vom Typ „dotnet“ gestartet wurden_.\r\n\r\nGibt an, in welcher Konsole das Zielprogramm gestartet werden soll. Weitere Informationen finden Sie unter „https://aka.ms/VSCode-CS-LaunchJson-Console“.",
+  "generateOptionsSchema.cwd.description": "Pfad zum Arbeitsverzeichnis des Programms, das gedebuggt wird. Der Standardwert ist der aktuelle Arbeitsbereich.",
+  "generateOptionsSchema.enableStepFiltering.markdownDescription": "Kennzeichnung zum Aktivieren des Schrittweisen Ausführens von Eigenschaften und Operatoren. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.env.description": "Umgebungsvariablen, die an das Programm übergeben werden.",
+  "generateOptionsSchema.envFile.markdownDescription": "Umgebungsvariablen, die von einer Datei an das Programm übergeben werden. Beispiel: \"${workspaceFolder}/.env\"",
+  "generateOptionsSchema.externalConsole.markdownDescription": "Das Attribut \"externalConsole\" ist veraltet. Verwenden Sie stattdessen \"console\". Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.justMyCode.markdownDescription": "Wenn diese Option aktiviert ist (Standardeinstellung), wird der Debugger nur angezeigt und in den Benutzercode (\"Mein Code\") eingeschritten. Dabei werden Systemcode und anderer Code ignoriert, der optimiert ist oder über keine Debugsymbole verfügt. [Weitere Informationen](https://aka.ms/VSCode-CS-LaunchJson-JustMyCode)",
+  "generateOptionsSchema.launchBrowser.args.description": "Die Argumente, die an den Befehl übergeben werden sollen, um den Browser zu öffnen. Dies wird nur verwendet, wenn das plattformspezifische Element (\"osx\", \"linux\" oder \"windows\") keinen Wert für \"args\" angibt. Verwenden Sie ${auto-detect-url}, um automatisch die Adresse zu verwenden, an der der Server lauscht.",
+  "generateOptionsSchema.launchBrowser.description": "Beschreibt Optionen zum Starten eines Webbrowsers als Teil des Starts.",
+  "generateOptionsSchema.launchBrowser.enabled.description": "Gibt an, ob das Starten des Webbrowsers aktiviert ist. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.launchBrowser.linux.args.description": "Die Argumente, die an den Befehl übergeben werden sollen, um den Browser zu öffnen. Verwenden Sie ${auto-detect-url}, um automatisch die Adresse zu verwenden, an der der Server lauscht.",
+  "generateOptionsSchema.launchBrowser.linux.command.description": "Die ausführbare Datei, die den Webbrowser startet.",
+  "generateOptionsSchema.launchBrowser.linux.description": "Linux-spezifische Optionen für Webstartkonfiguration. Der Browser wird standardmäßig mit \"xdg-open\" gestartet.",
+  "generateOptionsSchema.launchBrowser.osx.args.description": "Die Argumente, die an den Befehl übergeben werden sollen, um den Browser zu öffnen. Verwenden Sie ${auto-detect-url}, um automatisch die Adresse zu verwenden, an der der Server lauscht.",
+  "generateOptionsSchema.launchBrowser.osx.command.description": "Die ausführbare Datei, die den Webbrowser startet.",
+  "generateOptionsSchema.launchBrowser.osx.description": "OSX-spezifische Optionen für Webstartkonfiguration. Der Browser wird standardmäßig mit \"open\" gestartet.",
+  "generateOptionsSchema.launchBrowser.windows.args.description": "Die Argumente, die an den Befehl übergeben werden sollen, um den Browser zu öffnen. Verwenden Sie ${auto-detect-url}, um automatisch die Adresse zu verwenden, an der der Server lauscht.",
+  "generateOptionsSchema.launchBrowser.windows.command.description": "Die ausführbare Datei, die den Webbrowser startet.",
+  "generateOptionsSchema.launchBrowser.windows.description": "Windows-spezifische Optionen für Webstartkonfiguration. Der Browser wird standardmäßig mit \"cmd /c start\" gestartet.",
+  "generateOptionsSchema.launchSettingsFilePath.markdownDescription": "Der Pfad zu einer Datei \"launchSettings.json\". Wenn dies nicht festgelegt ist, sucht der Debugger in \"{cwd}/Properties/launchSettings.json\".",
+  "generateOptionsSchema.launchSettingsProfile.description": "Gibt bei Angabe den Namen des Profils in \"launchSettings.json\" an, das verwendet werden soll. Dies wird ignoriert, wenn launchSettings.json nicht gefunden wird. \"launchSettings.json\" wird aus dem angegebenen Pfad gelesen. Dabei muss es sich um die Eigenschaft \"launchSettingsFilePath\" oder um {cwd}/Properties/launchSettings.json handeln, wenn dies nicht festgelegt ist. Wenn dieser Wert auf NULL oder eine leere Zeichenfolge festgelegt ist, wird launchSettings.json ignoriert. Wenn dieser Wert nicht angegeben ist, wird das erste Projekt-Profil verwendet.",
+  "generateOptionsSchema.logging.browserStdOut.markdownDescription": "Kennzeichnung, um zu bestimmen, ob stdout-Text vom Start des Webbrowsers im Ausgabefenster protokolliert werden soll. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.logging.consoleUsageMessage.description": "Steuert, ob eine Nachricht protokolliert wird, wenn der Zielprozess eine Console.Read*-API aufruft und stdin an die Konsole umgeleitet wird.",
+  "generateOptionsSchema.logging.description": "Kennzeichnungen, um zu bestimmen, welche Nachrichtentypen im Ausgabefenster protokolliert werden sollen.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.all.enumDescription": "Hiermit werden alle Debugger-API-Aufrufe ausgegeben. Diese Option ist sehr ausführlich.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.error.enumDescription": "Hiermit werden Fehler aus Debugger-API-Aufrufen ausgegeben.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.markdownDescription": "Steuert, ob API-Aufrufe an \"Microsoft.VisualStudio.Debugger.Engine/vsdebugeng.h\" im Ausgabefenster ausgegeben werden sollen. Diese Option ist standardmäßig auf \"none\" festgelegt.",
+  "generateOptionsSchema.logging.diagnosticsLog.debugEngineAPITracing.none.enumDescription": "Ablaufverfolgung für API-Aufrufe deaktivieren",
+  "generateOptionsSchema.logging.diagnosticsLog.debugRuntimeEventTracing.markdownDescription": "Flag, mit dem festgelegt wird, ob die ausführliche Ablaufverfolgung für Ereignisse aktiviert werden soll, die von der zugrunde liegenden Runtime ausgelöst werden. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.logging.diagnosticsLog.description": "Einstellungen, mit denen festgelegt wird, welche Meldungen aus dem Diagnoseprotokoll des Debuggers im Ausgabefenster ausgegeben werden. Dieses Protokoll dient zur Unterstützung bei der Behandlung von Problemen mit dem Debugger.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.error.enumDescription": "Hiermit werden Diagnosemeldungen auf Fehlerebene ausgegeben.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.important.enumDescription": "Hiermit werden wichtige Diagnosemeldungen ausgegeben.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.markdownDescription": "Steuert, welche Meldungen vom Dispatcher des Debuggers im Ausgabefenster ausgegeben werden. Sofern nicht angegeben, wird standardmäßig \"none\" verwendet – es sei denn, eine der ausführlichen Protokolleinstellungen ist aktiviert (\"debugEngineAPITracing\", \"debugRuntimeEventTracing\", \"expressionEvaluationTracing\" oder \"startDebuggingTracing\"). In diesem Fall wird der Standardwert in \"normal\" geändert.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.none.enumDescription": "Hiermit werden keine zusätzlichen Diagnosemeldungen ausgegeben.",
+  "generateOptionsSchema.logging.diagnosticsLog.dispatcherMessages.normal.enumDescription": "Hiermit werden alle nicht ausführlichen Diagnosemeldungen ausgegeben.",
+  "generateOptionsSchema.logging.diagnosticsLog.expressionEvaluationTracing.markdownDescription": "Flag, mit dem festgelegt wird, ob die ausführliche Ablaufverfolgung für die Ausdrucksauswertung aktiviert werden soll. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.logging.diagnosticsLog.protocolMessages.markdownDescription": "Flag, mit dem festgelegt wird, ob die zwischen dem C#-Debugger und der Benutzeroberfläche ausgetauschten DAP-Protokollnachrichten im Ausgabefenster protokolliert werden sollen. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.logging.diagnosticsLog.startDebuggingTracing.markdownDescription": "Flag zur Festlegung, ob die ausführliche Ablaufverfolgung beim Starten des Debuggens aktiviert werden soll. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.logging.elapsedTiming.markdownDescription": "Bei einer Festlegung auf \"true\" umfasst die Nachrichtenprotokollierung die Eigenschaften \"adapterElapsedTime\" und \"engineElapsedTime\", um die Zeitspanne in Mikrosekunden anzugeben, die für eine Anforderung benötigt wurde. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.logging.engineLogging.deprecationMessage": "Die Einstellung \"logging.engineLogging\" wurde zugunsten von \"logging.diagnosticsLog.protocolMessages\" als veraltet eingestuft.",
+  "generateOptionsSchema.logging.exceptions.markdownDescription": "Kennzeichnung, um zu bestimmen, ob Ausnahmemeldungen im Ausgabefenster protokolliert werden sollen. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.logging.moduleLoad.markdownDescription": "Kennzeichnung, um zu bestimmen, ob Modulladeereignisse im Ausgabefenster protokolliert werden sollen. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.logging.processExit.markdownDescription": "Steuert, ob eine Nachricht protokolliert wird, wenn der Zielprozess beendet oder das Debuggen beendet wird. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.logging.programOutput.markdownDescription": "Kennzeichnung, um zu bestimmen, ob die Programmausgabe im Ausgabefenster protokolliert werden soll, wenn keine externe Konsole verwendet wird. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.logging.threadExit.markdownDescription": "Steuert, ob eine Nachricht protokolliert wird, wenn ein Thread im Zielprozess beendet wird. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.pipeTransport.debuggerPath.description": "Der vollständige Pfad zum Debugger auf dem Zielcomputer.",
+  "generateOptionsSchema.pipeTransport.description": "Wenn vorhanden, weist dies den Debugger an, eine Verbindung mit einem Remotecomputer mithilfe einer anderen ausführbaren Datei als Pipe herzustellen, die die Standardeingabe/-ausgabe zwischen VS Code und der ausführbaren .NET Core-Debugger-Back-End-Datei (vsdbg) weiterleitet.",
+  "generateOptionsSchema.pipeTransport.linux.description": "Linux-spezifische Optionen für Pipestartkonfiguration",
+  "generateOptionsSchema.pipeTransport.linux.pipeArgs.0.description": "Befehlszeilenargumente, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.linux.pipeArgs.1.description": "Zeichenfolgenversion von Befehlszeilenargumenten, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.linux.pipeCwd.description": "Der vollqualifizierte Pfad zum Arbeitsverzeichnis für das Pipeprogramm.",
+  "generateOptionsSchema.pipeTransport.linux.pipeEnv.description": "Umgebungsvariablen, die an das Pipeprogramm übergeben werden.",
+  "generateOptionsSchema.pipeTransport.linux.pipeProgram.description": "Der vollqualifizierte auszuführende Pipebefehl.",
+  "generateOptionsSchema.pipeTransport.linux.quoteArgs.description": "Sollten Argumente, die Zeichen enthalten, die in Anführungszeichen gesetzt werden müssen (Beispiel: Leerzeichen), in Anführungszeichen gesetzt werden? Der Standardwert ist \"true\". Bei Festlegung auf \"false\" wird der Debuggerbefehl nicht mehr automatisch in Anführungszeichen gesetzt.",
+  "generateOptionsSchema.pipeTransport.osx.description": "OSX-spezifische Optionen für Pipestartkonfiguration",
+  "generateOptionsSchema.pipeTransport.osx.pipeArgs.0.description": "Befehlszeilenargumente, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.osx.pipeArgs.1.description": "Zeichenfolgenversion von Befehlszeilenargumenten, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.osx.pipeCwd.description": "Der vollqualifizierte Pfad zum Arbeitsverzeichnis für das Pipeprogramm.",
+  "generateOptionsSchema.pipeTransport.osx.pipeEnv.description": "Umgebungsvariablen, die an das Pipeprogramm übergeben werden.",
+  "generateOptionsSchema.pipeTransport.osx.pipeProgram.description": "Der vollqualifizierte auszuführende Pipebefehl.",
+  "generateOptionsSchema.pipeTransport.osx.quoteArgs.description": "Sollten Argumente, die Zeichen enthalten, die in Anführungszeichen gesetzt werden müssen (Beispiel: Leerzeichen), in Anführungszeichen gesetzt werden? Der Standardwert ist \"true\". Bei Festlegung auf \"false\" wird der Debuggerbefehl nicht mehr automatisch in Anführungszeichen gesetzt.",
+  "generateOptionsSchema.pipeTransport.pipeArgs.0.description": "Befehlszeilenargumente, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.pipeArgs.1.description": "Zeichenfolgenversion von Befehlszeilenargumenten, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.pipeCwd.description": "Der vollqualifizierte Pfad zum Arbeitsverzeichnis für das Pipeprogramm.",
+  "generateOptionsSchema.pipeTransport.pipeEnv.description": "Umgebungsvariablen, die an das Pipeprogramm übergeben werden.",
+  "generateOptionsSchema.pipeTransport.pipeProgram.description": "Der vollqualifizierte auszuführende Pipebefehl.",
+  "generateOptionsSchema.pipeTransport.quoteArgs.description": "Sollten Argumente, die Zeichen enthalten, die in Anführungszeichen gesetzt werden müssen (Beispiel: Leerzeichen), in Anführungszeichen gesetzt werden? Der Standardwert ist \"true\". Bei Festlegung auf \"false\" wird der Debuggerbefehl nicht mehr automatisch in Anführungszeichen gesetzt.",
+  "generateOptionsSchema.pipeTransport.windows.description": "Windows-spezifische Optionen für Pipestartkonfiguration",
+  "generateOptionsSchema.pipeTransport.windows.pipeArgs.0.description": "Befehlszeilenargumente, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.windows.pipeArgs.1.description": "Zeichenfolgenversion von Befehlszeilenargumenten, die an das Pipeprogramm übergeben werden. Token ${debuggerCommand} in pipeArgs wird durch den vollständigen Debuggerbefehl ersetzt. Dieses Token kann inline mit anderen Argumenten angegeben werden. Wenn ${debuggerCommand} in keinem Argument verwendet wird, wird stattdessen der vollständige Debuggerbefehl am Ende der Argumentliste hinzugefügt.",
+  "generateOptionsSchema.pipeTransport.windows.pipeCwd.description": "Der vollqualifizierte Pfad zum Arbeitsverzeichnis für das Pipeprogramm.",
+  "generateOptionsSchema.pipeTransport.windows.pipeEnv.description": "Umgebungsvariablen, die an das Pipeprogramm übergeben werden.",
+  "generateOptionsSchema.pipeTransport.windows.pipeProgram.description": "Der vollqualifizierte auszuführende Pipebefehl.",
+  "generateOptionsSchema.pipeTransport.windows.quoteArgs.description": "Sollten Argumente, die Zeichen enthalten, die in Anführungszeichen gesetzt werden müssen (Beispiel: Leerzeichen), in Anführungszeichen gesetzt werden? Der Standardwert ist \"true\". Bei Festlegung auf \"false\" wird der Debuggerbefehl nicht mehr automatisch in Anführungszeichen gesetzt.",
+  "generateOptionsSchema.processId.0.markdownDescription": "Die Prozess-ID, an die angefügt werden soll. Verwenden Sie \"\", um eine Liste der ausgeführten Prozesse abzurufen, an die angefügt werden soll. Wenn \"processId\" verwendet wird, sollte \"processName\" nicht verwendet werden.",
+  "generateOptionsSchema.processId.1.markdownDescription": "Die Prozess-ID, an die angefügt werden soll. Verwenden Sie \"\", um eine Liste der ausgeführten Prozesse abzurufen, an die angefügt werden soll. Wenn \"processId\" verwendet wird, sollte \"processName\" nicht verwendet werden.",
+  "generateOptionsSchema.processName.markdownDescription": "Der Prozessname, an den angefügt werden soll. Wenn dies verwendet wird, sollte \"processId\" nicht verwendet werden.",
+  "generateOptionsSchema.program.markdownDescription": "Pfad zur Anwendungs-DLL oder ausführbaren .NET Core-Hostdatei, die gestartet werden soll.\r\nDiese Eigenschaft hat normalerweise folgendes Format: \"${workspaceFolder}/bin/Debug/(target-framework)/(project-name.dll)\"\r\n\r\nBeispiel: \"`${workspaceFolder}/bin/Debug/netcoreapp1.1/MyProject.dll`\r\n\r\nWo:\r\n\"(target-framework)\" ist das Framework, für das das debuggte Projekt erstellt wird. Dies wird normalerweise in der Projektdatei als TargetFramework-Eigenschaft gefunden.\r\n\r\n\"(project-name.dll)\" ist der Name der Buildausgabe-DLL des debuggten Projekts. Dies ist normalerweise identisch mit dem Projektdateinamen, aber mit der Erweiterung \".dll\".",
+  "generateOptionsSchema.requireExactSource.markdownDescription": "Kennzeichnung, dass der aktuelle Quellcode dem PDB entsprechen muss. Diese Option wird standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.sourceFileMap.markdownDescription": "Ordnet Buildzeitpfade lokalen Quellspeicherorten zu. Alle Instanzen des Buildzeitpfads werden durch den lokalen Quellpfad ersetzt.\r\n\r\nBeispiel:\r\n\r\n'{\"<build-path>\":\"<local-source-path>\"}'",
+  "generateOptionsSchema.sourceLinkOptions.additionalItems.enabled.markdownDescription": "Ist Source Link für diese URL aktiviert? Wenn keine Angabe erfolgt, wird diese Option standardmäßig auf \"true\" festgelegt.",
+  "generateOptionsSchema.sourceLinkOptions.markdownDescription": "Optionen zum Steuern der Verbindung von Source Link mit Webservern. [Weitere Informationen](https://aka.ms/VSCode-DotNet-SourceLink)",
+  "generateOptionsSchema.stopAtEntry.markdownDescription": "Bei \"true\" sollte der Debugger am Einstiegspunkt des Ziels beendet werden. Diese Option ist standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.suppressJITOptimizations.markdownDescription": "Bei \"true\" fordert der Debugger den Just-In-Time-Compiler auf, Code mit deaktivierten Optimierungen zu generieren, wenn ein optimiertes Modul (DLL- kompiliert in der Releasekonfiguration) im Zielprozess geladen wird. [Weitere Informationen](https://aka.ms/VSCode-CS-LaunchJson-SuppressJITOptimizations)",
+  "generateOptionsSchema.symbolOptions.cachePath.description": "Verzeichnis, in dem von Symbolservern heruntergeladene Symbole zwischengespeichert werden sollen. Wenn nicht angegeben, wird der Debugger unter Windows standardmäßig auf %TEMP%\\SymbolCache festgelegt, und unter Linux und macOS wird der Debugger standardmäßig auf ~/.dotnet/symbolcache festgelegt.",
+  "generateOptionsSchema.symbolOptions.description": "Optionen zum Steuern, wie Symbole (PDB-Dateien) gefunden und geladen werden.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.description": "Stellt Optionen bereit, um zu steuern, für welche Module (DLL-Dateien) der Debugger versuchen soll, Symbole (PDB-Dateien) zu laden.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.excludedModules.description": "Ein Array von Modulen, für das der Debugger keine Symbole laden soll. Platzhalter (Beispiel: MyCompany. *. dll) werden unterstützt.\r\n\r\nDiese Eigenschaft wird ignoriert, wenn „Modus“ nicht auf „loadAllButExcluded“ festgelegt ist.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.includeSymbolsNextToModules.description": "Wenn „true“, wird der Debugger für ein beliebiges Modul, das sich NICHT im Array „includedModules“ befindet, weiterhin neben dem Modul selbst und der ausführbaren Datei, die gestartet wird, überprüfen. Die Pfade in der Symbolsuchliste werden jedoch nicht überprüft. Diese Option ist standardmäßig auf „true“ eingestellt.\r\n\r\nDiese Eigenschaft wird ignoriert, wenn „Modus“ nicht auf „loadOnlyIncluded“ festgelegt ist.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.includedModules.description": "Ein Array von Modulen, für das der Debugger keine Symbole laden soll. Platzhalter (Beispiel: MyCompany. *. dll) werden unterstützt.\r\n\r\nDiese Eigenschaft wird ignoriert, wenn „Modus“ nicht auf „loadOnlyIncluded“ festgelegt ist.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.mode.description": "Steuert, in welchem der beiden grundlegenden Betriebsmodi der Modulfilter ausgeführt wird.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.mode.loadAllButExcluded.enumDescription": "Laden Sie Symbole für alle Module, es sei denn, das Modul befindet sich im Array „excludedModules“.",
+  "generateOptionsSchema.symbolOptions.moduleFilter.mode.loadOnlyIncluded.enumDescription": "Versuchen Sie nicht, Symbole für IRGENDEIN Modul zu laden, es sei denn, es befindet sich im Array „includedModules“, oder es wird über die Einstellung „includeSymbolsNextToModules“ hinzugefügt.",
+  "generateOptionsSchema.symbolOptions.searchMicrosoftSymbolServer.description": "Wenn „true“, wird der Microsoft-Symbolserver (https​://msdl.microsoft.com​/download/symbols) dem Symbolsuchpfad hinzugefügt. Wenn nicht angegeben, wird diese Option standardmäßig auf „false“ eingestellt.",
+  "generateOptionsSchema.symbolOptions.searchNuGetOrgSymbolServer.description": "Bei \"true\" wird der NuGet.org-Symbolserver (https​://symbols.nuget.org​/download/symbols) dem Symbolsuchpfad hinzugefügt. Wenn keine Angabe erfolgt, wird diese Option standardmäßig auf \"false\" festgelegt.",
+  "generateOptionsSchema.symbolOptions.searchPaths.description": "Array von Symbolserver-URLs (example: http​://MyExampleSymbolServer) oder Verzeichnisse (example: /build/symbols), um nach PDB-Dateien zu suchen. Diese Verzeichnisse werden zusätzlich zu den Standardspeicherorten durchsucht – neben dem Modul und dem Pfad, in dem die PDB-Datei ursprünglich abgelegt wurde.",
+  "generateOptionsSchema.targetArchitecture.markdownDescription": "[Nur beim lokalen macOS-Debuggen unterstützt]\r\n\r\nDie Architektur des Debuggens. Dies wird automatisch erkannt, es sei denn, dieser Parameter ist festgelegt. Zulässige Werte sind \"x86_64\" oder \"arm64\".",
+  "generateOptionsSchema.targetOutputLogPath.description": "Bei Festlegung wird Text, den die Zielanwendung in \"stdout\" und \"stderr\" (z. B. Console.WriteLine) schreibt, in der angegebenen Datei gespeichert. Diese Option wird ignoriert, wenn die Konsole auf einen anderen Wert als internalConsole festgelegt ist. Beispiel: \"${workspaceFolder}/out.txt\"",
+  "viewsWelcome.debug.contents": "[C#-Objekte für Build und Debuggen generieren](command:dotnet.generateAssets)\r\n\r\nWeitere Informationen zu launch.json finden Sie unter [Konfigurieren von launch.json für das C#-Debuggen](https://aka.ms/VSCode-CS-LaunchJson)."
+}