// ❌ Imperative accumulation
var result = new List<string>();
foreach (var item in items) {
    if (item.IsActive) result.Add(item.Name.ToUpper());
}
 
// ✅
var result = items
    .Where(i => i.IsActive)
    .Select(i => i.Name.ToUpper())
    .ToList();

// ❌ Manual grouping
var grouped = new Dictionary<string, List<Item>>();
foreach (var item in items) {
    if (!grouped.ContainsKey(item.Category))
        grouped[item.Category] = new List<Item>();
    grouped[item.Category].Add(item);
}
 
// ✅
var grouped = items.GroupBy(i => i.Category)
    .ToDictionary(g => g.Key, g => g.ToList());

// ❌ Checking Any() then First()
if (items.Any(i => i.IsValid)) {
    var first = items.First(i => i.IsValid);
}
 
// ✅
var first = items.FirstOrDefault(i => i.IsValid);
if (first is not null) { ... }

// ❌ Nested null checks
string city = null;
if (user != null && user.Address != null) {
    city = user.Address.City;
}
 
// ✅
var city = user?.Address?.City;

// ❌ Ternary for null fallback
var name = user != null ? user.Name : "Unknown";
 
// ✅
var name = user?.Name ?? "Unknown";

// ❌ Null check before event invocation
if (OnChanged != null) OnChanged(this, args);
 
// ✅
OnChanged?.Invoke(this, args);

// ❌ Throwing ArgumentNullException manually
if (name == null) throw new ArgumentNullException(nameof(name));
 
// ✅ (.NET 6+)
ArgumentNullException.ThrowIfNull(name);

// ❌ Blocking on async code
var result = GetDataAsync().Result; // deadlock risk
 
// ✅
var result = await GetDataAsync();

// ❌ async void (exceptions are unobservable)
async void OnButtonClick() { await DoWork(); }
 
// ✅ — async Task; only async void for event handlers that truly require it
async Task OnButtonClick() { await DoWork(); }

// ❌ Sequential awaits for independent work
var a = await FetchA();
var b = await FetchB();
 
// ✅
var (a, b) = (await Task.WhenAll(FetchA(), FetchB())) switch
{
    var r => (r[0], r[1])
};
// or cleaner with ValueTuple:
var taskA = FetchA();
var taskB = FetchB();
var a = await taskA;
var b = await taskB;

// ❌ Wrapping synchronous code in Task.Run inside a library
public Task<int> GetValue() => Task.Run(() => ComputeSync());
 
// ✅ — let the caller decide; expose sync method
public int GetValue() => ComputeSync();

// ❌ Manual equality, ToString, Deconstruct for data types
class Point {
    public int X { get; init; }
    public int Y { get; init; }
    // + Equals, GetHashCode, ToString...
}
 
// ✅ (C# 9+)
record Point(int X, int Y);

// ❌ if-else chain for type checking
if (shape is Circle) {
    var c = (Circle)shape;
    return c.Radius * c.Radius * Math.PI;
} else if (shape is Rectangle) { ... }
 
// ✅
return shape switch {
    Circle { Radius: var r } => r * r * Math.PI,
    Rectangle { Width: var w, Height: var h } => w * h,
    _ => throw new ArgumentException($"Unknown shape: {shape}")
};

// ❌ Range checking with && 
if (score >= 0 && score <= 100) { ... }
 
// ✅ (C# 9+)
if (score is >= 0 and <= 100) { ... }

// ❌ Catching Exception to log and swallow
try { Process(); }
catch (Exception ex) { logger.LogError(ex, "error"); }
 
// ✅ — catch specific, rethrow if you can't handle
try { Process(); }
catch (HttpRequestException ex) {
    throw new ServiceException("upstream failure", ex);
}

// ❌ throw ex (resets stack trace)
catch (Exception ex) { throw ex; }
 
// ✅
catch (Exception ex) { throw; } // preserves stack trace
// or wrap: throw new AppException("context", ex);

// ❌ Exceptions for flow control
try { return dict[key]; }
catch (KeyNotFoundException) { return defaultValue; }
 
// ✅
return dict.TryGetValue(key, out var value) ? value : defaultValue;

// ❌ Manual Dispose
var conn = new SqlConnection(cs);
conn.Open();
// ... use conn ...
conn.Dispose(); // missed on exception
 
// ✅
using var conn = new SqlConnection(cs);
conn.Open();
// disposed at end of scope

// ❌ Verbose using block
using (var reader = new StreamReader(path)) {
    return reader.ReadToEnd();
}
 
// ✅ (C# 8+)
using var reader = new StreamReader(path);
return reader.ReadToEnd();
// or just: return File.ReadAllText(path);