Hello World Visual Studio Code | Add A Custom Command

C/C++ for Visual Studio Code

C/C++ support for Visual Studio Code is provided by a Microsoft C/C++ extension to enable cross-platform C and C++ development on Windows, Linux, and macOS. When you create a

*.cpp

file, the extension adds features such as syntax highlighting (colorization), smart completions and hovers (IntelliSense), and error checking.

Developing the extension

Let’s make a change to the message:

1. Change the message from “Hello World from HelloWorld!” to “Hello VS Code” in
   
extension.ts

   .
2. Run Developer: Reload Window in the new window.
3. Run the command Hello World again.

You should see the updated message showing up.

Here are some ideas for things for you to try:

• Give the Hello World command a new name in the Command Palette.
• Contribute another command that displays current time in an information message. Contribution points are static declarations you make in the
  
package.json

  Extension Manifest to extend VS Code, such as adding commands, menus, or keybindings to your extension.
• Replace the
  
vscode.window.showInformationMessage

  with another VS Code API call to show a warning message.

Run Python code

Click the Run Python File in Terminal play button in the top-right side of the editor.

The button opens a terminal panel in which your Python interpreter is automatically activated, then runs

python3 hello.py

(macOS/Linux) or

python hello.py

(Windows):

There are three other ways you can run Python code within VS Code:

1. Right-click anywhere in the editor window and select Run > Python File in Terminal (which saves the file automatically):

2. Select one or more lines, then press Shift+Enter or right-click and select Run Selection/Line in Python Terminal. This command is convenient for testing just a part of a file.

3. From the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), select the Python: Start REPL command to open a REPL terminal for the currently selected Python interpreter. In the REPL, you can then enter and run lines of code one at a time.

Congrats, you just ran your first Python code in Visual Studio Code!

Enhance completions with AI

GitHub Copilot is an AI-powered code completion tool that helps you write code faster and smarter. You can use the GitHub Copilot extension in VS Code to generate code, or to learn from the code it generates.

GitHub Copilot provides suggestions for numerous languages and a wide variety of frameworks, and it works especially well for Python, JavaScript, TypeScript, Ruby, Go, C# and C++.

You can learn more about how to get started with Copilot in the Copilot documentation.

Debugging your Extension

Simply set a breakpoint, for example inside the registered command and run the

"Hello world"

command in the Extension Development VS Code instance.

Note: For TypeScript extensions, even though VS Code loads and executes


out/src/extension.js

, you are actually able to debug the original TypeScript code due to the generated source map

out/src/extension.js.map

and VS Code’s debugger support for source maps.

Tip: The Debug Console will show all the messages you log to the console.

To learn more about the extension development environment.

Open folder

By starting VS Code in a folder, that folder becomes your “workspace”. VS Code stores settings that are specific to that workspace in

.vscode/settings.json

, which are separate from user settings that are stored globally.

Using a terminal, create an empty folder called “hello”, navigate into it, and open VS Code (code) in that folder (.) by entering the following commands:


mkdir hello cd hello code .


Alternatively, you can run VS Code through the operating system UI, then use File > Open Folder to open the project folder.

Next steps

Now that you know the basics of working with Visual Studio Extensibility, here’s where you can learn more:

• Start to develop Visual Studio extensions – Samples, tutorials. and publishing your extension
• What’s new in the Visual Studio 2017 SDK – New extensibility features in Visual Studio 2017
• What’s new in the Visual Studio 2019 SDK – New extensibility features in Visual Studio 2019
• Inside the Visual Studio SDK – Learn the details of Visual Studio Extensibility

Getting Started with Python in VS Code

In this tutorial, you will learn how to use Python 3 in Visual Studio Code to create, run, and debug a Python “Roll a dice” application, work with virtual environments, use packages, and more! By using the Python extension, you turn VS Code into a great, lightweight Python editor.

If you are new to programming, check out the Visual Studio Code for Education – Introduction to Python course. This course offers a comprehensive introduction to Python, featuring structured modules in a ready-to-code browser-based development environment.

To gain a deeper understanding of the Python language, you can explore any of the programming tutorials listed on python.org within the context of VS Code.

For a Data Science focused tutorial with Python, check out our Data Science section.

Add a custom command

1. If you select the

   
.vsixmanifest

   manifest file, you can see what options are changeable, such as description, author, and version.

2. Right-click the project (not the solution). On the context menu, select Add, and then New Item.

3. Select the Extensibility section, and then choose Command.

4. In the Name field at the bottom, enter a filename such as Command.cs.

Your new command file is visible in Solution Explorer. Under the Resources node, you can find other files related to your command. For example, if you wish to modify the image, the PNG file is here.

Set up your C++ Environment

C++ is a compiled language meaning your program’s source code must be translated (compiled) before it can be run on your computer. The C/C++ extension doesn’t include a C++ compiler or debugger, since VS Code as an editor relies on command-line tools for the development workflow. You need to install these tools or use the tools already installed on your computer.

Check if you have a compiler installed

Note: There may already be a C++ compiler and debugger provided by your academic or work development environment. Check with your instructors or colleagues for guidance on installing the recommended C++ toolset (compiler, debugger, project system, linter).

Common compilers that already come preinstalled on some platforms are the GNU Compiler Collection (GCC) on Linux and the Clang tools with Xcode on macOS.

To check if you already have them installed:

1. Open a new VS Code terminal window using (⌃⇧` (Windows, Linux Ctrl+Shift+`))

2. Use the following command to check for the GCC compiler

   
g++

   :
   
g++ --version


   Or this command for the Clang compiler

   
clang

   :
   
clang --version


The output should show you the compiler version and details. If neither are found, make sure your compiler executable is in your platform path (

%PATH

on Windows,

$PATH

on Linux and macOS) so that the C/C++ extension can find it. Otherwise, use the instructions in the section below to install a compiler.

Install a compiler

If you don’t have a compiler installed, you can follow one of our installation tutorials:

Windows:

Linux:

macOS:

Note: If you would prefer a full Integrated Development Environment (IDE), with built-in compilation, debugging, and project templates (File > New Project), there are many options available, such as the Visual Studio Community edition.

Create a Hello World App

To make sure the compiler is installed and configured correctly, lets create a Hello World C++ program.

Create a C++ file

1. On Windows, launch a Windows command prompt (Enter Windows command prompt in the Windows search bar). On macOS and Linux, you can enter these commands in the terminal.
2. Run the following commands. They are creating an empty folder called
   
projects

   where you can place all your VS Code projects. The next commands create and navigate you to a subfolder called
   
helloworld

   . From there, you are opening
   
helloworld

   directly in VS Code using the
   
code

   command.


mkdir projects cd projects mkdir helloworld cd helloworld code .


The “code .” command opens VS Code in the current working folder, which becomes your “workspace”. Accept the Workspace Trust dialog by selecting Yes, I trust the authors since this is a folder you created.

Now create a new file called

helloworld.cpp

with the New File button in the File Explorer or File > New File command.

Add Hello World source code

Paste in the following source code:


#include

int main() { std::cout << "Hello World" << std::endl; }



Now press ⌘S (Windows, Linux Ctrl+S) to save the file. You can also enable AutoSave to automatically save your file changes, by checking Auto Save in the main File menu.

Install a Python interpreter

Along with the Python extension, you need to install a Python interpreter. Which interpreter you use is dependent on your specific needs, but some guidance is provided below.

Windows

Install Python from python.org. Use the Download Python button that appears first on the page to download the latest version.

Note: If you don’t have admin access, an additional option for installing Python on Windows is to use the Microsoft Store. The Microsoft Store provides installs of supported Python versions.

For additional information about using Python on Windows, see Using Python on Windows at Python.org

macOS

The system install of Python on macOS is not supported. Instead, a package management system like Homebrew is recommended. To install Python using Homebrew on macOS use

brew install python3

at the Terminal prompt.

Note: On macOS, make sure the location of your VS Code installation is included in your PATH environment variable. See these setup instructions for more information.

Linux

The built-in Python 3 installation on Linux works well, but to install other Python packages you must install

pip

with get-pip.py.

Other options

• Data Science: If your primary purpose for using Python is Data Science, then you might consider a download from Anaconda. Anaconda provides not just a Python interpreter, but many useful libraries and tools for data science.

• Windows Subsystem for Linux: If you are working on Windows and want a Linux environment for working with Python, the Windows Subsystem for Linux (WSL) is an option for you. If you choose this option, you’ll also want to install the WSL extension. For more information about using WSL with VS Code, see VS Code Remote Development or try the Working in WSL tutorial, which will walk you through setting up WSL, installing Python, and creating a Hello World application running in WSL.

Note: To verify that you’ve installed Python successfully on your machine, run one of the following commands (depending on your operating system):

Linux/macOS: open a Terminal Window and type the following command:


python3 --version


Windows: open a command prompt and run the following command:


py -3 --version


If the installation was successful, the output window should show the version of Python that you installed. Alternatively, you can use the


py -0

command in the VS Code integrated terminal to view the versions of python installed on your machine. The default interpreter is identified by an asterisk (*).

Run it

You can now run the source code in the Visual Studio Experimental Instance.

Step 1. Press F5 to run the Start Debugging command. This command builds your project and starts the debugger, launching a new instance of Visual Studio called the Experimental Instance.

Step 2. On the Tools menu of the Experimental Instance, click Say Hello World!.

You should see the output from your new custom command, in this case, the dialog in the center of the screen that gives you the Hello World! message.

Next steps

In the next topic, Extension Anatomy, we’ll take a closer look at the source code of the

Hello World

sample and explain key concepts.

You can find the source code of this tutorial at: https://github.com/microsoft/vscode-extension-samples/tree/main/helloworld-sample. The Extension Guides topic contains other samples, each illustrating a different VS Code API or Contribution Point, and following the recommendations in our UX Guidelines.

Using JavaScript

In this guide, we mainly describe how to develop VS Code extension with TypeScript because we believe TypeScript offers the best experience for developing VS Code extensions. However, if you prefer JavaScript, you can still follow along using helloworld-minimal-sample.

UX Guidelines

This is also a good time to review our UX Guidelines so you can start designing your extension user interface to follow the VS Code best practices.

Example – Hello World

Your First Extension

This document will take you through creating your first VS Code extension (“Hello World”) and will explain the basic VS Code extensibility concepts.

In this walkthrough, you’ll add a new command to VS Code which will display a simple “Hello World” message. Later in the walkthrough, you’ll interact with the VS Code editor and query for the user’s currently selected text.

The Structure of an Extension

After running, the generated extension should have the following structure:


. ├── .gitignore ├── .vscode // VS Code integration │ ├── launch.json │ ├── settings.json │ └── tasks.json ├── .vscodeignore ├── README.md ├── src // sources │ └── extension.ts // extension.js, in case of JavaScript extension ├── test // tests folder │ ├── extension.test.ts // extension.test.js, in case of JavaScript extension │ └── index.ts // index.js, in case of JavaScript extension ├── node_modules │ ├── vscode // language services │ └── typescript // compiler for typescript (TypeScript only) ├── out // compilation output (TypeScript only) │ ├── src │ | ├── extension.js │ | └── extension.js.map │ └── test │ ├── extension.test.js │ ├── extension.test.js.map │ ├── index.js │ └── index.js.map ├── package.json // extension's manifest ├── tsconfig.json // jsconfig.json, in case of JavaScript extension ├── typings // type definition files │ ├── node.d.ts // link to Node.js APIs │ └── vscode-typings.d.ts // link to VS Code APIs └── vsc-extension-quickstart.md // extension development quick start


Let’s go through the purpose of all these files and explain what they do:

The extension manifest: package.json

• Please read the
  
package.json

  extension manifest reference
• More information on
  
package.json

  contribution points
• Each VS Code extension must have a
  
package.json

  file that describes it and its capabilities.
• VS Code reads this file during start-up and reacts to each
  
contributes

  section immediately.

Example TypeScript extension manifest


{ "name": "myFirstExtension", "description": "", "version": "0.0.1", "publisher": "", "engines": { "vscode": "^0.10.1" }, "categories": [ "Other" ], "activationEvents": [ "onCommand:extension.sayHello" ], "main": "./out/src/extension", "contributes": { "commands": [{ "command": "extension.sayHello", "title": "Hello World" }] }, "scripts": { "vscode:prepublish": "node ./node_modules/vscode/bin/compile", "compile": "node ./node_modules/vscode/bin/compile -watch -p ./" }, "devDependencies": { "typescript": "^1.6.2", "vscode": "0.10.x" } }


Note: A JavaScript extension doesn’t require the


scripts

field as no compilation is needed.

• This specific package.json describes an extension that:
• contributes an entry to the Command Palette (
  
kb(workbench.action.showCommands)

  ) with the label
  
"Hello world"

  that will invoke a command
  
"extension.sayHello"

  .
• requests to get loaded (activationEvents) when the command
  
"extension.sayHello"

  is invoked.
• has its main JavaScript code in a file called
  
"./out/src/extension.js"

  .

Note: VS Code does not load the code of an extension eagerly at start-up. An extension must describe, through the


activationEvents

property under what conditions it should get activated (loaded).

Code

The generated extension’s code is in

extension.ts

(or

extension.js

in case of a JavaScript extension):


// The module 'vscode' contains the VS Code extensibility API // Import the module and reference it with the alias vscode in your code below import * as vscode from 'vscode'; // this method is called when your extension is activated // your extension is activated the very first time the command is executed export function activate(context: vscode.ExtensionContext) { // Use the console to output diagnostic information (console.log) and errors (console.error) // This line of code will only be executed once when your extension is activated console.log('Congratulations, your extension "my-first-extension" is now active!'); // The command has been defined in the package.json file // Now provide the implementation of the command with registerCommand // The commandId parameter must match the command field in package.json var disposable = vscode.commands.registerCommand('extension.sayHello', () => { // The code you place here will be executed every time your command is executed // Display a message box to the user vscode.window.showInformationMessage('Hello World!'); }); context.subscriptions.push(disposable); }


• Each extension should export from its main file a function named
  
activate()

  , which VS Code will invoke only once when any of the
  
activationEvents

  described in the
  
package.json

  file occur.
• This specific extension imports the
  
vscode

  API and then registers a command, associating a function to be called when the command
  
"extension.sayHello"

  gets invoked. The command’s implementation displays a “Hello world” message in VS Code.

Note: The


contributes

section of the

package.json

adds an entry to the Command Palette. The code in extension.ts/.js defines the implementation of

"extension.sayHello"

.

Note: For TypeScript extensions, the generated file


out/src/extension.js

will be loaded at runtime and executed by VS Code.

Miscellaneous files

• 
.vscode/launch.json

  defines launching VS Code in the Extension Development mode. It also points with
  
preLaunchTask

  to a task defined in
  
.vscode/tasks.json

  that runs the TypeScript compiler.
• 
.vscode/settings.json

  by default excludes the
  
out

  folder. You can modify which file types you want to hide.
• 
.gitignore

  – Tells Git version control which patterns to ignore.
• 
.vscodeignore

  – Tells the packaging tool which files to ignore when publishing the extension.
• 
README.md

  – README file describing your extension for VS Code users.
• 
vsc-extension-quickstart.md

  – A Quick Start guide for you.
• 
test/extension.test.ts

  – you can put your extension unit tests in here and run your tests against the VS Code API (see Testing Your Extension)

Run helloworld.cpp

1. Make sure you have

   
helloworld.cpp

   open so it is the active file in your editor.

2. Press the play button in the top right corner of the editor.

3. Choose C/C++: g++.exe build and debug active file from the list of detected compilers on your system.

You are only prompted to choose a compiler the first time you run

helloworld.cpp

. This compiler becomes “default” compiler set in your

tasks.json

file.

1. After the build succeeds, you should see “Hello World” appear in the integrated Terminal.

Congratulations! You’ve just run your first C++ program in VS Code! The next step is to learn more about the Microsoft C/C++ extension’s language features such as IntelliSense, code navigation, build configuration, and debugging using one of the Tutorials in the next section.

Example: Install MinGW-x64 on Windows

To understand the process, let’s install Mingw-w64 via MSYS2. Mingw-w64 is a popular, free toolset on Windows. It provides up-to-date native builds of GCC, Mingw-w64, and other helpful C++ tools and libraries.

1. Download using this direct link to the MinGW installer.

2. Run the installer and follow the steps of the installation wizard. Note, MSYS2 requires 64 bit Windows 8.1 or newer.

3. In the wizard, choose your desired Installation Folder. Record this directory for later. In most cases, the recommended directory is acceptable. The same applies when you get to setting the start menu shortcuts step. When complete, ensure the Run MSYS2 now box is checked and select Finish. A MSYS2 terminal window will then automatically open.

4. In this terminal, install the MinGW-w64 toolchain by running the following command:

   
pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain


5. Accept the default number of packages in the

   
toolchain

   group by pressing Enter.

6. Enter

   when prompted whether to proceed with the installation.

7. Add the path to your MinGW-w64

   
bin

   folder to the Windows
   
PATH

   environment variable by using the following steps:

   1. In the Windows search bar, type Settings to open your Windows Settings.
   2. Search for Edit environment variables for your account.
   3. In your User variables, select the
      
Path

      variable and then select Edit.
   4. Select New and add the MinGW-w64 destination folder you recorded during the installation process to the list. If you selected the default installation steps, the path is:
      
C:\msys64\ucrt64\bin

      .
   5. Select OK to save the updated PATH. For the new
      
PATH

      to be available, reopen your console windows.

8. Check that your MinGW-w64 tools are correctly installed and available, open a new Command Prompt and type:


gcc --version g++ --version gdb --version


You should see output that states which versions of GCC, g++ and GDB you have installed. If this is not the case, make sure your PATH entry matches the Mingw-w64 binary location where the compiler tools are located or reference the troubleshooting section.

Feedback

If you run into any issues or have suggestions for the Microsoft C/C++ extension, please file issues and suggestions on GitHub. If you haven’t already provided feedback, you can take this quick survey.

Getting Started with C# in VS Code

This getting started guide introduces you to C# and .NET for Visual Studio Code through the following tasks:

1. Installing and setting up your VS Code environment for C#.
2. Writing and running a simple “Hello World” application using C#.
3. Introduce you to other learning resources for C# in VS Code.

Keep in mind, that this guide won’t teach you C#. Instead, it teaches you how to get set up for C# development in VS Code. If you’re looking for resources to learn C#, check out our C# curriculum.

Installing your Extension Locally

So far, the extension you have written only runs in a special instance of VS Code, the Extension Development instance. To get your extension running in all instances of VS Code, you need to copy it to a new folder under your local extensions folder:

• Windows:
  
%USERPROFILE%\.vscode\extensions

• Mac/Linux:
  
$HOME/.vscode/extensions


Generate a New Extension

The simplest way to add your own functionality to VS Code is through adding a command. A command is registers a callback function which can be invoked from the Command Palette or with a key binding.

We have written a Yeoman generator to help get you started. Install Yeoman and the Yeoman VS Code Extension generator and scaffold a new extension:


npm install -g yo generator-code yo code


For the hello world extension, you can either create a TypeScript extension or a JavaScript one. For this example, we pick a TypeScript extension.

Running your Extension

Now that the roles of the files included in the extension are clarified, here is how your extension gets activated:

• The extension development instance discovers the extension and reads its
  
package.json

  file.
• Later when you press
  
kb(workbench.action.showCommands)

  :
• The registered commands are displayed in the Command Palette.
• In this list there is now an entry
  
"Hello world"

  that is defined in the
  
package.json

  .
• When selecting the
  
"Hello world"

  command:
• The command
  
"extension.sayHello"

  is invoked:
• An activation event
  
"onCommand:extension.sayHello"

  is created.
• All extensions listing this activation event in their
  
activationEvents

  are activated.
  • The file at
    
./out/src/extension.js

    gets loaded in the JavaScript VM.
  • VS Code looks for an exported function
    
activate

    and calls it.
  • The command
    
"extension.sayHello"

    is registered and its implementation is now defined.
• The file at
• The command
  
"extension.sayHello"

  implementation function is invoked.
• The command implementation displays the “Hello World” message.

Create a virtual environment

A best practice among Python developers is to use a project-specific

virtual environment

. Once you activate that environment, any packages you then install are isolated from other environments, including the global interpreter environment, reducing many complications that can arise from conflicting package versions. You can create non-global environments in VS Code using Venv or Anaconda with Python: Create Environment.

Open the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), start typing the Python: Create Environment command to search, and then select the command.

The command presents a list of environment types, Venv or Conda. For this example, select Venv.

The command then presents a list of interpreters that can be used for your project. Select the interpreter you installed at the beginning of the tutorial.

After selecting the interpreter, a notification will show the progress of the environment creation and the environment folder (

/.venv

) will appear in your workspace.

Ensure your new environment is selected by using the Python: Select Interpreter command from the Command Palette.

Note: For additional information about virtual environments, or if you run into an error in the environment creation process, see Environments.

Debugging the extension

VS Code’s built-in debugging functionality makes it easy to debug extensions. Set a breakpoint by clicking the gutter next to a line, and VS Code will hit the breakpoint. You can hover over variables in the editor or use the Run and Debug view in the left to check a variable’s value. The Debug Console allows you to evaluate expressions.

You can learn more about debugging Node.js apps in VS Code in the Node.js Debugging Topic.

Remote Development

VS Code and the C++ extension support Remote Development allowing you to work over SSH on a remote machine or VM, inside a Docker container, or in the Windows Subsystem for Linux (WSL).

To install support for Remote Development:

1. Install the VS Code Remote Development Extension Pack.
2. If the remote source files are hosted in WSL, use the WSL extension.
3. If you are connecting to a remote machine with SSH, use the Remote – SSH extension.
4. If the remote source files are hosted in a container (for example, Docker), use the Dev Containers extension.

A Simple Change

In

extension.ts

(or

extension.js

, in a JavaScript extension), try replacing the

extension.sayHello

command implementation to show the number of characters selected in the editor:


var editor = vscode.window.activeTextEditor; if (!editor) { return; // No open text editor } var selection = editor.selection; var text = editor.document.getText(selection); // Display a message box to the user vscode.window.showInformationMessage('Selected characters: ' + text.length);


Tip: Once you make changes to the extension source code, you need to restart the Extension Development instance of VS Code. You can do that by using


kbstyle(Ctrl+R)

(Mac:

kbstyle(Cmd+R)

) in the second instance or by clicking the Restart button at the top of your primary VS Code instance.

Video outline

• Download and install VS Code.
• Open a folder
  • File > Open Folder (Ctrl+K Ctrl+O)
• File Explorer
  • View > Explorer (⇧⌘E (Windows, Linux Ctrl+Shift+E))
• Search view
  • View > Search (⇧⌘F (Windows, Linux Ctrl+Shift+F))
• Source Control
  • View > Source Control (SCM) (⌃⇧G (Windows, Linux Ctrl+Shift+G))
• Run and Debug
  • View > Run (⇧⌘D (Windows, Linux Ctrl+Shift+D))
• Extensions view
  • View > Extensions (⇧⌘X (Windows, Linux Ctrl+Shift+X))
• Open the Command Palette.
  • View > Command Palette… (⇧⌘P (Windows, Linux Ctrl+Shift+P))
• Output panel
  • View > Output (⇧⌘U (Windows Ctrl+Shift+U, Linux Ctrl+K Ctrl+H))
• Debug Console
  • View > Debug Console (⇧⌘Y (Windows, Linux Ctrl+Shift+Y))
• Problems panel
  • View > Problems (⇧⌘M (Windows, Linux Ctrl+Shift+M))
• Integrated Terminal
  • View > Terminal (⌃` (Windows, Linux Ctrl+`))
• Create a new file
  • File > New File (⌘N (Windows, Linux Ctrl+N))
• Save a file
  • File > Save (⌘S (Windows, Linux Ctrl+S))
• Auto Save
  • File > Auto Save
• Run
  • Run > Start Debugging (F5)
• Programming language extensions
  • Python – IntelliSense, linting, debugging, code formatting, refactoring, and more.
  • Live Preview – Hosts a local server to preview your webpages.
• Zoom
  • Zoom out (⌘- (Windows, Linux Ctrl+-))
  • Zoom in (⌘= (Windows, Linux Ctrl+=))
• Customize your editor with color themes.
  • File > Preferences > Theme > Color Theme (⌘K ⌘T (Windows, Linux Ctrl+K Ctrl+T))

Create a Hello World app

First, ensure you are within the new folder (workspace) that you created. From here, you can create the project in two ways.

Use the Command Palette

1. Bring up the Command Palette using ⇧⌘P (Windows, Linux Ctrl+Shift+P) and then type “.NET”.
2. Find and select the .NET: New Project command.
3. After selecting the command, you’ll need to choose the project template. Choose Console app.
4. To run your app, select Run > Start Debugging in the upper menu, or use the F5 keyboard shortcut. To learn more about debugging your C# project, read the debugging documentation.

Use the terminal

1. Open a terminal/command prompt and navigate to the folder in which you’d like to create the app. Enter the following command in the command shell:

   
dotnet new console


2. When the project folder is first opened in VS Code:

   A “Required assets to build and debug are missing. Add them?” notification appears at the bottom right of the window.

   Select Yes.

3. Run the app by entering the following command in the command shell:

   
dotnet run


Modify the source code

At this point, the command and Button text are autogenerated and not that interesting. You can modify the VSCT file and CS file if you want to make changes.

• The VSCT file is where you can rename your commands, and define where they go in the Visual Studio command system. As you explore the VSCT file, notice comments that explain what each section of the VSCT code controls.

• The CS file is where you can define actions, such as the click handler.

1. In Solution Explorer, find the VSCT file for your extension VSPackage. In this case, it’s called HelloWorldPackage.vsct.

2. Change the

   
ButtonText

   parameter to
   
Say Hello World!

   .
   
...



Say Hello World!



...


3. Go back to Solution Explorer and find the Command.cs file. In the

   
Execute

   method, change the string
   
message

   from
   
string.Format(..)

   to
   
Hello World!

   .
   
... private void Execute(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); string message = "Hello World!"; string title = "Command"; // Show a message box to prove we were here VsShellUtilities.ShowMessageBox( this.ServiceProvider, message, title, OLEMSGICON.OLEMSGICON_INFO, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); } ...


Make sure to save your changes to each file.

Running your Extension

• Launch VS Code, choose
  
File

  >
  
Open Folder

  and pick the folder that you generated.
• Press
  
kb(workbench.action.debug.start)

  or click on the
  
Debug

  icon and click
  
Start

  .
• A new instance of VS Code will start in a special mode (
  
Extension Development Host

  ) and this new instance is now aware of your extension.
• Press
  
kb(workbench.action.showCommands)

  and run the command named
  
Hello World

  .
• Congratulations! You’ve just created and executed your first VS Code command!

Keywords searched by users: hello world visual studio code

Categories: Khám phá 36 Hello World Visual Studio Code

See more here: kientrucannam.vn

See more: https://kientrucannam.vn/vn/