Registrazione di più oggetti per vari motivi, quindi raggruppamento per tale motivo

Ho problemi a ripulire il mio codice e mi chiedevo se esistesse qualche tipo di pattern di cui non sono a conoscenza che possa aiutarmi in questa situazione.

Ho bisogno di elaborare un elenco di oggetti in vari metodi, da qualche parte in questi metodi, un oggetto nell'elenco può fallire per un motivo specifico, e le ragioni possono variare. Ho bisogno di generare gli oggetti che hanno fallito (possono essere convertiti in stringhe senza problemi) e, cosa più importante, perché hanno fallito.

A causa dell'elevato numero di oggetti che elaboro (da duecento a duemila), non riesco a elencare individualmente tutti quelli che hanno avuto problemi.

Prima avevo solo un motivo per cui qualcosa non funzionava, come "ID non valido". Così ho creato una lista che era "FailedAccounts", e poi ho prodotto qualcosa come "I seguenti account avevano un ID non valido:" Quindi fai uscire tutti gli elementi nella lista con una virgola tra loro. Ha funzionato bene.

Poi mi è stato detto "Beh, questi possono fallire a causa di un altro motivo". Così ho creato un secondo elenco, chiamandolo "XFailedAccounts". Quindi ora ho

"I seguenti account hanno un ID non valido:"

"I seguenti elementi hanno X":

Poi mi è stato dato un altro criterio. E poi un altro, e poi un altro.

Più di 4 elenchi è semplicemente disordinato. Ho bisogno di un modo per organizzare gli oggetti e poi raggrupparli in modo appropriato.

Ho considerato un dizionario / hash con la ragione come valore e l'oggetto come chiave, ma poi dovrei cercare e raggruppare per valore, che sconfigge lo scopo di un hash, penso, ma fornisce ancora meglio organizzazione che liste.

Tentativo 1

Poi ho esplorato la possibilità di creare diversi tipi di "lista" che ereditano da List, aggiungendo semplicemente un campo "reason". Gli account vengono quindi aggiunti all'elenco specifico. Quindi avrei qualcosa di simile:

class FailedAccountsList : List<string>
{
    string reason = "Failed Account ID"
}

public static FailedAccounts
{
    FailedAccountsList reason1 = new FailedAccountsList();
    FailedAccountsList reason2 = new FailedAccountsList();
}

Quindi terrei tutti questi elenchi diversi come oggetti statici in una classe statica chiamata "Elenchi di avvisi". E popola le singole liste mentre vado.

Certo, questo è più strutturato di avere più di 4 liste individuali, ma sembra davvero disordinato e brutto.

Tentativo 2

Ho creato un elenco SINGLE e creato un oggetto di tipo "FailedAccount" che contiene un account e un motivo. Dopo aver terminato di elaborare tutti gli oggetti, cerco motivi distinti, quindi li estraiamo e li inserisco in elenchi.

class FailedObj
{
    Object objectThatFailed;
    string Reason; (I can make this into an actual type instead of a string)
}

Il problema qui è che devo ripetere l'elenco "completo" N * volte distinto. Che immagino sia solo N volte, e poi di nuovo per ogni elemento della lista per produrre i singoli oggetti. Non è terribile, non eccezionale. Realisticamente con un massimo di 4000 oggetti non è un grande successo di prestazioni. Anche tenendo conto del sovraccarico di 4000 oggetti, non è grande nel grande schema delle cose. Ma non sono ancora soddisfatto.

Come faccio a trovare il modo migliore per fare cose come questa? Devo sudare sull'ottimizzazione se il grande O non è quadratico? Come posso migliorare e progettare un codice più pulito?