C# Advanced Concepts

// Define delegate type
public delegate void NotifyDelegate(string message);

// Method matching delegate signature
public void SendEmail(string message)
{
    Console.WriteLine($"Email: {message}");
}

// Usage
NotifyDelegate notify = SendEmail;
notify("Hello World");  // Calls SendEmail

content_copy

NotifyDelegate notify = SendEmail;
notify += SendSMS;
notify += LogToFile;

notify("Alert!");  // Calls all three methods

content_copy

// Action<T> - no return value
Action<string> print = (msg) => Console.WriteLine(msg);
print("Hello");

// Func<T, TResult> - has return value
Func<int, int, int> add = (a, b) => a + b;
int sum = add(5, 3);

// Predicate<T> - returns bool
Predicate<int> isEven = (n) => n % 2 == 0;
bool result = isEven(4); // true

content_copy

// Expression lambda
Func<int, int> square = x => x * x;

// Statement lambda
Func<int, int, int> max = (a, b) =>
{
    if (a > b) return a;
    return b;
};

// Multiple parameters
Func<int, int, int> multiply = (x, y) => x * y;

content_copy

var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// Filter even numbers
var evens = numbers.Where(n => n % 2 == 0);

// Transform
var squared = numbers.Select(n => n * n);

// Aggregate
var sum = numbers.Aggregate((a, b) => a + b);

content_copy

var students = new List<Student>
{
    new Student { Name = "Alice", Grade = 85 },
    new Student { Name = "Bob", Grade = 92 },
    new Student { Name = "Charlie", Grade = 78 }
};

// Query syntax
var topStudents = from s in students
                  where s.Grade >= 80
                  orderby s.Grade descending
                  select s.Name;

content_copy

// Method syntax (same query)
var topStudents = students
    .Where(s => s.Grade >= 80)
    .OrderByDescending(s => s.Grade)
    .Select(s => s.Name);

content_copy

// Filtering
var adults = people.Where(p => p.Age >= 18);

// Projection
var names = people.Select(p => p.Name);

// Ordering
var sorted = people.OrderBy(p => p.Age);

// Grouping
var grouped = people.GroupBy(p => p.City);

// Aggregation
var average = numbers.Average();
var max = numbers.Max();
var count = people.Count(p => p.Age > 30);

// First/Single
var first = people.First();
var single = people.Single(p => p.Id == 1);

content_copy

// Define entity
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

// DbContext
public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
    
    protected override void OnConfiguring(DbContextOptionsBuilder options)
    {
        options.UseSqlServer("connection_string");
    }
}

content_copy

using (var context = new AppDbContext())
{
    // Create
    var product = new Product { Name = "Laptop", Price = 999.99m };
    context.Products.Add(product);
    context.SaveChanges();
    
    // Read
    var products = context.Products.Where(p => p.Price > 500).ToList();
    
    // Update
    var item = context.Products.Find(1);
    item.Price = 899.99m;
    context.SaveChanges();
    
    // Delete
    context.Products.Remove(item);
    context.SaveChanges();
}

content_copy

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    
    // Navigation property
    public List<OrderItem> Items { get; set; }
}

public class OrderItem
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public int ProductId { get; set; }
    
    // Navigation properties
    public Order Order { get; set; }
    public Product Product { get; set; }
}

content_copy

public async Task<string> DownloadDataAsync(string url)
{
    using (var client = new HttpClient())
    {
        string result = await client.GetStringAsync(url);
        return result;
    }
}

// Usage
string data = await DownloadDataAsync("https://api.example.com");
Console.WriteLine(data);

content_copy

public static class StringExtensions
{
    public static bool IsValidEmail(this string email)
    {
        return email.Contains("@") && email.Contains(".");
    }
    
    public static string Reverse(this string str)
    {
        return new string(str.Reverse().ToArray());
    }
}

// Usage
string email = "test@example.com";
bool valid = email.IsValidEmail();  // true

string text = "Hello";
string reversed = text.Reverse();  // "olleH"

content_copy

// Lambda expression: parameter => expression
Func<int, int> square = x => x * x;
Console.WriteLine(square(5));  // Output: 25

// Multiple parameters
Func<int, int, int> add = (a, b) => a + b;
Console.WriteLine(add(3, 4));  // Output: 7

// Statement lambda (with curly braces)
Action<string> greet = name =>
{
    var message = $"Hello, {name}!";
    Console.WriteLine(message);
};

// Used in LINQ
var evens = numbers.Where(n => n % 2 == 0);

content_copy

// Basic usage
string name = null;
string displayName = name ?? "Guest";
Console.WriteLine(displayName);  // Output: Guest

// Chaining
string result = first ?? second ?? third ?? "Default";

// Common use case
var timeout = config.Timeout ?? 30;

content_copy

// Before: verbose null check
if (cache == null)
    cache = new Dictionary<string, object>();

// After: concise with ??=
cache ??= new Dictionary<string, object>();

// Lazy initialization
private Database _db;
public Database GetDatabase()
{
    _db ??= new Database();  // Initialize only once
    return _db;
}

content_copy

// Member access (?.)
Person person = null;
string name = person?.Name;  // Returns null, doesn't throw

// Chaining
var length = person?.Name?.Length;

// Array/indexer access (?[])
int[] numbers = null;
int? first = numbers?[0];  // Returns null

// Real-world example
var city = customer?.Address?.City ?? "Unknown";

// Safe event invocation
OnDataChanged?.Invoke(this, EventArgs.Empty);

content_copy

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

// Get elements from index 2 to 5 (exclusive)
var slice1 = numbers[2..5];  // { 2, 3, 4 }

// From start to index 3
var slice2 = numbers[..3];   // { 0, 1, 2 }

// From index 7 to end
var slice3 = numbers[7..];   // { 7, 8, 9 }

// Last 3 elements
var slice4 = numbers[^3..];  // { 7, 8, 9 }

// String slicing
string text = "Hello World";
string hello = text[..5];    // "Hello"

content_copy

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

var last = numbers[^1];      // 5 (last element)
var secondLast = numbers[^2]; // 4

// With strings
string text = "Programming";
char lastChar = text[^1];     // 'g'

// Combined with range
var lastThree = numbers[^3..]; // { 3, 4, 5 }

content_copy

// Define alias at top of file
using MyCompany = Company.MyApplication.Core;
using ThirdParty = ExternalLibrary.Core;

// Both have a class named "Logger"
MyCompany::Logger logger1 = new MyCompany::Logger();
ThirdParty::Logger logger2 = new ThirdParty::Logger();

// Global namespace alias
global::System.Console.WriteLine("Using global System");

content_copy

// Modern switch expression
string GetDayType(DayOfWeek day) => day switch
{
    DayOfWeek.Saturday or DayOfWeek.Sunday => "Weekend",
    _ => "Weekday"
};

// With pattern matching
decimal CalculateDiscount(Customer customer) => customer switch
{
    { IsPremium: true, YearsActive: > 5 } => 0.20m,
    { IsPremium: true } => 0.15m,
    { YearsActive: > 3 } => 0.10m,
    _ => 0.05m
};

content_copy

// Ignore out parameters
if (int.TryParse("123", out _))
    Console.WriteLine("Valid number");

// Deconstruction - ignore some values
var (name, _, age) = GetPersonInfo();

// Pattern matching - default case
var result = value switch
{
    1 => "One",
    2 => "Two",
    _ => "Other"
};

content_copy

string? nullableString = GetString();

// Without !, compiler warns
int length1 = nullableString.Length;  // Warning!

// With !, suppress the warning
int length2 = nullableString!.Length;  // No warning

// After null check
if (name != null)
    ProcessName(name!);  // Tell compiler it's safe

// WARNING: Only use when CERTAIN it's not null!

content_copy