¿Cómo realizo un FindAll () en un IList < T > ;? (por ejemplo, SortedList.Values)

Question

Estoy trabajando en un problema en C # 2.0 / .NET 2.0 donde tengo una lista ordenada y quiero buscar todos los valores " " (no las " claves ") de esta SortedList para una determinada subcadena y cuente cuántas ocurrencias hay.

Esto es lo que estoy tratando de hacer:

{
   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, esto no funciona porque mySortedList.Values ??devuelve un IList, mientras que " myValues ??" es una lista. He intentado " casting " el IList para que sea aceptado por myValues, pero no parece funcionar.

Por supuesto, puedo pasar por mySortedList.Values ??en un " foreach " bucle, pero realmente no quiero hacer esto.

¿Alguien tiene alguna sugerencia?

EDIT-1: Ok, bueno, parece que no hay una forma nativa de hacer esto fácilmente. Yo había asumido que solo me estaba perdiendo algo, pero aparentemente no. Así que supongo que solo voy a hacer un " foreach " sobre el IList.

Gracias por la retroalimentación a todos! Voté a todos arriba 1 porque pensé que todos los comentarios eran buenos. ¡Gracias de nuevo! :-)

EDIT-2: Parece que CMS tiene la respuesta que estaba buscando. La única advertencia con esto (como lo señaló Qwertie) es que existe una posible penalización en el rendimiento, ya que implica copiar todos los valores a otra Lista y luego buscar esa lista de principio a fin. Así que para listas cortas, esta respuesta es efectiva. Listas más largas? Bueno, eso depende de ti decidir ...

Answer 1

Desde Interfaz IList implementa IEnumerable , realmente puede obtener un Lista < T > de valores utilizando List < T > (IEnumerable) Constructor :

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

Answer 2

No puede convertir la propiedad Valores en Lista < cadena > porque no es una Lista < cadena > es un Diccionario < TKey, TValue > .ValueCollection.

Pero si usa LinqBridge (para .NET Framework 2.0 con C # 3.0) , este problema se resuelve fácilmente con LINQ de la siguiente manera:

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

(si aún está en C # 2.0, puede usar LINQ de los hombres pobres en cambio, con un poco más de trabajo)

Answer 3

Lástima que estés en .Net 2.0. Esto es exactamente para lo que es LINQ. ;)

Realmente no puedes hacer esto, ya que FindAll () es miembro de List. Podría crear una nueva Lista en mySortedList.Values, pero parece ser un desperdicio, ya que un nuevo objeto y una matriz subyacente deben asignarse solo para llamar a una función.

Acabaría de escribir una función de utilidad en alguna clase para listas llamadas FindAll () y luego pasar su IList y su delegado.

Answer 4

¿Ha probado SortedList 's GetValueList todavía? Esto le devolverá un 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();
    }

En Framework 2.0, quizás puedas hacer esto:

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

Pero eso es lo que realmente no querías hacer.