### Log output for Roslyn Copilot language server installation

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Example log entries observed in the C# Output pane indicating the installation process for the Roslyn Copilot language server.

```log
[info] Installing package 'Language server for Roslyn Copilot integration'
[info] Finished
```

--------------------------------

### Example launch.json Configuration for x64 Debugging

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Debugging-x64-processes-on-an-arm64-computer.md

This is an example of a launch.json configuration for debugging a .NET Core console application. It specifies the x64 dotnet executable and the target architecture.

```json
{
    // Use IntelliSense to find out which attributes exist for C# debugging
    // Use hover for the description of the existing attributes
    // For further information visit https://github.com/dotnet/vscode-csharp/blob/main/debugger-launchjson.md
    "name": ".NET Core Launch (console)",
    "type": "coreclr",
    "request": "launch",
    "preLaunchTask": "build",
    "cwd": "${workspaceFolder}",
    "program": "/usr/local/share/dotnet/x64/dotnet",
    "args": "${workspaceFolder}/bin/Debug/net8.0/ExampleProject.dll",
    "targetArchitecture": "x86_64"
}
```

--------------------------------

### Install NPM Authentication Helper

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Install the `ado-npm-auth` global package if you need to authenticate with the .NET eng AzDo artifacts feed when adding new packages.

```bash
npm install -g ado-npm-auth
```

--------------------------------

### Create Symbolic Link for .NET SDK Snap Install

Source: https://github.com/dotnet/vscode-csharp/wiki/Configuring-Snap-installs-of-dotnet-sdk

Use this command to create a symbolic link for the .NET SDK installed via Snap. This helps tools like OmniSharp resolve the SDK location. Ensure you have the necessary permissions to write to /usr/local/bin.

```bash
ln -s /snap/dotnet-sdk/current/dotnet /usr/local/bin/dotnet
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Installs project dependencies using npm. Authentication is only required when adding new packages.

```bash
npm ci
```

--------------------------------

### Install .NET Core Debugger for Linux ARM

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

Installs the .NET Core debugger to the specified directory on the target Linux ARM machine. Ensure you have curl and unzip installed.

```bash
curl -sSL https://aka.ms/getvsdbgsh | bash /dev/stdin -r linux-arm -v latest -l ~/vsdbg
```

--------------------------------

### Project Setup for Testing

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

This snippet demonstrates how to set up a project structure with a console application and an xUnit test project, linking them, and creating a solution file. Useful for setting up a test environment for C# projects.

```bash
mkdir project
mkdir test
dotnet new console -o project
dotnet new xunit -o test
dotnet add test/test.csproj reference project/project.csproj
dotnet new solution -n solution
dotnet sln solution.sln add test/test.csproj project/project.csproj
```

--------------------------------

### Blazor WASM Debugging Setup

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Command to create a new Blazor WebAssembly application for debugging.

```bash
$ dotnet new blazorwasm -o DebugTestProject
```

--------------------------------

### Install MicroBuild Signing Plugin

Source: https://github.com/dotnet/vscode-csharp/blob/main/msbuild/signing/SIGNING.md

Installs the MicroBuild signing plugin globally. This is a prerequisite for running signing targets locally and is typically handled by a pipeline step in CI environments.

```bash
npm run installSignPlugin
```

--------------------------------

### Install Azure Artifacts NuGet Credential Provider

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Instructions for installing the Azure Artifacts NuGet Credential Provider on Windows, which may be required for interactive authentication when running npm scripts.

```bash
Install-Package Microsoft.Azure.Services.AppAuthentication -Version 1.0.0
```

--------------------------------

### Example .runsettings File for MSTest 64-bit Worker

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Desktop-.NET-Framework.md

Create a .runsettings file to force MSTest projects to use a 64-bit worker process, which is required for debugging. This file specifies the target platform as 'x64'.

```xml
<?xml version="1.0" encoding="utf-8"?>
<RunSettings>
  <RunConfiguration>
    <TargetPlatform>x64</TargetPlatform>
  </RunConfiguration>
</RunSettings>
```

--------------------------------

### Install Debugger for WSL

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Windows-Subsystem-for-Linux.md

Installs the .NET Core debugger (vsdbg) for use with WSL. This command downloads and installs the latest version to the ~/vsdbg directory.

```bash
sudo apt-get install unzip
curl -sSL https://aka.ms/getvsdbgsh | bash /dev/stdin -v latest -l ~/vsdbg
```

--------------------------------

### Start Debugger as Server

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Troubleshoot-loading-the-.NET-Debug-Services.md

Initiates the debugger in server mode, redirecting logs to a specified file for troubleshooting. Ensure the log file path is accessible.

```bash
./vsdbg-ui --server 2> ~/vsdbg-ui.log
```

--------------------------------

### VS Code launch.json configuration for .NET Core

Source: https://github.com/dotnet/vscode-csharp/blob/main/debugger.md

Example configuration for launch.json to debug a .NET Core application. Ensure the 'program' property points to the correct application DLL.

```json
"configurations": [
		{
			"...": "...",
			"program": "${workspaceFolder}/MyLaunchingProject/bin/Debug/netcoreapp1.0/MyLaunchingProject.dll",

```

--------------------------------

### Authenticate with NPM Feed

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Run this command after installing `ado-npm-auth` to authenticate with the .NET eng AzDo artifacts feed by configuring your `.npmrc` file.

```bash
ado-npm-auth -c .npmrc
```

--------------------------------

### Download VSDBG using wget

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Attaching-to-remote-processes.md

An alternative method to download and install VSDBG using wget, suitable for systems where curl is not available.

```bash
wget https://aka.ms/getvsdbgsh -O - 2>/dev/null | /bin/sh /dev/stdin -v latest -l ~/vsdbg
```

--------------------------------

### Blazor project.razor.json Structure

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Example structure of the `project.razor.json` file for a Blazor project. It includes file path, configuration settings, project workspace state, and document details.

```JSON
{
  "FilePath": "c:\\Users\\JohnDoe\\Projects\\BlazorTestApp\\BlazorTestApp.csproj",
  "Configuration": {
    "ConfigurationName": "MVC-3.0",
    "LanguageVersion": "MVC-3.0",
    "Extensions": [
      {
        "ExtensionName": "MVC-3.0"
      }
    ]
  },
  "ProjectWorkspaceState": {
    "TagHelpers": [ /* LOTS OF ENTRIES HERE */ ],
    "CSharpLanguageVersion": 703 // This may be different
  },
  "RootNamespace": "BlazorTestApp",
  "Documents": [ /* LOTS OF ENTRIES HERE */]
}
```

--------------------------------

### Legacy Razor project.razor.json Structure

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Example structure of the `project.razor.json` file for a Legacy Razor project. Note the 'UnsupportedRazor' configuration and null RootNamespace.

```JSON
{
  "ProjectFilePath": "c:\\Users\\JohnDoe\\Projects\\LegacyRazorTestApp\\LegacyRazorTestApp.csproj",
  "Configuration": {
    "ConfigurationName": "UnsupportedRazor",
    "LanguageVersion": "1.0",
    "Extensions": [
      {
        "ExtensionName": "UnsupportedRazorExtension"
      }
    ]
  },
  "ProjectWorkspaceState": {
    "TagHelpers": [],
    "CSharpLanguageVersion": 703 // This may be different
  },
  "RootNamespace": null,
  "Documents": []
}
```

--------------------------------

### Razor Syntax Example with Diagnostics

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Demonstrates Razor syntax that initially produces a diagnostic error for a missing closing tag, which is then resolved by adding the corresponding closing tag.

```razor
@{ <strong></strong> }
```

--------------------------------

### Configure launch.json for Unlimited Core Dumps

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Attaching-to-remote-processes.md

Modifies the launch.json configuration to enable unlimited core dumps by setting the ulimit before starting the debugger. This is used in conjunction with core_pattern configuration.

```json
    "pipeArgs": [ "-T", "ExampleAccount@ExampleTargetComputer", "ulimit -c unlimited && ${debuggerCommand}" ],
```

--------------------------------

### Legacy Razor Formatting Example

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Illustrates the expected formatting within a Razor code block when hitting enter between curly braces in a legacy Razor project context.

```razor
{

}
```

--------------------------------

### ASP.NET Core Razor project.razor.json Structure

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Example structure of the `project.razor.json` file for an ASP.NET Core Razor project. This file contains configuration details, tag helper information, and document entries.

```JSON
{
  "FilePath": "c:\\Users\\JohnDoe\\Projects\\RazorCoreTestApp\\RazorCoreTestApp.csproj",
  "Configuration": {
    "ConfigurationName": "MVC-3.0",
    "LanguageVersion": "3.0",
    "Extensions": [
      {
        "ExtensionName": "MVC-3.0"
      }
    ]
  },
  "ProjectWorkspaceState": {
    "TagHelpers": [ /* LOTS OF ENTRIES HERE */ ],
    "CSharpLanguageVersion": 703 // This may be different
  },
  "RootNamespace": "RazorCoreTestApp",
  "Documents": [ /* LOTS OF ENTRIES HERE */]
}
```

--------------------------------

### Create Hosted Blazor WASM Project

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Use this command to set up a new Blazor WebAssembly project with a hosted backend for testing purposes. Ensure the `--hosted` flag is included.

```bash
$ dotnet new blazorwasm --hosted -o DebugHostedTestProject
```

--------------------------------

### Download VSDBG using curl

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Attaching-to-remote-processes.md

Installs the latest version of VSDBG (the .NET Core command line debugger) on the target server. Specify the desired installation path.

```bash
curl -sSL https://aka.ms/getvsdbgsh | /bin/sh /dev/stdin -v latest -l ~/vsdbg
```

--------------------------------

### Sample launch.json for Remote Debugging (Windows - Framework Dependent)

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

This configuration is for debugging a framework-dependent .NET Core application remotely on Linux ARM from a Windows machine. It requires PuTTY and a converted SSH keyfile.

```json
{
            "name": ".NET Core Remote Launch - Framework Dependent (console)",
            "type": "coreclr",
            "request": "launch",
            "program": "~/dotnet/dotnet",
            "args": ["./dotnetapp.dll"],
            "cwd": "~/dotnet-core-app",
            "stopAtEntry": false,
            "console": "internalConsole",
            "pipeTransport": {
                "pipeCwd": "${workspaceRoot}",
                "pipeProgram": "c:\\Program Files\\PuTTY\\plink.exe",
                "pipeArgs": [
                    "-i",
                    "mysshkeyfile.ppk",
                    "pi@10.10.10.10"
                ],
                "debuggerPath": "~/vsdbg/vsdbg"
            }
        }
```

--------------------------------

### Sample launch.json for .NET Core WSL Launch

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Windows-Subsystem-for-Linux.md

Configuration for launching a .NET Core application on WSL. It uses a preLaunchTask to publish the application and specifies pipe transport for debugging.

```json
{
           "name": ".NET Core WSL Launch",
           "type": "coreclr",
           "request": "launch",
           "preLaunchTask": "publish",
           "program": "/mnt/c/temp/dotnetapps/wslApp/bin/publish/wslApp.dll",
           "args": [],
           "cwd": "/mnt/c/temp/dotnetapps/wslApp",
           "stopAtEntry": false,
           "console": "internalConsole",
           "pipeTransport": {
               "pipeCwd": "${workspaceRoot}",
               "pipeProgram": "bash.exe",
               "pipeArgs": [ "-c" ],
               "debuggerPath": "~/vsdbg/vsdbg"
           }
       }
```

--------------------------------

### C# Go to Implementation for Interface

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Navigates to the implementation of an interface member.

```csharp
@functions {
  interface Foo {}
  class Bar: Foo {}
}
```

--------------------------------

### Sample launch.json for Remote Debugging (macOS/Linux - Standalone)

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

This configuration is for debugging a self-contained .NET Core application remotely on Linux ARM from a macOS or Linux machine using SSH.

```json
    {
        "name": ".NET Core Remote Launch - Standalone Application (console)",
        "type": "coreclr",
        "request": "launch",
        "program": "MyConsoleApp",
        "args": [],
        "cwd": "~/MyConsoleApp",
        "stopAtEntry": false,
        "console": "internalConsole",
        "pipeTransport": {
            "pipeCwd": "${workspaceRoot}",
            "pipeProgram": "/usr/bin/ssh",
            "pipeArgs": [
                "-T", "-i", "mysshkeyfile",
                "pi@10.10.10.10"
            ],
            "debuggerPath": "~/vsdbg/vsdbg"
            }
    }
```

--------------------------------

### Watch for Code Changes

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Starts a process that watches for code changes and automatically recompiles or reloads as needed. This is optional.

```bash
npm run watch
```

--------------------------------

### Create .NET Core Console App for CultureInfo Test

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Testing-libicu-compatibility-on-Linux.md

Creates a new .NET 5.0 console application named CultureInfoTest to verify libicu compatibility.

```bash
dotnet new console -f net5.0 -o CultureInfoTest
```

```bash
cd CultureInfoTest
```

--------------------------------

### Package VSIX for Extension Release

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Execute this npm script to create platform-specific VSIX packages for the extension, which can then be manually installed in VS Code.

```bash
npm run vsix:release:package
```

--------------------------------

### Download and Extract .NET Core Runtime (2.1)

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

Downloads and extracts a specific version of the .NET Core runtime for Linux ARM to a local directory. This is for framework-dependent deployments.

```bash
mkdir ~/dotnet & curl -sSL https://dotnetcli.blob.core.windows.net/dotnet/Runtime/2.1.3/dotnet-runtime-2.1.3-linux-arm.tar.gz |
    tar xvzf /dev/stdin -C ~/dotnet
```

--------------------------------

### Sample launch.json for .NET Core WSL Attach

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Windows-Subsystem-for-Linux.md

Configuration for attaching to a running .NET Core process on WSL. It uses pipe transport and allows selecting the remote process to attach to.

```json
       {
           "name": ".NET Core WSL Attach",
           "type": "coreclr",
           "request": "attach",
           "processId": "${command:pickRemoteProcess}",
           "pipeTransport": {
               "pipeCwd": "${workspaceRoot}",
               "pipeProgram": "bash.exe",
               "pipeArgs": [ "-c" ],
               "debuggerPath": "~/vsdbg/vsdbg",
               "quoteArgs": true
           }
       }
```

--------------------------------

### Attach Failed Telemetry Event on macOS

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Attaching-to-remote-processes.md

Example telemetry event indicating a debugger attach failure on macOS. This often correlates with Developer Mode not being enabled.

```javascript
{
   "event":"output",
   "body": {
   "category":"telemetry",
   "output":"VS/Diagnostics/Debugger/vsdbg/AttachFailed",
   "data":{
      "VS.Diagnostics.Debugger.vsdbg.OSFamily":"Darwin",
      "VS.Diagnostics.Debugger.vsdbg.ErrorCode":-2147024809
}

```

--------------------------------

### macOS Debugger Crash Call Stack

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Diagnosting-'Debug-adapter-process-has-terminated-unexpectedly'.md

This is an example of a call stack from a debugger crash on macOS. It helps identify the sequence of function calls leading to the termination.

```text
Thread 9 Crashed:
0   libsystem_c.dylib             	0x00007fffbbc43b52 strlen + 18
1   libc++.1.dylib                	0x00007fffba7e0b27 std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::assign(char const*) + 21
2   libvsdbg.dylib                	0x0000000103fab41f VsCode::LaunchOptions::Deserialize(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > const&, VsCode::LaunchOptions&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&) + 1999
3   libvsdbg.dylib                	0x0000000103f70fe0 VsCode::CVsCodeProtocol::HandleLaunchRequest(rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator> const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, unsigned int&, bool&) + 288
4   libvsdbg.dylib                	0x0000000103f6e6a0 VsCode::CVsCodeProtocol::HandleRequest(char const*) + 1648
5   libvsdbg.dylib                	0x0000000103f62e7c std::__1::__function::__func<VsCode::CommandQueue::SyncCommand(std::__1::function<int ()>)::$_1, std::__1::allocator<VsCode::CommandQueue::SyncCommand(std::__1::function<int ()>)::$_1>, int ()>::operator()() + 28
6   libvsdbg.dylib                	0x0000000103f629f8 VsCode::CommandQueue::CommandLoop() + 360
7   libvsdbg.dylib                	0x0000000103f6cfc7 CVsCodeMainLoop::Run() + 103
8   libvsdbg.dylib                	0x0000000103f10b41 RunMainLoop + 17
9   ???                           	0x000000011038d5a3 0 + 4567127459
10  ???                           	0x000000011038128e 0 + 4567077518
11  ???                           	0x000000010fee99c6 0 + 4562262470
12  ???                           	0x000000010fe99e71 0 + 4561935985
13  ???                           	0x000000010fee9fc7 0 + 4562264007
14  ???                           	0x000000010fee9ce8 0 + 4562263272
15  ???                           	0x000000010feffd25 0 + 4562353445
16  libcoreclr.dylib              	0x00000001017c99a1 CallDescrWorkerInternal + 124
17  libcoreclr.dylib              	0x00000001016b5b43 MethodDescCallSite::CallTargetWorker(unsigned long const*, unsigned long*, int) + 707
18  libcoreclr.dylib              	0x00000001016d1025 QueueUserWorkItemManagedCallback(void*) + 165
19  libcoreclr.dylib              	0x000000010167515a ManagedThreadBase_DispatchOuter(ManagedThreadCallState*) + 378
20  libcoreclr.dylib              	0x0000000101675803 ManagedThreadBase::ThreadPool(ADID, void (*)(void*), void*) + 51
21  libcoreclr.dylib              	0x0000000101669d4c ManagedPerAppDomainTPCount::DispatchWorkItem(bool*, bool*) + 268
22  libcoreclr.dylib              	0x0000000101694b00 ThreadpoolMgr::WorkerThreadStart(void*) + 992
23  libcoreclr.dylib              	0x00000001014ede48 CorUnix::CPalThread::ThreadEntry(void*) + 328
24  libsystem_pthread.dylib       	0x00007fffbbe269af _pthread_body + 180
25  libsystem_pthread.dylib       	0x00007fffbbe268fb _pthread_start + 286
26  libsystem_pthread.dylib       	0x00007fffbbe26101 thread_start + 13
```

--------------------------------

### Enable Debugging into .NET Runtime

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Debugging-into-the-.NET-Runtime-itself.md

Configure these settings in your launch.json to debug into the .NET Runtime. Ensure 'justMyCode' is false and symbol servers are enabled. 'suppressJITOptimizations' and 'COMPlus_ReadyToRun' are crucial for disabling runtime optimizations.

```json
    "justMyCode": false,
    "symbolOptions": {
        "searchMicrosoftSymbolServer": true
    },
    "suppressJITOptimizations": true,
    "env": {
        "COMPlus_ReadyToRun": "0"
    }
```

--------------------------------

### Configure Debug Server in launch.json for Console Logging

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Enabling-C

Set up launch.json to use a specific debug server port and enable console logging for advanced troubleshooting. This is helpful for issues occurring early in debugger startup or when the debugger crashes.

```json
{
   "version": "0.2.0",
   "configurations": [
        {
            "debugServer": 4711,
            "name": ".NET Core Launch (console)",
            "...": "...",
        },
        { "...": "..." }
    ]
}
```

--------------------------------

### Run .NET Application on Linux ARM

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

Executes a .NET Core application's DLL using the locally installed .NET Core runtime on the Linux ARM device.

```bash
$ ~/dotnet/dotnet MyConsoleApp.dll
```

--------------------------------

### Open Project in VS Code

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Opens the current directory in Visual Studio Code.

```bash
code .
```

--------------------------------

### Run 'Branch snap' GitHub Action for main to prerelease

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Execute the 'Branch snap' GitHub action by selecting 'main' as the base branch to merge code from main to the prerelease branch.

```bash
Run workflow
Base branch: main
```

--------------------------------

### Configure SSH Attach for .NET Core

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Attaching-to-remote-processes.md

Add this configuration to your .vscode/launch.json file to enable attaching to a remote .NET Core process via SSH. Ensure VSDBG is installed on the target machine.

```json
{
            "name": ".NET Core SSH Attach",
            "type": "coreclr",
            "request": "attach",
            "processId": "${command:pickRemoteProcess}",
            "pipeTransport": {
                "pipeProgram": "ssh",
                "pipeArgs": [ "-T", "ExampleAccount@ExampleTargetComputer" ],
                "debuggerPath": "~/vsdbg/vsdbg",
                "pipeCwd": "${workspaceRoot}",
                "quoteArgs": true
            },
            "sourceFileMap": {
                "/home/ExampleAccount/ExampleProject": "${workspaceRoot}"
            }
        }
```

--------------------------------

### Sample tasks.json for 'publish' task

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Windows-Subsystem-for-Linux.md

Defines a 'publish' task for tasks.json, used to build and publish a .NET Core project. This task is typically referenced by the preLaunchTask in launch.json.

```json
{
    "version": "2.0.0",
    "tasks": [
        ...
        {
            "label": "publish",
            "command": "dotnet",
            "type": "process",
            "args": [
                "publish",
                "${workspaceFolder}/wslApp.csproj",
                "/property:GenerateFullPaths=true",
                "/consoleloggerparameters:NoSummary",
                "-o",
                "${workspaceFolder}/bin/publish"
            ]
        }
    ]
}
```

--------------------------------

### Run npm script to update Roslyn version

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Execute the 'updateRoslynVersion' npm script to ensure the specified Roslyn package version is available in the feeds. Ensure the Azure Artifacts NuGet Credential Provider is installed if needed.

```bash
npm run updateRoslynVersion
```

--------------------------------

### Windows Event Log Details for Debugger Crash

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Diagnosting-'Debug-adapter-process-has-terminated-unexpectedly'.md

This is an example of the event details you might find in the Windows Event Viewer (Application log) when the debug adapter process terminates unexpectedly. It provides crucial information for diagnosing the root cause.

```text
Faulting application name: vsdbg-ui.exe, version: 1.1.0.1179, time stamp: 0x58224b03
Faulting module name: vsdbg.DLL, version: 15.1.10517.0, time stamp: 0x591cc77d
Exception code: 0xc0000005
Fault offset: 0x00000000002e3d3a
Faulting process id: 0x2dd8
Faulting application start time: 0x01d2cf58f1e7031e
Faulting application path: C:\Users\greggm\.vscode\extensions\ms-dotnettools.csharp-1.21.18\.debugger\vsdbg-ui.exe
Faulting module path: C:\Users\greggm\.vscode\extensions\ms-dotnettools.csharp-1.21.18\.debugger\vsdbg.DLL
Report Id: 694807aa-44e0-42d3-8129-437f457a5efd
Faulting package full name:
Faulting package-relative application ID:
```

--------------------------------

### VS Code launch.json for Remote Debugging (Framework Dependent)

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

Configuration for VS Code to remotely debug a framework-dependent .NET Core console application on Linux ARM via SSH. Ensure the 'program' path points to the dotnet executable and 'debuggerPath' to the installed vsdbg.

```json
{
    "name": ".NET Core Remote Launch - Framework Dependent (console)",
    "type": "coreclr",
    "request": "launch",
    "program": "~/dotnet/dotnet",
    "args": [
        "./MyConsoleApp.dll"
    ],
    "cwd": "~/MyConsoleApp",
    "stopAtEntry": false,
    "console": "internalConsole",
    "pipeTransport": {
        "pipeCwd": "${workspaceRoot}",
        "pipeProgram": "/usr/bin/ssh",
        "pipeArgs": [
            "-T", "-i", "mysshkeyfile",
            "pi@10.10.10.10"
        ],
        "debuggerPath": "~/vsdbg/vsdbg"
        }
    }
```

--------------------------------

### Run Standalone Blazor WASM Project

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Execute the created standalone Blazor WebAssembly project from the command line. This step is necessary before attaching the debugger.

```bash
$ cd DebugTestProject
$ dotnet run
```

--------------------------------

### TagHelper Quick Info

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Provides IntelliSense quick info for TagHelpers when hovering over the opening tag.

```html
<environment></environment>
```

--------------------------------

### Test Application Execution on Linux ARM

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Remote-Debugging-On-Linux-Arm.md

This command demonstrates how to run a self-contained .NET Core application after it has been deployed to a Linux ARM device.

```bash
$ ./MyConsoleApp
```

--------------------------------

### Create a new .NET console project

Source: https://github.com/dotnet/vscode-csharp/blob/main/debugger.md

Use 'dotnet new console' to create a new console application. This command is run from the VS Code terminal.

```bash
cd ~
dotnet new console
```

--------------------------------

### Run 'Branch snap' GitHub Action for prerelease to release

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Execute the 'Branch snap' GitHub action by selecting 'prerelease' as the workflow branch to merge code from prerelease to the release branch.

```bash
Run workflow
Workflow branch: prerelease
```

--------------------------------

### Run Unit Tests

Source: https://github.com/dotnet/vscode-csharp/blob/main/CONTRIBUTING.md

Executes all unit tests for the project.

```bash
npm run test:unit
```

--------------------------------

### Run .NET Core Console App

Source: https://github.com/dotnet/vscode-csharp/blob/main/docs/debugger/Testing-libicu-compatibility-on-Linux.md

Executes the .NET Core console application to perform the libicu compatibility test.

```bash
dotnet run
```

--------------------------------

### C# Go to Implementation in Razor

Source: https://github.com/dotnet/vscode-csharp/blob/main/test-plan.md

Navigates from an interface or abstract class usage to its implementation in Razor.

```razor
@functions {interface Foo {} class Bar: Foo {}}
```