C# Programming Tutorial for Beginners

Introduction to C#: What is C# and Why Learn It?

Understanding C#

C# is a modern, object-oriented programming language developed by Microsoft. It's widely used for building web services with ASP.NET Core, desktop applications with .NET, and games with Unity. Learning C# opens opportunities in enterprise software, cloud services, game development, and cross-platform mobile development via MAUI and Xamarin.

• Object-oriented programming
• Cross-platform development (via .NET)
• Strongly typed language with compile-time checks
• Deep ecosystem integration with the .NET platform

Versions and Compatibility

This tutorial uses examples compatible with C# 10+ and .NET 6/7/8. Code samples use top-level statements (available in C# 9/10) and target net6.0 or later. When you follow along, choose the .NET SDK that matches your target runtime:

• Use .NET 6, 7, or 8 depending on your platform support and hosting environment.
• Common libraries mentioned: ASP.NET Core and Entity Framework Core (EF Core) aligned with .NET releases (EF Core 6/7/8 when targeting the corresponding runtimes).
• Testing libraries: xUnit (commonly v2.4.x) and MSTest for integration scenarios.

Example CLI to create a console project targeting .NET 6:

dotnet new console -n MyApp -f net6.0

Setting Up Your Development Environment: Tools and Installation

Installing Visual Studio

To begin coding in C#, install an IDE or editor that supports .NET development. Microsoft Visual Studio (for Windows and macOS) is the most feature-complete option for C#. Visual Studio Code with the C# extension (OmniSharp) is a lightweight alternative that works across platforms.

• Install Visual Studio with the '.NET desktop development' or 'ASP.NET and web development' workloads for full tooling.
• Or install Visual Studio Code and add the C# extension (OmniSharp) for editing and debugging support across platforms.
• Install the .NET SDK that matches the tutorial examples (for example .NET 6, 7, or 8).
• Verify installation by running: dotnet --info.

Basic Syntax and Data Types: Your First Lines of Code

Writing Your First C# Program

C# programs are structured in namespaces, classes, and methods. The classic "Hello, World!" example demonstrates how to print to the console:

using System;

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

With top-level statements (C# 10+), the same program is shorter and idiomatic for small console apps:

Console.WriteLine("Hello, World!");

Common built-in types include:

• int — integers
• string — text
• bool — true/false values
• double, decimal — floating-point numbers (use decimal for monetary values)

Control Structures: Making Decisions and Looping

Understanding Control Structures

Control structures manage program flow and include conditionals and loops. Clear use of these constructs makes programs maintainable and predictable.

• if / else for conditional logic
• switch for multi-way branching
• for, foreach for counted iteration
• while, do-while for conditional iteration

Example if-statement:

if (userRole == "Admin")
{
    // Admin logic
}

Basic Exception Handling

Runtime errors happen. Learning how to handle exceptions safely is essential for beginners. Use try/catch blocks to handle predictable exceptions and to keep your application from crashing unexpectedly.

Simple try-catch example

using System;

Console.Write("Enter an integer: ");
var input = Console.ReadLine();

try
{
    int value = int.Parse(input ?? string.Empty); // may throw FormatException
    Console.WriteLine($"You entered: {value}");
}
catch (FormatException ex)
{
    // Handle a known exception type - avoid swallowing the exception
    Console.WriteLine("Input was not a valid integer. Please enter digits only.");
    Console.WriteLine($"Debug info: {ex.Message}");
}
catch (Exception ex)
{
    // Fallback for unexpected exceptions
    Console.WriteLine("An unexpected error occurred.");
    // In production, log the full exception rather than printing sensitive details
}
finally
{
    // Optional cleanup logic (closing streams, releasing handles)
    Console.WriteLine("Operation complete.");
}

Best practices

• Catch the most specific exception you can (e.g., FormatException, ArgumentNullException), not general Exception, unless you rethrow or log.
• Do not use exceptions for control flow; validate input first when possible (e.g., int.TryParse instead of catching FormatException).
• When rethrowing, preserve the original stack trace using throw;, not throw ex;.
• Avoid exposing sensitive information in error messages returned to users. Log details securely (structured logs) and surface friendly messages to users.
• Use exception filters (C# when) for conditional handling, e.g., catch (Exception ex) when (IsTransient(ex)).

Troubleshooting tips

• If a specific block repeatedly throws the same exception, add input validation and unit tests to reproduce and prevent it.
• Use logging frameworks (Microsoft.Extensions.Logging) to capture exception details with correlation IDs for easier debugging in production.
• Test database connectivity and external services separately; wrap remote calls in try-catch and implement retries for transient faults.

Object-Oriented Programming in C#: Concepts and Examples

Fundamentals of OOP

C# embraces OOP: classes, inheritance, encapsulation, and polymorphism help you model real-world concepts and reuse code.

Example class definition (expanded for clarity):

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }

    public Book(string title, string author)
    {
        Title = title;
        Author = author;
    }

    public override string ToString() => $"{Title} by {Author}";
}

Building a Simple Application: From Code to Execution

Beginner-Friendly Console App (Runnable)

Note: This section provides a small, complete console application you can run locally. Advanced topics such as ASP.NET Core Identity, EF Core, and JWT are described separately in the Advanced Concepts (Optional) section—those are not required to follow this beginner example.

The following is a minimal in-memory "Book Manager" console app that demonstrates types, lists, loops, and simple user input. It uses top-level statements and targets .NET 6+.

Steps to run:

1. Create a project: dotnet new console -n BookManager -f net6.0
2. Replace the generated Program.cs with the code below and run dotnet run.

using System;
using System.Collections.Generic;

var books = new List();
var running = true;

while (running)
{
    Console.WriteLine("\nBook Manager - choose an option:");
    Console.WriteLine("1) Add book");
    Console.WriteLine("2) List books");
    Console.WriteLine("3) Exit");
    Console.Write("Choice: ");

    var choice = Console.ReadLine();

    switch (choice)
    {
        case "1":
            Console.Write("Title: ");
            var title = Console.ReadLine() ?? string.Empty;
            Console.Write("Author: ");
            var author = Console.ReadLine() ?? string.Empty;
            books.Add(new Book(title, author));
            Console.WriteLine("Book added.");
            break;
        case "2":
            if (books.Count == 0) Console.WriteLine("No books yet.");
            else
            {
                Console.WriteLine("Books:");
                for (int i = 0; i < books.Count; i++)
                    Console.WriteLine($"{i + 1}. {books[i]}");
            }
            break;
        case "3":
            running = false;
            break;
        default:
            Console.WriteLine("Invalid choice.");
            break;
    }
}

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }

    public Book(string title, string author)
    {
        Title = title;
        Author = author;
    }

    public override string ToString() => $"{Title} by {Author}";
}

This small app reinforces the basics: types, collections, loops, and user input. Extend it by adding file persistence, validation, or unit tests as you progress. Consider using int.TryParse where appropriate to avoid exceptions from bad input.

Basic Debugging (Visual Studio & VS Code)

Debugging is a core skill. Learn to set breakpoints, inspect variables, and step through code to understand runtime behavior. Debugging early will save hours compared to diagnosing issues only from logs.

Visual Studio (Windows/macOS)

• Open your solution or folder, set a breakpoint by clicking in the gutter next to a line or pressing F9.
• Start debugging with F5 (Start Debugging) or choose Run > Start Debugging. The debugger will pause at the breakpoint.
• Use Step Into (F11), Step Over (F10), and Step Out (Shift+F11) to traverse code. Inspect variables in the Locals and Autos windows, and use Watch to evaluate expressions over time.
• Use the Immediate window to evaluate expressions or call methods at runtime.
• For exceptions, open Exception Settings and enable break on thrown exceptions to catch the root cause earlier.

Visual Studio Code (cross-platform)

Visual Studio Code plus the C# extension (OmniSharp) provides a lightweight debugger for .NET console apps.

1. Install Visual Studio Code and the C# extension.
2. Open the project folder, press F5 to run the default debug configuration, or create a launch.json in the .vscode folder.

Example launch.json for a simple console app (VS Code will often scaffold this for you):

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": ".NET Launch (console)",
      "type": "coreclr",
      "request": "launch",
      "preLaunchTask": "build",
      "program": "${workspaceFolder}/bin/Debug/net6.0/BookManager.dll",
      "args": [],
      "cwd": "${workspaceFolder}",
      "console": "integratedTerminal"
    }
  ]
}

Key VS Code debugging tips:

• Set breakpoints by clicking in the gutter or pressing F9. Start debugging with F5.
• Use the Debug view to inspect Variables, Watch expressions, and the Call Stack. The Debug Console lets you evaluate expressions at breakpoints.
• When debugging multi-threaded or async code, inspect the Call Stack and asynchronous call contexts to trace flows across awaits.

Practical debugging workflow

• Reproduce the issue locally in Debug configuration; add a breakpoint near the suspected area.
• Inspect inputs, intermediate values, and external call results (API responses, DB queries).
• Use unit tests to isolate logic and reproduce defects deterministically.
• When working with remote environments, use logging with correlation IDs and attach the remote debugger or use snapshots where available.

Advanced Concepts (Optional)

Implementing Core Features (Overview)

The following material describes higher-level, production-oriented features you may explore after getting comfortable with basics. These are labeled "Advanced" because they introduce frameworks, persistence, and authentication that require additional setup and understanding.

Common libraries and scenarios:

• ASP.NET Core (web APIs and MVC) — aligned with the .NET release you choose to target
• Entity Framework Core (EF Core 6/7/8) for ORM and database migrations
• ASP.NET Core Identity for user and role management
• JWT (JSON Web Tokens) for stateless authentication in APIs

Minimal example showing where Identity is configured in a modern Program.cs (ASP.NET Core minimal hosting model). This is for illustration — full setup requires a DbContext, connection string, and packages such as Microsoft.EntityFrameworkCore.SqlServer or another provider.

var builder = WebApplication.CreateBuilder(args);

// Add EF Core DbContext (configure your provider and connection string)
// builder.Services.AddDbContext(options =>
//     options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Configure Identity with EF stores (requires ApplicationDbContext and packages)
// builder.Services.AddIdentity()
//     .AddEntityFrameworkStores()
//     .AddDefaultTokenProviders();

var app = builder.Build();
app.Run();

Security and operational tips when moving to these advanced features:

• Use HTTPS everywhere in production and enable HSTS where appropriate.
• Store secrets (connection strings, signing keys) in environment variables or a secure store such as Azure Key Vault.
• Use strong password policies and multi-factor authentication when applicable; Identity provides extensibility points.
• When issuing JWTs, sign tokens with an appropriate key (asymmetric keys recommended for distributed systems) and set short lifetimes plus refresh tokens.
• Keep packages up to date; test EF Core migrations in a staging environment before production.

Testing and Debugging (Best Practices)

For reliable systems, add automated tests and use the debugger and structured logging to inspect runtime behavior.

• Unit testing: xUnit is widely used (xUnit v2.4.x). Keep unit tests fast and focused.
• Integration testing: use test host servers and in-memory databases where appropriate to test real flows.
• Use structured logging (Microsoft.Extensions.Logging) and correlate logs using request IDs.
• Visual Studio and Visual Studio Code provide step-through debugging, breakpoints, and variable inspection — invaluable for diagnosing issues.

Example assertion (xUnit):

Assert.True(result.IsSuccess);

Troubleshooting tips:

• If migrations fail, check the connection string and ensure the database exists and the account has permissions.
• When authentication fails, inspect token contents and middleware configuration, and verify clock skew and token signing keys.
• Use dependency injection to make components testable and to replace external dependencies with fakes or mocks in tests.