This is your brain. This is your brain on computers.

Learn Visual Studio 2019 With No Experience in 2020

Whether you’re a student about to graduate, a recent graduate with a STEM degree, someone wanting to switch careers to software development, or someone just interested in learning more about software development, chances are high that you’ll need to use Visual Studio 2019 (and future versions) to manage your code. As one of the most complete IDEs on the market (free versions too), you’ll find support for C#, VB, C++, Python, C, HTML, CSS, TypeScript, F#, and a few others. With extensions, you might find support for more. That said, the flexibility and volume of choices can be overwhelming to beginners who have no idea where to start. Lucky you. You’ve found the perfect place to learn Visual Studio 2019 with no prior experience.

Yes, Visual Studio is tied to Windows. Yes, it’s created by Microsoft. Both of those associations can discourage people tied to open source. But the reality of the situation is that Microsoft has been making big strides in open source by creating tools like Visual Studio Code, opening up the source for .NET Core, and integrating Linux with Windows. Say whatever you want about Microsoft’s motives, some of their ducks are certainly in a row.

Here’s a quick disclaimer. This guide isn’t intended to be the absolute end to all Visual Studio documentation. If you read this guide from beginning to end, you’ll be dangerous enough to create solutions and projects, manage your files, manage project dependencies, customize your workspace, edit code, compile projects, fix errors, use source control, and get set up with some application extensions. No section will be exhaustive in its focus but will guide you in a direction of where to go so that you can begin learning more through hands on experience and self-learning.

By the way! Visual Studio 2019 is just one of the many great tools we suggest installing into your toolbox. There are other IDEs, lightweight editors, and development applications that you should learn so that you’ll have flexible options when tackling complex problems.


First things first. You’ll need to download and install Visual Studio before you can begin using it obviously. Don’t confuse Visual Studio 2019 with Visual Studio Code. They’re different tools for different purposes. In this guide, we are exclusively focusing on Visual Studio 2019.

Download Visual Studio 2019 Community Edition (free). Read our pricing guide for more detailed comparisons between editions. We suggest the Community Edition because you won’t need any of the features offered by the pricier (and they can be pricey) tiers.

Browser window showing where to click to download Visual Studio 2019 community edition.

You’re not going to need the thousands of options that are available to you during the initial installation process. This guide only uses the “.NET Core cross-platform development” group and its required dependencies. Feel free to opt in to anything else you think looks interesting but be aware that you will have to download everything. Some of these options can increase the download size by 5+ GB. Don’t worry if you don’t select anything else right now. You can always open this installer later and incrementally install things that you want to learn.

Visual Studio installer UI showing to install only .NET Core tooling.

Let the installer do its thing. Sit back, relax, and wait for the magic. While it’s downloading, you can check out our article on 5 Essential Visual Studio Extensions. Used properly, extensions have the potential to boost your productivity and development efficiency.

Creating a Project

Once everything is installed, the first order of business is to create something and take a tour of the user interface. Go ahead and open Visual Studio. You’ll first see the splash screen with some options to open or create projects.

In Visual Studio, the core collection of files is considered a Project. For example, you could have a Console App Project, a Website Project, or a Database Project.

Here is a non-exhaustive list of some things a Project determines:

  • Which files belong together (code, plain text, JSON, dependencies, and more)
  • Dependencies of that project such as NuGet packages (more on these later), DLLs, Windows SDKs, or other Projects that you’ve created
  • Which frameworks are being targeted during the compile process (.NET Framework version, .NET Core version)
  • Output types of the compilation such as executable or library

Since you have nothing created yet, you’ll have to create a new project in the lower right.

Visual Studio comes packed with project templates based on the options you selected during installation. For example, if you chose .NET Core and Database Tools, you’ll see project templates for .NET Console Apps, Database Projects, and other projects in those categories.

In your case, if you followed this guide exactly, you should search for “console” in the search box at the top to find the “C# Console App (.NET Core)” template. The language is indicated by the little green “C#” icon next to the title of the project template. Select it and click Next.

Visual Studio UI showing where to create a new .NET Core console application.

Next, name your project and confirm that the location in which it will be created is accurate. The worst feeling is when you’ve just created something but have no idea where it went on your hard drive. Keep the Solution name the same as the Project name for now. We’ll explain more about this later.

Visual Studio will then bootstrap whatever template you chose and open everything in the main user interface window for you to begin creating code.

Getting Acquainted With the UI

If you’ve never used Visual Studio before (and we’re assuming you haven’t), then you might be overwhelmed by the sheer volume of choices presented to you after project creation. Don’t look at everything at once. Let’s break down the user interface into the main sections one by one so that you can begin to understand them in isolation. Then you’ll be able to piece them together to understand how they interact with each other.

Note that this section of the guide isn’t intended to explain everything there is to know about each user interface group. There are detailed sections later in this guide which do a better job at that. Instead, use this section to get an overall picture of the main user interface to understand what and where things are located.

Remember to refer back to this image for each of the subsections below as the numbers correlate to the headers.

(1) Toolbars

Starting from the top are the toolbars (of which there are many that you can customize). By default, you’ll see the menu bar and the standard bar. While you can add and remove toolbars and the items within them, don’t go overboard. You’ll probably end up confusing yourself with too many or not enough options. We find that sticking to the default covers most scenarios. Of course, you can ignore us entirely and make it work best for you!

  1. New, Open, Save: Icons to open the new project wizard, open an existing file, save the currently open file, and save all files simultaneously. We suggest memorizing the shortcuts for these.
  2. Build: Menu to build, clean, rebuild, and manage build configurations. See below section on compiling your project.
  3. Debug: Button to begin debugging your project. See below section on debugging your project.
  4. Search: Global search across literally everything in Visual Studio including menus, settings, your solution, your project, your files. This is a seriously cool feature that makes it easy to find whatever you’re looking for anywhere in the application.

(2) Login to Microsoft Account

Many of the built-in features to Visual Studio require you to login to your Microsoft account so that you can link the product to your account. This will make sure that you’re licensed to use the edition you downloaded (in this case Community is free). You can also synchronize your Visual Studio settings across devices using your Microsoft account. If you don’t have a Microsoft account, you can also use your GitHub account. If you don’t have a GitHub account, you really should get one ASAP!

(3) Solution Explorer

On the right is the Solution Explorer. This is where you manage projects, dependencies, files, and more. If you’re familiar with the Windows File Explorer, then you’ll see that it’s quite similar. See the section below regarding Managing Files in a Project for more details.

  1. Solution Name: Name of the solution that is currently open. Solutions are collections of Projects which make it easy to group together related Projects for an application. For example, a web application might have a Project for HTML and CSS, a Project for business logic, and another Project for database connections.
  2. Project Names: List of Projects that exist under the opened Solution. Here you can add, remove, rename, and modify specific Projects.
  3. Dependencies List in Project: Dependencies are libraries and Projects that are required to exist before your application will function.
  4. File List in Project: List of files that exist in the project such as configuration files, classes, and databases.

(4) Text Editor

This is what you’re here for, right? The majority of the user interface is consumed by the text editor and rightly so. It is, after all, the most used part of the tool.

  1. Opened Files Tab: Across the top of the editor is a collection of tabs for each opened file.
  2. File Context: Below that is a bar indicating the context of the open file in relation to the Solution and Project. From left to right you can see the Project in which the file belongs, the namespace of the active class, and the name of the active function.
  3. File Content Editor: The editor where you can obviously type your code!
  4. Error/Warning Indicator: A quick visual indicator if there are any problems, errors, or warnings with the current state of your Project.
  5. File Metadata: A quick indicator of which line and character the cursor is, if you have TABS or SPACES active, and which line ending character you have active (CR, LF, CRLF).

(5) Errors, Output, More…

Across the bottom is a customizable collection of supporting windows such as Error List, Output, and Package Manage Console. There are a lot of other windows that can be docked here (many of them come from extensions), but we won’t cover them all here. The most important one to get used to is the Errors List Window. It will be your best friend and your worst enemy.

  1. Filter Errors, Warnings, Info: The three buttons near the top allow you to show/hide errors, warnings, and info messages in case you want to drill down into specific bug finding modes.
  2. Errors, Warnings, Info List: Displays detailed error, warning, and info messages about the active Solution. For example, if files can’t be found, or your code contains syntax errors, you’ll see a breakdown with line numbers of where those errors are occurring.
  3. Output and Package Manager Console Windows: Tabs across the bottom to switch between supporting windows. The Output Window is a generic console output for build results. The Package Manager Console is a Powershell emulator used to manage optional NuGet packages in your Solution and Projects.

(6) Properties Window

In the bottom right is a window containing details about the actively selected object in the editor. Pictured here is what the window displays if you have the Program.cs file selected and opened. This allows you to see and modify properties about the file such as build tasks, file names, and file paths.

Note that this window can vary dramatically depending on each type of object selected, so it isn’t possible to show every type of variation in this guide. The important thing to know is that this window is where you go to see details about selected objects. This becomes most important when using user interface designers with tools like WPF and Windows Forms.

Managing Solutions, Projects, and Files

A large portion of time in any development effort is spent managing files. Whether you’re creating them, moving them around, renaming them because you hate your original idea, or deleting them out of frustration, you’re going to need to get used to the way in which you perform these operations in Visual Studio. Sure, you can use the command line, but why context switch away from a perfectly good user interface complete with shortcuts?

Solution Explorer

Mentioned briefly above in this article, the Solution Explorer is where you manage all files in your Solutions and Projects. In this Window, the most commonly used features are:

  • Rename Solution, Projects, and Files
  • Add Projects to the active Solution
  • Add Files to the Projects in the Solution
  • Remove Projects from the active Solution
  • Remove files from the Projects in the Solution
  • Cut, Copy, Move Files between Projects and Folders
  • Build Solution and Projects
  • Manage NuGet packages in Solution and Project
  • Add references and dependencies to a Project

There are many other options that are revealed when right clicking on a Solution, Project, or File, so take some time to look through those menus. Many extensions and updates will modify these context menus, so be aware that they may grow over time.

Solutions Versus Projects

As a reminder, there are differences between Solutions and Projects. Projects are collections of Files and Dependencies to build compiled for a specific purpose like a library or an executable. Solutions are collections of Projects which make it easy to group together related Projects for an application. For example, a web application might have a Project for HTML and CSS, a Project for business logic, and another Project for database connections.

Here is a non-exhaustive list of some things a Project determines:

  • Which files belong together (code, plain text, JSON, dependencies, and more)
  • Dependencies of that project such as NuGet packages (more on these later), DLLs, Windows SDKs, or other Projects that you’ve created
  • Which frameworks are being targeted during the compile process (.NET Framework version, .NET Core version)
  • Output types of the compilation such as executable or library

Here is a non-exhaustive list of somethings a Solution determines:

  • Which Projects belong together (UI/UX, business logic, database connections)
  • Active build configurations to determine if Projects should be build using flags like 32-bit or 64-bit (and many other options)
  • Which Project is the “Startup Project” to determine where the entry point of the application is during debugging sessions

You can only have one active Solution open at any given time. If you attempt to open another Solution, Visual Studio will warn you that it will close the existing Solution and open whichever one you’ve requested. Keep that in mind in case you have unsaved changes.


Every Project has dependencies. Even if you built nothing more than a Console App that outputs “Hello World,” your Project will still have a dependency on the .NET Framework to function correctly. Traditionally, managing dependencies has been described as “hell.” Fortunately, Visual Studio makes it easy to manage your dependencies to avoid getting in to things like circular dependency loops or versioning mismatches.

In the Solution Explorer, you’ll see a drop down of dependencies of things like COM libraries, Frameworks, NuGet Packages, and referenced Projects. This helps you understand what you need before your project will compile and provides you with a hierarchy of dependencies for dependencies. Yikes, that sounds ugly, but it’s not so bad when you drill in to see everything on which your application relies.

References and be added and removed by right clicking the dependencies drop down. In the case of adding dependencies, you will use the Reference Manager Window. In this window, you’ll have the ability to search for local Projects to reference, COM libraries installed on your machine, or browsing manually for DLLs on your machine. You might use the last option in case you downloaded a precompiled library online that you want to manually reference and use in your project.

Add a New Class to Project

Using the Project created at the beginning of this guide, let’s add a new class file to the Project.

  • Right click the Project
  • Click Add > New Item…
  • Select Class from the window
  • Name the Class “MyClass” at the bottom
  • Click Add

Notice that a new file was added in the tree of your Project in the Solution Explorer. Now you can open that file and begin editing it if Visual Studio hasn’t already opened it for you.

You can add files at any level of the file hierarchy including at the top level Solution, the inner Projects, or folders within either of those levels.

Modify Files via Text Editor

Clicking on a File in the Solution Explorer will open it in the Text Editor. This is the main way that you interact with and modify files.

We highly suggest you perform the following customization until you get to a point where you are comfortable with the look and feel of the editor. You are, after all, going to spend the vast majority of your time interacting with this section. If it doesn’t feel right, you’ll experience a huge motivation drain.

  • Zoom: In the lower left, you’ll see a zoom indicator. Move it up and down until you find a good size for you.
  • TABS or SPACES: In the lower right, you’ll see a “TABS” or “SPC” text which indicates if you’re using TABS or SPACES. Obviously this is hugely personal, so we won’t tell you which one to pick, but definitely pick one that makes you happy.
  • Syntax highlighting: We wrote about this one in another article because it’s super important. In our opinion, the default colors in Visual Studio aren’t the greatest (especially the light theme). Install the Color Themes and the Color Themes Editor extensions to play around with colors that make you feel the most productive. Or use a prebuilt theme like Dainty.

The rest of the text editor is self explanatory if you’ve ever used any other text editor. Type what you want into it to create your code and be on with your day.

Simple Code Navigation

In complex Solutions, you’ll have a variety of Projects filled with a variety of Files which are in turn filled with a variety of classes and functions. Memorizing where everything is simply isn’t possible. Consider a scenario wherein you’ve created a function that’s called from three different Projects. A few months will go by, and we guarantee you’ll forget from where that function is called. As you’re editing your function, you might want to know which consumers you’ll break by updating a function signature.

That’s where the following code navigation shortcuts come in handy. All the commands seen below are used in the context of a selected item in the text editor window. You may want to jump to a definition of an object, a function, or a class. Or maybe you want to traverse an inheritance tree to quickly find where a base function is implemented.

Note that the shortcuts below are the default choices. You can change them to whatever you want.

Peek Definition (ALT + F12). In the screenshot below, you can see that the ProcessCommandAsync function is being called and its definition is revealed through the Peek Definition command. Instead of navigating you away from your current editor, the definition of the function will be revealed in a small box below the calling site. This lets you quickly look at where and what the implementation for the function is. Note that if you are referencing a function on an interface, the definition will be the interface and not the implementation. See “Go To Implementation” below.

Go To Definition (F12). Similar to Peek Definition, Go To Definition will reveal where the function is defined but will open the file in which the function is defined and switch the current editor to that file. Note that if you are referencing a function on an interface, the definition will be the interface and not the implementation. See “Go To Implementation” below.

Go To Base (ALT + HOME). In the event that you are using a class that inherits from a base class, you can jump from that class directly to its base class through this option. This makes it easier to traverse up an inheritance hierarchy.

Go To Implementation (CTRL + F12). This is probably our most used shortcut aside from saving and building the Solution. While you can use Go To Definition to see where the function is defined, you won’t be able to see the implementation if the definition exists on an interface. This option will bypass the interface definition and take you directly to the definition of the function. Note that if there are multiple definitions (for example, your interface IRunnable is implemented by both Cat and Dog classes, you will need to tell the editor which of the definitions you want to see.

Find All References (SHIFT + F12). Remember we mentioned at the beginning of this section that you would probably forget from where your function is being called? This command is your best friend in those scenarios. You can easily find all places that an object, class, or function is being referenced in your Solution by selecting the object and using this command. You’ll be presented with a hierarchy of where the references are located in the References Window tab next to the Error List and Output Windows. Clicking on a reference in the window will navigate you to the file and line where the reference is found.

View Call Hierarchy (CTRL + K, CTRL + T). For a more detailed look into the full context of a function, you can use this command to see a detailed hierarchy of everything involved in the calling chain. As seen in the screenshot below, the ProcessCommandAsync function in the IAzureFunctionClient interface is called from the ExecuteAsync function in the TwitchBotWorker class. Clicking the specific call will show the call site details in the right window with the code at that line, the file name, and the exact line numbers and help you navigate to that location immediately. Use this function when you want a complete view of a function’s reference chain.

Compiling Code

Creating Projects and writing code wouldn’t be very useful if you couldn’t compile it. That is the whole point of an IDE, isn’t it? To make the configuration and compilation process easier?

In the main toolbar, click Build to see options related to building the entire solution, building a specific project. or managing build configurations. Here’s a quick rundown of the most popular options:

  • Build Solution: builds the entire solution by compiling all projects and linking dependencies
  • Rebuild Solution: cleans and then builds the entire solution
  • Clean Solution: removes files from output directories (typically bin and obj folders)
  • Configuration Manager: allows you to configure specific build details and customization for each project’s build steps

Test Compile

Using the project at the beginning of this guide, build your solution. Navigate to the output directory of your solution to see what the build process created. The output directory is most likely at a location like so: <path to your solution>\<project name>\bin\Debug\netcoreapp3.1

Note that the netcoreapp3.1 folder will change based on the version of .NET Core that you’re targeting in your build configuration (see below).

If compilation was successful, you’ll see the output of the build includes an executable, a DLL, configuration files, and the debugging symbols (pdb).

Build Configurations

Under the Configuration Manager option in the Build menu (also accessible by right clicking the Solution in the Solution Explorer), you can set up solution configurations to create customized build steps. This allows you to select a build configuration per project, which platform to target (32-bit, 64-bit), which projects should be built, and which should be deployed. For most projects, the default setup is enough, but you may want to create your own build configurations if you have custom build tasks or unique constraints depending on your project’s needs.

So what the heck is a build configuration then? Right click any project in the Solution Explorer and click Properties. Then click the Application and Build tabs on the left. You’ll see the the application details and build configurations for that project displayed.

In the Application tab, you’ll see the following:

  • Assembly name: determines the name of the library and executable files that are output during compilation
  • Default namespace: determines the namespace that is included by default when you create new classes and interfaces
  • Target framework: determines which .NET framework is targeted as part of compilation
  • Output type: determines if this will compile to a library DLL or an application executable
  • Startup object: if this is an application project (like a Console Application), determines where the entry point of the application is (like a Main method)

In the Build tab, if this is a new project, you’ll probably see “Active (Debug)” showing in the Configuration drop down. That means if you build or debug the project now, the “Debug” configuration will apply. Changing the drop down will change the active build configuration and thus alter the build and debug process in real time.

You shouldn’t need to modify anything in these windows unless you have unique constraints or needs for your project. The defaults are usually enough to get you by for personal projects, especially those that you’re building for your GitHub portfolio.

Reference the image below for information about some common build options.

  • Define DEBUG constant includes a compiler constant named DEBUG that you can use with the #if DEBUG syntax to execute code only if this constant is defined
  • Define TRACE constant includes a compiler constant named TRACE to indicate inclusion of verbose logs
  • Optimize code flag has too many variables to explain in this article, but it’s common to include in release builds due to potential performance and size improvements. Read more here.
  • Output path is simply the folder to which the compilation process will output. Unless you really need to change this, leave it blank to keep the default.

Fixing Errors and Warnings

Over time, you will inevitably run into compilation and project errors and warnings. While the latter can sometimes safely be ignored, the former most certainly needs to be addressed before you can make any progress.

While it isn’t possible to outline the details of every type of error since there are an uncountable number of them, we can at least explain where you find the errors and general advice of tackling them.

There are two main scenarios under which you will encounter build errors. First, Visual Studio will automatically flag errors in real time such as when you forget a semi-colon to end a line. Second, when you build the solution, errors may appear related to dependencies, disk permissions, or other more egregious errors that Visual Studio doesn’t detect in real time.

Regardless of when the errors are found, you’ll see them listed in the Error List at the bottom of the application. This window will indicate the type of error, a usually helpful description, the project/file in which it occurred, and the exact line number. Double-clicking on an error will open the affected file and jump to the relevant line number. Then you can begin to fix the problem quickly.

Remember to use resources like StackOverflow if you get stuck on a specific error. Search before you ask because it’s extremely likely someone else has already found and resolved the same problem. As you continue to learn (stay organized and motivated), you’ll start to familiarize yourself with the most common types of errors and immediately know how to fix it.


There’s a lot to like about Visual Studio, but the debugging experience isn’t just liked; it’s loved. This feature alone will quite literally save you hours of time when trying to figure out why your application is not working. You’ll have the ability to step into a specific line being executed at run time, rewind execution, inspect variables, navigate throughout the stack, and a lot more.

Using the project created at the beginning of this guide, you should have a Console Application with nothing more than a Program class, a Main method and a Console.WriteLine statement like seen below:

class Program
  static void Main(string[] args)
    Console.WriteLine("Hello World!");

Modify this to declare a variable, initialize its value, and then write it to the console like below:

class Program
  static void Main(string[] args)
    int x = 10;

Click in the gutter to the left of the Console.WriteLine statement to add a breakpoint (indicated by a red dot, see below). This indicates that you want the debugger to stop on this line to allow you to inspect the context.

Now click the “Play/Debug” button in the standard toolbar as described in the “Getting Acquainted With the UI” section of this guide. This will start the debugger, launch whatever Project is set as the “Startup Project” in the Solution properties, and enter the class that is set as the “Startup object”. By default, the Program class will be the startup object.

The debugger will pause on your breakpoint and focus your window to that line. If you hover variables, you’ll see a popup (like the one seen below) which shows the value of that variable. In the below screenshot, you can see that x is equal to 10 at the time of calling the WriteLine statement. More complex objects have the ability to drill in to the object hierarchy using this debugging inspection.

You can also use the bottom windows like Autos, Locals, Call Stack, and Breakpoints to see more contextual details of where you’re paused in the debugger.

  • Autos will show values of variables at the highlighted breakpoint. In this case, we see x = 10.
  • Locals will show values of variables in the local scope beyond the highlighted breakpoint.
  • Call Stack will show the entire function call stack with the current breakpoint highlighted in the stack. You can click to jump up and down the stack in this window.

Using Git

Note! Check out our complete guide to using Visual Studio 2019 with Git for a comprehensive look at the most common use case scenarios.

Many developers prefer having the ability to manage source code repositories inline with the development environment to reduce having to context switch between applications. The downside to this is that you lose the flexibility and customization of the command line. If you’re new to Git, we suggest you start with our extensive guide to Git and follow that up with this section so that you know how things are working under the hood.

In the same window as the Solution Explorer (on the right by default), there’s a tab named Team Explorer. Click that to show all the functionality for managing code repositories (whether it’s in TFVC or Git).

Here is a high level description of each section. Check out our huge guide to using Visual Studio 2019 + Git for a comprehensive look at the most common use cases.

  • Changes: Similar to using git diff by seeing which files have been added/modified/deleted and what the line differences are. Opening the changed file shows the side by side file differences.
  • Branches: Shows local and remote branches for whatever repository you have open. Allows you to create, modify, delete, and checkout branches. Remember to branch and merge often!
  • Pull Requests: This is only applicable when connecting to a remote repository that supports pull requests like GitHub. You can create pull requests, see which ones you’ve created, and see which ones are assigned to you. While we prefer to use the user interfaces provided by the specific host like GitHub or Bitbucket, this feature can be mildly useful if you absolutely prefer your entire developer workflow to stay in Visual Studio.
  • Sync: When connected to a remote repository, you can use this option to fetch, pull, push, and sync changes to and from remotes. “Sync” in this context means that it will pull and push changes simultaneously to avoid having to perform the operations separately.
  • Tags: Here you can create tags, push tags to a remote, and create branches from a tag.
  • Settings: Enter global and repository settings like user name, email address, default repository locations, default merge/diff tools, remotes, ignore and attribute files, and a variety of other Git settings.

Installing Extensions

Note! Check out our favorite top 5 Visual Studio 2019 extensions for productivity boosting and efficiency gaining improvements.

Extensions are a huge benefit to Visual Studio mainly due to the great SDK that Microsoft publishes but also because of the large ecosystem already available for you to use. Like any application that allows for custom extensions and plug-ins, however, you can get yourself into trouble by installing too many of them. Experiment with some to find the best that work for your use cases. Don’t go overboard because you’ll get overwhelmed by the options added to context menus and may even have performance problems with conflicting extensions. Also, be aware that some of the more popular extensions are free trials that require payment.

To start, click Extensions > Manage Extensions from the main toolbar.

You’ll see the following on the left:

  • Installed: Shows the currently installed extensions.
  • Online: Shows extensions that are available to install from the online marketplace.
  • Updates: Shows extensions that you have installed and which have updates from the online marketplace.
  • Roaming Extension Manager: Allows you to keep a list of extensions synchronized across devices.

Note that it can be confusing to think that you are looking at installed extensions when in fact you are looking at online extensions. The user interface doesn’t make it obviously clear if the extension is installed or not. Look for the green check mark next to an extension to see if you have it installed.

To download an extension, go to the Online tab, find one that you want, and click the Download button. After download, Visual Studio will sometimes require you to restart the application to complete the installation or update process.

To update an extension, go to the Updates tab, find one that you want to update, and click the Update button. Like installing a new extension, you might need to restart Visual Studio.

To remove an extension, go to the Installed tab, find on that you want to remove, and click the Disable, Revert, or Uninstall button. Again, you might need to restart Visual Studio to complete the process.

Justin Skiles

Justin Skiles

Justin has been developing enterprise application software for over 10 years primarily using Microsoft stacks, Azure, and various open source tools. He has most recently been trying his best as a Manager and Director of Software Engineering in the health care industry.

Share the Knowledge

Share on facebook
Share on twitter
Share on linkedin
Share on pinterest
Share on facebook
Share on twitter
Share on linkedin
Share on pinterest

Follow our updates



Keep Exploring. Choose Your Path.