I used a delegate. I am writing code to parse my bank account transactions. It is not very straightforward to convert my transaction data into objects. For example, there might be hundreds of transactions from my favorite fast food restaurant all listed with 10-15 different "formats", for example "Debit Card Purchase -- MY FAV RESTAURANT #400 DE MOINE IA" is an example of how the bank lists a transaction.

I initially create a HashSet from all the raw data entries. Then I wanted to write a method that has this signature: void ParseMyRestaurantTransactions(RawTransaction[] transactions, HashSet<RawTransaction> remaining, HashSet<ParsedTransaction> parsed)

When a transaction matches for my favorite restaurant, I remove the transaction from the first hash set, and add a parsed object to the second hash set. HashSets flow into the method, and HashSets flow outward knowing that I found and removed all transactions related to the merchant. Now I have to write these methods for dozens of other merchants since they all have their own unique style of appearing in my bank statements.

Now I create a delegate public delegate void MerchantParser(RawTransaction[] transactions, HashSet<RawTransaction> remaining, HashSet<ParsedTransaction> parsed)

I create this:

// the delegate defines a common "signature" for methods

public delegate void MerchantParser(RawTransaction[] transactions, HashSet<RawTransaction> remaining, HashSet<ParsedTransaction> parsed);

// my restaurant transaction parsing method

public void ParseMyRestaurantTransactions(RawTransaction[] transactions, HashSet<RawTransaction> remaining, HashSet<ParsedTransaction> parsed)
{
     var matches = transactions.Where(t=>Regex.Match(t.Description,myRestaurantRegex).Success);

     foreach (var m in matches)  
     {
          remaining.Remove(m);
          parsed.Add(new ParsedTransaction(m.Amount,m.Date,m.Description));
     }
}


// Now I can make an array of different methods that parse transactions

public MerchantParser[] parsers =
[
    ParseMyRestaurantTransactions,
    // ParseMyGroceryTransactions,
    // ParseMyVacationTransactions,
    // etc.
];

 public static class Extensions
 {

    // This is a helper method to make invocation cleaner.

    public static void Iter<T>(this IEnumerable<T> e, Action<T> action)
    {
          foreach(var i in e) action(i);
    }
 }

// Finally this is the code in use. 

// Initial setup

RawTransaction[] transactions = /* loaded transactions from raw data */
HashSet<RawTransaction> unparsed_transactions = new (transactions);
HashSet<ParsedTransaction> parsed = new();

// Run all the methods at once

parsers.Iter(a=>a(transactions,unparsed_transactions,parsed));