C# Programming Guide
A Comprehensive Introduction to the C# Language and .NET
A structured reference covering core syntax, object-oriented design, collections, error handling,
concurrency, and ecosystem best practices.
Table of Contents
1. Introduction to C#
2. Variables, Types, and Operators
3. Control Flow
4. Methods and Parameters
5. Object-Oriented Programming
6. Collections and Generics
7. Exception Handling
8. Asynchronous Programming
9. Delegates, Events, and Lambdas
10. The .NET Ecosystem and Best Practices
11. Testing in C#
12. Common Design Patterns in C#
13. Performance Considerations
14. Common Pitfalls
15. Further Resources
1. Introduction to C#
C# (pronounced 'C sharp') is a modern, object-oriented, type-safe programming language developed
by Microsoft as part of its .NET initiative. First released in 2000 and designed primarily by Anders
Hejlsberg, C# was built to combine the productivity of high-level languages with the performance and
control of lower-level languages like C and C++.
C# runs on the Common Language Runtime (CLR), a virtual machine environment that handles
memory management, exception handling, and security. Because of this managed execution model,
C# offers automatic garbage collection, strong type checking, and a rich standard library through the
.NET Base Class Library (BCL).
Today C# is used to build web applications with [Link], desktop applications with WPF and
WinForms, mobile applications with .NET MAUI, games with the Unity engine, and cloud-native
microservices with .NET's cross-platform runtime.
// A minimal C# program
using System;
class Program
{
static void Main(string[] args)
{
[Link]("Hello, World!");
}
}
2. Variables, Types, and Operators
C# is a statically typed language, meaning every variable's type is known at compile time. The
language supports value types such as int, double, bool, and char, as well as reference types such as
string, arrays, and custom classes. The 'var' keyword allows the compiler to infer a variable's type
from its initializer while still enforcing static typing.
C# also supports nullable value types (int?, bool?) which let value types hold a null in addition to their
normal range of values, and it provides a rich set of arithmetic, relational, logical, and bitwise
operators similar to those found in C and Java.
int age = 30;
double price = 19.99;
bool isActive = true;
string name = "Ada";
var count = 10; // inferred as int
int? maybeNull = null; // nullable value type
int sum = age + count;
bool isAdult = age >= 18;
3. Control Flow
C# provides the standard set of control-flow constructs found in most C-family languages: if/else
statements, switch statements (and the newer switch expressions), for loops, while loops, do-while
loops, and foreach loops for iterating over collections.
Pattern matching, introduced in later versions of C#, extends the switch statement to match on types,
shapes of data, and relational patterns, making conditional logic more expressive and reducing
boilerplate code.
for (int i = 0; i < 5; i++)
{
[Link]($"Iteration {i}");
}
int score = 85;
string grade = score switch
{
>= 90 => "A",
>= 80 => "B",
>= 70 => "C",
_ => "F"
};
4. Methods and Parameters
Methods in C# are declared with an access modifier, a return type, a name, and a parameter list. C#
supports optional parameters with default values, named arguments, and variable-length parameter
lists using the 'params' keyword.
Methods can also be overloaded, meaning multiple methods can share the same name as long as
their parameter signatures differ. Local functions, which are functions declared inside another
method, allow for tightly scoped helper logic.
static int Add(int a, int b = 10)
{
return a + b;
}
static int Sum(params int[] numbers)
{
int total = 0;
foreach (var n in numbers) total += n;
return total;
}
int result = Add(5); // uses default b
int total = Sum(1, 2, 3, 4, 5); // params array
5. Object-Oriented Programming
C# is fundamentally an object-oriented language, supporting the four pillars of OOP: encapsulation,
inheritance, polymorphism, and abstraction. Classes define blueprints for objects, encapsulating both
data (fields, properties) and behavior (methods).
C# supports single inheritance of classes but multiple implementation of interfaces. Abstract classes
and interfaces both allow you to define contracts that derived types must fulfill, while virtual and
override keywords enable runtime polymorphism.
Properties, a distinctive C# feature, provide a clean syntax for exposing fields with optional validation
logic in their getters and setters, without requiring explicit getter/setter method calls from client code.
public abstract class Shape
{
public abstract double Area();
}
public class Circle : Shape
{
public double Radius { get; set; }
public Circle(double radius) => Radius = radius;
public override double Area() => [Link] * Radius * Radius;
}
6. Collections and Generics
The [Link] namespace provides strongly typed, reusable collection classes
such as List, Dictionary, Queue, and Stack. Generics allow these collections (and custom types) to
operate on any data type while preserving compile-time type safety and avoiding the cost of boxing
and unboxing.
LINQ (Language Integrated Query) extends collections with a declarative, SQL-like syntax for
filtering, projecting, sorting, and aggregating data, whether the source is an in-memory list, an XML
document, or a database.
List<int> numbers = new List<int> { 5, 3, 9, 1, 4 };
[Link]();
var evens = [Link](n => n % 2 == 0).ToList();
Dictionary<string, int> ages = new Dictionary<string, int>
{
["Alice"] = 30,
["Bob"] = 25
};
7. Exception Handling
C# uses a try/catch/finally model for handling runtime errors. Exceptions are objects derived from the
[Link] class, and custom exception types can be created by subclassing it. The 'finally'
block guarantees that cleanup code runs whether or not an exception occurred.
The 'using' statement (and using declarations) provide a concise way to ensure that objects
implementing IDisposable, such as file handles and database connections, are properly disposed of
even when exceptions occur.
try
{
int[] arr = new int[3];
[Link](arr[5]);
}
catch (IndexOutOfRangeException ex)
{
[Link]($"Error: {[Link]}");
}
finally
{
[Link]("Cleanup complete.");
}
8. Asynchronous Programming
C# has first-class support for asynchronous programming through the async and await keywords,
built on top of the Task and Task types. This model allows developers to write asynchronous code
that reads like synchronous code, avoiding deeply nested callbacks.
Asynchronous methods are especially important for I/O-bound operations such as web requests, file
access, and database queries, since they free up threads to handle other work while waiting for an
operation to complete.
public async Task<string> DownloadPageAsync(string url)
{
using var client = new HttpClient();
string content = await [Link](url);
return content;
}
// Calling code
string html = await DownloadPageAsync("[Link]
9. Delegates, Events, and Lambdas
Delegates are type-safe function pointers that allow methods to be passed as arguments. Events,
built on delegates, implement the observer pattern, enabling objects to notify subscribers when
something of interest occurs, commonly used in GUI programming.
Lambda expressions provide a concise syntax for writing inline anonymous functions, and are heavily
used with LINQ and delegate-based APIs such as event handlers and callback parameters.
public delegate void Notify(string message);
public class Publisher
{
public event Notify OnPublish;
public void Publish(string msg) => OnPublish?.Invoke(msg);
}
var publisher = new Publisher();
[Link] += msg => [Link]($"Received: {msg}");
[Link]("New article!");
10. The .NET Ecosystem and Best Practices
Modern C# development typically happens within the .NET platform, which includes [Link] Core
for web APIs and MVC applications, Entity Framework Core for object-relational mapping, and NuGet
as the package manager for sharing and consuming libraries.
Best practices in C# include following consistent naming conventions (PascalCase for types and
methods, camelCase for local variables), preferring immutability where practical, using dependency
injection for loosely coupled designs, writing unit tests with frameworks like xUnit or NUnit, and
enabling nullable reference type checking to catch potential null-reference bugs at compile time.
As of recent versions, C# continues to evolve with features like records for immutable data types,
pattern matching enhancements, and top-level statements that simplify small programs and scripts.
public record Person(string Name, int Age);
var alice = new Person("Alice", 30);
var olderAlice = alice with { Age = 31 };
[Link](alice);
[Link](olderAlice);
11. Testing in C#
C# developers commonly write automated tests using frameworks such as xUnit, NUnit, or MSTest,
all of which integrate with the 'dotnet test' command and with Visual Studio's Test Explorer. Mocking
libraries like Moq allow dependencies to be replaced with test doubles so that units can be tested in
isolation.
Good testing practice includes following the Arrange-Act-Assert structure, keeping tests small and
focused, and using dependency injection so that components can be easily substituted with mocks
during testing.
using Xunit;
public class CalculatorTests
{
[Fact]
public void Add_ReturnsSum()
{
var result = [Link](2, 3);
[Link](5, result);
}
}
12. Common Design Patterns in C#
C# is well suited to classic object-oriented design patterns thanks to its strong support for interfaces,
generics, and delegates. The Dependency Injection pattern is especially central to modern C#
applications, and [Link] Core includes a built-in DI container for registering and resolving
services.
Other frequently used patterns include Repository (for abstracting data access), Factory (for
encapsulating object creation), and Observer, which maps naturally onto C#'s built-in event and
delegate mechanisms.
public interface IRepository<T>
{
T GetById(int id);
void Add(T entity);
}
public class InMemoryRepository<T> : IRepository<T>
{
private readonly Dictionary<int, T> _items = new();
public T GetById(int id) => _items[id];
public void Add(T entity) => _items[_items.Count] = entity;
}
13. Performance Considerations
C# offers several tools for writing high-performance code, including value types (structs) to avoid
heap allocations, Span and Memory for working with contiguous memory without copying, and the
ability to write unsafe code with pointers when absolutely necessary.
The .NET runtime includes a tiered just-in-time compiler and a generational garbage collector, both of
which are tuned automatically but can be configured for specific workloads. Profiling tools such as
dotnet-trace and Visual Studio's diagnostic tools help identify bottlenecks.
public struct Point
{
public double X, Y;
}
Span<int> numbers = stackalloc int[5] { 1, 2, 3, 4, 5 };
int sum = 0;
foreach (var n in numbers) sum += n;
14. Common Pitfalls
Common mistakes in C# include forgetting to dispose of IDisposable objects (mitigated by 'using'
statements), comparing reference types with '==' when value equality was intended, and accidentally
capturing a loop variable by reference in a closure, which historically caused subtle bugs (largely
fixed for foreach loops since C# 5).
Null reference exceptions remain one of the most common runtime errors; enabling nullable reference
types in the project settings helps the compiler flag potential null dereferences at compile time rather
than at runtime.
#nullable enable
string? maybeName = GetName();
// Compiler warns if you use maybeName without a null check
if (maybeName is not null)
{
[Link]([Link]());
}
15. Further Resources
Microsoft Learn ([Link]) hosts the official C# and .NET documentation, including
language reference guides, tutorials, and API references for the entire Base Class Library. The .NET
blog covers new language and runtime features as they are released.
The open-source Roslyn compiler platform, community resources like C# Corner and Stack Overflow,
and books such as 'C# in Depth' provide additional depth for developers who want to master the
language's more advanced features.
// Explore language versions and features:
// [Link]
// [Link]