public static class StringExtensions
{
    extension(string text)
    {
        // Extension property — use it like: email.IsValidEmail
        public bool IsValidEmail => text.Contains('@') && text.Contains('.');
        // Extension property — use it like: sentence.WordCount
        public int WordCount => text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
    }
    extension(string)
    {
        // Static extension property — use it like: string.Placeholder
        public static string Placeholder => "N/A";
        // User-defined operator — use it like: "hello" * 3  =>  "hellohellohello"
        public static string operator *(string text, int times) =>
            string.Concat(Enumerable.Repeat(text, times));
    }
}
// Usage:
string email = "dev@example.com";
Console.WriteLine(email.IsValidEmail);        // True
Console.WriteLine("hello world".WordCount);   // 2
Console.WriteLine(string.Placeholder);        // N/A
Console.WriteLine("ping! " * 3);             // ping! ping! ping!

public class UserProfile
{
    // Compiler synthesizes the backing field automatically
    public string Username
    {
        get;
        set => field = string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentException("Username cannot be blank.")
            : value.Trim().ToLower();
    }
    public int Age
    {
        get;
        set => field = (value is < 0 or > 150)
            ? throw new ArgumentOutOfRangeException(nameof(Age), "Age must be between 0 and 150.")
            : value;
    }
}
// Usage:
var profile = new UserProfile();
profile.Username = "  Alice  ";  // stored as "alice"
profile.Age = 30;                // fine
profile.Age = 200;               // throws ArgumentOutOfRangeException

public class Cart
{
    public string PromoCode { get; set; }
    public List<string> Items { get; set; } = new();
    public decimal Discount { get; set; }
}
Cart activeCart = GetActiveCart(); // might return null
// Old way — manual null guard required:
if (activeCart != null)
{
    activeCart.PromoCode = "SAVE20";
    activeCart.Discount += 20m;
}
// C# 14 — clean and concise:
activeCart?.PromoCode = "SAVE20";
activeCart?.Discount += 20m;   // compound assignment works too!
// The promo code lookup won't even run if activeCart is null:
activeCart?.PromoCode = FetchBestPromoFromApi();

// A method that processes data efficiently using ReadOnlySpan
static double AverageTemperature(ReadOnlySpan<double> readings)
{
    double sum = 0;
    foreach (var temp in readings) sum += temp;
    return sum / readings.Length;
}
double[] dailyReadings = { 22.5, 23.1, 21.8, 24.0, 22.9 };
// C# 14: the array converts implicitly — no .AsSpan() call needed
double avg = AverageTemperature(dailyReadings);
Console.WriteLine($"Average: {avg:F1}°C"); // Average: 22.9°C
// Span and ReadOnlySpan also compose more naturally with generics
ReadOnlySpan<char> greeting = "Hello, World!";
Span<char> buffer = new char[greeting.Length];
greeting.CopyTo(buffer);

// Before C# 14 — you had to supply dummy type arguments:
string name1 = nameof(Dictionary<string, int>); // "Dictionary"
string name2 = nameof(List<object>);             // "List"
// C# 14 — just use the unbound form:
string name3 = nameof(Dictionary<,>);  // "Dictionary"
string name4 = nameof(List<>);         // "List"
string name5 = nameof(Func<,,>);       // "Func"
// Real-world use: building a generic cache key or log label
public static string CacheKey<T>() => $"cache:{nameof(List<>)}:{typeof(T).Name}";
Console.WriteLine(CacheKey<int>());    // cache:List:Int32
Console.WriteLine(CacheKey<string>()); // cache:List:String

// A delegate for a try-parse style conversion
delegate bool TryConvert<TIn, TOut>(TIn input, out TOut result);
// Before C# 14 — all parameter types had to be spelled out:
TryConvert<string, int> parseOld = (string text, out int result) =>
    int.TryParse(text, out result);
// C# 14 — just add the modifier, skip the type:
TryConvert<string, int> parseInt  = (text, out result) => int.TryParse(text, out result);
TryConvert<string, bool> parseBool = (text, out result) => bool.TryParse(text, out result);
// Works great for inline swap utilities with ref params:
delegate void Swapper<T>(ref T a, ref T b);
Swapper<int> swap = (ref a, ref b) => (a, b) = (b, a);
int x = 10, y = 20;
swap(ref x, ref y);
Console.WriteLine($"x={x}, y={y}"); // x=20, y=10

// File: OrderProcessor.cs  (your hand-written code)
public partial class OrderProcessor
{
    // Defining declaration — no body, no initializer
    public partial OrderProcessor(string region);
    public void Process(Order order) => Console.WriteLine($"Processing in {_region}");
}
// File: OrderProcessor.Generated.cs  (source generator output)
public partial class OrderProcessor
{
    private readonly string _region;
    private readonly ILogger _logger;
    // Implementing declaration — has the body and base/this call
    public partial OrderProcessor(string region) : base()
    {
        _region = region;
        _logger = LoggerFactory.Create(b => b.AddConsole()).CreateLogger<OrderProcessor>();
        _logger.LogInformation("OrderProcessor created for region: {Region}", region);
    }
}

public struct Budget
{
    public decimal Amount { get; private set; }
    public Budget(decimal amount) => Amount = amount;
    // Standard addition
    public static Budget operator +(Budget a, Budget b) => new(a.Amount + b.Amount);
    // User-defined compound: += can now enforce a cap rule
    public static Budget operator +=(Budget current, Budget extra)
    {
        var newAmount = current.Amount + extra.Amount;
        return new Budget(Math.Min(newAmount, 100_000m)); // cap at 100k
    }
    public override string ToString() => $"${Amount:N0}";
}
var budget = new Budget(90_000m);
budget += new Budget(15_000m); // would be 105k — capped to 100k
Console.WriteLine(budget);     // $100,000