Lambda “no puede ser inferida a partir de el uso de”

Tengo el siguiente diccionario declaró:

private readonly Dictionary<int, Image> dictionary;

Y tengo un método, el cual está causando un error del compilador:

    public IQueryable<Image> Find(Func<Image, bool> exp)
    {
        return  dictionary.Single(exp);
    }

El error que me sale es:

Error   1   The type arguments for method 'System.Linq.Enumerable.Single<TSource>(System.Collections.Generic.IEnumerable<TSource>, System.Func<TSource,bool>)' cannot be inferred from the usage. Try specifying the type arguments explicitly. C:\work\MSD-AIDS-Images\MSD-AIDS-Images-Test\TestImageRepository.cs 34  30  MSD-AIDS-Images-Test

He probado con el google, me parece que no puede encontrar nada definitivo en cuanto a lo que estoy haciendo mal

Editar – Este es lunes por la mañana en el trabajo.

Quise poner “donde”, no solo

Editar 2!

Ok, el código ahora es este:

public IQueryable<Image> Find(Func<Image, bool> exp)
{
    return dictionary.Values.Where(exp);
}

Ahora me sale el siguiente error:

Error   1   Cannot implicitly convert type 'System.Collections.Generic.IEnumerable<MSD_AIDS_Images_Data.Image>' to 'System.Linq.IQueryable<MSD_AIDS_Images_Data.Image>'. An explicit conversion exists (are you missing a cast?)    C:\work\MSD-AIDS-Images\MSD-AIDS-Images-Test\TestImageRepository.cs 34  20  MSD-AIDS-Images-Test

Como un FYI, el método no es para implementar una interfaz, la declaración de que es:

IQueryable<T> Find(Func<T, bool> exp);

Esto se ha vuelto más complicado de lo que debería!

Como ya he dicho – cambiar el tipo de retorno de IEnumerable<Imagen>

OriginalEl autor qui | 2009-02-09

3 respuestas

  1. 7

    ¿Qué es lo que estás tratando de hacer? Por ejemplo, Single devolverá una instancia de T, no un IQueryable<T> (y para los objetos, usted probablemente debería ser el uso de IEnumerable<T> de todos modos)…

    Se siente como usted desee:

    public Image Find(Func<Image, bool> predicate)
    {
        return dictionary.Values.Single(predicate);
    }

    Por supuesto, usted puede hacer esto a nivel mundial como un método de extensión a través de algo como:

    (editar incluye Where de la pregunta edición)

    static class DictionaryExtensions
    {
        public static TValue FindSingle<TKey, TValue>(
            this IDictionary<TKey, TValue> dictionary,
            Func<TValue, bool> predicate)
        {
            return dictionary.Values.Single(predicate);
        }
        public static IEnumerable<TValue> Find<TKey, TValue>(
            this IDictionary<TKey, TValue> dictionary,
            Func<TValue, bool> predicate)
        {
            return dictionary.Values.Where(predicate);
        }
    }

    (No estoy seguro de que es mucho más difícil para la persona que llama para hacer esto por sí mismos, aunque)

    El .los valores de bits es lo que yo necesitaba realmente, para obtener la respuesta. He editado mi pregunta para aclarar lo que yo iba para
    Tenga en cuenta que con el lugar Donde te gustaría volver típicamente IEnumerable<Imagen> etc – me alegro de que tengo ordenados, aunque ;-p
    En realidad, no se ordenan! Más por venir…

    OriginalEl autor

  2. 3

    Una conversión explícita existe (¿falta una pieza?)

    Hay dos Where métodos, uno en Sistema.Linq.Enumerable (que se está utilizando), y uno en Sistema.Linq.Consultable (que crees que se debe utilizar, de acuerdo a que tipo de retorno).

    Usted necesita para hacer uno de los siguientes:

    • cambiar el tipo de retorno a IEnumerable<Image> – recomiendo este!
    • cambiar la llamada al método Queryable.Where(dictionary.Values.AsQueryable(), exp)
    • llamada AsQueryable()
    De hecho! He cambiado a IEnumerable y que hizo el truco

    OriginalEl autor

  3. 2

    IDictionary<TKey, TValue> implementa IEnumerable<KeyValuePair<TKey,TValue>>, por lo que su Func debería parecerse más a Func<KeyValuePair<TKey,TValue>>.

    OriginalEl autor

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *