C#

Advanced C# Features Example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

// Records for immutable data
public record Person(string FirstName, string LastName, int Age);

class Program
{
    static async Task Main()
    {
        // LINQ and collection initializers
        var people = new List<Person> {
            new("John", "Doe", 30),
            new("Jane", "Smith", 25),
            new("Bob", "Johnson", 45)
        };
        
        // Pattern matching with switch expression
        string GetLifeStage(Person p) => p.Age switch {
            < 18 => "Child",
            < 65 => "Adult",
            _ => "Senior"
        };
        
        // Async/await pattern
        await Task.WhenAll(
            people.Select(async p => {
                await Task.Delay(100); // Simulating async work
                Console.WriteLine($"{p.FirstName} is a {GetLifeStage(p)}");
            })
        );
        
        // Extension methods and LINQ
        var adults = people.Where(p => p.Age >= 18)
                          .OrderBy(p => p.LastName)
                          .Select(p => $"{p.FirstName} {p.LastName}");
                          
        Console.WriteLine($"Adults: {string.Join(", ", adults)}");
    }
}
        

Technical Example - .NET Assembly Structure:

// C# source code
namespace Example {
    public class Demo {
        public string GetMessage() => "Hello from .NET";
    }
}

/* Compilation Process:
1. C# compiler (csc.exe) compiles to CIL in assembly (Example.dll)
2. Assembly contains:
   - PE (Portable Executable) header
   - CLR header
   - Metadata tables (TypeDef, MethodDef, etc.)
   - CIL bytecode
   - Resources (if any)
3. When executed, CLR:
   - Loads assembly
   - Verifies CIL
   - JIT compiles methods as needed
   - Executes resulting machine code
*/
        

Memory Usage and Aliasing:

// These types are aliases for .NET framework types
// int is an alias for System.Int32
int number = 42;  
System.Int32 sameNumber = 42;  // Identical to the above

// string is an alias for System.String
string text = "Hello";
System.String sameText = "Hello";  // Identical to the above
        

Default Values:

// Numeric types default to 0
int defaultInt = default;     // 0
double defaultDouble = default;  // 0.0

// Boolean defaults to false
bool defaultBool = default;   // false

// Char defaults to '\0' (the null character)
char defaultChar = default;   // '\0'

// Reference types default to null
string defaultString = default;  // null
object defaultObject = default;  // null
        

// Basic declaration with explicit type
int counter;            // Declared but uninitialized
int score = 100;        // Declaration with initialization
string firstName = "John", lastName = "Doe";  // Multiple variables of same type
        

// Implicitly typed local variables
var count = 10;             // Inferred as int
var name = "Jane";          // Inferred as string
var items = new List(); // Inferred as List
        

// Constants must be initialized at declaration
const double Pi = 3.14159;
const string AppName = "MyApplication";
        

// Class-level readonly field
public class ConfigManager
{
    // Can only be assigned in declaration or constructor
    private readonly string _configPath;
    
    public ConfigManager(string path)
    {
        _configPath = path;  // Legal assignment in constructor
    }
}
        

// Using default value expressions
int number = default;        // 0
bool flag = default;         // false
string text = default;       // null
List list = default;    // null

// With explicit type (C# 7.1+)
var defaultInt = default(int);     // 0
var defaultBool = default(bool);   // false
        

// Value types that can also be null
int? nullableInt = null;
int? anotherInt = 42;

// C# 8.0+ nullable reference types
string? nullableName = null;  // Explicitly indicates name can be null
        

// Object initializer syntax
var person = new Person { 
    FirstName = "John", 
    LastName = "Doe",
    Age = 30 
};

// Collection initializer syntax
var numbers = new List { 1, 2, 3, 4, 5 };

// Dictionary initializer
var capitals = new Dictionary {
    ["USA"] = "Washington D.C.",
    ["France"] = "Paris",
    ["Japan"] = "Tokyo"
};
        

// Declaration patterns (C# 7.0+)
if (someValue is int count)
{
    // count is declared and initialized inside the if condition
    Console.WriteLine($"The count is {count}");
}

// Switch expressions with declarations (C# 8.0+)
var description = obj switch {
    int n when n < 0 => "Negative number",
    int n => $"Positive number: {n}",
    string s => $"String of length {s.Length}",
    _ => "Unknown type"
};
        

// Resource declaration with automatic disposal
using var file = new StreamReader("data.txt");
// file is disposed at the end of the current block
        

// The type is inferred from the variable declaration
List numbers = new();   // Same as new List()
Dictionary> map = new();  // Type inferred from left side
        

if (condition) 
{
    // Executed when condition is true
}
        

if (condition) 
{
    // Executed when condition is true
} 
else 
{
    // Executed when condition is false
}
        

if (condition1) 
{
    // Code block 1
} 
else if (condition2) 
{
    // Code block 2
} 
else 
{
    // Default code block
}
        

switch (expression) 
{
    case constant1:
        // Code executed when expression equals constant1
        break;
    case constant2:
    case constant3: // Fall-through is allowed between cases
        // Code executed when expression equals constant2 or constant3
        break;
    default:
        // Code executed when no match is found
        break;
}
        

string greeting = dayOfWeek switch 
{
    DayOfWeek.Monday => "Starting the week",
    DayOfWeek.Friday => "TGIF",
    DayOfWeek.Saturday or DayOfWeek.Sunday => "Weekend!",
    _ => "Regular day"
};
        

switch (obj) 
{
    case int i when i > 0:
        Console.WriteLine($"Positive integer: {i}");
        break;
    case string s:
        Console.WriteLine($"String: {s}");
        break;
    case null:
        Console.WriteLine("Null value");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}
        

// Syntax: condition ? expression_if_true : expression_if_false
int abs = number < 0 ? -number : number;
        

for (int i = 0; i < collection.Length; i++)
{
    // Loop body
}
        

while (condition)
{
    // Loop body
}
        

do
{
    // Loop body
} while (condition);
        

foreach (var item in collection)
{
    // Process item
}
        

Approximate expansion of a foreach loop:

// This foreach:
foreach (var item in collection)
{
    Console.WriteLine(item);
}

// Expands to something like:
{
    using (var enumerator = collection.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            var item = enumerator.Current;
            Console.WriteLine(item);
        }
    }
}
        

// Instead of:
var result = new List<int>();
foreach (var item in collection)
{
    if (item.Value > 10)
        result.Add(item.Value * 2);
}

// Use:
var result = collection
    .Where(item => item.Value > 10)
    .Select(item => item.Value * 2)
    .ToList();
        

Parallel.For(0, items.Length, i =>
{
    ProcessItem(items[i]);
});

Parallel.ForEach(collection, item =>
{
    ProcessItem(item);
});
        

Array Declarations and Initialization Patterns

// Declaration patterns
int[] numbers;           // Declaration only (null reference)
numbers = new int[5];    // Allocation with default values

// Initialization patterns
int[] a = new int[5];               // Initialized with default values (all 0)
int[] b = new int[5] { 1, 2, 3, 4, 5 }; // Explicit size with initialization
int[] c = new int[] { 1, 2, 3, 4, 5 };  // Size inferred from initializer
int[] d = { 1, 2, 3, 4, 5 };           // Shorthand initialization

// Type inference with arrays (C# 3.0+)
var scores = new[] { 1, 2, 3, 4, 5 }; // Type inferred as int[]

// Array initialization with new expression
var students = new string[3] {
    "Alice",
    "Bob", 
    "Charlie"
};
        

Multi-dimensional vs Jagged Arrays

// Rectangular 2D array (elements stored in continuous memory block)
int[,] matrix = new int[3, 4]; // 3 rows, 4 columns
matrix[1, 2] = 10;

// Jagged array (array of arrays, allows rows of different lengths)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4];
jaggedArray[1] = new int[2];
jaggedArray[2] = new int[5];
jaggedArray[0][2] = 10;

// Performance comparison:
// - Rectangular arrays have less memory overhead
// - Jagged arrays often have better performance for larger arrays
// - Jagged arrays allow more flexibility in dimensions
        

System.Array Methods and LINQ Operations

int[] numbers = { 5, 3, 8, 1, 2, 9, 4 };

// Array methods
Array.Sort(numbers);                 // In-place sort
Array.Reverse(numbers);              // In-place reverse
int index = Array.BinarySearch(numbers, 5); // Binary search (requires sorted array)
Array.Clear(numbers, 0, 2);          // Clear first 2 elements (set to default)
int[] copy = new int[7];
Array.Copy(numbers, copy, numbers.Length); // Copy array
Array.ForEach(numbers, n => Console.WriteLine(n)); // Apply action to each element

// LINQ operations on arrays
using System.Linq;

int[] filtered = numbers.Where(n => n > 3).ToArray();
int[] doubled = numbers.Select(n => n * 2).ToArray();
int sum = numbers.Sum();
double average = numbers.Average();
int max = numbers.Max();
bool anyGreaterThan5 = numbers.Any(n => n > 5);
        

// Using Span for zero-allocation slicing
int[] data = new int[100];
Span slice = data.AsSpan(10, 20); // Points to elements 10-29
slice[5] = 42; // Modifies data[15]

// Efficient array manipulation without copying
void ProcessRange(Span buffer)
{
    for (int i = 0; i < buffer.Length; i++)
    {
        buffer[i] *= 2;
    }
}
ProcessRange(data.AsSpan(50, 10)); // Process elements 50-59 efficiently
        

// Array covariance example
object[] objects = new string[10]; // Legal due to covariance

// This will compile but throw ArrayTypeMismatchException at runtime:
// objects[0] = 42; // Cannot store int in string[]

// Proper way to avoid covariance issues - use generics:
List strings = new List();
// List