Lambda "no puede ser inferido a partir del uso"

Question

he declarado el diccionario siguiente:

private readonly Dictionary<int, Image> dictionary; 

Y tengo un método, que está causando un error de compilación:

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

El error que consigo 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 intentado googlear alrededor, me parece que no puede encontrar nada definitivo en cuanto a lo que estoy haciendo mal

Editar - Esto es el lunes por la mañana en el trabajo.

que significaba poner "donde", no solo

Editar 2!

Ok, el código es ahora esto:

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 es decir:

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

¡Esto se ha complicado más de lo debido!

Answer 1

¿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, probablemente debería estar utilizando IEnumerable<T> de todos modos) ...

Se siente como que quieren:

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:

(edición incluye Where de edición de preguntas)

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 a hacerlo por sí mismos, aunque)

Answer 2

IDictionary<TKey, TValue> implementa IEnumerable<KeyValuePair<TKey,TValue>>, por lo que su Func debe verse más como Func<KeyValuePair<TKey,TValue>>.

Answer 3

An explicit conversion exists (are you missing a cast?)

Hay dos métodos, uno Where en System.Linq.Enumerable (que se está utilizando), y uno en System.Linq.Queryable (que crees que debería estar usando, de acuerdo con ese tipo de devolución).

que tiene que hacer uno de los siguientes:

• el cambio del tipo de retorno a IEnumerable<Image> - recomiendo esto!
• cambio de la llamada al método de Queryable.Where(dictionary.Values.AsQueryable(), exp)
• llamada AsQueryable()