Sbarazzarsi di oggetti morti in un gioco in modo efficace?

Sto usando un ciclo for o ciclo foreach (non importa) per scorrere tutti i miei oggetti quando devono essere aggiornati o disegnati. Tuttavia, quando un oggetto viene ucciso, voglio che venga rimosso di nuovo dalla raccolta.

Faccio questo aggiungendo l'oggetto a un elenco di oggetti morti e poi, quando tutto è stato disegnato e aggiornato, passo attraverso tutto in questo elenco, rimuovendo anche gli oggetti nell'elenco dalla fonte originale.

C'è un modo migliore per farlo?

Innanzitutto: terminologia. Se dici "lista dei rifiuti", la gente penserà che stai parlando del Garbage Collector. Chiamiamolo la "lista morta".

Come probabilmente hai scoperto, quindi la tua domanda, non puoi rimuovere elementi da una raccolta mentre stai iterando attraverso di essa. Se la tua raccolta è un modo List<>allora il modo più semplice per rimuovere elementi da essa è:

for(int i = list.Count-1; i >= 0; --i)
{
    if(list[i].IsDead)
        list.RemoveAt(i);
}

Si noti che si esegue l'iterazione all'indietro . È possibile rimuovere gli elementi mentre si procede in avanti, ma è più caotico e richiede a goto. Non puoi farlo con foreach.

Puoi effettuare la rimozione separatamente dal tuo ciclo di aggiornamento. Oppure puoi unirlo nel tuo ciclo di aggiornamento. Fai sempre ilRemoveAt la fine del loop: dopo quel punto nel loop,list[i] non può essere considerato valido (diventa nuovamente valido alla successiva iterazione).

Si noti inoltre che ogni oggetto ha il suo IsDead flag (se si utilizza il modello di eliminazione, è possibile crearlo IsDisposed) - in realtà non è necessario mantenere un "elenco morto".

L'uso di un flag su ciascun elemento è preferibile per le prestazioni, poiché si evita di dover cercare nell'elenco per eseguire la rimozione. Ed è anche preferibile per la progettazione - significa che ogni oggetto può facilmente verificare se è morto - quindi non chiamare accidentalmente alcun metodo su di esso (se questi oggetti implementano il modello usa e getta, potrebbero lanciareObjectDisposedException in questo caso ).

Se si dispone di una raccolta diversa da a List<>, la rimozione di elementi morti da quella raccolta può comunque comportare la creazione di un elenco morto (poiché la rimozione durante l'iterazione potrebbe non essere possibile). A mio avviso, è più bello, dal punto di vista del design, creare la lista morta proprio prima che venga utilizzata, ripetendo la raccolta alla ricerca di IsDeadbandiere, piuttosto che cercare di mantenere la lista mentre gli oggetti vengono uccisi.

Una volta che hai finito con un elenco morto, dovresti Clear()farlo e poi tenerlo in giro per riutilizzarlo in seguito.

Il 99,9% delle volte, il Garbage Collector (GC) si prenderà cura di tutto senza problemi. Lascia che faccia il suo lavoro dopo aver cancellato / annullato quegli oggetti. C'è una latenza nella pulizia che dipende da una serie di fattori (ad esempio quanti blocchi di memoria sono stati assegnati ad esempio) ma in genere non è necessario nemmeno saperlo, figuriamoci preoccuparsene. È progettato per funzionare. Questo è uno dei motivi per cui stai usando C # e non C.

Per quanto riguarda le prestazioni di GC in generale, non ti preoccupare eccessivamente a meno che tu non sappia (attraverso la profilazione) che sta creando un collo di bottiglia - questo è solo in giochi piuttosto impegnativi, in generale. In questo caso, guarda GC.Collect () e le sue varie insidie, in modo da sapere quando è appropriato usarlo. Suggerisco di cercare su Google "force gc xna", c'è un sacco di materiale là fuori.