Welcome to the Lounge

list.WhenNotEmpty()?.ForEach(s => s.Prepare(out var r)?.Manipulate(r));

// Debuggable
var filtered = myList.Where(...);
var ordered = filtered.OrderBy(...);
var result = ordered.ToList();
return result;

// Readable
return myList
   .Where(...)
   .OrderBy(...)
   .ToList();

string Foo(int x) {
  if (x == 1) return "one";
  else return "not one";
}

string Foo(int x)
{
  if(x == 1)
    { 
       return "one";
    }
    else
    {
       return "not one";
    }
  }
}

string Foo(this int x) => (x == 1) ? "one" : "not one";

string Foo(int x) {
  if (x == 1) return "one";
  else return "not one";
}

KBZX5000 wrote:

because they look so damn familiar.

for (once) {
  if (complex condition) {
    ...do this and that...
    break;
  if (another complex condition) {
    ...do something else...
    break;
  ... as many processing alternatives as relevant ...
}

// transfer
if(AccountHasFunds(sourceAccount, amount)){
  debit(sourceAccount, amount);
  credit(targetAccount amount);
}

Quote:

compiler does something more optimized... Or perhaps some other underlying reason?

void TransferFunds(source, target, amount){

  // Business - more compressed to highlight business logic
  if(AccountHasFunds(sourceAccount, amount)){
    transaction {
      debit(sourceAccount, amount);
      credit(targetAccount amount);
    }
    success: {}
    rollback: {}
  } else { CancelTransfer(); }

  // Technology - more expanded too see details and maintain

  [Description("Validates account balance equals or exceeds amount")]
  bool AccountHasFunds(string account, decimal amount){
    var accountBalance = account.GetBalance();
    if ( accountBalance >= amount){
      return true;
    else {
      return false;
    }
  }

  [Description("Debits amount from account")]
  void Credit(…){
    …
  }

  ...
}

Quote:

string Foo(int x){
if (x == 1) {
return "one";
} else {
return "not one";
}
}

string Foo(int x) { return x == 1 ? "one" : "not one"; }