C# (pronounced “C Sharp”) is a powerful and flexible programming language created by Microsoft. Since its inception, guided by Anders Hejlsberg (the genius behind Turbo Pascal and Delphi), C# has focused on making programmers more productive. It’s general-purpose, type-safe, and object-oriented. Over the years, C# has spread its wings beyond just Windows, now running on macOS, Linux, Android, iOS, and even inside your web browser through technologies like Blazor.

In this blog, we’ll explore the fundamentals of C#, the .NET platform, object-oriented features, concurrency handling with async/await, and more—with lots of easy-to-understand examples.

Object-Oriented Programming in C#

C# is deeply rooted in Object-Oriented Programming (OOP). The three major pillars of OOP are:

• Encapsulation: Wrap data (fields, properties) and code (methods) inside a class so that the internal details remain hidden, and users only see a simplified interface.

• Inheritance: Create new classes that reuse, extend, or modify existing classes.

• Polymorphism: Treat different classes in a common way, usually by sharing a base class or an interface.

Unified Type System

All types in C#—whether built-in (like int and string) or custom—inherit from a single root type called object. For example, int.ToString() works because int eventually derives from object, which provides the ToString() method.

Classes and Interfaces

A class can contain data (fields, properties) and behavior (methods, events). An interface defines what methods or properties must be available, but not how they are implemented. Interfaces let you create loosely coupled code, making it easier to change or swap implementations later.

Properties, Methods, and Events

• Properties: Look like fields but actually run code when you read or write them.

• Methods: Functions defined inside a class to do work.

• Events: Special members used to broadcast happenings (“events”) to other parts of your program.

Example: A Simple Class

public class Car
{
    // A property (encapsulated state)
    public string Color { get; set; }

    // A method (behavior)
    public void Drive()
    {
        Console.WriteLine("The car is driving!");
    }

    // An event (for notifying others)
    public event Action OnEngineStart;

    public void StartEngine()
    {
        Console.WriteLine("Engine started.");
        OnEngineStart?.Invoke(); // Trigger the event if there are any subscribers
    }
}

Example: Using an Interface

public interface IVehicle
{
    void Drive();
}

public class Car : IVehicle
{
    public string Color { get; set; }
    public void Drive()
    {
        Console.WriteLine("Car is driving!");
    }
}

Functional Features in C#

Though primarily OOP-focused, C# also supports functional programming features:

• Functions as Values: You can treat methods like data, passing them around using delegates or lambda expressions.

• Immutable and Declarative Code: Instead of changing variables all the time, C# encourages you to write code that’s cleaner, clearer, and easier to reason about. Features like lambda expressions and LINQ queries make your code more concise.

Lambda Expression Example

Func<int, int> square = x => x * x;
int result = square(5); // result = 25

Type Safety

C# is type-safe, meaning it checks types at compile time (static typing) and ensures that the objects you manipulate actually support what you’re doing. This reduces runtime errors and makes large programs more manageable.

Strong Typing Example

int number = 10;
string text = "Hello";

// The following line would cause a compile-time error!
// number = text; // Cannot assign string to an int variable

Memory Management

C# uses automatic memory management with a Garbage Collector (GC). The GC runs in the background and frees memory for objects that are no longer referenced. You don’t have to manually deallocate memory as you would in languages like C++.

If you need super-fast performance and direct memory manipulation, you can still use pointers and unsafe code blocks, but that’s a rare scenario.

Concurrency in C#

Task-Based Asynchronous Programming

Modern apps often need to run multiple operations at once without blocking the user. C# makes concurrency easier through the async/await keywords and the Task and Task classes. This approach, called Task-based Asynchronous Pattern (TAP), simplifies writing asynchronous code.

Imagine you want to download data from the internet without freezing your UI. With async/await, you write code that “looks” synchronous but actually runs asynchronously, letting other work continue.

Async/Await Example

public async Task<string> FetchDataFromServerAsync()
{
    using HttpClient client = new HttpClient();
    string result = await client.GetStringAsync("https://example.com/data");
    return result;
}

public async Task ShowDataAsync()
{
    Console.WriteLine("Fetching data...");
    string data = await FetchDataFromServerAsync();
    Console.WriteLine("Data fetched: " + data);
}

• async in the method signature indicates that the method uses asynchronous operations.

• await tells C# to pause execution until the async operation completes, without blocking other work.

Platform Support

C# and .NET can run on various platforms:

• Windows (desktop, server, and command-line apps)

• macOS (web and command-line apps, plus rich-client apps via Mac Catalyst)

• Linux (web and command-line apps)

• Android and iOS (mobile apps using .NET MAUI)

• Windows 10 devices like Xbox, Surface Hub, and HoloLens

• In Web Browsers via Blazor, by compiling C# to WebAssembly

.NET Ecosystem: CLR, BCL, and Runtimes

To run your C# code, you need a runtime. The runtime provides:

• CLR (Common Language Runtime): Manages memory, handles exceptions, and compiles Intermediate Language (IL) into machine code.

• BCL (Base Class Library): Provides essential building blocks—collections, file I/O, networking, cryptography, and more.

Different runtimes (also called frameworks) mix and match these pieces with extra libraries for web, mobile, or desktop apps.

Major .NET Runtimes

1. .NET 8:

   • Microsoft’s latest LTS open-source, cross-platform runtime.

   • Supports web, console, Windows desktop (WinUI 3), macOS, iOS, and Android.

   • Not pre-installed on Windows, but easy to download.

2. Windows Desktop and WinUI 3:

   • For rich desktop apps on Windows 10+.

   • WinUI 3 provides modern controls and styles.

3. MAUI (Multi-platform App UI):

   • Primarily for mobile apps (iOS, Android).

   • Also can create desktop apps for Windows and macOS.

4. .NET Framework:

   • The original Windows-only runtime.

   • Great for legacy apps, still supported, but no big new features coming.

Other niche runtimes exist, like Unity (for games) and UWP (for Windows devices like Xbox and HoloLens). The ecosystem is huge, ensuring you can find the right tool for every job.

Hello World Example

Let’s see the simplest C# program:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World from C#!");
    }
}

How to run it:

• Install the .NET 8 SDK or a newer version.

• Open a terminal in the folder where you saved Program.cs.

• Run:

    dotnet new console
    dotnet run
  

You’ll see "Hello, World from C#!" on the screen.

Conclusion

C# and the .NET ecosystem provide a robust, flexible, and modern environment for building almost any type of application. With its object-oriented foundation, functional touches, type safety, automatic memory management, and the powerful async/await concurrency model, C# remains one of the most vibrant and future-proof languages out there.

Whether you want to build websites, mobile apps, desktop software, or even games, C# and .NET are ready to help you bring your ideas to life. And remember, as you dive deeper, you’ll discover even more exciting features—like pattern matching, records for immutable data, and tools like LINQ for querying data with elegance.