Unione di due raccolte<T>

Question

Ho una funzione che restituisce a Collection<string>, e che si richiama ricorsivamente per restituirne eventualmente uno big Collection<string>.

Ora, mi chiedo solo quale sia l'approccio migliore per unire gli elenchi? Collection.CopyTo() copia solo in string[] e utilizza a foreach() il loop sembra essere inefficiente.Tuttavia, poiché voglio filtrare anche i duplicati, sento che mi ritroverò con un foreach che chiama Contains() sul Collection.

Mi chiedo, esiste un modo più efficiente per avere una funzione ricorsiva che restituisca un elenco di stringhe senza duplicati?Non devo usare a Collection, può essere praticamente qualsiasi tipo di dati adatto.

Unica esclusione, sono vincolato a Visual Studio 2005 e .net 3.0, quindi niente LINQ.

Modificare: Chiarire:La funzione porta un utente fuori da Active Directory, esamina i rapporti diretti dell'utente e quindi esamina in modo ricorsivo i rapporti diretti di ogni utente.Quindi il risultato finale è un elenco di tutti gli utenti che si trovano nella "catena di comando" di un determinato utente. Poiché questo viene eseguito abbastanza spesso e al momento richiede 20 secondi per alcuni utenti, sto cercando modi per migliorarlo.Anche la memorizzazione nella cache del risultato per 24 ore è nella mia lista, ma voglio vedere come migliorarla prima di applicare la memorizzazione nella cache.

Answer 1

Se stai utilizzando List<> puoi utilizzare .AddRange per aggiungere un elenco all'altro elenco.

Oppure puoi utilizzare yield return per combinare le liste al volo in questo modo:

public IEnumerable<string> Combine(IEnumerable<string> col1, IEnumerable<string> col2)
{
    foreach(string item in col1)
        yield return item;

    foreach(string item in col2)
        yield return item;
}

Answer 2

Potresti voler dare un'occhiata Iesi.Collezioni E Iesi.Collezioni generiche estese (perché la prima edizione è stata realizzata nella 1.1 quando ancora non esistevano i generici).

Extended Iesi ha una classe ISet che agisce esattamente come un HashSet:impone membri univoci e non consente duplicati.

La cosa interessante di Iesi è che ha impostato operatori invece di metodi per unire raccolte, quindi puoi scegliere tra unione (|), intersezione (&), XOR (^) e così via.

Answer 3

Penso HashSet<T> è di grande aiuto.

IL HashSet<T> La classe fornisce operazioni di set di prestazioni ad alte prestazioni.Un set è una raccolta che non contiene elementi duplicati e i cui elementi non sono in ordine particolare.

Basta aggiungere elementi e quindi utilizzare CopyTo.

---

Aggiornamento: HashSet<T> è in .Net 3.5

Forse puoi usare Dictionary<TKey, TValue>.L'impostazione di una chiave duplicata su un dizionario non genererà un'eccezione.

Answer 4

Puoi passare il metodo Collection nel tuo metodo per riferimento in modo da poter semplicemente aggiungere elementi ad esso, in questo modo non devi restituire nulla.Questo è come potrebbe apparire se lo facessi in C#.

class Program
{
    static void Main(string[] args)
    {
        Collection<string> myitems = new Collection<string>();
        myMthod(ref myitems);
        Console.WriteLine(myitems.Count.ToString());
        Console.ReadLine();
    }

    static void myMthod(ref Collection<string> myitems)
    {
        myitems.Add("string");
        if(myitems.Count <5)
            myMthod(ref myitems);
    }
}

Come affermato da @Zooba Il passaggio per ref non è necessario qui, se si passa per valore funzionerà anche.

Answer 5

Per quanto riguarda la fusione:

Mi chiedo, esiste un modo più efficiente per avere una funzione ricorsiva che restituisce un elenco di stringhe senza duplicati?Non devo usare una raccolta, può essere praticamente qualsiasi tipo di dati adatto.

La tua funzione assembla un valore restituito, giusto?Stai dividendo a metà l'elenco fornito, invocando nuovamente self (due volte) e quindi unendo questi risultati.

Durante la fase di unione, perché non controllare prima di aggiungere ogni stringa al risultato?Se è già lì, saltalo.

Supponendo che tu stia lavorando con elenchi ordinati, ovviamente.