Given event records with idempotency keys, return the first event for each key in arrival order.

Implement DeduplicateEvents(IEnumerable<EventRecord> events). Keep the first event for each non-empty idempotency key, preserve arrival order for kept events, and skip later duplicates.

Input keys: A, B, A, C, B Output keys: A, B, C

• Null input returns an empty list.
• A blank idempotency key is invalid and should be skipped.
• The first event wins.
• The output preserves arrival order of the kept events.

I would maintain a HashSet<string> of keys already seen and a result list. For each event, I validate that the key exists, then call seen.Add(key). Add returns true only for the first occurrence, so the condition stays concise. I would mention that this is in-memory dedupe; production idempotency still needs durable storage or database constraints.

public sealed record EventRecord(string IdempotencyKey, string Payload);

public static IReadOnlyList<EventRecord> DeduplicateEvents(IEnumerable<EventRecord>? events)
{
    if (events is null)
    {
        return Array.Empty<EventRecord>();
    }

    var seen = new HashSet<string>(StringComparer.Ordinal);
    var result = new List<EventRecord>();

    foreach (var eventRecord in events)
    {
        if (string.IsNullOrWhiteSpace(eventRecord.IdempotencyKey))
        {
            continue;
        }

        if (seen.Add(eventRecord.IdempotencyKey))
        {
            result.Add(eventRecord);
        }
    }

    return result;
}

Time is O(n) on average because hash lookups are O(1). Space is O(k), where k is the number of unique idempotency keys kept.

• Null input.
• Blank or whitespace keys.
• All events duplicate the same key.
• No duplicates.
• Case sensitivity of keys, which must be agreed with the domain.

• Use duplicate keys separated by many other events.
• Use invalid blank keys to confirm they do not enter the hash set.
• Use keys with different casing if the rule is case-sensitive.

• Using Distinct() and losing control over which event is kept.
• Sorting events and losing arrival order.
• Treating in-memory dedupe as durable idempotency.
• Not defining case sensitivity.