C# Union vs Contiene per gli elenchi di dati continui

Question

Ho difficoltà a trovare le risposte a una domanda relativa a un codice specifico per ciò a cui sto lavorando e non riesco a trovare alcuna documentazione su come funziona l'Unione al suo meccanica di base in C#. Quindi il problema è questo.

Ho una serie di dati che funziona in modo simile a questo esempio:

 object[] someMainTypeArray = new object [n]; 
    List<object> objList2 = new List<object>(); 
    foreach (object obj in someMainTypeArray) { 
     List<object> objList1 = new List<object>() { "1","2","3" }; 
     //each obj has a property that will generate a list of data 
     //objList1 is the result of the data specific to obj 
     //some of this data could be duplicates 
     //Which is better, this: 
     foreach (object test in objList1) { 
      if (!objList2.Contains(test)) { 
       objList2.Add(test); 
      } 
     } 
     //or this: 
     objList2 = objList2.Union(objList1).ToList(); 
     //Also, assume this has to happen anywhere from 0 to 60 times per second 
    } 

È più efficace lasciare dell'Unione fare tutto il lavoro? O è meglio confrontare ogni elemento usando Contains?

Se No per entrambi, qual è il modo migliore per compilare elenchi univoci utilizzando il minor tempo di elaborazione possibile?

L'efficienza è la chiave per questo. Inoltre, questo non è compito a casa, o qualcosa di relativo al lavoro, solo imparando collegato.

Gli elenchi sono continui in fase di esecuzione nel modo in cui vengono infine cancellati e ripopolati. Le modifiche negli elenchi vengono utilizzate per prendere decisioni in base al fatto che gli elenchi dei risultati finali che sono tutti simili a questo esempio vengano utilizzati per creare un elenco finale e se tale elenco è vuoto, è una condizione di errore e quella lista non è vuota, è una condizione di successo.

Ecco un frammento del codice in questione per una delle liste create:

 Player.ClearMoves(); 
    List<Pair<BoardLocation, BoardLocation>> attacking = new List<Pair<BoardLocation, BoardLocation>>(); 
    foreach (ChessPiece p in Board[this.Player.Opponent]) { 
     if (p.TheoryMove(this.Location)) { 
      foreach (Pair<BoardLocation , BoardLocation> l in Utility.GetLocations(p.Location , this.Location)) { 
       if (!attacking.Contains(l)) { 
       attacking.Add(l); 
       } 
      } 
     } 
    } 
    if (attacking.Count < 1) { 
     return false; 
    }