Come si trasferisce l'esecuzione di un'espressione creata da un oggetto IQueryable su un IEnumerable?

Question

Nel mio codice vorrei rendere IQueryable i miei repository. In questo modo, i criteri per la selezione saranno un albero di espressioni linq.

Ora, se voglio deridere il mio repository in teoria, questo è molto semplice: basta implementare l'interfaccia del mio repository (che è anche un oggetto IQueryable).

L'implementazione del mio finto repository sarebbe solo una raccolta in memoria, ma la mia domanda è: conosci un modo semplice per implementare l'interfaccia IQueryable del mio mock, per trasferire la query nella mia raccolta in memoria (IEnumerable)?

Grazie per la tua risposta,

Qualche precisione

L'oggetto client del mio repository utilizzerà il mio repository in questo modo:

var result = dalla voce in MyRepository dove entry.Product == " SomeProduct " seleziona la voce;

Ciò che ToList o AsEnumerable è eseguire la query e restituire il risultato come Elenco o IEnumerable. Ma devo implementare l'interfaccia IQueryable sul mio repository, con un IQueryProvider che trasforma l'espressione in una chiamata in un oggetto IEnumerable.

Soluzione

L'implementazione della soluzione sta delegando una chiamata a IQueryable alla mia raccolta di memorie con AsQueryable.

public class MockRepository : IQueryable<DomainObject>
    {
        private List<DomainObject> inMemoryList = new List<DomainObject>();

        #region IEnumerable<DomainObject> Members

        public IEnumerator<DomainObject> GetEnumerator()
        {
            return inMemoryList.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return inMemoryList.GetEnumerator();
        }

        #endregion

        #region IQueryable Members

        public Type ElementType
        {
            get
            {
                return inMemoryList.AsQueryable().ElementType;
            }
        }

        public Expression Expression
        {
            get
            {
                return inMemoryList.AsQueryable().Expression;
            }
        }

        public IQueryProvider Provider
        {
            get
            {
                return inMemoryList.AsQueryable().Provider;
            }
        }

        #endregion
    }

Answer 1

Usa AsQueryable sulle tue beffe. Ora sono interrogabili e puoi trattarli come qualsiasi altro interrogabile.

Answer 2

Si può utilizzare il metodo di estensione

.ToList<>