Filtraggio delle raccolte in C #

Sto cercando un modo molto veloce per filtrare una raccolta in C #. Attualmente sto utilizzando raccolte List <object> generiche, ma sono aperto all'utilizzo di altre strutture se funzionano meglio.

Attualmente, sto solo creando un nuovo elenco <oggetto> e passando in rassegna l'elenco originale. Se i criteri di filtro corrispondono, inserisco una copia nel nuovo elenco.

C'è un modo migliore per farlo? Esiste un modo per filtrare in modo che non sia richiesto un elenco temporaneo?

Se stai usando C # 3.0 puoi usare linq, molto meglio e molto più elegante:

List<int> myList = GetListOfIntsFromSomewhere();

// This will filter out the list of ints that are > than 7, Where returns an
// IEnumerable<T> so a call to ToList is required to convert back to a List<T>.
List<int> filteredList = myList.Where( x => x > 7).ToList();

Se non riesci a trovare .Where, significa che devi importare using System.Linq;nella parte superiore del file.

Ecco un blocco di codice / esempio di alcuni filtri di elenco che utilizzano tre diversi metodi che ho messo insieme per mostrare i filtri di elenco basati su Lambdas e LINQ.

#region List Filtering

static void Main(string[] args)
{
    ListFiltering();
    Console.ReadLine();
}

private static void ListFiltering()
{
    var PersonList = new List<Person>();

    PersonList.Add(new Person() { Age = 23, Name = "Jon", Gender = "M" }); //Non-Constructor Object Property Initialization
    PersonList.Add(new Person() { Age = 24, Name = "Jack", Gender = "M" });
    PersonList.Add(new Person() { Age = 29, Name = "Billy", Gender = "M" });

    PersonList.Add(new Person() { Age = 33, Name = "Bob", Gender = "M" });
    PersonList.Add(new Person() { Age = 45, Name = "Frank", Gender = "M" });

    PersonList.Add(new Person() { Age = 24, Name = "Anna", Gender = "F" });
    PersonList.Add(new Person() { Age = 29, Name = "Sue", Gender = "F" });
    PersonList.Add(new Person() { Age = 35, Name = "Sally", Gender = "F" });
    PersonList.Add(new Person() { Age = 36, Name = "Jane", Gender = "F" });
    PersonList.Add(new Person() { Age = 42, Name = "Jill", Gender = "F" });

    //Logic: Show me all males that are less than 30 years old.

    Console.WriteLine("");
    //Iterative Method
    Console.WriteLine("List Filter Normal Way:");
    foreach (var p in PersonList)
        if (p.Gender == "M" && p.Age < 30)
            Console.WriteLine(p.Name + " is " + p.Age);

    Console.WriteLine("");
    //Lambda Filter Method
    Console.WriteLine("List Filter Lambda Way");
    foreach (var p in PersonList.Where(p => (p.Gender == "M" && p.Age < 30))) //.Where is an extension method
        Console.WriteLine(p.Name + " is " + p.Age);

    Console.WriteLine("");
    //LINQ Query Method
    Console.WriteLine("List Filter LINQ Way:");
    foreach (var v in from p in PersonList
                      where p.Gender == "M" && p.Age < 30
                      select new { p.Name, p.Age })
        Console.WriteLine(v.Name + " is " + v.Age);
}

private class Person
{
    public Person() { }
    public int Age { get; set; }
    public string Name { get; set; }
    public string Gender { get; set; }
}

#endregion

List<T> ha un FindAll metodo che farà il filtraggio per te e restituirà un sottoinsieme dell'elenco.

MSDN ha un ottimo esempio di codice qui: http://msdn.microsoft.com/en-us/library/aa701359(VS.80).aspx

EDIT: ho scritto questo prima di avere una buona conoscenza di LINQ e del Where()metodo. Se dovessi scrivere questo oggi probabilmente userei il metodo menzionato da Jorge sopra. Il FindAllmetodo funziona comunque se sei bloccato in un ambiente .NET 2.0.

È possibile utilizzare IEnumerable per eliminare la necessità di un elenco temporaneo.

public IEnumerable<T> GetFilteredItems(IEnumerable<T> collection)
{
    foreach (T item in collection)
    if (Matches<T>(item))
    {
        yield return item;
    }
}

dove Matches è il nome del tuo metodo di filtro. E puoi usarlo come:

IEnumerable<MyType> filteredItems = GetFilteredItems(myList);
foreach (MyType item in filteredItems)
{
    // do sth with your filtered items
}

Questo chiamerà la funzione GetFilteredItems quando necessario e in alcuni casi che non si utilizzano tutti gli elementi nella raccolta filtrata, potrebbe fornire un buon guadagno in termini di prestazioni.

Per farlo sul posto, puoi usare il metodo RemoveAll della classe "List <>" insieme a una classe "Predicate" personalizzata ... ma tutto ciò che fa è ripulire il codice ... sotto il cofano sta facendo lo stesso cosa sei ... ma sì, lo fa sul posto, quindi fai lo stesso con l'elenco delle temp.

È possibile utilizzare il metodo FindAll dell'elenco, fornendo un delegato su cui filtrare. Tuttavia , sono d'accordo con @ IainMH che non vale la pena preoccuparsi troppo se non è un elenco enorme.

Se stai usando C # 3.0 puoi usare linq

Oppure, se preferisci, usa la sintassi di query speciale fornita dal compilatore C # 3:

var filteredList = from x in myList
                   where x > 7
                   select x;

L'uso di LINQ è relativamente più lento rispetto all'utilizzo di un predicato fornito con il FindAllmetodo Elenchi . Prestare attenzione anche a LINQ poiché l'enumerazione di listnon viene effettivamente eseguita fino a quando non si accede al risultato. Ciò può significare che, quando pensi di aver creato un elenco filtrato, il contenuto potrebbe differire da quello che ti aspettavi quando lo hai letto.

Se la tua lista è molto grande e stai filtrando ripetutamente - puoi ordinare l'elenco originale sull'attributo filter, ricerca binaria per trovare i punti di inizio e fine.

Ora iniziale O (n * log (n)) quindi O (log (n)).

Il filtraggio standard richiederà O (n) ogni volta.