# C# Comprehensive Reference
> By [ConstructG.com](https://constructg.com) – The Ultimate C# Learning Platform (Covers DSA, Avalonia UI, and Unity)
> Comprehensive guide covering all C# features through version 14
## Table of Contents
1. [Introduction to C#](#1-introduction-to-c)
2. [Core Language Fundamentals](#2-core-language-fundamentals)
3. [Variables and Data Types](#3-variables-and-data-types)
4. [Operators](#4-operators)
5. [Strings and Text Handling](#5-strings-and-text-handling)
6. [Control Flow](#6-control-flow)
7. [Methods and Functions](#7-methods-and-functions)
8. [Object-Oriented Programming](#8-object-oriented-programming)
9. [Structs and Records](#9-structs-and-records)
10. [Interfaces](#10-interfaces)
11. [Enums and Flags](#11-enums-and-flags)
12. [Collections and Data Structures](#12-collections-and-data-structures)
13. [Generics](#13-generics)
14. [Delegates and Events](#14-delegates-and-events)
15. [LINQ (Language Integrated Query)](#15-linq-language-integrated-query)
16. [Advanced Pattern Matching](#16-advanced-pattern-matching)
17. [Asynchronous Programming](#17-asynchronous-programming)
18. [Resource Management](#18-resource-management)
19. [Reflection and Metadata](#19-reflection-and-metadata)
20. [Interoperability](#20-interoperability)
21. [Code Organization](#21-code-organization)
22. [Advanced Language Features](#22-advanced-language-features)
23. [C# 11-15 Feature Highlights](#23-c-11-15-feature-highlights)
24. [Performance Optimization](#24-performance-optimization)
25. [Best Practices and Coding Conventions](#25-best-practices-and-coding-conventions)
26. [Tooling and Ecosystem](#26-tooling-and-ecosystem)
27. [Resources and Further Learning](#27-resources-and-further-learning)
# 1. Introduction to C#
## What is C#?
C# (pronounced "C-sharp") is a modern, type-safe, object-oriented programming language developed by Microsoft. It was designed by Anders Hejlsberg and his team as part of the .NET initiative and was approved as a standard by ECMA and ISO.
Key characteristics of C#:
- **Type-safe**: The C# compiler ensures that operations are performed only on variables of appropriate types.
- **Object-oriented**: C# supports encapsulation, inheritance, and polymorphism.
- **Component-oriented**: C# provides features like properties, events, and attributes that make it ideal for building software components.
- **Modern**: C# continues to evolve with regular updates that introduce new features and improvements.
- **Versatile**: C# can be used to build a wide range of applications, from desktop to web to mobile to cloud services.
## Evolution of C# (Version History)
C# has evolved significantly since its initial release, with each version introducing new features and improvements:
| Version | Year | .NET Version | Key Features |
| ---------- | --------- | -------------- | ----------------------------------------------------------------------------------------------- |
| C# 1.0 | 2002 | .NET 1.0 | First release with basic OOP features |
| C# 2.0 | 2005 | .NET 2.0 | Generics, nullable types, iterators, anonymous methods |
| C# 3.0 | 2007 | .NET 3.5 | LINQ, lambda expressions, extension methods, anonymous types |
| C# 4.0 | 2010 | .NET 4.0 | Dynamic binding, named/optional parameters, covariance/contravariance |
| C# 5.0 | 2012 | .NET 4.5 | Async/await pattern |
| C# 6.0 | 2015 | .NET 4.6 | String interpolation, null-conditional operators, expression-bodied members |
| C# 7.0 | 2017 | .NET 4.7 | Tuples, pattern matching, local functions, ref returns |
| C# 7.1-7.3 | 2017-2018 | .NET 4.7-4.7.2 | Async Main, default literal, tuple naming, ref locals/returns |
| C# 8.0 | 2019 | .NET Core 3.0 | Nullable reference types, async streams, indices/ranges, switch expressions |
| C# 9.0 | 2020 | .NET 5 | Records, init-only properties, top-level statements, pattern matching enhancements |
| C# 10.0 | 2021 | .NET 6 | Global using directives, file-scoped namespaces, record structs, interpolated string handlers |
| C# 11.0 | 2022 | .NET 7 | Raw string literals, list patterns, required members, auto-default structs |
| C# 12.0 | 2023 | .NET 8 | Primary constructors, collection expressions, inline arrays, ref readonly parameters |
| C# 13.0 | 2024 | .NET 9 | Params collections, ref struct interfaces, partial properties, field keyword (preview) |
| C# 14.0 | 2025 | .NET 10 | Extension members, null-conditional assignment, field keyword, user-defined compound assignment |
| C# 15.0 | 2026 | .NET 11 | Collection expression arguments |
## C# and the .NET Platform
C# is closely tied to the .NET platform, which provides the runtime environment and libraries necessary for C# applications to run.
### Components of the .NET Platform:
1. **Common Language Runtime (CLR)**: The execution environment that manages memory, handles exceptions, and provides other services for running C# code.
2. **Base Class Library (BCL)**: A comprehensive collection of reusable types for common tasks such as string manipulation, data collection, database connectivity, and file I/O.
3. **Intermediate Language (IL)**: C# code is compiled into IL, which is then just-in-time (JIT) compiled to native code at runtime.
4. **Language Interoperability**: The .NET platform supports multiple languages (C#, F#, Visual Basic), allowing them to work together seamlessly.
### .NET Implementations:
- **.NET (formerly .NET Core)**: Cross-platform, open-source implementation for building apps that run on Windows, Linux, and macOS.
- **.NET Framework**: The original Windows-only implementation (now in maintenance mode).
- **Mono**: An open-source implementation of .NET for platforms where the official .NET runtime isn't available.
- **Xamarin**: An implementation for building mobile apps for iOS and Android.
- **.NET MAUI**: Multi-platform App UI for building cross-platform desktop and mobile apps.
### Key .NET Features:
- **Cross-platform**: Modern .NET runs on Windows, macOS, and Linux.
- **Open Source**: The .NET platform is open source and community-driven.
- **Performance**: .NET provides high-performance capabilities for demanding applications.
- **Microservices**: .NET is well-suited for building microservices architectures.
- **Cloud-Ready**: .NET integrates well with cloud platforms like Azure.
## Getting Started with C#
To start developing with C#, you'll need:
1. **Development Environment**:
- Visual Studio (Windows/Mac)
- Visual Studio Code with C# extension (cross-platform)
- JetBrains Rider (cross-platform)
2. **.NET SDK**: Download from [dotnet.microsoft.com](https://dotnet.microsoft.com/download)
3. **Basic Commands**:
```bash
# Create a new console application
dotnet new console -n MyFirstApp
# Build the application
dotnet build
# Run the application
dotnet run
```
4. **Hello World Example**:
```csharp
// Using top-level statements (C# 9.0+)
Console.WriteLine("Hello, World!");
// Traditional approach
namespace MyFirstApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
}
}
}
```
## Resources for Learning C#
- [Microsoft Learn C# Documentation](https://learn.microsoft.com/en-us/dotnet/csharp/)
- [C# Language Specification](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/)
- [.NET API Browser](https://learn.microsoft.com/en-us/dotnet/api/)
- [C# Corner](https://www.c-sharpcorner.com/)
- [Stack Overflow C# Questions](https://stackoverflow.com/questions/tagged/c%23)
# 2. Core Language Fundamentals
## Program Structure
A C# program consists of one or more files containing declarations in namespaces. These declarations define types (classes, structs, interfaces, etc.) that contain members (methods, properties, fields, etc.).
### Basic Structure
```csharp
// Namespace declaration
namespace MyApplication
{
// Type declaration (class)
public class Program
{
// Member declaration (method)
public static void Main(string[] args)
{
// Statements
Console.WriteLine("Hello, World!");
}
}
}
```
### File-Scoped Namespaces (C# 10+)
```csharp
// File-scoped namespace (no curly braces needed)
namespace MyApplication;
// Type declarations directly in the namespace
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
}
}
```
## Entry Points
Every C# application needs an entry point - the location where execution begins. C# provides two approaches for defining entry points.
### Traditional Main Method
The traditional approach uses a static method named `Main` inside a class or struct:
```csharp
namespace MyApplication
{
class Program
{
// Entry point with void return type
public static void Main(string[] args)
{
Console.WriteLine("Application started");
// Access command-line arguments
if (args.Length > 0)
{
Console.WriteLine($"First argument: {args[0]}");
}
}
// Alternative: Entry point with int return type (for exit codes)
// public static int Main(string[] args)
// {
// // Return 0 for success, non-zero for error
// return 0;
// }
// Alternative: Entry point without parameters
// public static void Main()
// {
// // No access to command-line arguments
// }
// Alternative: Async entry point (C# 7.1+)
// public static async Task Main(string[] args)
// {
// await SomeAsyncMethod();
// }
}
}
```
### Top-Level Statements (C# 9+)
Modern C# allows you to write your program's code directly in a file without explicitly defining a class or Main method:
```csharp
// This is a complete C# program with top-level statements
Console.WriteLine("Hello from top-level statements!");
// Access command-line arguments via the args variable
if (args.Length > 0)
{
Console.WriteLine($"First argument: {args[0]}");
}
// You can define methods and types after the top-level statements
void PrintMessage(string message)
{
Console.WriteLine($"Message: {message}");
}
// Call the method
PrintMessage("Top-level statements make code simpler");
// Define a class
class Configuration
{
public string Version { get; set; } = "1.0";
}
// Use the class
var config = new Configuration();
Console.WriteLine($"Version: {config.Version}");
```
**Important notes about top-level statements:**
- Only one file in your application can use top-level statements
- All top-level statements must precede any type or namespace declarations in the file
- The compiler automatically generates a class and Main method behind the scenes
- The `args` parameter is automatically available for command-line arguments
## Basic Syntax
### Statements and Expressions
- **Statement**: A complete command that performs an action. Statements end with a semicolon (`;`).
- **Expression**: A piece of code that evaluates to a value.
```csharp
// Assignment statement containing an expression (5 + 3)
int result = 5 + 3;
// Method call statement
Console.WriteLine(result);
// Declaration statement
string message;
// Expression statement (method call)
CalculateValue();
// Expression statement (increment)
counter++;
```
### Code Blocks and Scope
Code blocks are defined by curly braces `{}` and create a scope for variables:
```csharp
{
// Start of a block
int x = 10; // Variable x is only accessible within this block
{
// Nested block
int y = 20; // Variable y is only accessible within this nested block
Console.WriteLine(x); // Can access x from the outer block
}
// Console.WriteLine(y); // Error: y is not accessible here
} // End of block
// Console.WriteLine(x); // Error: x is not accessible here
```
### Identifiers
Identifiers are names for variables, methods, classes, etc.:
```csharp
// Valid identifiers
int age;
string firstName;
double _temperature;
bool isValid;
int MaxCount;
// Invalid identifiers
// int 1stPlace; // Cannot start with a digit
// string class; // Cannot use a keyword
// double my-value; // Cannot use hyphens
// Using a keyword as an identifier with @ prefix
string @class = "Computer Science";
int @int = 42;
```
### Keywords
C# has two types of keywords:
1. **Reserved keywords**: Cannot be used as identifiers without the `@` prefix.
2. **Contextual keywords**: Have special meaning only in specific contexts.
```csharp
// Some common reserved keywords
// abstract, as, base, bool, break, byte, case, catch, char, checked, class, const,
// continue, decimal, default, delegate, do, double, else, enum, event, explicit,
// extern, false, finally, fixed, float, for, foreach, goto, if, implicit, in, int,
// interface, internal, is, lock, long, namespace, new, null, object, operator, out,
// override, params, private, protected, public, readonly, ref, return, sbyte, sealed,
// short, sizeof, stackalloc, static, string, struct, switch, this, throw, true, try,
// typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, volatile, while
// Some contextual keywords
// add, and, alias, ascending, async, await, by, descending, dynamic, equals, from,
// get, global, group, init, into, join, let, nameof, not, notnull, on, or, orderby,
// partial, record, remove, required, select, set, unmanaged, value, var, when, where, yield
```
## Comments
Comments are used to document code and are ignored by the compiler.
### Single-Line Comments
```csharp
// This is a single-line comment
int x = 10; // This comment is at the end of a line
```
### Multi-Line Comments
```csharp
/* This is a multi-line comment
that spans multiple lines
and can be used for longer explanations */
int y = 20;
```
### XML Documentation Comments
XML documentation comments are used to generate documentation for your code:
```csharp
///
/// Calculates the sum of two integers.
///
/// The first integer.
/// The second integer.
/// The sum of the two integers.
/// Thrown when the sum is too large for an int.
///
///
/// int result = Add(5, 3); // Returns 8
///
///
public int Add(int a, int b)
{
return a + b;
}
```
Common XML documentation tags:
| Tag | Description |
| ------------- | ---------------------------------------------------- |
| `` | Provides a brief description of the type or member |
| `` | Describes a parameter |
| `` | Describes the return value |
| `` | Documents an exception that may be thrown |
| `` | Provides additional information |
| `` | Provides an example of how to use the method or type |
| `` | Formats text as code |
| `` | Creates a link to another type or member |
| `` | Creates a "see also" link |
| `` | Describes a property |
| `` | Describes a type parameter for a generic |
## Using Directives
Using directives help manage namespaces and types, making code more readable and maintainable.
### Namespace Imports
```csharp
// Import a namespace to use its types without fully qualifying them
using System;
using System.Collections.Generic;
using System.Linq;
// Now you can use types from these namespaces directly
List numbers = new List();
DateTime now = DateTime.Now;
```
### Static Imports (C# 6+)
```csharp
// Import static members of a type
using static System.Math;
using static System.Console;
// Now you can use the static members directly
double result = Sqrt(16); // Instead of Math.Sqrt(16)
WriteLine("Hello"); // Instead of Console.WriteLine("Hello")
```
### Namespace Aliases
```csharp
// Create an alias for a namespace or type
using IO = System.IO;
using Text = System.Text;
// Use the alias
IO.FileInfo file = new IO.FileInfo("data.txt");
Text.StringBuilder sb = new Text.StringBuilder();
```
### Type Aliases (C# 12+)
```csharp
// Create an alias for a type, including complex types
using Point = (double X, double Y);
using UserInfo = Dictionary;
// Use the alias
Point location = (3.5, 2.0);
UserInfo user = new UserInfo { ["Name"] = "John", ["Email"] = "john@example.com" };
```
### Global Using Directives (C# 10+)
Global using directives apply to all files in the project. They're typically placed in a dedicated file (e.g., `GlobalUsings.cs`):
```csharp
// These using directives apply to all files in the project
global using System;
global using System.Collections.Generic;
global using System.Linq;
global using System.Threading.Tasks;
```
### Implicit Usings (C# 10+)
In .NET 6+, you can enable implicit usings in your project file to automatically include common namespaces:
```xml
enable
```
This automatically includes namespaces like `System`, `System.Collections.Generic`, `System.Linq`, etc., based on your project type.
## Semicolons and Statement Termination
In C#, statements are terminated with semicolons (`;`):
```csharp
int x = 10; // Semicolon terminates the statement
Console.WriteLine(x); // Another statement
// Multiple statements on one line (not recommended for readability)
int y = 20; Console.WriteLine(y);
// Statement blocks don't need semicolons
if (x > 5)
{
Console.WriteLine("x is greater than 5");
} // No semicolon needed after the closing brace
// Exception: Expression-bodied members use semicolons
public int Square(int x) => x * x; // Semicolon required
```
## Resources
- [C# Language Reference](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/)
- [C# Programming Guide](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/)
- [C# Coding Conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions)
# 3. Variables and Data Types
## Value Types vs Reference Types
One of the most fundamental concepts in C# is the distinction between value types and reference types.
### Value Types
- **Storage**: Stored directly on the stack (or inline in a containing type)
- **Assignment**: Copying a value type creates a complete, independent copy of the data
- **Examples**: All primitive numeric types, `bool`, `char`, `struct`, `enum`
```csharp
int a = 10;
int b = a; // 'b' gets a copy of the value of 'a'
b = 20; // Changing 'b' does NOT affect 'a'
Console.WriteLine(a); // Output: 10
Console.WriteLine(b); // Output: 20
```
### Reference Types
- **Storage**: The reference (pointer) is stored on the stack, but the actual object is stored on the heap
- **Assignment**: Copying a reference type copies only the reference, not the data it points to
- **Examples**: `string`, `object`, arrays, `class`, `interface`, `delegate`, `record` (by default)
```csharp
public class Person
{
public string Name { get; set; }
}
Person p1 = new Person { Name = "Alice" };
Person p2 = p1; // 'p2' references the same object as 'p1'
p2.Name = "Bob"; // Changing the object through 'p2' affects what 'p1' sees
Console.WriteLine(p1.Name); // Output: "Bob"
Console.WriteLine(p2.Name); // Output: "Bob"
```
## Primitive Types
C# provides a set of built-in primitive types that map directly to .NET types.
### Integer Types
| C# Type | .NET Type | Size | Range |
| -------- | --------- | ------------------ | ------------------------------------------------------- |
| `byte` | Byte | 8-bit unsigned | 0 to 255 |
| `sbyte` | SByte | 8-bit signed | -128 to 127 |
| `short` | Int16 | 16-bit signed | -32,768 to 32,767 |
| `ushort` | UInt16 | 16-bit unsigned | 0 to 65,535 |
| `int` | Int32 | 32-bit signed | -2,147,483,648 to 2,147,483,647 |
| `uint` | UInt32 | 32-bit unsigned | 0 to 4,294,967,295 |
| `long` | Int64 | 64-bit signed | -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
| `ulong` | UInt64 | 64-bit unsigned | 0 to 18,446,744,073,709,551,615 |
| `nint` | IntPtr | Platform-dependent | Depends on platform (32-bit or 64-bit) |
| `nuint` | UIntPtr | Platform-dependent | Depends on platform (32-bit or 64-bit) |
```csharp
byte smallNumber = 255;
int regularNumber = 42;
long bigNumber = 9223372036854775807;
// Numeric literals
int decimalLiteral = 42;
int hexLiteral = 0x2A; // Hexadecimal (base 16)
int binaryLiteral = 0b101010; // Binary (base 2)
int underscoreDigits = 1_000_000; // Digit separators for readability
```
### Floating-Point Types
| C# Type | .NET Type | Size | Precision | Range |
| --------- | --------- | ------- | -------------------- | ------------------------------- |
| `float` | Single | 32-bit | ~6-9 digits | ±1.5 × 10^−45 to ±3.4 × 10^38 |
| `double` | Double | 64-bit | ~15-17 digits | ±5.0 × 10^−324 to ±1.7 × 10^308 |
| `decimal` | Decimal | 128-bit | 28-29 decimal places | ±1.0 × 10^−28 to ±7.9 × 10^28 |
```csharp
float singlePrecision = 3.14f; // Note the 'f' suffix
double doublePrecision = 3.14159265359; // Default for floating-point literals
decimal highPrecision = 3.14159265359m; // Note the 'm' suffix, ideal for financial calculations
```
### Other Primitive Types
| C# Type | .NET Type | Description |
| ------- | --------- | --------------------------------- |
| `bool` | Boolean | Represents true or false |
| `char` | Char | A single 16-bit Unicode character |
```csharp
bool isValid = true;
char letter = 'A';
char unicodeChar = '\u0041'; // Unicode representation of 'A'
char escapeChar = '\n'; // Newline escape sequence
```
### Special Types
| C# Type | .NET Type | Description |
| --------- | --------- | ----------------------------------- |
| `string` | String | A sequence of characters |
| `object` | Object | The base type for all types in C# |
| `dynamic` | Dynamic | Bypasses compile-time type checking |
```csharp
string message = "Hello, World!";
object anyValue = 42; // Can hold any type
dynamic dynamicValue = "test"; // Type checking at runtime
dynamicValue = 123; // Can change type at runtime
```
## Type Inference (var)
The `var` keyword instructs the compiler to infer the type of a variable from its initializer expression.
```csharp
// The compiler infers these types automatically
var age = 30; // int
var name = "John"; // string
var prices = new List(); // List
var tuple = (Id: 1, Name: "Item"); // (int Id, string Name)
// var must be initialized
// var uninitializedVar; // Error: Implicitly-typed variables must be initialized
// var is still strongly typed at compile time
// age = "thirty"; // Error: Cannot convert string to int
```
**When to use `var`**:
- When the type is obvious from the right side of the assignment
- With complex generic types to improve readability
- When the exact type isn't important to the code's readability
**When not to use `var`**:
- When the type isn't obvious from the initialization
- When you want to be explicit about the type for clarity
## Constants and Readonly
### Constants
Constants are values that cannot be changed after declaration and must be known at compile time.
```csharp
// Compile-time constants (must be primitive types or string)
const double Pi = 3.14159265359;
const string AppName = "MyApp";
const int MaxRetries = 3;
// Constants are implicitly static
// You can use them without creating an instance of the class
Console.WriteLine(Math.PI); // Using a constant from the Math class
```
### Readonly Fields
Readonly fields can only be assigned during declaration or in a constructor.
```csharp
public class Configuration
{
// Can be assigned at declaration
public readonly string AppName = "MyApp";
// Or in a constructor
public readonly DateTime StartTime;
public Configuration()
{
StartTime = DateTime.Now;
}
}
// Usage
var config = new Configuration();
Console.WriteLine(config.StartTime); // OK
// config.StartTime = DateTime.Now; // Error: Cannot assign to readonly field
```
### Static Readonly Fields
Combine `static` and `readonly` for values that should be shared across all instances but can't be determined at compile time.
```csharp
public class ApiClient
{
// Initialized once at runtime, shared by all instances
public static readonly HttpClient SharedClient = new HttpClient();
}
```
### Init-only Properties (C# 9+)
Properties with the `init` accessor can only be set during object initialization.
```csharp
public class User
{
// Can only be set during initialization
public string Id { get; init; } = Guid.NewGuid().ToString();
public string Username { get; init; }
}
// Usage
var user = new User { Username = "john_doe" }; // OK
// user.Username = "jane_doe"; // Error: Init-only property
```
### Required Members (C# 11+)
The `required` modifier ensures that a property or field must be initialized during object creation.
```csharp
public class Customer
{
// Must be initialized when creating a Customer
public required string Name { get; set; }
public required string Email { get; set; }
public string? Phone { get; set; } // Optional
}
// Usage
var customer = new Customer
{
Name = "Alice Smith",
Email = "alice@example.com"
// Phone is optional
};
// This would cause a compile-time error:
// var invalidCustomer = new Customer { Name = "Bob" };
// Error: Customer.Email is required
```
## Nullable Types
### Nullable Value Types
Value types normally cannot be `null`. By adding a `?`, you create a special wrapper (`System.Nullable`) that allows a value type to hold either a value or `null`.
```csharp
// Nullable value types
int? nullableInt = null;
bool? nullableBool = null;
DateTime? nullableDate = null;
// Checking for null
if (nullableInt.HasValue)
{
Console.WriteLine($"Value: {nullableInt.Value}");
}
else
{
Console.WriteLine("No value");
}
// Null-coalescing operator (??) provides a default value
int definitelyInt = nullableInt ?? 0;
// Null-conditional operator (?.) safely accesses members
int? length = nullableString?.Length;
```
### Nullable Reference Types (C# 8+)
In a nullable-enabled context, reference types are non-nullable by default. Adding a `?` explicitly marks a reference type as nullable.
```csharp
#nullable enable // Enable nullable reference types
// Non-nullable reference type (cannot be null)
string nonNullableString = "Hello";
// nonNullableString = null; // Warning: Converting null literal to non-nullable type
// Nullable reference type (can be null)
string? nullableString = null; // OK
// The compiler warns about potential null reference exceptions
Console.WriteLine(nullableString.Length); // Warning: Possible null reference exception
// Null checking is required before use
if (nullableString != null)
{
Console.WriteLine(nullableString.Length); // OK
}
// Or use the null-conditional operator
Console.WriteLine(nullableString?.Length);
#nullable disable // Disable nullable reference types
```
## Nullable Context
The nullable context determines how the compiler interprets reference types with respect to nullability.
### Project-wide Nullable Context
In your `.csproj` file:
```xml
enable
```
Options:
- `disable`: Nullable reference types are not enabled (default for older projects)
- `enable`: Nullable reference types are enabled for the entire project
- `warnings`: Enable warnings but not errors
- `annotations`: Enable nullable annotations but not warnings
### File-level Nullable Context
```csharp
#nullable enable // Enable nullable reference types for this file
#nullable disable // Disable nullable reference types for this file
#nullable restore // Restore to project default
// You can also enable/disable warnings only
#nullable enable warnings
#nullable disable warnings
```
### Pragma-level Nullable Context
```csharp
#pragma warning disable nullable
// Code here won't generate nullable warnings
#pragma warning restore nullable
```
## Type Conversion and Casting
### Implicit Conversions
Implicit conversions happen automatically when there's no risk of data loss.
```csharp
int intValue = 42;
long longValue = intValue; // Implicit conversion from int to long
char charValue = 'A';
int asciiValue = charValue; // Implicit conversion from char to int
// Derived class to base class
Dog dog = new Dog();
Animal animal = dog; // Implicit conversion from Dog to Animal
```
### Explicit Conversions (Casting)
Explicit conversions require a cast operator and may result in data loss.
```csharp
double doubleValue = 42.5;
int intValue = (int)doubleValue; // Explicit conversion, loses the decimal part
// Base class to derived class (requires runtime check)
Animal animal = new Dog();
Dog dog = (Dog)animal; // Explicit conversion, throws if animal isn't a Dog
// Alternative using the as operator (returns null instead of throwing)
Dog? safeDog = animal as Dog;
if (safeDog != null)
{
safeDog.Bark();
}
```
### Type Conversion Methods
```csharp
// Convert class methods
string numberString = "42";
int parsedInt = Convert.ToInt32(numberString);
double parsedDouble = Convert.ToDouble(numberString);
// Parse methods
int parsedInt2 = int.Parse(numberString);
double parsedDouble2 = double.Parse("42.5");
// TryParse methods (safer, doesn't throw exceptions)
if (int.TryParse(numberString, out int result))
{
Console.WriteLine($"Parsed successfully: {result}");
}
else
{
Console.WriteLine("Parsing failed");
}
```
### Boxing and Unboxing
Boxing is the process of converting a value type to a reference type (`object`). Unboxing is the reverse.
```csharp
// Boxing (value type to reference type)
int number = 42;
object boxed = number; // Boxing
// Unboxing (reference type back to value type)
int unboxed = (int)boxed; // Unboxing
// Boxing/unboxing has performance implications and should be avoided in performance-critical code
```
## Default Values
Every type in C# has a default value.
```csharp
// Default values for value types
int defaultInt = default; // 0
bool defaultBool = default; // false
char defaultChar = default; // '\0'
DateTime defaultDateTime = default; // 01/01/0001 00:00:00
// Default values for reference types
string defaultString = default; // null
object defaultObject = default; // null
List defaultList = default; // null
// The default operator can be used with any type
var defaultValue = default(double); // 0.0
```
## Resources
- [Value Types (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types)
- [Reference Types (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types)
- [Nullable Reference Types (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/nullable-references)
- [Type Conversion (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions)
# 4. Operators
Operators are special symbols that perform operations on one or more operands (variables or values) to produce a result.
## Arithmetic Operators
Arithmetic operators perform mathematical calculations.
| Operator | Name | Example | Result |
| -------- | ------------------ | ----------- | ------------------------------------- |
| `+` | Addition | `5 + 3` | `8` |
| `-` | Subtraction | `5 - 3` | `2` |
| `*` | Multiplication | `5 * 3` | `15` |
| `/` | Division | `5 / 3` | `1` (integer division) |
| `/` | Division | `5.0 / 3.0` | `1.6666...` (floating-point division) |
| `%` | Modulo (Remainder) | `5 % 3` | `2` |
```csharp
int a = 10;
int b = 3;
int sum = a + b; // 13
int difference = a - b; // 7
int product = a * b; // 30
int quotient = a / b; // 3 (integer division truncates the result)
int remainder = a % b; // 1
// Division behavior depends on operand types
double c = 10.0;
double d = 3.0;
double result = c / d; // 3.3333... (floating-point division)
// Integer division truncation can be surprising
int negativeResult = -5 / 2; // -2, not -2.5
```
### Increment and Decrement Operators
| Operator | Name | Effect |
| -------- | --------- | -------------------- |
| `++` | Increment | Increases value by 1 |
| `--` | Decrement | Decreases value by 1 |
These operators can be used in prefix or postfix form:
```csharp
int x = 5;
int y;
// Prefix increment (increment, then use the value)
y = ++x; // x is now 6, y is 6
// Postfix increment (use the value, then increment)
x = 5; // Reset x
y = x++; // x is now 6, but y is 5
// Prefix decrement
y = --x; // x is now 5, y is 5
// Postfix decrement
y = x--; // x is now 4, but y is 5
```
## Assignment Operators
Assignment operators assign values to variables.
| Operator | Name | Example | Equivalent |
| -------- | ------------------------------- | --------------------- | ------------- |
| `=` | Simple assignment | `x = 5` | `x = 5` |
| `+=` | Addition assignment | `x += 5` | `x = x + 5` |
| `-=` | Subtraction assignment | `x -= 5` | `x = x - 5` |
| `*=` | Multiplication assignment | `x *= 5` | `x = x * 5` |
| `/=` | Division assignment | `x /= 5` | `x = x / 5` |
| `%=` | Modulo assignment | `x %= 5` | `x = x % 5` |
| `&=` | Bitwise AND assignment | `x &= 5` | `x = x & 5` |
| ` | =` | Bitwise OR assignment | `x | = 5` | `x = x | 5` |
| `^=` | Bitwise XOR assignment | `x ^= 5` | `x = x ^ 5` |
| `<<=` | Left shift assignment | `x <<= 2` | `x = x << 2` |
| `>>=` | Right shift assignment | `x >>= 2` | `x = x >> 2` |
| `>>>=` | Unsigned right shift assignment | `x >>>= 2` | `x = x >>> 2` |
```csharp
int x = 10;
x += 5; // x is now 15
x -= 3; // x is now 12
x *= 2; // x is now 24
x /= 6; // x is now 4
x %= 3; // x is now 1
// Compound assignments work with other types too
string message = "Hello";
message += " World"; // message is now "Hello World"
```
### User-Defined Compound Assignment (C# 14)
In C# 14, you can define custom implementations for compound assignment operators in your own types.
```csharp
public readonly struct Money
{
public decimal Amount { get; }
public Money(decimal amount) => Amount = amount;
// Define the addition operator
public static Money operator +(Money left, Money right) =>
new Money(left.Amount + right.Amount);
// Define the compound addition assignment operator (C# 14)
public static Money operator +=(Money left, Money right) =>
new Money(left.Amount + right.Amount * 0.9m); // 10% discount on additions!
}
// Usage
var wallet = new Money(100);
wallet += new Money(50); // Uses the custom += operator, applying the discount
Console.WriteLine(wallet.Amount); // Output: 145 (100 + 45)
```
## Comparison Operators
Comparison operators compare two values and return a boolean result (`true` or `false`).
| Operator | Name | Example | Result |
| -------- | ------------------------ | -------- | ------- |
| `==` | Equal to | `5 == 5` | `true` |
| `!=` | Not equal to | `5 != 3` | `true` |
| `>` | Greater than | `5 > 3` | `true` |
| `<` | Less than | `5 < 3` | `false` |
| `>=` | Greater than or equal to | `5 >= 5` | `true` |
| `<=` | Less than or equal to | `5 <= 3` | `false` |
```csharp
int a = 10;
int b = 20;
bool isEqual = (a == b); // false
bool isNotEqual = (a != b); // true
bool isGreater = (a > b); // false
bool isLess = (a < b); // true
bool isGreaterOrEqual = (a >= b); // false
bool isLessOrEqual = (a <= b); // true
// String comparison
string s1 = "hello";
string s2 = "hello";
bool stringsEqual = (s1 == s2); // true
// Reference equality vs. value equality
object obj1 = new object();
object obj2 = new object();
bool objectsEqual = (obj1 == obj2); // false (different objects)
// For reference types, == checks reference equality by default
// unless the type overrides the == operator
```
## Logical Operators
Logical operators perform logical operations on boolean values.
| Operator | Name | Example | Result |
| -------- | ----------- | --------------- | ---------- |
| `&&` | Logical AND | `true && false` | `false` |
| ` | | ` | Logical OR | `true | | false` | `true` |
| `!` | Logical NOT | `!true` | `false` |
```csharp
bool a = true;
bool b = false;
bool andResult = a && b; // false (both must be true)
bool orResult = a || b; // true (at least one must be true)
bool notResult = !a; // false (inverts the value)
// Short-circuit evaluation
// In a && b, if a is false, b is not evaluated
// In a || b, if a is true, b is not evaluated
bool isValid = false;
bool isExpensive = CheckIfExpensive(); // This won't be called due to short-circuiting
if (isValid && isExpensive)
{
// This block won't execute
}
```
### Logical Operators with Non-Boolean Operands (C# 11+)
C# 11 introduced the ability to use logical operators with non-boolean operands through the `INumber` interface.
```csharp
// Works with numeric types that implement INumber
int result1 = 5 & 3; // Bitwise AND: 1 (0101 & 0011 = 0001)
int result2 = 5 | 3; // Bitwise OR: 7 (0101 | 0011 = 0111)
int result3 = 5 ^ 3; // Bitwise XOR: 6 (0101 ^ 0011 = 0110)
```
## Bitwise Operators
Bitwise operators perform operations on the binary representations of integer values.
| Operator | Name | Example | Result |
| -------- | -------------------- | ---------- | ------------------------------------- |
| `&` | Bitwise AND | `5 & 3` | `1` (0101 & 0011 = 0001) |
| ` | ` | Bitwise OR | `5 | 3` | `7` (0101 | 0011 = 0111) |
| `^` | Bitwise XOR | `5 ^ 3` | `6` (0101 ^ 0011 = 0110) |
| `~` | Bitwise NOT | `~5` | `-6` (inverts all bits) |
| `<<` | Left shift | `5 << 1` | `10` (shifts bits left) |
| `>>` | Right shift | `5 >> 1` | `2` (shifts bits right) |
| `>>>` | Unsigned right shift | `5 >>> 1` | `2` (shifts bits right, fills with 0) |
```csharp
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
int bitwiseAnd = a & b; // 0001 = 1
int bitwiseOr = a | b; // 0111 = 7
int bitwiseXor = a ^ b; // 0110 = 6
int bitwiseNot = ~a; // 1111...1010 = -6 (in two's complement)
int leftShift = a << 2; // 0101 << 2 = 010100 = 20
int rightShift = a >> 1; // 0101 >> 1 = 0010 = 2
// Unsigned right shift (C# 11+)
uint c = 0x80000000; // Most significant bit is 1
uint unsignedRightShift = c >>> 1; // 0x40000000
```
## Null-Related Operators
C# provides several operators for working safely with potentially null values.
### Null-Coalescing Operator (`??`)
Returns the left operand if it's not null, otherwise returns the right operand.
```csharp
string name = null;
string displayName = name ?? "Guest"; // "Guest"
// Can be chained
string firstName = null;
string middleName = null;
string lastName = "Smith";
string fullName = firstName ?? middleName ?? lastName ?? "Unknown"; // "Smith"
```
### Null-Coalescing Assignment Operator (`??=`) (C# 8+)
Assigns the right operand to the left operand only if the left operand is null.
```csharp
string name = null;
name ??= "Guest"; // name is now "Guest"
// Equivalent to:
// if (name == null)
// name = "Guest";
// Another example
List numbers = null;
numbers ??= new List(); // Initialize only if null
numbers.Add(42); // Safe to use now
```
### Null-Conditional Operator (`?.` and `?[]`)
Safely accesses members or elements of a potentially null object. Returns null if the object is null instead of throwing a `NullReferenceException`.
```csharp
// Without null-conditional operator
string length = null;
if (name != null)
{
length = name.Length.ToString();
}
// With null-conditional operator
string length = name?.Length.ToString(); // null if name is null
// Chaining
int? charCount = customer?.Address?.Street?.Length; // null if any part is null
// With indexers
int? firstItem = array?[0]; // null if array is null
// With method calls
string upperName = name?.ToUpper(); // null if name is null
// Combined with null-coalescing
int length = name?.Length ?? 0; // 0 if name is null
```
### Null-Conditional Assignment Operator (`?.=`) (C# 14)
Allows assignment to occur conditionally when the receiver is non-null. If the receiver is null, the assignment is skipped entirely.
```csharp
public class User { public string? DisplayName { get; set; } }
void UpdateName(User? user, string newName)
{
// Without the operator, you'd need to write:
// if (user != null) user.DisplayName = newName;
// With the operator, it's more concise:
user?.DisplayName = newName; // Assignment only happens if user is not null
}
// Works with events too:
public class Button { public event Action? Clicked; }
void RegisterHandler(Button? button)
{
// Safely add an event handler only if button is not null
button?.Clicked += () => Console.WriteLine("Button was clicked!");
}
```
## Conditional Operator (Ternary Operator)
The conditional operator `?:` evaluates a boolean expression and returns one of two values depending on the result.
```csharp
// Syntax: condition ? true-value : false-value
int age = 20;
string message = (age >= 18) ? "Adult" : "Minor"; // "Adult"
// Can be nested (but may reduce readability)
int value = 15;
string description = (value < 0) ? "Negative" :
(value == 0) ? "Zero" : "Positive"; // "Positive"
// Can be used in expressions
int a = 5;
int b = 3;
int max = (a > b) ? a : b; // 5
// With null-conditional operator
string name = null;
int length = name?.Length ?? 0; // 0 (name?.Length is null, so ?? returns 0)
```
## Type-Testing Operators
Type-testing operators check the type of an object.
### `is` Operator
Tests if an object is compatible with a given type.
```csharp
object obj = "Hello";
bool isString = obj is string; // true
bool isInt = obj is int; // false
// With pattern matching (C# 7+)
if (obj is string s)
{
// s is a string variable containing the value of obj
Console.WriteLine(s.Length); // 5
}
// With negation (C# 9+)
if (obj is not int)
{
Console.WriteLine("Not an integer");
}
```
### `as` Operator
Attempts to cast an object to a specified reference type, returning null if the cast fails.
```csharp
object obj = "Hello";
// Without 'as'
try
{
string str = (string)obj; // Throws InvalidCastException if obj is not a string
}
catch (InvalidCastException)
{
// Handle exception
}
// With 'as'
string str = obj as string; // Returns null if obj is not a string
if (str != null)
{
Console.WriteLine(str.Length); // 5
}
// Note: 'as' only works with reference types and nullable value types
// int i = obj as int; // Error: Cannot use 'as' with value type 'int'
int? i = obj as int?; // Works with nullable value types
```
### `typeof` Operator
Returns the `System.Type` object for a type.
```csharp
Type stringType = typeof(string);
Console.WriteLine(stringType.Name); // "String"
// Useful for reflection
MethodInfo method = typeof(string).GetMethod("Substring", new[] { typeof(int), typeof(int) });
// With generics
Type listType = typeof(List);
Type genericListType = typeof(List<>); // Open generic type
```
## Nameof Operator (C# 6+)
The `nameof` operator returns the name of a variable, type, or member as a string constant.
```csharp
// With variables
string firstName = "John";
Console.WriteLine(nameof(firstName)); // "firstName"
// With properties
Console.WriteLine(nameof(Console.Title)); // "Title"
// With types
Console.WriteLine(nameof(DateTime)); // "DateTime"
// With methods
Console.WriteLine(nameof(Console.WriteLine)); // "WriteLine"
// With parameters
void Process(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException(nameof(fileName));
}
}
// With unbound generic types (C# 14+)
Console.WriteLine(nameof(List<>)); // "List"
```
## Index and Range Operators (C# 8+)
### Index Operator (`^`)
The `^` operator creates an `Index` that counts from the end of a sequence.
```csharp
string[] names = { "Alice", "Bob", "Charlie", "David", "Eve" };
// From the start (0-based)
string first = names[0]; // "Alice"
// From the end (^1 means "1 from the end")
string last = names[^1]; // "Eve"
string secondLast = names[^2]; // "David"
// Can be stored in a variable
Index lastIndex = ^1;
string lastAgain = names[lastIndex]; // "Eve"
```
### Range Operator (`..`)
The `..` operator creates a `Range` that specifies a start and end for a range of elements.
```csharp
string[] names = { "Alice", "Bob", "Charlie", "David", "Eve" };
// Range from start to end
string[] allNames = names[0..5]; // All 5 names
string[] allNamesImplicit = names[..]; // All names
// Range with specific start and end
string[] middle = names[1..4]; // "Bob", "Charlie", "David"
// Range from start to specific end
string[] firstThree = names[..3]; // "Alice", "Bob", "Charlie"
// Range from specific start to end
string[] lastThree = names[2..]; // "Charlie", "David", "Eve"
// Using ^ operator in ranges
string[] lastTwo = names[^2..]; // "David", "Eve"
string[] middleThree = names[1..^1]; // "Bob", "Charlie", "David"
// Can be stored in variables
Index start = 1;
Index end = ^1;
Range middleRange = start..end;
string[] middleAgain = names[middleRange]; // "Bob", "Charlie", "David"
```
## Operator Precedence and Associativity
Operators have different precedence levels that determine the order of evaluation in an expression.
### Precedence (from highest to lowest)
1. Primary operators: `x.y`, `x?.y`, `x?[y]`, `f(x)`, `a[i]`, `x++`, `x--`, `new`, `typeof`, `checked`, `unchecked`, `default`, `nameof`, `sizeof`, `stackalloc`
2. Unary operators: `+x`, `-x`, `!x`, `~x`, `++x`, `--x`, `^x`, `(T)x`, `await`, `&x`, `*x`, `true`, `false`
3. Range operator: `x..y`
4. Multiplicative operators: `x * y`, `x / y`, `x % y`
5. Additive operators: `x + y`, `x - y`
6. Shift operators: `x << y`, `x >> y`, `x >>> y`
7. Relational operators: `x < y`, `x > y`, `x <= y`, `x >= y`, `is`, `as`
8. Equality operators: `x == y`, `x != y`
9. Logical AND operator: `x & y`
10. Logical XOR operator: `x ^ y`
11. Logical OR operator: `x | y`
12. Conditional AND operator: `x && y`
13. Conditional OR operator: `x || y`
14. Null-coalescing operator: `x ?? y`
15. Conditional operator: `x ? y : z`
16. Assignment and lambda operators: `x = y`, `x += y`, `x -= y`, etc., `=>`
### Associativity
When operators have the same precedence, associativity determines the order of evaluation:
- **Left-associative**: Most binary operators (e.g., `a + b + c` is evaluated as `(a + b) + c`)
- **Right-associative**: Assignment operators, conditional operator, null-coalescing operator (e.g., `a = b = c` is evaluated as `a = (b = c)`)
```csharp
// Example of precedence
int result = 2 + 3 * 4; // 14, not 20, because * has higher precedence than +
// Example of associativity
int a, b, c;
a = b = c = 5; // Right-associative: a = (b = (c = 5))
// Using parentheses to override precedence
int explicitResult = (2 + 3) * 4; // 20
```
## Resources
- [C# Operators (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/)
- [Operator Precedence (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/#operator-precedence)
- [Null-Conditional Operators (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/member-access-operators#null-conditional-operators--and-)
# 5. Strings and Text Handling
Strings in C# are immutable sequences of Unicode characters represented by the `string` type (an alias for `System.String`). C# offers a rich set of string manipulation features, from basic concatenation to advanced interpolation and raw string literals.
## String Creation and Basics
### String Declaration and Initialization
```csharp
// String declaration and initialization
string empty = ""; // Empty string
string nullString = null; // Null string (no object)
string name = "John"; // String literal
string emptyString = string.Empty; // Preferred way to create an empty string
// String concatenation
string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName; // "John Doe"
// String constructor
char[] letters = { 'H', 'e', 'l', 'l', 'o' };
string greeting = new string(letters); // "Hello"
string repeated = new string('*', 10); // "**********"
```
### String Immutability
Strings in C# are immutable, meaning once created, their contents cannot be changed. Operations that appear to modify a string actually create a new string.
```csharp
string original = "Hello";
string modified = original.Replace('H', 'J'); // Creates a new string "Jello"
Console.WriteLine(original); // Still "Hello"
Console.WriteLine(modified); // "Jello"
```
## String Interpolation (C# 6+)
String interpolation provides a more readable and convenient syntax to format strings with expressions.
```csharp
// Basic string interpolation
string name = "Alice";
int age = 30;
string message = $"My name is {name} and I am {age} years old.";
// Expressions in interpolation
string result = $"5 + 3 = {5 + 3}";
// Format specifiers
decimal price = 123.45m;
string formattedPrice = $"Price: {price:C}"; // "Price: $123.45" (culture-specific)
// Alignment and formatting
int value = 42;
string aligned = $"{value,10}"; // Right-aligned in 10-character field
string formatted = $"{value:D6}"; // "000042"
// Multiple lines
string multiLine = $"Name: {name}\nAge: {age}";
// Escaping braces
string escaped = $"{{This is in braces}} but {name} is interpolated.";
// Conditional expressions
string status = $"Status: {(age >= 18 ? "Adult" : "Minor")}";
// Calling methods
string upper = $"Uppercase: {name.ToUpper()}";
```
### Common Format Specifiers
| Specifier | Description | Example | Output |
| ---------- | ------------------ | ------------- | --------------- |
| `C` or `c` | Currency | `{123.45:C}` | `$123.45` |
| `D` or `d` | Decimal (integers) | `{42:D6}` | `000042` |
| `E` or `e` | Exponential | `{1234.56:E}` | `1.234560E+003` |
| `F` or `f` | Fixed-point | `{123.45:F1}` | `123.5` |
| `G` or `g` | General | `{1234.56:G}` | `1234.56` |
| `N` or `n` | Number with commas | `{1234.56:N}` | `1,234.56` |
| `P` or `p` | Percent | `{0.1234:P}` | `12.34%` |
| `X` or `x` | Hexadecimal | `{255:X}` | `FF` or `ff` |
## Verbatim Strings
Verbatim strings, prefixed with `@`, preserve all whitespace and escape sequences literally.
```csharp
// Without verbatim string (need to escape backslashes)
string path = "C:\\Program Files\\App\\Data.txt";
// With verbatim string (no need to escape backslashes)
string verbatimPath = @"C:\Program Files\App\Data.txt";
// Multiline verbatim string
string multiline = @"This is a
multiline string
that preserves all line breaks
and indentation.";
// Escaping double quotes in verbatim strings (use double double-quotes)
string quote = @"He said, ""Hello, world!""";
// Combining verbatim with interpolation
string verbatimInterpolated = $@"User: {name}
Path: {verbatimPath}";
```
## Raw String Literals (C# 11+)
Raw string literals, delimited by at least three double quotes (`"""`), provide an even more flexible way to include literal text, especially for multi-line content with quotes and special characters.
```csharp
// Basic raw string literal
string json = """
{
"name": "John Doe",
"age": 30,
"isActive": true
}
""";
// Raw string with interpolation
string name = "Alice";
string age = "25";
string interpolatedJson = $"""
{
"name": "{name}",
"age": {age},
"isActive": true
}
""";
// Controlling indentation with raw strings
string indentedCode = """
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
""";
// Using more than three quotes for delimiter
string complexText = """"
This text contains """ triple quotes
without needing to escape them.
"""";
// Raw string literals can contain any characters without escaping
string regex = """
The regex pattern \d{3}-\d{2}-\d{4} matches a SSN.
""";
```
## String Methods and Properties
C# strings provide numerous methods for manipulation and inspection.
### Basic Properties
```csharp
string text = "Hello, World!";
int length = text.Length; // 13
bool isEmpty = string.IsNullOrEmpty(text); // false
bool isWhitespace = string.IsNullOrWhiteSpace(text); // false
```
### Searching and Comparing
```csharp
string text = "Hello, World!";
// Searching
bool contains = text.Contains("World"); // true
bool startsWith = text.StartsWith("Hello"); // true
bool endsWith = text.EndsWith("!"); // true
int indexOfWorld = text.IndexOf("World"); // 7
int lastIndexOfL = text.LastIndexOf("l"); // 10
int indexOfZ = text.IndexOf("Z"); // -1 (not found)
// Comparing
string a = "apple";
string b = "banana";
int comparison = string.Compare(a, b); // -1 (a comes before b)
bool equals = a.Equals(b); // false
// Case-insensitive comparison
bool equalsIgnoreCase = a.Equals("APPLE", StringComparison.OrdinalIgnoreCase); // true
bool containsIgnoreCase = text.Contains("world", StringComparison.OrdinalIgnoreCase); // true
// Different comparison types
StringComparison[] comparisons = {
StringComparison.Ordinal, // Fast, case-sensitive, culture-agnostic
StringComparison.OrdinalIgnoreCase, // Fast, case-insensitive, culture-agnostic
StringComparison.CurrentCulture, // Slow, case-sensitive, culture-sensitive
StringComparison.CurrentCultureIgnoreCase, // Slow, case-insensitive, culture-sensitive
StringComparison.InvariantCulture, // Slow, case-sensitive, culture-invariant
StringComparison.InvariantCultureIgnoreCase // Slow, case-insensitive, culture-invariant
};
```
### Modifying Strings
Remember that these methods don't modify the original string but return a new string.
```csharp
string text = "Hello, World!";
// Changing case
string upper = text.ToUpper(); // "HELLO, WORLD!"
string lower = text.ToLower(); // "hello, world!"
string upperInvariant = text.ToUpperInvariant(); // Culture-insensitive uppercase
// Trimming
string paddedText = " Hello ";
string trimmed = paddedText.Trim(); // "Hello"
string trimStart = paddedText.TrimStart(); // "Hello "
string trimEnd = paddedText.TrimEnd(); // " Hello"
// Specific characters to trim
string trimChars = "###Hello###".Trim('#'); // "Hello"
// Replacing
string replaced = text.Replace("Hello", "Hi"); // "Hi, World!"
string replacedChars = text.Replace('o', '0'); // "Hell0, W0rld!"
// Substring
string sub1 = text.Substring(7); // "World!"
string sub2 = text.Substring(7, 5); // "World"
// Inserting and removing
string inserted = text.Insert(5, " there"); // "Hello there, World!"
string removed = text.Remove(5, 7); // "Hello!"
// Padding
string padded = "Hello".PadLeft(10); // " Hello"
string paddedChar = "Hello".PadRight(10, '*'); // "Hello*****"
// Joining strings
string[] words = { "Hello", "World" };
string joined = string.Join(", ", words); // "Hello, World"
string joined2 = string.Join(" | ", new[] { "A", "B", "C" }); // "A | B | C"
```
### Splitting Strings
```csharp
string text = "apple,banana,orange";
// Basic split
string[] fruits = text.Split(','); // ["apple", "banana", "orange"]
// Split with multiple delimiters
string data = "apple,banana;orange:grape";
string[] fruits2 = data.Split(new[] { ',', ';', ':' }); // ["apple", "banana", "orange", "grape"]
// Split with options
string line = "apple,,banana,,,orange";
string[] fruits3 = line.Split(',', StringSplitOptions.RemoveEmptyEntries); // ["apple", "banana", "orange"]
// Split with count
string longText = "one,two,three,four,five";
string[] parts = longText.Split(',', 3); // ["one", "two", "three,four,five"]
// Split lines
string multiline = "Line 1\r\nLine 2\nLine 3";
string[] lines = multiline.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None);
```
## StringBuilder
For scenarios involving multiple string modifications, `StringBuilder` provides better performance than concatenating strings.
```csharp
using System.Text;
// Creating a StringBuilder
StringBuilder sb = new StringBuilder();
StringBuilder sb2 = new StringBuilder("Initial text");
StringBuilder sb3 = new StringBuilder(50); // With capacity
// Appending
sb.Append("Hello");
sb.Append(' ');
sb.Append("World");
sb.AppendLine("!"); // Adds a newline
sb.AppendLine("Next line");
sb.AppendFormat("The time is {0:t}", DateTime.Now);
// Inserting
sb.Insert(5, " there");
// Removing
sb.Remove(5, 6);
// Replacing
sb.Replace("World", "Universe");
// Getting the result
string result = sb.ToString();
// Performance example
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 10000; i++)
{
builder.Append(i.ToString());
builder.Append(',');
}
string numbers = builder.ToString();
```
## String Formatting
The `string.Format` method provides a way to create formatted strings.
```csharp
// Basic formatting
string formatted = string.Format("Name: {0}, Age: {1}", "John", 30);
// Multiple occurrences of the same value
string repeated = string.Format("{0} {0} {0}", "Hip");
// Format specifiers
string formatted2 = string.Format("Price: {0:C}, Date: {1:d}", 123.45, DateTime.Now);
// Alignment
string aligned = string.Format("{0,10} | {1,-10}", "Right", "Left");
// Custom format for DateTime
DateTime date = new DateTime(2023, 12, 31);
string customDate = string.Format("Year: {0:yyyy}, Month: {0:MM}, Day: {0:dd}", date);
// Custom numeric format
double number = 1234.5678;
string customNumber = string.Format("{0:#,##0.00}", number); // "1,234.57"
```
## UTF-8 String Literals (C# 11+)
UTF-8 string literals create a byte representation of a string encoded in UTF-8, which is the standard for the web and many file formats.
```csharp
// UTF-8 string literal
ReadOnlySpan utf8Data = "Hello, World!"u8;
// This is more efficient than:
byte[] bytes = System.Text.Encoding.UTF8.GetBytes("Hello, World!");
// Useful for APIs that work with UTF-8 encoded data
using System.Text.Json;
ReadOnlySpan jsonUtf8 = """{"name":"John"}"""u8;
var document = JsonDocument.Parse(jsonUtf8);
```
## String Interpolation Handlers (C# 10+)
String interpolation handlers allow for custom processing of interpolated strings.
```csharp
// Using the built-in StringBuilder interpolation handler
var sb = new StringBuilder();
string name = "Alice";
int age = 30;
// This uses the handler to build the string without creating intermediate strings
sb.AppendFormat($"Name: {name}, Age: {age}");
// Custom interpolation handler example (simplified)
using System.Runtime.CompilerServices;
public static class LoggerExtensions
{
public static void LogInformation(this ILogger logger, [InterpolatedStringHandlerArgument("logger")] LogInterpolatedStringHandler message)
{
if (message.IsEnabled)
{
logger.Log(LogLevel.Information, message.GetFormattedText());
}
}
}
// Usage
logger.LogInformation($"User {userId} logged in at {DateTime.Now}");
```
## Common String Operations
### Checking String Content
```csharp
// Check if string is null or empty
if (string.IsNullOrEmpty(text))
{
// Handle empty string
}
// Check if string is null, empty, or whitespace
if (string.IsNullOrWhiteSpace(text))
{
// Handle empty or whitespace string
}
// Check if string contains a substring
if (text.Contains("search", StringComparison.OrdinalIgnoreCase))
{
// Contains the substring (case-insensitive)
}
```
### String Validation
```csharp
// Check if string is a valid number
bool isNumber = int.TryParse(text, out _);
// Check if string matches a pattern (using Regex)
using System.Text.RegularExpressions;
bool isEmail = Regex.IsMatch(text, @"^[^@\s]+@[^@\s]+\.[^@\s]+$");
// Check if string is a valid date
bool isDate = DateTime.TryParse(text, out _);
```
### String Transformation
```csharp
// Convert first letter to uppercase
string capitalize(string s) => string.IsNullOrEmpty(s)
? s
: char.ToUpper(s[0]) + s.Substring(1);
// Truncate string with ellipsis
string truncate(string s, int maxLength) => s.Length <= maxLength
? s
: s.Substring(0, maxLength - 3) + "...";
// Convert to title case
using System.Globalization;
string titleCase = CultureInfo.CurrentCulture.TextInfo.ToTitleCase("hello world");
```
## String Interning
String interning is a mechanism that stores only one copy of each unique string literal in the application.
```csharp
// These point to the same string in memory
string a = "Hello";
string b = "Hello";
Console.WriteLine(object.ReferenceEquals(a, b)); // true
// But these don't (unless optimized by the compiler)
string c = "Hel" + "lo";
string d = new string(new char[] { 'H', 'e', 'l', 'l', 'o' });
Console.WriteLine(object.ReferenceEquals(a, c)); // might be true (compiler optimization)
Console.WriteLine(object.ReferenceEquals(a, d)); // false
// Explicitly intern a string
string interned = string.Intern(d);
Console.WriteLine(object.ReferenceEquals(a, interned)); // true
```
## Resources
- [String Class (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/api/system.string)
- [String Interpolation (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated)
- [StringBuilder Class (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/api/system.text.stringbuilder)
- [Standard Numeric Format Strings (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings)
- [Custom Numeric Format Strings (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings)
- [Standard Date and Time Format Strings (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings)
- [Custom Date and Time Format Strings (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings)
# 6. Control Flow
Control flow statements determine the order in which code is executed. C# provides a rich set of control flow constructs for conditional execution, loops, and branching.
## Conditional Statements
### if, else if, else
The `if` statement executes a block of code if a specified condition is true.
```csharp
int age = 25;
// Basic if statement
if (age >= 18)
{
Console.WriteLine("You are an adult.");
}
// if-else statement
if (age >= 18)
{
Console.WriteLine("You are an adult.");
}
else
{
Console.WriteLine("You are a minor.");
}
// if-else if-else chain
if (age < 13)
{
Console.WriteLine("Child");
}
else if (age < 18)
{
Console.WriteLine("Teenager");
}
else if (age < 65)
{
Console.WriteLine("Adult");
}
else
{
Console.WriteLine("Senior");
}
// Nested if statements
if (age >= 18)
{
if (age < 21)
{
Console.WriteLine("You are an adult, but cannot drink in the US.");
}
else
{
Console.WriteLine("You are an adult and can drink in the US.");
}
}
```
### Conditional (Ternary) Operator
The conditional operator `?:` is a shorthand for the if-else statement.
```csharp
int age = 20;
// Ternary operator
string status = (age >= 18) ? "Adult" : "Minor";
// Equivalent if-else
string status2;
if (age >= 18)
{
status2 = "Adult";
}
else
{
status2 = "Minor";
}
// Nested ternary (use with caution for readability)
string category = (age < 13) ? "Child" :
(age < 18) ? "Teenager" :
(age < 65) ? "Adult" : "Senior";
// Ternary with expressions
int a = 5, b = 10;
int max = (a > b) ? a : b; // 10
```
### switch Statement
The `switch` statement selects a statement list to execute based on a pattern match with a match expression.
```csharp
int day = 3;
// Basic switch on a value
switch (day)
{
case 1:
Console.WriteLine("Monday");
break;
case 2:
Console.WriteLine("Tuesday");
break;
case 3:
Console.WriteLine("Wednesday");
break;
case 4:
Console.WriteLine("Thursday");
break;
case 5:
Console.WriteLine("Friday");
break;
case 6:
case 7:
Console.WriteLine("Weekend");
break;
default:
Console.WriteLine("Invalid day");
break;
}
// Switch with pattern matching (C# 7+)
object obj = "Hello";
switch (obj)
{
case int i:
Console.WriteLine($"Integer: {i}");
break;
case string s:
Console.WriteLine($"String: {s}");
break;
case bool b when b == true: // Case with a when condition
Console.WriteLine("True boolean");
break;
case null:
Console.WriteLine("Null value");
break;
default:
Console.WriteLine("Unknown type");
break;
}
// Switch with ranges (C# 9+)
int score = 85;
switch (score)
{
case >= 90:
Console.WriteLine("A");
break;
case >= 80:
Console.WriteLine("B");
break;
case >= 70:
Console.WriteLine("C");
break;
case >= 60:
Console.WriteLine("D");
break;
default:
Console.WriteLine("F");
break;
}
```
### switch Expression (C# 8+)
The `switch` expression is a more concise form of the switch statement that returns a value.
```csharp
int day = 3;
// Basic switch expression
string dayName = day switch
{
1 => "Monday",
2 => "Tuesday",
3 => "Wednesday",
4 => "Thursday",
5 => "Friday",
6 or 7 => "Weekend",
_ => "Invalid day" // Default case
};
// Switch expression with pattern matching
object obj = "Hello";
string typeDescription = obj switch
{
int i => $"Integer: {i}",
string s => $"String: {s}",
bool b when b == true => "True boolean",
null => "Null value",
_ => "Unknown type"
};
// Switch expression with property patterns (C# 8+)
var person = new { Name = "John", Age = 25 };
string description = person switch
{
{ Name: "John", Age: 25 } => "John who is 25",
{ Name: "John" } => "John with any age",
{ Age: > 18 } => "Any adult",
_ => "Unknown person"
};
// Switch expression with tuple patterns (C# 8+)
var point = (X: 5, Y: -2);
string quadrant = point switch
{
(0, 0) => "Origin",
(_, 0) => "X-axis",
(0, _) => "Y-axis",
(> 0, > 0) => "First quadrant",
(< 0, > 0) => "Second quadrant",
(< 0, < 0) => "Third quadrant",
(> 0, < 0) => "Fourth quadrant",
_ => "Unknown"
};
```
### Null-Coalescing Operator (`??`)
The null-coalescing operator `??` returns the left-hand operand if it isn't null; otherwise, it returns the right-hand operand.
```csharp
string name = null;
string displayName = name ?? "Guest"; // "Guest"
// Chaining null-coalescing operators
string firstName = null;
string middleName = null;
string lastName = "Smith";
string fullName = firstName ?? middleName ?? lastName ?? "Unknown"; // "Smith"
```
### Null-Coalescing Assignment Operator (`??=`) (C# 8+)
The null-coalescing assignment operator `??=` assigns the right-hand operand to the left-hand operand only if the left-hand operand is null.
```csharp
string name = null;
name ??= "Guest"; // name is now "Guest"
// Equivalent to:
// if (name == null)
// name = "Guest";
// Useful for lazy initialization
List numbers = null;
(numbers ??= new List()).Add(5); // Initialize and use in one line
Console.WriteLine(numbers.Count); // 1
```
## Iteration Statements (Loops)
### for Loop
The `for` loop executes a block of code repeatedly until a specified condition evaluates to false.
```csharp
// Basic for loop
for (int i = 0; i < 5; i++)
{
Console.WriteLine(i); // 0, 1, 2, 3, 4
}
// Multiple initialization and iterators
for (int i = 0, j = 10; i < j; i++, j--)
{
Console.WriteLine($"i = {i}, j = {j}"); // i=0,j=10; i=1,j=9; i=2,j=8; i=3,j=7; i=4,j=6
}
// Omitting parts of the for statement
int k = 0;
for (; k < 5;)
{
Console.WriteLine(k);
k++;
}
// Infinite loop (use with caution)
// for (;;)
// {
// // Code that runs forever (until break)
// }
// Nested for loops
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 2; j++)
{
Console.WriteLine($"({i},{j})");
}
}
```
### foreach Loop
The `foreach` loop iterates over elements in a collection.
```csharp
// foreach with array
string[] names = { "Alice", "Bob", "Charlie" };
foreach (string name in names)
{
Console.WriteLine(name);
}
// foreach with List
List numbers = new List { 1, 2, 3, 4, 5 };
foreach (int number in numbers)
{
Console.WriteLine(number);
}
// foreach with Dictionary
Dictionary ages = new Dictionary
{
{ "Alice", 25 },
{ "Bob", 30 },
{ "Charlie", 35 }
};
foreach (KeyValuePair pair in ages)
{
Console.WriteLine($"{pair.Key} is {pair.Value} years old");
}
// Using deconstruction with foreach (C# 7+)
foreach (var (name, age) in ages)
{
Console.WriteLine($"{name} is {age} years old");
}
// foreach with custom types that implement IEnumerable
foreach (var item in myCustomCollection)
{
// Process item
}
```
### while Loop
The `while` loop executes a block of code as long as a specified condition is true.
```csharp
// Basic while loop
int i = 0;
while (i < 5)
{
Console.WriteLine(i); // 0, 1, 2, 3, 4
i++;
}
// while with complex condition
string input = "";
while (input != "exit" && input != "quit")
{
Console.Write("Enter command (type 'exit' to quit): ");
input = Console.ReadLine().ToLower();
// Process input
}
// Infinite loop with break
int j = 0;
while (true)
{
Console.WriteLine(j);
j++;
if (j >= 5)
break;
}
```
### do-while Loop
The `do-while` loop is similar to the while loop, except the condition is evaluated after the loop body executes, ensuring the loop body runs at least once.
```csharp
// Basic do-while loop
int i = 0;
do
{
Console.WriteLine(i); // 0, 1, 2, 3, 4
i++;
} while (i < 5);
// do-while for input validation
string password;
do
{
Console.Write("Enter a password (at least 6 characters): ");
password = Console.ReadLine();
} while (password.Length < 6);
// do-while that always executes at least once
int j = 10;
do
{
Console.WriteLine("This runs once even though the condition is false");
} while (j < 5);
```
## Jump Statements
### break Statement
The `break` statement terminates the closest enclosing loop or switch statement.
```csharp
// break in a for loop
for (int i = 0; i < 10; i++)
{
if (i == 5)
break; // Exit the loop when i is 5
Console.WriteLine(i); // 0, 1, 2, 3, 4
}
// break in a while loop
int j = 0;
while (j < 10)
{
if (j == 5)
break; // Exit the loop when j is 5
Console.WriteLine(j); // 0, 1, 2, 3, 4
j++;
}
// break in a nested loop (only breaks out of the innermost loop)
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (i == 1 && j == 1)
break; // Breaks out of the inner loop only
Console.WriteLine($"({i},{j})");
}
}
// break in a switch statement
int day = 3;
switch (day)
{
case 1:
Console.WriteLine("Monday");
break; // Exit the switch
case 2:
Console.WriteLine("Tuesday");
break; // Exit the switch
default:
Console.WriteLine("Other day");
break; // Exit the switch
}
```
### continue Statement
The `continue` statement skips the rest of the current iteration and proceeds to the next iteration of the loop.
```csharp
// continue in a for loop
for (int i = 0; i < 10; i++)
{
if (i % 2 == 0)
continue; // Skip even numbers
Console.WriteLine(i); // 1, 3, 5, 7, 9
}
// continue in a while loop
int j = 0;
while (j < 10)
{
j++;
if (j % 2 == 0)
continue; // Skip even numbers
Console.WriteLine(j); // 1, 3, 5, 7, 9
}
// continue in a nested loop (only affects the innermost loop)
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (j == 1)
continue; // Skip when j is 1
Console.WriteLine($"({i},{j})"); // (0,0), (0,2), (1,0), (1,2), (2,0), (2,2)
}
}
```
### return Statement
The `return` statement exits the current method and optionally returns a value.
```csharp
// return with a value
int Add(int a, int b)
{
return a + b; // Return the sum and exit the method
}
// Early return for validation
bool IsValidUsername(string username)
{
if (string.IsNullOrEmpty(username))
return false; // Invalid: empty username
if (username.Length < 3)
return false; // Invalid: too short
if (username.Length > 20)
return false; // Invalid: too long
// More validation...
return true; // Valid username
}
// return without a value (in a void method)
void ProcessData(int[] data)
{
if (data == null || data.Length == 0)
return; // Exit the method early
// Process the data...
}
```
### goto Statement
The `goto` statement transfers control to a labeled statement. While generally discouraged in modern programming, it can be useful in specific scenarios.
```csharp
// goto with a label
int i = 0;
start: // Label
Console.WriteLine(i);
i++;
if (i < 5)
goto start; // Go back to the 'start' label
// goto in a nested loop (can break out of multiple loops)
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (i == 1 && j == 1)
goto exit; // Exit both loops
Console.WriteLine($"({i},{j})");
}
}
exit: // Label
Console.WriteLine("Exited loops");
// goto in a switch statement
int option = 2;
switch (option)
{
case 1:
Console.WriteLine("Option 1");
goto case 3; // Execute case 3 after this
case 2:
Console.WriteLine("Option 2");
goto case 1; // Execute case 1 after this
case 3:
Console.WriteLine("Option 3");
break;
default:
Console.WriteLine("Default option");
break;
}
// Output: "Option 2", "Option 1", "Option 3"
```
## Exception Handling
### try-catch-finally
The `try-catch-finally` statement handles exceptions that might occur during execution.
```csharp
// Basic try-catch
try
{
int result = 10 / 0; // This will throw a DivideByZeroException
Console.WriteLine(result); // This line won't execute
}
catch (DivideByZeroException ex)
{
Console.WriteLine($"Error: {ex.Message}"); // "Error: Attempted to divide by zero."
}
// Multiple catch blocks
try
{
string text = null;
int length = text.Length; // This will throw a NullReferenceException
}
catch (NullReferenceException ex)
{
Console.WriteLine("Null reference error: " + ex.Message);
}
catch (ArgumentException ex)
{
Console.WriteLine("Argument error: " + ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("General error: " + ex.Message); // Catches any other exception
}
// try-catch-finally
try
{
File.ReadAllText("nonexistent.txt"); // This will throw a FileNotFoundException
}
catch (FileNotFoundException ex)
{
Console.WriteLine($"File not found: {ex.Message}");
}
finally
{
Console.WriteLine("This always executes, whether an exception occurred or not");
// Clean up resources, close files, etc.
}
// Nested try-catch
try
{
try
{
int result = 10 / 0;
}
catch (ArithmeticException ex)
{
Console.WriteLine("Inner catch: " + ex.Message);
throw; // Re-throw the exception to the outer catch
}
}
catch (Exception ex)
{
Console.WriteLine("Outer catch: " + ex.Message);
}
```
### throw Statement
The `throw` statement throws an exception.
```csharp
// Throwing a predefined exception
void ProcessAge(int age)
{
if (age < 0)
throw new ArgumentException("Age cannot be negative");
// Process age...
}
// Re-throwing an exception
try
{
int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Logging the error: " + ex.Message);
throw; // Re-throw the same exception
}
// Throwing a new exception with the original as inner exception
try
{
File.ReadAllText("config.txt");
}
catch (FileNotFoundException ex)
{
throw new ApplicationException("Configuration error", ex);
}
// Creating and throwing a custom exception
public class CustomException : Exception
{
public CustomException(string message) : base(message) { }
public CustomException(string message, Exception inner) : base(message, inner) { }
}
void ProcessData(string data)
{
if (string.IsNullOrEmpty(data))
throw new CustomException("Data cannot be empty");
}
```
### Exception Filters (C# 6+)
Exception filters allow you to specify a condition for a catch block.
```csharp
// Basic exception filter
try
{
ProcessFile("data.txt");
}
catch (IOException ex) when (ex.HResult == -2147024816) // File not found
{
Console.WriteLine("The file was not found");
}
catch (IOException ex) when (ex.HResult == -2147024864) // Path not found
{
Console.WriteLine("The path was not found");
}
catch (IOException ex) // Any other IO exception
{
Console.WriteLine("IO error: " + ex.Message);
}
// Exception filter with logging (without handling)
try
{
// Some code that might throw
}
catch (Exception ex) when (LogException(ex))
{
// This block never executes because LogException returns false
}
bool LogException(Exception ex)
{
Console.WriteLine($"Exception logged: {ex.Message}");
return false; // Don't handle the exception, let it propagate
}
// Exception filter with complex conditions
try
{
// Some code that might throw
}
catch (Exception ex) when (ex.Message.Contains("specific error") && DateTime.Now.DayOfWeek == DayOfWeek.Monday)
{
Console.WriteLine("Specific error occurred on Monday");
}
```
## Pattern Matching (C# 7+)
Pattern matching allows you to test if an expression matches a certain pattern and extract information from it.
### Type Patterns
```csharp
// Type pattern with 'is'
object obj = "Hello";
if (obj is string s)
{
Console.WriteLine($"String of length {s.Length}"); // Uses the extracted variable 's'
}
// Type pattern with 'switch'
switch (obj)
{
case int i:
Console.WriteLine($"Integer: {i}");
break;
case string s:
Console.WriteLine($"String: {s}");
break;
case bool b:
Console.WriteLine($"Boolean: {b}");
break;
case null:
Console.WriteLine("Null value");
break;
default:
Console.WriteLine("Unknown type");
break;
}
```
### Constant Patterns
```csharp
// Constant pattern with 'is'
object value = 42;
if (value is 42)
{
Console.WriteLine("Value is 42");
}
// Constant pattern with 'switch'
switch (value)
{
case 0:
Console.WriteLine("Zero");
break;
case 42:
Console.WriteLine("The answer");
break;
case null:
Console.WriteLine("Null");
break;
default:
Console.WriteLine("Something else");
break;
}
```
### Relational Patterns (C# 9+)
```csharp
// Relational patterns with 'is'
int age = 25;
if (age is >= 18 and < 65)
{
Console.WriteLine("Working age adult");
}
// Relational patterns with 'switch'
string description = age switch
{
< 0 => "Invalid age",
0 => "Newborn",
< 13 => "Child",
< 18 => "Teenager",
< 65 => "Adult",
_ => "Senior"
};
```
### Logical Patterns (C# 9+)
```csharp
// 'and', 'or', and 'not' patterns
int value = 7;
if (value is > 0 and < 10 and not 5)
{
Console.WriteLine("Single positive digit, not 5");
}
// Combined with other patterns
object obj = "Hello";
if (obj is string { Length: > 3 and < 10 })
{
Console.WriteLine("String with length between 4 and 9");
}
```
### Property Patterns (C# 8+)
```csharp
// Simple property pattern
var person = new { Name = "John", Age = 25 };
if (person is { Age: >= 18 })
{
Console.WriteLine("Adult");
}
// Nested property pattern
var order = new { Customer = new { Name = "Alice", IsVip = true }, Total = 100.0 };
if (order is { Customer: { IsVip: true }, Total: >= 50.0 })
{
Console.WriteLine("VIP order with high value");
}
// Property pattern with switch expression
string description = person switch
{
{ Name: "John", Age: 25 } => "John who is 25",
{ Name: "John" } => "John with any age",
{ Age: >= 18 } => "Any adult",
_ => "Unknown person"
};
```
### Tuple Patterns (C# 8+)
```csharp
// Tuple pattern with switch expression
var point = (X: 5, Y: -2);
string quadrant = point switch
{
(0, 0) => "Origin",
(_, 0) => "X-axis",
(0, _) => "Y-axis",
(> 0, > 0) => "First quadrant",
(< 0, > 0) => "Second quadrant",
(< 0, < 0) => "Third quadrant",
(> 0, < 0) => "Fourth quadrant",
_ => "Unknown"
};
// Tuple pattern with method parameters
string Classify(int x, int y) => (x, y) switch
{
(0, 0) => "Origin",
var (a, b) when a > 0 && b > 0 => "First quadrant",
var (a, b) when a < 0 && b > 0 => "Second quadrant",
var (a, b) when a < 0 && b < 0 => "Third quadrant",
var (a, b) when a > 0 && b < 0 => "Fourth quadrant",
_ => "On an axis"
};
```
### List Patterns (C# 11+)
```csharp
// List pattern with 'is'
int[] numbers = { 1, 2, 3 };
if (numbers is [1, 2, 3])
{
Console.WriteLine("Exact match: [1, 2, 3]");
}
// List pattern with discard
if (numbers is [1, _, 3])
{
Console.WriteLine("First element is 1, last is 3");
}
// List pattern with 'var'
if (numbers is [var first, _, var last])
{
Console.WriteLine($"First: {first}, Last: {last}");
}
// List pattern with slice pattern
if (numbers is [1, .. var middle, 3])
{
Console.WriteLine($"Middle: {string.Join(", ", middle)}"); // "2"
}
// List pattern with switch expression
string description = numbers switch
{
[] => "Empty array",
[var single] => $"Single element: {single}",
[var first, var second] => $"Two elements: {first}, {second}",
[1, 2, 3] => "Exactly [1, 2, 3]",
[1, ..] => "Starts with 1",
[.., 3] => "Ends with 3",
_ => "Other array"
};
```
## Resources
- [C# Control Flow (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/selection-statements)
- [C# Loops (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements)
- [C# Exception Handling (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-statements)
- [C# Pattern Matching (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns)
# 7. Methods and Functions
Methods in C# are blocks of code that perform a specific task. They are the fundamental building blocks of code reuse and help organize code into logical units.
## Method Declaration and Invocation
### Basic Method Declaration
```csharp
// Method with no parameters and no return value (void)
void SayHello()
{
Console.WriteLine("Hello, World!");
}
// Method with parameters and a return value
int Add(int a, int b)
{
return a + b;
}
// Method with multiple parameters of different types
string FormatName(string firstName, string lastName, int age)
{
return $"{firstName} {lastName}, Age: {age}";
}
// Method with local variables
double CalculateAverage(int[] numbers)
{
int sum = 0;
foreach (int number in numbers)
{
sum += number;
}
return (double)sum / numbers.Length;
}
```
### Method Invocation
```csharp
// Calling a method with no parameters
SayHello(); // Output: "Hello, World!"
// Calling a method with parameters
int sum = Add(5, 3); // sum = 8
// Calling a method with named arguments (order doesn't matter)
string fullName = FormatName(lastName: "Doe", age: 30, firstName: "John");
// Calling a method with an array parameter
int[] scores = { 85, 90, 78, 92, 88 };
double average = CalculateAverage(scores); // average = 86.6
```
## Method Parameters
### Parameter Modifiers
```csharp
// Regular parameters (passed by value)
void ModifyValue(int x)
{
x = 10; // Only modifies the local copy
}
// ref parameter (passed by reference)
void ModifyRef(ref int x)
{
x = 10; // Modifies the original variable
}
// out parameter (must be assigned in the method)
void GetValues(out int x, out int y)
{
x = 10; // Must assign a value to x
y = 20; // Must assign a value to y
}
// in parameter (read-only reference, C# 7.2+)
void ProcessReadOnly(in int x)
{
// x = 10; // Error: Cannot modify 'in' parameter
Console.WriteLine(x); // Can read the value
}
// Usage examples
int a = 5;
ModifyValue(a);
Console.WriteLine(a); // Output: 5 (unchanged)
int b = 5;
ModifyRef(ref b);
Console.WriteLine(b); // Output: 10 (modified)
GetValues(out int c, out int d);
Console.WriteLine($"c = {c}, d = {d}"); // Output: "c = 10, d = 20"
int e = 5;
ProcessReadOnly(in e); // Passing by read-only reference
```
### Optional Parameters
```csharp
// Method with optional parameters (must have default values)
void DisplayMessage(string message, bool uppercase = false, int repeatCount = 1)
{
for (int i = 0; i < repeatCount; i++)
{
Console.WriteLine(uppercase ? message.ToUpper() : message);
}
}
// Calling with all parameters
DisplayMessage("Hello", true, 3);
// Calling with some optional parameters omitted
DisplayMessage("Hello", true); // repeatCount uses default value 1
DisplayMessage("Hello"); // uppercase and repeatCount use default values
// Calling with named arguments (can skip optional parameters)
DisplayMessage(message: "Hello", repeatCount: 2); // Skips uppercase parameter
```
### Params Array
```csharp
// Method with params array (must be the last parameter)
int Sum(params int[] numbers)
{
int total = 0;
foreach (int number in numbers)
{
total += number;
}
return total;
}
// Calling with individual arguments
int sum1 = Sum(1, 2, 3, 4, 5); // sum1 = 15
// Calling with an array
int[] values = { 10, 20, 30 };
int sum2 = Sum(values); // sum2 = 60
// Calling with no arguments
int sum3 = Sum(); // sum3 = 0
// Params with other parameters
string Concatenate(string separator, params string[] strings)
{
return string.Join(separator, strings);
}
string result = Concatenate(", ", "apple", "banana", "orange"); // "apple, banana, orange"
```
### Parameter Validation
```csharp
// Validating parameters with guard clauses
void ProcessData(string data)
{
// Guard clauses for parameter validation
if (data == null)
throw new ArgumentNullException(nameof(data));
if (string.IsNullOrWhiteSpace(data))
throw new ArgumentException("Data cannot be empty or whitespace.", nameof(data));
// Process the data...
Console.WriteLine($"Processing: {data}");
}
// Using pattern matching for validation (C# 10+)
void ProcessUser(User user)
{
ArgumentNullException.ThrowIfNull(user); // Throws if user is null
ArgumentException.ThrowIfNullOrEmpty(user.Name); // Throws if Name is null or empty
// Process the user...
}
```
## Method Overloading
Method overloading allows multiple methods with the same name but different parameter lists.
```csharp
// Overloaded methods with different parameter counts
void Display(int value)
{
Console.WriteLine($"Integer: {value}");
}
void Display(string text)
{
Console.WriteLine($"String: {text}");
}
void Display(int value, string format)
{
Console.WriteLine($"Formatted: {value.ToString(format)}");
}
// Calling overloaded methods
Display(42); // Calls the first method
Display("Hello"); // Calls the second method
Display(42, "X"); // Calls the third method (formats as hex: "2A")
// Overloaded methods with different parameter types
double Calculate(double a, double b)
{
return a + b;
}
string Calculate(string a, string b)
{
return a + b; // String concatenation
}
// Calling overloaded methods with different types
double result1 = Calculate(3.5, 2.5); // result1 = 6.0
string result2 = Calculate("Hello, ", "World!"); // result2 = "Hello, World!"
```
## Return Types and Values
### Basic Return Types
```csharp
// Returning a value
int Add(int a, int b)
{
return a + b;
}
// Returning a reference type
string GetGreeting(string name)
{
return $"Hello, {name}!";
}
// Returning void (no value)
void LogMessage(string message)
{
Console.WriteLine($"[LOG] {message}");
// No return statement needed for void methods
}
// Multiple return statements
bool IsEven(int number)
{
if (number % 2 == 0)
return true;
else
return false;
}
// Early returns for validation
int Divide(int a, int b)
{
if (b == 0)
return 0; // Early return to avoid division by zero
return a / b;
}
```
### Returning Multiple Values
```csharp
// Using out parameters
void GetDimensions(string text, out int length, out int wordCount)
{
length = text.Length;
wordCount = text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
}
// Using a tuple (C# 7+)
(int Length, int WordCount) GetDimensionsTuple(string text)
{
int length = text.Length;
int wordCount = text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
return (length, wordCount);
}
// Using a custom class or struct
public class TextStats
{
public int Length { get; set; }
public int WordCount { get; set; }
}
TextStats GetTextStats(string text)
{
return new TextStats
{
Length = text.Length,
WordCount = text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length
};
}
// Usage examples
string sample = "Hello, world!";
// Using out parameters
GetDimensions(sample, out int len1, out int words1);
Console.WriteLine($"Length: {len1}, Words: {words1}");
// Using a tuple
var stats = GetDimensionsTuple(sample);
Console.WriteLine($"Length: {stats.Length}, Words: {stats.WordCount}");
// Or with deconstruction:
var (len2, words2) = GetDimensionsTuple(sample);
Console.WriteLine($"Length: {len2}, Words: {words2}");
// Using a custom class
TextStats textStats = GetTextStats(sample);
Console.WriteLine($"Length: {textStats.Length}, Words: {textStats.WordCount}");
```
### Ref Returns and Locals (C# 7+)
```csharp
// Returning a reference to an array element
ref int FindLargest(int[] numbers)
{
int largestIndex = 0;
for (int i = 1; i < numbers.Length; i++)
{
if (numbers[i] > numbers[largestIndex])
largestIndex = i;
}
return ref numbers[largestIndex];
}
// Usage
int[] values = { 3, 7, 1, 9, 4 };
ref int largest = ref FindLargest(values);
Console.WriteLine(largest); // Output: 9
// Modifying the value through the reference
largest = 100;
Console.WriteLine(values[3]); // Output: 100 (the array element was modified)
```
## Expression-Bodied Members (C# 6+)
Expression-bodied members provide a concise syntax for methods with a single expression.
```csharp
// Expression-bodied method (C# 6+)
int Add(int a, int b) => a + b;
// Expression-bodied void method (C# 7+)
void Greet(string name) => Console.WriteLine($"Hello, {name}!");
// Expression-bodied property (C# 6+)
public string FullName => $"{FirstName} {LastName}";
// Expression-bodied property with getter and setter (C# 7+)
private string _name;
public string Name
{
get => _name;
set => _name = value ?? "Unknown";
}
// Expression-bodied constructor (C# 7+)
public Person(string name) => Name = name;
// Expression-bodied finalizer/destructor (C# 7+)
~Person() => Console.WriteLine("Finalizer called");
// Expression-bodied indexer (C# 7+)
public string this[int index] => _items[index];
```
## Local Functions (C# 7+)
Local functions are methods defined inside other methods.
```csharp
// Method with a local function
int Factorial(int n)
{
// Local function defined inside Factorial
int CalculateFactorial(int number)
{
if (number <= 1)
return 1;
return number * CalculateFactorial(number - 1);
}
// Input validation in the outer method
if (n < 0)
throw new ArgumentException("Input must be non-negative", nameof(n));
return CalculateFactorial(n);
}
// Local function that captures variables from the enclosing scope
void ProcessData(int[] data)
{
int threshold = 10;
// Local function that uses 'threshold' from the enclosing scope
bool IsAboveThreshold(int value)
{
return value > threshold;
}
foreach (int value in data)
{
if (IsAboveThreshold(value))
{
Console.WriteLine($"{value} is above the threshold");
}
}
}
// Static local function (C# 8+) - cannot capture variables from the enclosing scope
void ProcessValues(int[] values)
{
// Static local function
static int Square(int x)
{
return x * x;
}
for (int i = 0; i < values.Length; i++)
{
values[i] = Square(values[i]);
}
}
```
## Extension Methods
Extension methods allow you to add methods to existing types without modifying them.
```csharp
// Extension methods must be defined in a static class
public static class StringExtensions
{
// Extension method for string (note the 'this' modifier on the first parameter)
public static bool IsNullOrWhiteSpace(this string str)
{
return string.IsNullOrWhiteSpace(str);
}
// Extension method with additional parameters
public static string Truncate(this string str, int maxLength)
{
if (str == null)
return null;
return str.Length <= maxLength ? str : str.Substring(0, maxLength) + "...";
}
}
// Extension method for IEnumerable
public static class EnumerableExtensions
{
public static double Average(this IEnumerable source, Func selector)
{
int sum = 0;
int count = 0;
foreach (T item in source)
{
sum += selector(item);
count++;
}
return count > 0 ? (double)sum / count : 0;
}
}
// Usage
string text = " ";
bool isEmpty = text.IsNullOrWhiteSpace(); // Using the extension method
string longText = "This is a very long text that needs to be truncated";
string truncated = longText.Truncate(20); // "This is a very long..."
List people = new List
{
new Person { Name = "Alice", Age = 25 },
new Person { Name = "Bob", Age = 30 },
new Person { Name = "Charlie", Age = 35 }
};
double averageAge = people.Average(p => p.Age); // Using the extension method
```
## Delegates and Function Types
Delegates are type-safe function pointers that can reference methods with compatible signatures.
### Delegate Declaration and Usage
```csharp
// Delegate declaration
public delegate int MathOperation(int a, int b);
// Methods that match the delegate signature
int Add(int a, int b) => a + b;
int Subtract(int a, int b) => a - b;
int Multiply(int a, int b) => a * b;
// Using delegates
void UseDelegates()
{
// Assigning a method to a delegate
MathOperation operation = Add;
int result = operation(5, 3); // result = 8
// Changing the delegate to point to a different method
operation = Multiply;
result = operation(5, 3); // result = 15
// Creating a delegate with an anonymous method (C# 2.0+)
MathOperation divide = delegate(int a, int b) { return b != 0 ? a / b : 0; };
result = divide(10, 2); // result = 5
// Creating a delegate with a lambda expression (C# 3.0+)
MathOperation power = (a, b) => (int)Math.Pow(a, b);
result = power(2, 3); // result = 8
}
```
### Built-in Delegate Types
```csharp
// Action delegates (for methods that return void)
Action sayHello = () => Console.WriteLine("Hello");
Action greet = name => Console.WriteLine($"Hello, {name}!");
Action introduce = (name, age) => Console.WriteLine($"I'm {name}, {age} years old");
// Func delegates (for methods that return a value)
Func add = (a, b) => a + b;
Func getLength = s => s?.Length ?? 0;
Func average = (a, b, c) => (a + b + c) / 3;
// Predicate delegate (for methods that return bool)
Predicate isEven = n => n % 2 == 0;
Predicate isLongString = s => s?.Length > 10;
// Using the delegates
sayHello(); // Output: "Hello"
greet("John"); // Output: "Hello, John!"
introduce("Alice", 30); // Output: "I'm Alice, 30 years old"
int sum = add(5, 3); // sum = 8
int length = getLength("Hello"); // length = 5
double avg = average(10, 20, 30); // avg = 20
bool even = isEven(4); // even = true
bool isLong = isLongString("Hello, World!"); // isLong = true
```
### Multicast Delegates
```csharp
// Delegate for event handling
public delegate void LogEventHandler(string message);
// Methods that match the delegate signature
void ConsoleLogger(string message) => Console.WriteLine($"CONSOLE: {message}");
void FileLogger(string message) => File.AppendAllText("log.txt", $"{message}\n");
void DatabaseLogger(string message) => Console.WriteLine($"DB: {message}");
// Using multicast delegates
void UseMulticastDelegates()
{
// Creating a multicast delegate
LogEventHandler logger = ConsoleLogger;
// Adding more methods to the invocation list
logger += FileLogger;
logger += DatabaseLogger;
// Invoking the delegate calls all methods in the invocation list
logger("System started"); // Logs to console, file, and database
// Removing a method from the invocation list
logger -= FileLogger;
// Now only logs to console and database
logger("Operation completed");
}
```
## Anonymous Methods and Lambda Expressions
### Anonymous Methods (C# 2.0+)
```csharp
// Anonymous method with a delegate
Func add = delegate(int a, int b) { return a + b; };
// Anonymous method with no parameters
Action sayHello = delegate { Console.WriteLine("Hello!"); };
// Anonymous method with a block of code
Predicate isEven = delegate(int n)
{
// Can contain multiple statements
if (n < 0)
n = -n; // Make positive
return n % 2 == 0;
};
// Using anonymous methods
int sum = add(5, 3); // sum = 8
sayHello(); // Output: "Hello!"
bool even = isEven(-4); // even = true
```
### Lambda Expressions (C# 3.0+)
```csharp
// Expression lambda (single expression)
Func add = (a, b) => a + b;
// Statement lambda (code block)
Func divide = (a, b) =>
{
if (b == 0)
return 0;
return a / b;
};
// Lambda with no parameters
Action sayHello = () => Console.WriteLine("Hello!");
// Lambda with a single parameter (parentheses optional)
Func isEven = n => n % 2 == 0;
Func getLength = (s) => s?.Length ?? 0;
// Lambda capturing variables from the enclosing scope
int factor = 10;
Func multiply = n => n * factor;
// Using lambda expressions
int sum = add(5, 3); // sum = 8
int quotient = divide(10, 2); // quotient = 5
sayHello(); // Output: "Hello!"
bool even = isEven(4); // even = true
int length = getLength("Hello"); // length = 5
int product = multiply(5); // product = 50 (5 * 10)
```
### Lambda Expressions with LINQ
```csharp
List numbers = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Using lambda with Where
var evenNumbers = numbers.Where(n => n % 2 == 0);
// Using lambda with Select
var squares = numbers.Select(n => n * n);
// Using lambda with multiple conditions
var filteredNumbers = numbers.Where(n => n > 3 && n < 8);
// Using lambda with complex projections
var numberInfo = numbers.Select(n => new
{
Number = n,
Square = n * n,
IsEven = n % 2 == 0
});
// Using lambda with aggregation
int sum = numbers.Sum(n => n);
double average = numbers.Average(n => n);
int max = numbers.Max(n => n);
```
## Asynchronous Methods (async/await)
Asynchronous methods allow non-blocking execution of code that performs I/O operations or other potentially long-running tasks.
```csharp
// Asynchronous method that returns a Task
public async Task DoWorkAsync()
{
Console.WriteLine("Starting work...");
// Simulate asynchronous work
await Task.Delay(1000);
Console.WriteLine("Work completed");
}
// Asynchronous method that returns a Task
public async Task CalculateAsync(int a, int b)
{
Console.WriteLine("Starting calculation...");
// Simulate asynchronous calculation
await Task.Delay(1000);
return a + b;
}
// Asynchronous method with exception handling
public async Task FetchDataAsync(string url)
{
try
{
using (HttpClient client = new HttpClient())
{
// Asynchronously get the response
string response = await client.GetStringAsync(url);
return response;
}
}
catch (HttpRequestException ex)
{
Console.WriteLine($"Error fetching data: {ex.Message}");
return null;
}
}
// Calling asynchronous methods
public async Task RunAsync()
{
// Await the void Task
await DoWorkAsync();
// Await and get the result from Task
int result = await CalculateAsync(5, 3);
Console.WriteLine($"Result: {result}");
// Fetch data from a URL
string data = await FetchDataAsync("https://api.example.com/data");
Console.WriteLine($"Data length: {data?.Length ?? 0}");
}
// Running multiple asynchronous operations in parallel
public async Task RunParallelAsync()
{
// Start multiple operations without awaiting immediately
Task task1 = CalculateAsync(5, 3);
Task task2 = CalculateAsync(10, 20);
Task task3 = CalculateAsync(7, 8);
// Await all tasks to complete
await Task.WhenAll(task1, task2, task3);
// Get the results
int result1 = task1.Result;
int result2 = task2.Result;
int result3 = task3.Result;
Console.WriteLine($"Results: {result1}, {result2}, {result3}");
}
```
## Resources
- [C# Methods (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/methods)
- [C# Parameters (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters)
- [C# Extension Methods (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods)
- [C# Delegates (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/)
- [C# Lambda Expressions (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions)
- [C# Asynchronous Programming (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/)
# 8. Classes and Objects
Classes are the fundamental building blocks of object-oriented programming in C#. They encapsulate data (fields) and behavior (methods) into a single unit.
## Class Declaration and Instantiation
### Basic Class Declaration
```csharp
// Basic class declaration
public class Person
{
// Fields (instance variables)
private string _name;
private int _age;
// Properties
public string Name
{
get { return _name; }
set { _name = value; }
}
public int Age
{
get { return _age; }
set { _age = value; }
}
// Constructor
public Person(string name, int age)
{
_name = name;
_age = age;
}
// Methods
public void Introduce()
{
Console.WriteLine($"Hi, I'm {_name} and I'm {_age} years old.");
}
public bool IsAdult()
{
return _age >= 18;
}
}
```
### Object Instantiation
```csharp
// Creating an object using the constructor
Person person1 = new Person("Alice", 30);
// Using object initializer syntax (C# 3.0+)
Person person2 = new Person("Bob", 25)
{
// Additional property initialization
Name = "Bob Smith" // Updates the Name property after constructor
};
// Using var keyword (type inference)
var person3 = new Person("Charlie", 35);
// Using target-typed new expression (C# 9.0+)
Person person4 = new("David", 40);
// Accessing properties
string name = person1.Name;
int age = person1.Age;
// Setting properties
person1.Name = "Alice Smith";
person1.Age = 31;
// Calling methods
person1.Introduce();
bool isAdult = person1.IsAdult();
```
## Class Members
### Fields
Fields are variables declared within a class.
```csharp
public class Counter
{
// Private field (instance variable)
private int _count;
// Public field (generally not recommended, use properties instead)
public int MaxValue;
// Static field (shared across all instances)
public static int TotalCounters;
// Readonly field (can only be assigned in declaration or constructor)
public readonly string Id;
// Const field (compile-time constant)
public const int DefaultMaxValue = 100;
// Static readonly field (runtime constant)
public static readonly DateTime StartupTime = DateTime.Now;
public Counter(string id)
{
Id = id; // Readonly field can be set in constructor
TotalCounters++; // Increment static field
MaxValue = DefaultMaxValue; // Using const value
}
}
// Usage
Counter c1 = new Counter("c1");
Counter c2 = new Counter("c2");
Console.WriteLine(Counter.TotalCounters); // 2 (static field)
Console.WriteLine(Counter.DefaultMaxValue); // 100 (const field)
Console.WriteLine(Counter.StartupTime); // Time when the app started (static readonly)
c1.MaxValue = 200; // Changing public field
// c1.Id = "new-id"; // Error: readonly field cannot be changed after initialization
```
### Properties
Properties provide a flexible mechanism to read, write, or compute the value of a private field.
```csharp
public class Temperature
{
// Backing field
private double _celsius;
// Full property with custom getter and setter
public double Celsius
{
get { return _celsius; }
set { _celsius = value; }
}
// Property with validation
public double Fahrenheit
{
get { return _celsius * 9 / 5 + 32; }
set { _celsius = (value - 32) * 5 / 9; }
}
// Auto-implemented property (compiler generates backing field)
public string Scale { get; set; } = "Metric";
// Read-only property (no setter)
public bool IsFreezing
{
get { return _celsius <= 0; }
}
// Expression-bodied property (C# 6+)
public bool IsBoiling => _celsius >= 100;
// Property with private setter
public DateTime LastUpdated { get; private set; }
// Static property
public static double AbsoluteZero { get; } = -273.15;
// Init-only property (C# 9+)
public string Unit { get; init; } = "°C";
public void Update(double celsius)
{
_celsius = celsius;
LastUpdated = DateTime.Now; // Can modify private setter from within the class
}
}
// Usage
Temperature temp = new Temperature();
temp.Celsius = 25;
Console.WriteLine(temp.Fahrenheit); // 77
temp.Scale = "Scientific";
// temp.Unit = "K"; // Error: Init-only property can only be set during initialization
Temperature temp2 = new Temperature { Celsius = 100, Unit = "K" }; // Init-only property set during initialization
Console.WriteLine(Temperature.AbsoluteZero); // -273.15 (static property)
```
### Auto-Implemented Properties
```csharp
public class Product
{
// Basic auto-implemented property
public string Name { get; set; }
// Auto-implemented property with default value (C# 6+)
public decimal Price { get; set; } = 0.0m;
// Read-only auto-implemented property
public string SKU { get; }
// Property with private setter
public DateTime CreatedDate { get; private set; }
// Init-only property (C# 9+)
public string Category { get; init; }
// Required property (C# 11+)
public required string Id { get; set; }
public Product(string sku)
{
SKU = sku;
CreatedDate = DateTime.Now;
}
}
// Usage
// Product p1 = new Product("ABC123"); // Error: Required property Id must be set
Product p2 = new Product("ABC123")
{
Id = "P12345",
Name = "Laptop",
Price = 999.99m,
Category = "Electronics"
};
// p2.Category = "Computers"; // Error: Init-only property cannot be changed after initialization
// p2.SKU = "XYZ789"; // Error: Read-only property cannot be changed
```
### Methods
Methods define the behavior of a class.
```csharp
public class Calculator
{
// Instance method
public int Add(int a, int b)
{
return a + b;
}
// Method with optional parameters
public double Divide(double a, double b = 1.0)
{
if (b == 0)
throw new DivideByZeroException();
return a / b;
}
// Method with out parameter
public bool TryParse(string input, out int result)
{
return int.TryParse(input, out result);
}
// Method with ref parameter
public void Swap(ref int a, ref int b)
{
int temp = a;
a = b;
b = temp;
}
// Static method
public static int Max(int a, int b)
{
return (a > b) ? a : b;
}
// Expression-bodied method (C# 6+)
public int Multiply(int a, int b) => a * b;
// Async method
public async Task FetchDataAsync(string url)
{
using (HttpClient client = new HttpClient())
{
return await client.GetStringAsync(url);
}
}
}
// Usage
Calculator calc = new Calculator();
int sum = calc.Add(5, 3); // 8
double quotient = calc.Divide(10); // 10.0 (uses default value for b)
calc.TryParse("42", out int number); // number = 42
int x = 5, y = 10;
calc.Swap(ref x, ref y); // x = 10, y = 5
int maximum = Calculator.Max(8, 12); // 12 (static method)
```
### Constructors
Constructors initialize objects of a class.
```csharp
public class Car
{
// Fields
private string _make;
private string _model;
private int _year;
// Default constructor (no parameters)
public Car()
{
_make = "Unknown";
_model = "Unknown";
_year = DateTime.Now.Year;
Console.WriteLine("Default constructor called");
}
// Parameterized constructor
public Car(string make, string model, int year)
{
_make = make;
_model = model;
_year = year;
Console.WriteLine("Parameterized constructor called");
}
// Constructor with optional parameters
public Car(string make, string model, int year = 2023)
{
_make = make;
_model = model;
_year = year;
}
// Constructor chaining using 'this'
public Car(string make) : this(make, "Unknown", DateTime.Now.Year)
{
Console.WriteLine("Single parameter constructor called");
}
// Static constructor (called once before any instance is created or static members are accessed)
static Car()
{
Console.WriteLine("Static constructor called");
// Initialize static fields/properties
}
// Properties
public string Make { get => _make; set => _make = value; }
public string Model { get => _model; set => _model = value; }
public int Year { get => _year; set => _year = value; }
// Method
public string GetInfo() => $"{_year} {_make} {_model}";
}
// Usage
Car car1 = new Car(); // Default constructor
Car car2 = new Car("Toyota", "Camry", 2022); // Parameterized constructor
Car car3 = new Car("Honda"); // Constructor with one parameter, chains to parameterized constructor
```
### Destructors/Finalizers
Destructors (also called finalizers) are used to perform cleanup operations before an object is garbage collected.
```csharp
public class ResourceHolder
{
private IntPtr _handle; // Unmanaged resource
private bool _disposed = false;
public ResourceHolder(IntPtr handle)
{
_handle = handle;
Console.WriteLine("Resource acquired");
}
// Finalizer/Destructor
~ResourceHolder()
{
Dispose(false);
Console.WriteLine("Finalizer called");
}
// Implement IDisposable pattern for deterministic cleanup
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this); // Prevent finalizer from running
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
// Dispose managed resources
}
// Dispose unmanaged resources
if (_handle != IntPtr.Zero)
{
// CloseHandle(_handle);
_handle = IntPtr.Zero;
Console.WriteLine("Resource released");
}
_disposed = true;
}
}
}
// Usage
using (ResourceHolder resource = new ResourceHolder(new IntPtr(1234)))
{
// Use the resource
} // Dispose is called automatically at the end of the block
```
### Indexers
Indexers allow objects to be indexed like arrays.
```csharp
public class StringCollection
{
private List _items = new List();
// Basic indexer
public string this[int index]
{
get
{
if (index < 0 || index >= _items.Count)
throw new IndexOutOfRangeException();
return _items[index];
}
set
{
if (index < 0 || index >= _items.Count)
throw new IndexOutOfRangeException();
_items[index] = value;
}
}
// Overloaded indexer with string parameter
public string this[string name]
{
get
{
return _items.FirstOrDefault(item => item.Equals(name, StringComparison.OrdinalIgnoreCase));
}
}
// Method to add items
public void Add(string item)
{
_items.Add(item);
}
// Property to get count
public int Count => _items.Count;
}
// Usage
StringCollection fruits = new StringCollection();
fruits.Add("Apple");
fruits.Add("Banana");
fruits.Add("Orange");
string fruit = fruits[1]; // "Banana"
fruits[1] = "Mango"; // Changes "Banana" to "Mango"
string found = fruits["apple"]; // "Apple" (case-insensitive)
```
## Access Modifiers
Access modifiers control the accessibility of classes and their members.
```csharp
// Public class (accessible from any assembly)
public class PublicClass
{
// Public member (accessible from any code)
public void PublicMethod() { }
// Private member (accessible only within the containing class)
private void PrivateMethod() { }
// Protected member (accessible within the containing class and derived classes)
protected void ProtectedMethod() { }
// Internal member (accessible within the containing assembly)
internal void InternalMethod() { }
// Protected internal member (accessible within the containing assembly or derived classes)
protected internal void ProtectedInternalMethod() { }
// Private protected member (C# 7.2+, accessible within the containing class or derived classes in the same assembly)
private protected void PrivateProtectedMethod() { }
}
// Internal class (accessible only within the containing assembly)
internal class InternalClass
{
// Members here...
}
// Class with no access modifier is internal by default
class DefaultClass
{
// Members here...
}
```
## Static Classes and Members
Static classes and members belong to the class itself rather than to instances of the class.
```csharp
// Static class (cannot be instantiated)
public static class MathUtility
{
// Static field
public static double Pi = 3.14159;
// Static property
public static double E { get; } = 2.71828;
// Static method
public static double Square(double number)
{
return number * number;
}
// Static constructor (called once before any static member is accessed)
static MathUtility()
{
Console.WriteLine("MathUtility initialized");
}
}
// Regular class with static members
public class Counter
{
// Instance field
private int _count;
// Static field (shared across all instances)
private static int _totalCount;
// Instance property
public int Count
{
get { return _count; }
set { _count = value; }
}
// Static property
public static int TotalCount
{
get { return _totalCount; }
}
// Instance method
public void Increment()
{
_count++;
_totalCount++;
}
// Static method
public static void Reset()
{
_totalCount = 0;
// _count = 0; // Error: Cannot access instance field from static method
}
}
// Usage
double area = MathUtility.Pi * MathUtility.Square(5); // Using static class
Counter c1 = new Counter();
Counter c2 = new Counter();
c1.Increment(); // c1.Count = 1, Counter.TotalCount = 1
c2.Increment(); // c2.Count = 1, Counter.TotalCount = 2
c1.Increment(); // c1.Count = 2, Counter.TotalCount = 3
Console.WriteLine(Counter.TotalCount); // 3
Counter.Reset(); // Resets TotalCount to 0
```
## Inheritance
Inheritance allows a class to inherit fields, properties, and methods from another class.
```csharp
// Base class
public class Animal
{
// Protected field (accessible in derived classes)
protected string _name;
// Public property
public string Species { get; set; }
// Constructor
public Animal(string name, string species)
{
_name = name;
Species = species;
}
// Virtual method (can be overridden in derived classes)
public virtual void MakeSound()
{
Console.WriteLine("Animal makes a sound");
}
// Non-virtual method
public void Sleep()
{
Console.WriteLine($"{_name} is sleeping");
}
}
// Derived class
public class Dog : Animal
{
// Additional property
public string Breed { get; set; }
// Constructor that calls the base class constructor
public Dog(string name, string breed) : base(name, "Canine")
{
Breed = breed;
}
// Override the virtual method
public override void MakeSound()
{
Console.WriteLine($"{_name} barks");
}
// New method specific to Dog
public void Fetch()
{
Console.WriteLine($"{_name} is fetching");
}
}
// Another derived class
public class Cat : Animal
{
// Constructor
public Cat(string name) : base(name, "Feline")
{
}
// Override the virtual method
public override void MakeSound()
{
Console.WriteLine($"{_name} meows");
}
// Method that hides the base class method (not recommended, use override instead)
public new void Sleep()
{
Console.WriteLine($"{_name} is taking a cat nap");
}
}
// Usage
Animal animal = new Animal("Generic Animal", "Unknown");
animal.MakeSound(); // "Animal makes a sound"
Dog dog = new Dog("Buddy", "Golden Retriever");
dog.MakeSound(); // "Buddy barks"
dog.Sleep(); // "Buddy is sleeping" (inherited from Animal)
dog.Fetch(); // "Buddy is fetching"
Cat cat = new Cat("Whiskers");
cat.MakeSound(); // "Whiskers meows"
cat.Sleep(); // "Whiskers is taking a cat nap"
// Polymorphism
Animal dogAsAnimal = new Dog("Rex", "German Shepherd");
dogAsAnimal.MakeSound(); // "Rex barks" (calls the overridden method)
dogAsAnimal.Sleep(); // "Rex is sleeping" (calls the base class method)
// dogAsAnimal.Fetch(); // Error: Animal doesn't have a Fetch method
Animal catAsAnimal = new Cat("Felix");
catAsAnimal.Sleep(); // "Felix is sleeping" (calls the base class method, not the hiding method)
```
### Abstract Classes and Methods
Abstract classes cannot be instantiated and may contain abstract methods that derived classes must implement.
```csharp
// Abstract base class
public abstract class Shape
{
// Regular property
public string Color { get; set; }
// Constructor
public Shape(string color)
{
Color = color;
}
// Abstract method (must be implemented by derived classes)
public abstract double CalculateArea();
// Virtual method (can be overridden, but has a default implementation)
public virtual void Display()
{
Console.WriteLine($"A {Color} shape");
}
// Regular method
public void SetColor(string color)
{
Color = color;
}
}
// Concrete derived class
public class Circle : Shape
{
public double Radius { get; set; }
public Circle(double radius, string color) : base(color)
{
Radius = radius;
}
// Implementation of abstract method
public override double CalculateArea()
{
return Math.PI * Radius * Radius;
}
// Override of virtual method
public override void Display()
{
Console.WriteLine($"A {Color} circle with radius {Radius}");
}
}
// Another concrete derived class
public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public Rectangle(double width, double height, string color) : base(color)
{
Width = width;
Height = height;
}
// Implementation of abstract method
public override double CalculateArea()
{
return Width * Height;
}
// Override of virtual method
public override void Display()
{
Console.WriteLine($"A {Color} rectangle with dimensions {Width}x{Height}");
}
}
// Usage
// Shape shape = new Shape("Red"); // Error: Cannot create an instance of an abstract class
Circle circle = new Circle(5.0, "Blue");
Console.WriteLine($"Circle area: {circle.CalculateArea()}"); // ~78.54
circle.Display(); // "A Blue circle with radius 5"
Rectangle rectangle = new Rectangle(4.0, 6.0, "Green");
Console.WriteLine($"Rectangle area: {rectangle.CalculateArea()}"); // 24
rectangle.Display(); // "A Green rectangle with dimensions 4x6"
// Polymorphism with abstract base class
Shape shapeRef = circle;
Console.WriteLine($"Shape area: {shapeRef.CalculateArea()}"); // ~78.54 (calls Circle's implementation)
```
### Sealed Classes and Methods
Sealed classes cannot be inherited, and sealed methods cannot be overridden in derived classes.
```csharp
// Base class
public class Vehicle
{
public virtual void Start()
{
Console.WriteLine("Vehicle starting");
}
public virtual void Stop()
{
Console.WriteLine("Vehicle stopping");
}
}
// Derived class with a sealed method
public class Car : Vehicle
{
// Sealed override method (cannot be overridden in derived classes)
public sealed override void Start()
{
Console.WriteLine("Car starting");
}
public override void Stop()
{
Console.WriteLine("Car stopping");
}
}
// Sealed class (cannot be inherited)
public sealed class ElectricCar : Car
{
// Can override non-sealed methods
public override void Stop()
{
Console.WriteLine("Electric car stopping");
}
// Cannot override sealed methods
// public override void Start() { } // Error: Cannot override sealed method
}
// Cannot derive from a sealed class
// public class LuxuryElectricCar : ElectricCar { } // Error: Cannot inherit from sealed class
```
## Interfaces
Interfaces define a contract that implementing classes must follow.
```csharp
// Interface declaration
public interface IShape
{
// Property signature (no implementation)
double Area { get; }
// Method signature (no implementation)
void Draw();
// Default interface method (C# 8.0+)
void PrintInfo()
{
Console.WriteLine($"Shape with area: {Area}");
}
}
// Another interface
public interface IColorable
{
string Color { get; set; }
void SetColor(string color);
}
// Class implementing a single interface
public class Circle : IShape
{
public double Radius { get; set; }
public Circle(double radius)
{
Radius = radius;
}
// Implementing the Area property
public double Area => Math.PI * Radius * Radius;
// Implementing the Draw method
public void Draw()
{
Console.WriteLine($"Drawing a circle with radius {Radius}");
}
}
// Class implementing multiple interfaces
public class Rectangle : IShape, IColorable
{
public double Width { get; set; }
public double Height { get; set; }
public string Color { get; set; }
public Rectangle(double width, double height, string color)
{
Width = width;
Height = height;
Color = color;
}
// Implementing IShape.Area
public double Area => Width * Height;
// Implementing IShape.Draw
public void Draw()
{
Console.WriteLine($"Drawing a {Color} rectangle with dimensions {Width}x{Height}");
}
// Implementing IColorable.SetColor
public void SetColor(string color)
{
Color = color;
}
}
// Usage
Circle circle = new Circle(5.0);
circle.Draw(); // "Drawing a circle with radius 5"
Console.WriteLine($"Circle area: {circle.Area}"); // ~78.54
circle.PrintInfo(); // "Shape with area: 78.54" (default interface method)
Rectangle rectangle = new Rectangle(4.0, 6.0, "Blue");
rectangle.Draw(); // "Drawing a Blue rectangle with dimensions 4x6"
Console.WriteLine($"Rectangle area: {rectangle.Area}"); // 24
rectangle.SetColor("Red"); // Changes color to "Red"
// Using interfaces for polymorphism
IShape shape = circle;
shape.Draw(); // "Drawing a circle with radius 5"
IColorable colorable = rectangle;
colorable.SetColor("Green"); // Changes color to "Green"
```
### Interface Inheritance
Interfaces can inherit from other interfaces.
```csharp
// Base interface
public interface IEntity
{
string Id { get; }
DateTime CreatedDate { get; }
}
// Interface inheriting from another interface
public interface IAuditable : IEntity
{
string CreatedBy { get; }
DateTime? LastModifiedDate { get; }
string LastModifiedBy { get; }
}
// Interface with multiple inheritance
public interface IFullAuditable : IAuditable, ISoftDelete
{
bool IsActive { get; set; }
}
// Another interface
public interface ISoftDelete
{
bool IsDeleted { get; set; }
DateTime? DeletedDate { get; set; }
string DeletedBy { get; set; }
}
// Class implementing an interface with inheritance
public class User : IAuditable
{
public string Id { get; set; } // From IEntity
public DateTime CreatedDate { get; set; } // From IEntity
public string CreatedBy { get; set; } // From IAuditable
public DateTime? LastModifiedDate { get; set; } // From IAuditable
public string LastModifiedBy { get; set; } // From IAuditable
// Additional properties
public string Username { get; set; }
public string Email { get; set; }
}
```
### Explicit Interface Implementation
Explicit interface implementation allows a class to implement multiple interfaces that have members with the same name.
```csharp
// Two interfaces with a method of the same name
public interface IDrawable
{
void Draw();
}
public interface IPrintable
{
void Print();
void Draw(); // Same name as IDrawable.Draw
}
// Class implementing both interfaces explicitly
public class Document : IDrawable, IPrintable
{
// Explicit implementation of IDrawable.Draw
void IDrawable.Draw()
{
Console.WriteLine("Drawing for display");
}
// Explicit implementation of IPrintable.Draw
void IPrintable.Draw()
{
Console.WriteLine("Drawing for printing");
}
// Regular implementation of IPrintable.Print
public void Print()
{
Console.WriteLine("Printing document");
}
// Class's own Draw method
public void Draw()
{
Console.WriteLine("Drawing document (class method)");
}
}
// Usage
Document doc = new Document();
doc.Draw(); // "Drawing document (class method)"
doc.Print(); // "Printing document"
// Accessing explicit interface implementations
((IDrawable)doc).Draw(); // "Drawing for display"
((IPrintable)doc).Draw(); // "Drawing for printing"
IDrawable drawable = doc;
drawable.Draw(); // "Drawing for display"
IPrintable printable = doc;
printable.Draw(); // "Drawing for printing"
printable.Print(); // "Printing document"
```
## Polymorphism
Polymorphism allows objects of different types to be treated as objects of a common base type.
```csharp
// Base class
public class Shape
{
public virtual double CalculateArea()
{
return 0;
}
public virtual void Draw()
{
Console.WriteLine("Drawing a shape");
}
}
// Derived classes
public class Circle : Shape
{
public double Radius { get; set; }
public Circle(double radius)
{
Radius = radius;
}
public override double CalculateArea()
{
return Math.PI * Radius * Radius;
}
public override void Draw()
{
Console.WriteLine($"Drawing a circle with radius {Radius}");
}
}
public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public Rectangle(double width, double height)
{
Width = width;
Height = height;
}
public override double CalculateArea()
{
return Width * Height;
}
public override void Draw()
{
Console.WriteLine($"Drawing a rectangle with dimensions {Width}x{Height}");
}
}
// Usage
Shape shape1 = new Circle(5.0);
Shape shape2 = new Rectangle(4.0, 6.0);
// Polymorphic behavior
shape1.Draw(); // "Drawing a circle with radius 5"
shape2.Draw(); // "Drawing a rectangle with dimensions 4x6"
Console.WriteLine($"Area of shape1: {shape1.CalculateArea()}"); // ~78.54
Console.WriteLine($"Area of shape2: {shape2.CalculateArea()}"); // 24
// List of different shapes treated as a common type
List shapes = new List
{
new Circle(3.0),
new Rectangle(2.0, 5.0),
new Circle(4.0)
};
// Process all shapes polymorphically
foreach (Shape shape in shapes)
{
shape.Draw();
Console.WriteLine($"Area: {shape.CalculateArea()}");
}
```
## Encapsulation
Encapsulation is the bundling of data and methods that operate on that data within a single unit (class) and restricting access to some of the object's components.
```csharp
public class BankAccount
{
// Private fields (encapsulated data)
private string _accountNumber;
private decimal _balance;
private readonly List _transactionHistory = new List();
// Constructor
public BankAccount(string accountNumber, decimal initialDeposit)
{
if (string.IsNullOrWhiteSpace(accountNumber))
throw new ArgumentException("Account number cannot be empty", nameof(accountNumber));
if (initialDeposit < 0)
throw new ArgumentException("Initial deposit cannot be negative", nameof(initialDeposit));
_accountNumber = accountNumber;
_balance = initialDeposit;
RecordTransaction($"Initial deposit: {initialDeposit:C}");
}
// Public properties (controlled access to private fields)
public string AccountNumber => _accountNumber; // Read-only
public decimal Balance => _balance; // Read-only
public IReadOnlyList TransactionHistory => _transactionHistory.AsReadOnly(); // Read-only view
// Public methods (controlled operations on private data)
public void Deposit(decimal amount)
{
if (amount <= 0)
throw new ArgumentException("Deposit amount must be positive", nameof(amount));
_balance += amount;
RecordTransaction($"Deposit: {amount:C}");
}
public bool Withdraw(decimal amount)
{
if (amount <= 0)
throw new ArgumentException("Withdrawal amount must be positive", nameof(amount));
if (amount > _balance)
{
RecordTransaction($"Withdrawal failed: Insufficient funds for {amount:C}");
return false;
}
_balance -= amount;
RecordTransaction($"Withdrawal: {amount:C}");
return true;
}
// Private helper method
private void RecordTransaction(string transaction)
{
_transactionHistory.Add($"{DateTime.Now}: {transaction}");
}
}
// Usage
BankAccount account = new BankAccount("123456789", 1000);
Console.WriteLine($"Account: {account.AccountNumber}, Balance: {account.Balance:C}");
account.Deposit(500);
Console.WriteLine($"New balance: {account.Balance:C}"); // $1,500.00
bool withdrawalSuccess = account.Withdraw(2000);
Console.WriteLine($"Withdrawal successful: {withdrawalSuccess}"); // false
Console.WriteLine($"Balance after withdrawal attempt: {account.Balance:C}"); // Still $1,500.00
withdrawalSuccess = account.Withdraw(700);
Console.WriteLine($"Withdrawal successful: {withdrawalSuccess}"); // true
Console.WriteLine($"Balance after withdrawal: {account.Balance:C}"); // $800.00
// View transaction history
Console.WriteLine("Transaction History:");
foreach (string transaction in account.TransactionHistory)
{
Console.WriteLine(transaction);
}
// Cannot modify private fields directly
// account._balance = 1000000; // Error: _balance is inaccessible
// account.TransactionHistory.Add("Fraudulent transaction"); // Error: Cannot modify a read-only collection
```
## Object Initialization and Object Initializers
Object initializers provide a concise syntax to set properties during object creation.
```csharp
// Class with properties
public class Person
{
// Auto-implemented properties
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
public string Email { get; set; }
// Default constructor
public Person()
{
}
// Parameterized constructor
public Person(string firstName, string lastName)
{
FirstName = firstName;
LastName = lastName;
}
// Method
public string GetFullName() => $"{FirstName} {LastName}";
}
// Usage
// Traditional way (without object initializer)
Person person1 = new Person();
person1.FirstName = "John";
person1.LastName = "Doe";
person1.Age = 30;
person1.Email = "john.doe@example.com";
// Using object initializer syntax
Person person2 = new Person
{
FirstName = "Jane",
LastName = "Smith",
Age = 25,
Email = "jane.smith@example.com"
};
// Using object initializer with constructor
Person person3 = new Person("Bob", "Johnson")
{
Age = 40,
Email = "bob.johnson@example.com"
};
// Collection initializers
List people = new List
{
new Person { FirstName = "Alice", LastName = "Brown", Age = 35 },
new Person { FirstName = "Charlie", LastName = "Davis", Age = 28 },
new Person("David", "Wilson") { Age = 45 }
};
// Dictionary initializers
Dictionary personDict = new Dictionary
{
["employee1"] = new Person { FirstName = "Eve", LastName = "Taylor" },
["employee2"] = new Person { FirstName = "Frank", LastName = "Miller" }
};
// Anonymous types (C# 3.0+)
var anonymousPerson = new
{
FirstName = "Grace",
LastName = "Lee",
Age = 32,
Email = "grace.lee@example.com"
};
Console.WriteLine($"{anonymousPerson.FirstName} {anonymousPerson.LastName}, {anonymousPerson.Age}");
```
## Partial Classes and Methods
Partial classes allow splitting a class definition across multiple files.
```csharp
// File1.cs
public partial class Customer
{
// Fields
private string _name;
private string _email;
// Constructor
public Customer(string name, string email)
{
_name = name;
_email = email;
}
// Properties
public string Name
{
get { return _name; }
set { _name = value; }
}
public string Email
{
get { return _email; }
set { _email = value; }
}
// Partial method declaration (must be implemented in another partial class)
partial void OnNameChanged(string oldName, string newName);
// Method that calls the partial method
public void ChangeName(string newName)
{
string oldName = _name;
_name = newName;
OnNameChanged(oldName, newName); // Will only execute if implemented
}
}
// File2.cs
public partial class Customer
{
// Additional fields
private List _orders = new List();
// Additional properties
public IReadOnlyList Orders => _orders.AsReadOnly();
// Additional methods
public void AddOrder(string orderNumber)
{
_orders.Add(orderNumber);
Console.WriteLine($"Order {orderNumber} added for {_name}");
}
// Implementation of the partial method
partial void OnNameChanged(string oldName, string newName)
{
Console.WriteLine($"Name changed from {oldName} to {newName}");
}
}
// Usage
Customer customer = new Customer("John Doe", "john.doe@example.com");
customer.AddOrder("ORD-12345");
customer.ChangeName("John Smith"); // Triggers the OnNameChanged partial method
```
## Resources
- [C# Classes and Objects (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/classes)
- [C# Properties (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)
- [C# Inheritance (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/inheritance)
- [C# Interfaces (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/interfaces)
- [C# Polymorphism (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/polymorphism)
- [C# Object Initializers (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers)
# 9. Structs and Records
## Structs
Structs are value types that can contain data members and function members, similar to classes but with some key differences.
### Basic Struct Declaration
```csharp
// Basic struct declaration
public struct Point
{
// Fields
private int _x;
private int _y;
// Properties
public int X
{
get { return _x; }
set { _x = value; }
}
public int Y
{
get { return _y; }
set { _y = value; }
}
// Constructor
public Point(int x, int y)
{
_x = x;
_y = y;
}
// Method
public double DistanceFromOrigin()
{
return Math.Sqrt(_x * _x + _y * _y);
}
// Override ToString method
public override string ToString()
{
return $"({_x}, {_y})";
}
}
```
### Struct Instantiation and Usage
```csharp
// Creating a struct using the constructor
Point p1 = new Point(3, 4);
// Creating a struct using object initializer
Point p2 = new Point { X = 5, Y = 12 };
// Default constructor (all fields initialized to default values)
Point p3 = new Point();
p3.X = 1;
p3.Y = 2;
// Using var keyword
var p4 = new Point(7, 8);
// Calling methods
double distance = p1.DistanceFromOrigin(); // 5.0
Console.WriteLine(p1.ToString()); // "(3, 4)"
// Structs are value types (copied by value)
Point p5 = p1;
p5.X = 10;
Console.WriteLine($"p1: {p1}"); // "p1: (3, 4)" - original unchanged
Console.WriteLine($"p5: {p5}"); // "p5: (10, 4)" - modified copy
```
### Readonly Structs (C# 7.2+)
```csharp
// Readonly struct (all members must be readonly)
public readonly struct Temperature
{
// Readonly fields
private readonly double _celsius;
// Constructor
public Temperature(double celsius)
{
_celsius = celsius;
}
// Readonly properties
public double Celsius => _celsius;
public double Fahrenheit => _celsius * 9 / 5 + 32;
public double Kelvin => _celsius + 273.15;
// Readonly methods
public readonly override string ToString()
{
return $"{_celsius}°C";
}
// Readonly methods can't modify state
// public void SetCelsius(double value) { _celsius = value; } // Error: Can't modify readonly field
}
// Usage
Temperature temp = new Temperature(25);
Console.WriteLine(temp.Fahrenheit); // 77
Console.WriteLine(temp); // "25°C"
```
### Ref Structs (C# 7.2+)
```csharp
// Ref struct (can only be stored on the stack, not the heap)
public ref struct StackOnlyData
{
public int Value;
public Span Buffer; // Span is also a ref struct
public StackOnlyData(int value, Span buffer)
{
Value = value;
Buffer = buffer;
}
}
// Usage
void ProcessData()
{
Span buffer = stackalloc byte[100]; // Stack-allocated buffer
StackOnlyData data = new StackOnlyData(42, buffer);
data.Buffer[0] = 255;
// Ref structs can't be:
// - Used as field in a class or non-ref struct
// - Boxed to object or dynamic
// - Used in async methods
// - Used in iterator methods
// - Captured by lambda expressions
}
```
### Record Structs (C# 10+)
```csharp
// Record struct (value type with value-based equality)
public record struct Point3D(double X, double Y, double Z);
// Usage
Point3D p1 = new Point3D(1, 2, 3);
Point3D p2 = new Point3D(1, 2, 3);
Point3D p3 = new Point3D(4, 5, 6);
Console.WriteLine(p1 == p2); // True (value-based equality)
Console.WriteLine(p1 == p3); // False
// Deconstruction
var (x, y, z) = p1;
Console.WriteLine($"X: {x}, Y: {y}, Z: {z}"); // "X: 1, Y: 2, Z: 3"
// With-expression for non-destructive mutation
Point3D p4 = p1 with { Z = 10 };
Console.WriteLine(p4); // Point3D { X = 1, Y = 2, Z = 10 }
```
### Readonly Record Structs (C# 10+)
```csharp
// Readonly record struct (immutable value type with value-based equality)
public readonly record struct Coordinate(double Latitude, double Longitude);
// Usage
Coordinate c1 = new Coordinate(40.7128, -74.0060); // New York
Coordinate c2 = new Coordinate(40.7128, -74.0060); // Same coordinates
Coordinate c3 = new Coordinate(34.0522, -118.2437); // Los Angeles
Console.WriteLine(c1 == c2); // True
Console.WriteLine(c1 == c3); // False
// With-expression creates a new instance
Coordinate c4 = c1 with { Longitude = -73.9352 };
Console.WriteLine(c4); // Coordinate { Latitude = 40.7128, Longitude = -73.9352 }
```
## Records (C# 9+)
Records are reference types designed for immutable data models with value-based equality semantics.
### Basic Record Declaration
```csharp
// Positional record (concise syntax)
public record Person(string FirstName, string LastName, int Age);
// Usage
Person person1 = new Person("John", "Doe", 30);
Person person2 = new Person("John", "Doe", 30);
Person person3 = new Person("Jane", "Smith", 25);
// Value-based equality
Console.WriteLine(person1 == person2); // True (same property values)
Console.WriteLine(person1 == person3); // False (different property values)
// ToString() is auto-implemented
Console.WriteLine(person1); // Person { FirstName = John, LastName = Doe, Age = 30 }
// Deconstruction
var (firstName, lastName, age) = person1;
Console.WriteLine($"{firstName} {lastName}, {age}"); // "John Doe, 30"
// With-expression for non-destructive mutation
Person olderPerson = person1 with { Age = 31 };
Console.WriteLine(olderPerson); // Person { FirstName = John, LastName = Doe, Age = 31 }
```
### Record with Additional Members
```csharp
// Record with additional members
public record Employee(string FirstName, string LastName, string Department, decimal Salary)
{
// Additional property
public string FullName => $"{FirstName} {LastName}";
// Additional method
public decimal CalculateAnnualSalary() => Salary * 12;
// Custom constructor that calls the primary constructor
public Employee(string firstName, string lastName)
: this(firstName, lastName, "General", 5000m)
{
Console.WriteLine("Employee created with default department and salary");
}
// Override ToString
public override string ToString()
{
return $"{FullName} - {Department}";
}
}
// Usage
Employee emp1 = new Employee("Alice", "Johnson", "Engineering", 8000m);
Console.WriteLine(emp1.FullName); // "Alice Johnson"
Console.WriteLine(emp1.CalculateAnnualSalary()); // 96000
Employee emp2 = new Employee("Bob", "Smith"); // Uses custom constructor
Console.WriteLine(emp2); // "Bob Smith - General"
// With-expression works with all properties
Employee promotedEmp = emp1 with { Department = "Engineering Management", Salary = 10000m };
```
### Record Inheritance
```csharp
// Base record
public record Person(string FirstName, string LastName);
// Derived record
public record Student(string FirstName, string LastName, string Major, double GPA)
: Person(FirstName, LastName);
// Another derived record
public record Teacher(string FirstName, string LastName, string Subject, int YearsOfExperience)
: Person(FirstName, LastName);
// Usage
Student student = new Student("Emma", "Davis", "Computer Science", 3.8);
Teacher teacher = new Teacher("Michael", "Wilson", "Mathematics", 15);
// Inheritance is considered in equality
Student student2 = new Student("Emma", "Davis", "Computer Science", 3.8);
Person person = new Person("Emma", "Davis");
Console.WriteLine(student == student2); // True
Console.WriteLine(student == person); // False (different types)
// With-expression with inheritance
Student transferStudent = student with { Major = "Data Science" };
Console.WriteLine(transferStudent); // Student { FirstName = Emma, LastName = Davis, Major = Data Science, GPA = 3.8 }
```
### Record vs Class vs Struct
```csharp
// Class (reference type, reference equality)
public class PersonClass
{
public string FirstName { get; init; }
public string LastName { get; init; }
public PersonClass(string firstName, string lastName)
{
FirstName = firstName;
LastName = lastName;
}
}
// Record (reference type, value equality)
public record PersonRecord(string FirstName, string LastName);
// Struct (value type, value equality)
public struct PersonStruct
{
public string FirstName { get; init; }
public string LastName { get; init; }
}
// Record struct (value type, value equality with record features)
public record struct PersonRecordStruct(string FirstName, string LastName);
// Usage comparison
void CompareTypes()
{
// Class instances
var class1 = new PersonClass("John", "Doe");
var class2 = new PersonClass("John", "Doe");
Console.WriteLine(class1 == class2); // False (reference equality)
// Record instances
var record1 = new PersonRecord("John", "Doe");
var record2 = new PersonRecord("John", "Doe");
Console.WriteLine(record1 == record2); // True (value equality)
// Struct instances
var struct1 = new PersonStruct { FirstName = "John", LastName = "Doe" };
var struct2 = new PersonStruct { FirstName = "John", LastName = "Doe" };
Console.WriteLine(struct1.Equals(struct2)); // True (value equality)
// Record struct instances
var recordStruct1 = new PersonRecordStruct("John", "Doe");
var recordStruct2 = new PersonRecordStruct("John", "Doe");
Console.WriteLine(recordStruct1 == recordStruct2); // True (value equality)
// Mutation
// class1.FirstName = "Jane"; // Error if init-only property
// record1.FirstName = "Jane"; // Error (records are immutable)
// struct1.FirstName = "Jane"; // Error if init-only property
// recordStruct1.FirstName = "Jane"; // Error (record structs are immutable)
// Non-destructive mutation
var record3 = record1 with { FirstName = "Jane" };
var recordStruct3 = recordStruct1 with { FirstName = "Jane" };
}
```
## Resources
- [C# Structs (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct)
- [C# Records (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record)
- [C# Value Types (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types)
- [C# Reference Types (Microsoft Docs)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types)
# 10. Generics
Generics allow you to define type-safe data structures and algorithms without committing to specific data types.
## Generic Classes and Interfaces
### Basic Generic Class
```csharp
// Generic class with one type parameter
public class Box
{
// Field of type T
private T _value;
// Constructor
public Box(T value)
{
_value = value;
}
// Property
public T Value
{
get { return _value; }
set { _value = value; }
}
// Method that returns the type name
public string GetTypeName()
{
return typeof(T).Name;
}
}
// Usage
Box intBox = new Box(42);
Console.WriteLine(intBox.Value); // 42
Console.WriteLine(intBox.GetTypeName()); // "Int32"
Box stringBox = new Box("Hello");
Console.WriteLine(stringBox.Value); // "Hello"
Console.WriteLine(stringBox.GetTypeName()); // "String"
// Target-typed new (C# 9.0+)
Box doubleBox = new(3.14);
```
### Generic Class with Multiple Type Parameters
```csharp
// Generic class with multiple type parameters
public class Pair
{
public TFirst First { get; set; }
public TSecond Second { get; set; }
public Pair(TFirst first, TSecond second)
{
First = first;
Second = second;
}
public override string ToString()
{
return $"({First}, {Second})";
}
}
// Usage
Pair pair1 = new Pair(1, "One");
Console.WriteLine(pair1); // "(1, One)"
Pair pair2 = new Pair("Ready", true);
Console.WriteLine(pair2); // "(Ready, True)"
// Using var with generics
var pair3 = new Pair(3.14, 2.71);
```
### Generic Interface
```csharp
// Generic interface
public interface IRepository
{
T GetById(int id);
IEnumerable GetAll();
void Add(T item);
void Update(T item);
void Delete(int id);
}
// Implementation for a specific type
public class CustomerRepository : IRepository
{
private List _customers = new List();
public Customer GetById(int id)
{
return _customers.FirstOrDefault(c => c.Id == id);
}
public IEnumerable GetAll()
{
return _customers;
}
public void Add(Customer item)
{
_customers.Add(item);
}
public void Update(Customer item)
{
var index = _customers.FindIndex(c => c.Id == item.Id);
if (index >= 0)
_customers[index] = item;
}
public void Delete(int id)
{
_customers.RemoveAll(c => c.Id == id);
}
}
// Another implementation for a different type
public class ProductRepository : IRepository
{
// Similar implementation for Product type
}
```
### Generic Interface with Multiple Type Parameters
```csharp
// Generic interface with multiple type parameters
public interface IConverter
{
TOutput Convert(TInput input);
}
// Implementation
public class StringToIntConverter : IConverter
{
public int Convert(string input)
{
return int.Parse(input);
}
}
public class DateTimeToStringConverter : IConverter
{
public string Convert(DateTime input)
{
return input.ToString("yyyy-MM-dd");
}
}
// Usage
IConverter numberConverter = new StringToIntConverter();
int number = numberConverter.Convert("42"); // 42
IConverter dateConverter = new DateTimeToStringConverter();
string dateStr = dateConverter.Convert(DateTime.Now); // "2023-07-25"
```
## Generic Methods
### Basic Generic Method
```csharp
// Class with generic methods
public class Utilities
{
// Generic method with one type parameter
public T[] CreateArray(T item, int count)
{
T[] array = new T[count];
for (int i = 0; i < count; i++)
{
array[i] = item;
}
return array;
}
// Generic method with type inference
public void Swap(ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
// Generic method with constraints
public bool AreEqual(T a, T b) where T : IEquatable
{
return a.Equals(b);
}
}
// Usage
Utilities utils = new Utilities();
// Explicit type parameter
string[] names = utils.CreateArray("John", 3);
// ["John", "John", "John"]
// Type inference (compiler determines T is int)
int[] numbers = utils.CreateArray(42, 4);
// [42, 42, 42, 42]
// Swap values
int x = 5, y = 10;
utils.Swap(ref x, ref y);
Console.WriteLine($"x = {x}, y = {y}"); // "x = 10, y = 5"
// Using constrained method
bool equal = utils.AreEqual("hello", "hello"); // true
```
### Generic Method in Non-Generic Class
```csharp
// Non-generic class with generic methods
public class ArrayHelper
{
// Generic method to find the first occurrence
public int FindIndex(T[] array, T item)
{
for (int i = 0; i < array.Length; i++)
{
if (EqualityComparer.Default.Equals(array[i], item))
return i;
}
return -1;
}
// Generic method with predicate
public T Find(T[] array, Predicate predicate)
{
foreach (T item in array)
{
if (predicate(item))
return item;
}
return default;
}
// Generic method that returns a generic collection
public List Filter(T[] array, Func filter)
{
List result = new List();
foreach (T item in array)
{
if (filter(item))
result.Add(item);
}
return result;
}
}
// Usage
ArrayHelper helper = new ArrayHelper();
string[] fruits = { "apple", "banana", "cherry", "date" };
int index = helper.FindIndex(fruits, "cherry"); // 2
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int firstEven = helper.Find(numbers, n => n % 2 == 0); // 2
List evenNumbers = helper.Filter(numbers, n => n % 2 == 0);
// [2, 4, 6, 8, 10]
```
### Extension Methods with Generics
```csharp
// Generic extension methods
public static class EnumerableExtensions
{
// Extension method for any IEnumerable
public static T FirstOrDefault(this IEnumerable source, T defaultValue)
{
foreach (T item in source)
{
return item;
}
return defaultValue;
}
// Extension method with predicate
public static bool Any(this IEnumerable source, Func predicate)
{
foreach (T item in source)
{
if (predicate(item))
return true;
}
return false;
}
// Extension method that transforms elements
public static IEnumerable Select(
this IEnumerable source,
Func selector)
{
foreach (T item in source)
{
yield return selector(item);
}
}
}
// Usage
List numbers = new List { 1, 2, 3, 4, 5 };
// Using extension methods
int first = numbers.FirstOrDefault(-1); // 1
bool hasEven = numbers.Any(n => n % 2 == 0); // true
// Transforming elements
IEnumerable numberStrings = numbers.Select(n => n.ToString());
// ["1", "2", "3", "4", "5"]
```
## Generic Constraints
Generic constraints limit the types that can be used as type arguments in a generic type or method.
### Type Constraints
```csharp
// Class constraint (T must be a class)
public class Repository where T : class
{
public void Save(T entity)
{
// Only reference types allowed
Console.WriteLine($"Saving {entity}");
}
}
// Struct constraint (T must be a value type)
public class ValueProcessor where T : struct
{
public T Process(T value)
{
// Only value types allowed
Console.WriteLine($"Processing {value}");
return value;
}
}
// Interface constraint (T must implement an interface)
public class Sorter where T : IComparable
{
public void Sort(T[] items)
{
Array.Sort(items);
}
}
// Base class constraint (T must inherit from a specific class)
public class EntityValidator where T : Entity
{
public bool Validate(T entity)
{
return entity.IsValid();
}
}
// Usage
Repository customerRepo = new Repository();
// Repository intRepo = new Repository(); // Error: int is not a class
ValueProcessor intProcessor = new ValueProcessor();
// ValueProcessor stringProcessor = new ValueProcessor(); // Error: string is not a struct
Sorter stringSorter = new Sorter();
// Sorter