Your First Console Application

The Development Workflow

Every .NET application follows this workflow:

1. Create Project    → dotnet new
2. Write Code        → Edit .cs files
3. Build             → dotnet build (compile C# to IL)
4. Run               → dotnet run (execute your app)
5. Test & Debug      → Fix issues, repeat 2-4
6. Publish           → dotnet publish (deploy)

Let's walk through this entire process step by step!

Step 1: Create Your First Project

Open a terminal (Command Prompt, PowerShell, or Terminal) and navigate to where you want to create your project. For example:

# Windows
cd C:\Users\YourName\Projects

# macOS/Linux
cd ~/Projects

Now create a new console application:

dotnet new console -n HelloWorld

You'll see output like:

The template "Console App" was created successfully.

Processing post-creation actions...
Restoring C:\Users\YourName\Projects\HelloWorld\HelloWorld.csproj:
  Determining projects to restore...
  Restored C:\Users\YourName\Projects\HelloWorld\HelloWorld.csproj (in 234 ms).
Restore succeeded.

Navigate into your new project:

cd HelloWorld

Step 2: Explore What Was Created

List the files in your project directory:

# Windows (PowerShell)
dir

# macOS/Linux
ls -la

You'll see:

• Program.cs - Your C# source code file
• HelloWorld.csproj - Project configuration file
• obj/ - Build artifacts (auto-generated)

Step 3: Look at the Generated Code

Open Program.cs in any text editor. You'll see:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

That's it! Just one line of code. This is called a top-level statement—a simplified syntax introduced in C# 9 that removes boilerplate code.

Traditional vs Modern Syntax

Here's what the same program looks like in traditional C# syntax:

using System;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

Both do the exact same thing! Modern C# just removes the ceremony.

Step 4: Run Your Application

Let's run the app! In your terminal (make sure you're in the HelloWorld directory):

dotnet run

You'll see:

Hello, World!

What Happened Behind the Scenes?

1. Compilation: C# compiler (Roslyn) compiled Program.cs to Intermediate Language (IL)
2. Output: Created HelloWorld.dll in the bin/Debug/net8.0/ folder
3. Execution: .NET Runtime loaded the DLL and executed your code
4. Result: "Hello, World!" printed to the console

Step 5: Modify Your Application

Let's make it more interesting! Open Program.cs and replace the content with:

// Welcome message
Console.WriteLine("Welcome to .NET!");
Console.WriteLine("==================\n");

// Get user's name
Console.Write("What's your name? ");
string? name = Console.ReadLine();

// Greet the user
Console.WriteLine($"\nHello, {name}! Welcome to your .NET journey!");

// Show .NET version
Console.WriteLine($"You're running .NET {Environment.Version}");

Run it again:

dotnet run

Now it's interactive! Try it:

Welcome to .NET!
==================

What's your name? John
Hello, John! Welcome to your .NET journey!
You're running .NET 8.0.0

Step 6: Build a Simple InvenTrack Inventory Checker

Let's create something more practical—a simple inventory checker for InvenTrack! Replace Program.cs with:

// InvenTrack - Simple Inventory Checker
Console.WriteLine("╔════════════════════════════════════╗");
Console.WriteLine("║   InvenTrack Inventory Checker    ║");
Console.WriteLine("╚════════════════════════════════════╝\n");

// Sample inventory data
string productName = "Laptop - Dell XPS 15";
string sku = "LAP-DELL-XPS15";
int quantityInStock = 15;
decimal unitPrice = 1299.99m;
int reorderLevel = 10;

// Display product information
Console.WriteLine("Product Information:");
Console.WriteLine("--------------------");
Console.WriteLine($"Name:     {productName}");
Console.WriteLine($"SKU:      {sku}");
Console.WriteLine($"Price:    ${unitPrice:N2}");
Console.WriteLine($"In Stock: {quantityInStock} units\n");

// Calculate total value
decimal totalValue = quantityInStock * unitPrice;
Console.WriteLine($"Total Inventory Value: ${totalValue:N2}\n");

// Check stock status
Console.WriteLine("Stock Status:");
Console.WriteLine("-------------");

if (quantityInStock == 0)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine("⚠️  OUT OF STOCK - Reorder immediately!");
}
else if (quantityInStock <= reorderLevel)
{
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.WriteLine($"⚠️  LOW STOCK - Only {quantityInStock} units remaining");
    Console.WriteLine($"   Consider reordering (threshold: {reorderLevel} units)");
}
else
{
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine("✓ Stock levels are healthy");
}

// Reset console color
Console.ResetColor();

// Interactive: Check another product
Console.WriteLine("\n--------------------");
Console.Write("Enter quantity to check: ");
string? input = Console.ReadLine();

if (int.TryParse(input, out int checkQuantity))
{
    decimal value = checkQuantity * unitPrice;
    Console.WriteLine($"\n{checkQuantity} units would be worth: ${value:N2}");
}
else
{
    Console.WriteLine("\nInvalid quantity entered.");
}

Run it:

dotnet run

You'll see a beautiful, color-coded inventory report:

╔════════════════════════════════════╗
║   InvenTrack Inventory Checker    ║
╚════════════════════════════════════╝

Product Information:
--------------------
Name:     Laptop - Dell XPS 15
SKU:      LAP-DELL-XPS15
Price:    $1,299.99
In Stock: 15 units

Total Inventory Value: $19,499.85

Stock Status:
-------------
⚠️  LOW STOCK - Only 15 units remaining
   Consider reordering (threshold: 10 units)

--------------------
Enter quantity to check: 50

50 units would be worth: $64,999.50

Understanding the Build Process

dotnet run vs dotnet build

# Build only (compile, don't run)
dotnet build

# Build and run
dotnet run

When you run dotnet build, you'll see:

MSBuild version 17.8.0+b89cb5fde for .NET
  Determining projects to restore...
  All projects are up-to-date for restore.
  HelloWorld -> C:\Projects\HelloWorld\bin\Debug\net8.0\HelloWorld.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Where's the Output?

After building, check the bin/Debug/net8.0/ folder:

• HelloWorld.dll - Your compiled application (IL code)
• HelloWorld.exe - Windows launcher (on Windows only)
• HelloWorld.deps.json - Dependency information
• HelloWorld.runtimeconfig.json - Runtime configuration

Opening Your Project in an IDE

Visual Studio 2022

1. Open Visual Studio
2. Click "Open a project or solution"
3. Navigate to your project folder
4. Select HelloWorld.csproj
5. Click "Open"

Now you can edit, build, and run from within Visual Studio. Press F5 to run with debugging, or Ctrl+F5 to run without debugging.

Visual Studio Code

1. Open VS Code
2. Click "File" → "Open Folder"
3. Select your HelloWorld folder
4. VS Code will detect the C# project and offer to add build assets—click "Yes"

Press F5 to run with debugging.

Common Commands Reference

Command	What It Does
dotnet new console -n MyApp	Create a new console application
dotnet run	Build and run the application
dotnet build	Compile the application
dotnet clean	Delete build artifacts (bin/obj folders)
dotnet watch run	Run and auto-restart on file changes
dotnet publish	Prepare app for deployment

Key Takeaways

• Create projects with dotnet new console -n ProjectName
• Program.cs contains your C# code
• Top-level statements simplify console apps (no Main method needed)
• dotnet run builds and executes your application
• dotnet build compiles without running
• Compiled output goes to bin/Debug/net8.0/
• String interpolation ($"...") embeds variables in strings
• Console.WriteLine() prints output
• Console.ReadLine() reads user input
• You can change console colors with Console.ForegroundColor
• Use int.TryParse() to safely convert strings to numbers