C# Tutorial: Learn .NET Language from Scratch (2026)

Published: September 5, 2025 | Category: Programming | Reading time: ~15 min

C# distills the best ideas from C++, Java, and Delphi into a cohesive, well-designed language. I have built desktop financial tools with WPF, microservices on Azure Functions, and game scripts in Unity — all in C#. The .NET standard library covers virtually every infrastructure need out of the box.

This tutorial focuses on the features that made me most productive: LINQ, async/await, and the type system. If you come from Java or C++, the transition is smooth but the idioms are distinctively C#.

📖 Table of Contents

LINQ
Async and Await
Properties and Events
Generics
Reflection
GC Mechanics

LINQ

LINQ turns data transformations into declarative queries that read like SQL. The compiler translates query syntax into method calls on IEnumerable<T>. Deferred execution means the query runs when you iterate, not when you define it. I have replaced hundreds of nested foreach loops with LINQ expressions.

var adults = from p in people
              where p.Age >= 18
              orderby p.LastName
              select new { p.FirstName, p.LastName };

var adults2 = people
    .Where(p => p.Age >= 18)
    .OrderBy(p => p.LastName)
    .Select(p => new { p.FirstName, p.LastName });

Async and Await

async/await converts async code into a compiler-generated state machine. Methods return Task or Task<T>. await yields to the caller until the operation completes. Use ConfigureAwait(false) in libraries to avoid capturing the synchronization context, preventing deadlocks in UI and ASP.NET contexts.

public async Task FetchAsync(string url) {
    using var client = new HttpClient();
    return await client
        .GetStringAsync(url)
        .ConfigureAwait(false);
}

var t1 = FetchAsync("https://api.example.com/1");
var t2 = FetchAsync("https://api.example.com/2");
await Task.WhenAll(t1, t2);

Properties and Events

Properties encapsulate fields with get/set accessors. Auto-properties generate backing fields automatically. Init-only setters (C# 9) enable object initializers for immutable properties. Events use delegates for publish-subscribe. Always check for null before invoking — null means no subscribers.

public class Person {
    public string Name { get; init; }
    public int BirthYear { get; set; }
    public int Age => DateTime.Now.Year - BirthYear;

    public event EventHandler? Birthday;
    public void Celebrate() {
        Birthday?.Invoke(this, EventArgs.Empty);
    }
}

Generics

Generics enable type-safe reusable code without boxing. Constraints (where T : class) restrict allowed types. The JIT generates specialized code for value types and shared code for reference types. Covariance (out) and contravariance (in) control type compatibility for generic interfaces.

public class Repo where T : class, IEntity {
    readonly List _items = new();
    public T? Find(int id) =>
        _items.FirstOrDefault(e => e.Id == id);
    public void Add(T item) => _items.Add(item);
}

public interface IEntity { int Id { get; } }

Reflection

Reflection inspects types and members at runtime. You can enumerate properties, invoke methods, and read custom attributes. It is slower than compile-time code but essential for serializers, ORMs, and DI containers. Attributes decorate code with metadata; call GetCustomAttributes to retrieve them at runtime.

[AttributeUsage(AttributeTargets.Property)]
class LabelAttribute : Attribute {
    public string Text { get; }
    public LabelAttribute(string t) => Text = t;
}

var prop = typeof(Person).GetProperty("Name");
var attr = prop?.GetCustomAttribute();

GC Mechanics

The .NET GC is generational and compacting. Gen 0 collects short-lived objects frequently and cheaply; Gen 2 collects long-lived objects with a full pause. Objects over 85 KB go to the Large Object Heap, which is not compacted. Implement IDisposable for unmanaged resources and call Dispose in a using block.

class Resource : IDisposable {
    IntPtr _native;
    bool _disposed;

    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool d) {
        if (!_disposed && d)
            Free(_native);
        _disposed = true;
    }

    ~Resource() => Dispose(false);
}

Frequently Asked Questions

ref vs out vs in?

ref requires pre-initialization; out does not and the method must assign; in passes a read-only reference.

Record vs class?

Records have value equality semantics. Use for DTOs; classes for mutable objects with identity.

How does using work?

The compiler generates try/finally that calls Dispose on the resource when the block exits.

string vs StringBuilder?

string is immutable; concatenation creates a new string. StringBuilder uses a mutable buffer for efficient appending.

Originally published on Ayodhyyya. Last updated June 1, 2026.