Como faço para executar uma FindAll () em um IList ? (por ex.) SortedList.Values

Question

Eu estou trabalhando em um problema em C # 2.0 / .NET 2.0 onde eu tenho um SortedList e pretende procurar todos os "valores" (não as "chaves") deste SortedList para um determinado substring e contar quantas ocorrências existem.

Este é o que estou tentando fazer:

{
   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, isso não funciona porque mySortedList.Values ??retorna um IList, enquanto "MyValues" é uma lista. Eu tentei "lançar" o IList para que ele seria aceito por MyValues, mas não parece trabalho.

É claro, posso loop sobre mySortedList.Values ??em um loop "foreach", mas eu realmente não quero fazer isso.

Alguém tem alguma sugestão?

EDIT-1: Ok, bem, parece que não há uma maneira nativa para fazer isso facilmente. Eu tinha assumido que eu só estava faltando alguma coisa, mas aparentemente eu não sou. Então eu acho que estou indo só para fazer um "foreach" sobre o IList.

Obrigado pelo feedback todos! Votei todos até 1 porque eu pensei que todo o feedback foi bom. Obrigado novamente! : -)

EDIT-2: Parece que CMS tem a resposta que eu estava procurando. A única ressalva com isso (como Qwertie apontado) é que há uma penalidade potencial de desempenho, uma vez que envolve a cópia de todos os valores para outra lista e, em seguida, pesquisar essa lista acabamento do início ao. Assim, para listas curtas, esta resposta é eficaz. listas de mais tempo? bem, isso é até você para decidir ...

Answer 1

Uma vez que a IList interface IEnumerable , você pode realmente ter uma List<T> de valores usando o List<T> (IEnumerable) Constructor :

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

Answer 2

Você não pode lançar a propriedade Valores a List , porque não é um List -., É um Dictionary .ValueCollection

Mas se você usar LINQBridge (para o .NET Framework 2.0 com C # 3.0) , este problema é facilmente resolvido com LINQ o seguinte:

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

(se você ainda está em C # 2.0, você pode usar Pobre-man LINQ de em vez disso, com um pouco mais de trabalho)

Answer 3

Pena que você está em .Net 2.0. Este é exatamente o LINQ é para. ;)

Você não pode realmente fazer isso, já que FindAll () é um membro da lista. Você poderia criar uma nova lista sobre os mySortedList.Values, mas parece ser um desperdício, uma vez que um novo objeto e necessidades de matriz subjacentes a ser alocado apenas para chamar uma função.

Eu tinha acabado de escrever uma função de utilidade em alguma classe para listas de chamada FindAll () e, em seguida, passar o seu IList e delegado.

Answer 4

Você já tentou de SortedList GetValueList ainda? Isso vai lhe dar de volta um IList de valores.

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();
    }

Em Framework 2.0, talvez pode fazer isso:

    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;
    }

Mas isso é o que você realmente não quer fazer.