Chapter 2 - Setting Up Your .NET API Development Environment

Setting Up Your .NET API Development Environment

Before building robust and production-grade APIs, you must configure a proper development environment. A clean setup ensures smooth coding, debugging, package management, and deployment workflows. In this chapter, we will go through every essential component, including .NET installation, IDE setup, database tools, Git, API testing tools, and Docker.

1. Install the Latest .NET SDK

The .NET SDK includes compilers, runtime, CLI tools, and libraries needed to build Web APIs. Always install the latest LTS version (.NET 6 or .NET 8).

Check if .NET is installed:

dotnet --version

Check installed SDKs:

dotnet --list-sdks

Check installed runtimes:

dotnet --list-runtimes

If no SDK is installed, download from the Microsoft .NET download page. Once installed, re-run the above commands to confirm.

2. Choose Your IDE

Two primary IDEs are used for .NET API development:

Visual Studio 2022

Best for Windows users
Built-in Web API templates
Powerful debugger, profiler, and designer
NuGet + Git integration
Docker support

Visual Studio Code

Cross-platform (Windows, Linux, macOS)
Requires C# Dev Kit extension
Lightweight and fast
Perfect for containerized environments

3. Create Your First Web API Project

After installing the SDK and IDE, you can create your first API using the .NET CLI. Run the following command:

dotnet new webapi -o MyFirstApi

Navigate into the project folder:

cd MyFirstApi

Run the project:

dotnet run

This launches Kestrel web server. You will see output similar to:


Building...
info: Microsoft.Hosting.Lifetime[14]
Now listening on: https://localhost:7224
Now listening on: http://localhost:5224

4. Understanding the Generated Folder Structure

The default .NET API folder structure looks like this:


MyFirstApi/
│-- Controllers/
│     └── WeatherForecastController.cs
│-- Properties/
│-- appsettings.json
│-- Program.cs
│-- MyFirstApi.csproj

Sample Program.cs (shortened):


var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();

This is the heart of your API application: configuration, services, routing, and pipeline.

5. Install Database Tools

Most APIs rely on a relational database. The recommended option is SQL Server or Azure SQL.

Connection String Example (appsettings.json):


"ConnectionStrings": {
    "DefaultConnection": 
        "Server=localhost;Database=MyApiDb;Trusted_Connection=True;"
}

Useful DB Tools:

SQL Server Management Studio (SSMS)
Azure Data Studio
SQL Server Express
PostgreSQL / MySQL (optional)

6. Install API Testing Tools

To test API endpoints easily, install:

Postman – Best for testing REST APIs
Swagger – Auto-generated from .NET templates
Thunder Client (VS Code extension)

Sample GET request using curl:

curl -X GET https://localhost:7224/WeatherForecast

7. Install Git & Configure Version Control

Git is essential for tracking changes and enabling collaboration.

Initialize Git:

git init

Add files:

git add .

Commit changes:

git commit -m "Initial project setup for .NET API"

Connect to GitHub:


git remote add origin https://github.com/username/MyFirstApi.git
git push -u origin main

8. Set Up Docker (Optional but Important)

Docker helps you package your API into containers, making deployment easier and consistent.

Sample Dockerfile for ASP.NET Core API:


FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyFirstApi.dll"]

Build Docker Image:

docker build -t myfirstapi .

Run Container:

docker run -p 8080:80 myfirstapi

9. Recommended Extensions for Productivity

VS Code Extensions:

C# Dev Kit
REST Client
GitLens
Docker Extension
Prettier

Visual Studio Extensions:

EF Core Power Tools
Azure App Service Tools
ReSharper (optional)

Conclusion

Your .NET API development environment is now fully set up. You have installed the .NET SDK, configured your IDE, chosen database tools, installed API testing tools, set up Git version control, and even prepared Docker for future deployment. With this foundation ready, you can now confidently move toward building real APIs.

In the next chapter, we will explore the foundational REST principles that shape every modern API you build.

IndianTechnoEra