Come eseguo un FindAll () su un IList < T > ;? (es. SortedList.Values)

Question

Sto lavorando a un problema in C # 2.0 / .NET 2.0 in cui ho un elenco ordinato e voglio cercare tutti i "valori" " (non le "chiavi") di questo elenco ordinato per una determinata sottostringa e conta il numero di occorrenze presenti.

Questo è quello che sto cercando di fare:

{
   Sortedlist<string,string> mySortedList;
   // some code that instantiates mySortedList and populates it with data
   List<string> myValues = mySortedList.Values;  // <== does not work
   int namesFound = myValues.FindAll(ByName(someName)).Count;
}

Naturalmente, questo non funziona perché mySortedList.Values ??restituisce un IList, mentre " myValues ??" è un elenco. Ho provato " casting " l'IList in modo che venga accettato da myValues, ma non sembra funzionare.

Ovviamente, posso scorrere su mySortedList.Values ??in un "foreach" loop, ma non voglio davvero farlo.

Qualcuno ha qualche suggerimento?

EDIT-1: Ok, beh, sembra che non ci sia un modo nativo per farlo facilmente. Avevo supposto che mi mancasse qualcosa, ma a quanto pare non lo sono. Quindi immagino che farò solo un "foreach" sopra l'IList.

Grazie per il feedback a tutti! Ho votato tutti su 1 perché pensavo che tutto il feedback fosse buono. Grazie ancora! : -)

EDIT-2: sembra che CMS abbia la risposta che stavo cercando. L'unica avvertenza in questo senso (come sottolineato da Qwertie) è che esiste una potenziale penalità prestazionale poiché comporta la copia di tutti i valori in un altro Elenco e la ricerca dall'inizio alla fine di tale elenco. Quindi, per gli elenchi brevi, questa risposta è efficace. Elenchi più lunghi? bene, spetta a te decidere ...

Answer 1

Dato che Interfaccia IList implementa IEnumerable , puoi effettivamente ottenere un Elenco < T > di valori usando Elenco < T > Costruttore (IEnumerable) :

List<string> myValues = new List<string>(mySortedList.Values);

Answer 2

Non puoi eseguire il cast della proprietà Values ??su List < string > perché non è un elenco < string > - è un dizionario < TKey, TValue > .ValueCollection.

Ma se utilizzi LinqBridge (per .NET Framework 2.0 con C # 3.0) , questo problema può essere facilmente risolto con LINQ come segue:

SortedList<string, string> m = ...;
int namesFound = m.Values.Where(v => v.Contains("substring")).Count();

(se sei ancora su C # 2.0, puoi usare LINQ dei poveri invece, con un po 'più di lavoro)

Answer 3

Peccato che tu sia in .Net 2.0. Questo è esattamente lo scopo di LINQ. ;)

Non puoi davvero farlo, poiché FindAll () è un membro di List. È possibile creare un nuovo elenco su mySortedList.Values, ma sembra essere uno spreco, poiché un nuovo oggetto e un array sottostante devono essere allocati solo per chiamare una funzione.

Scriverei solo una funzione di utilità in qualche classe per gli elenchi chiamati FindAll () e quindi passerei il tuo IList e delegato.

Answer 4

Hai provato SortedList GetValueList ancora? Questo ti restituirà un IList di valori.

Answer 5

    static void Main(string[] args)
    {
        string someName = "two";
        SortedList<string, string> mySortedList = new SortedList<string,string>()
        {
            {"key1", "This is key one"},
            {"key2", "This is key two"},
            {"key3", "This is key three"},
        };

        int namesFound = mySortedList.Values.Where(i => i.Contains(someName)).Count();
        Console.WriteLine(namesFound);
        Console.ReadKey();
    }

In Framework 2.0, forse puoi farlo:

    static void Main(string[] args)
    {
        string someName = "two";
        SortedList<string, string> mySortedList = new SortedList<string,string>()
        {
            {"key1", "This is key one"},
            {"key2", "This is key two"},
            {"key3", "This is key three"},
        };

        int namesFound = FindAll(mySortedList.Values, someName).Count ;
        Console.WriteLine(namesFound);
        Console.ReadKey();
    }
    public static IList<String> FindAll(IList<String> items, string item)
    {
        List<String> result = new List<string>();
        foreach (String s in items)
        {
            if (s.Contains(item))
            {
                result.Add(s);
            }
        }
        return result;
    }

Ma questo è quello che davvero non volevi fare.