In che modo linq esegue effettivamente il codice per recuperare i dati dall'origine dati?

Question

Inizierò a lavorare su xamarin a breve e trasferirò molto codice dal java di android studio a C#.

in Java Sto usando un classi personalizzate che sono dati argomenti condizioni ecc, convertirli in istruzioni SQL e quindi carica i risultati agli oggetti nel modello del progetto

Quello di cui sono sicuro di è LINQ castrato è un migliore opzione per filtrare tali dati.

Per esempio cosa sarebbe successo al momento è somethng lungo queste linee

List<Customer> customers = (new CustomerDAO()).get_all() 

O se ho una condizione di

List<Customer> customers = (new CustomerDAO()).get(new Condition(CustomerDAO.Code, equals, "code1") 

Ora supponiamo Ho trasferito le classi di C# e desidero fare qualcosa simile al secondo caso.

Così ho probabilmente scrivere qualcosa sulla falsariga di:

var customers = from customer 
    in (new CustomerDAO()).get_all() 
    where customer.code.equals("code1") 
    select customer 

So che la query viene eseguita solo quando in realtà cerco di clienti di accesso, ma se devo accessi multipli ai clienti (Proviamo Dite che in seguito userò 4 foreach loop in seguito) il metodo get_all sarà chiamato 4 volte? o i risultati sono memorizzati alla prima esecuzione?

Inoltre è più efficiente (in termini di tempo perché la memoria probabilmente non lo è) solo per mantenere il metodo get_all() e usare linq per filtrare i risultati? O utilizzare la mia configurazione esistente che esegue in effetti

Select * from Customers where code = 'code1' 

E carica i risultati su un oggetto?

Grazie in anticipo per qualsiasi aiuto che potete fornire

Edit: sì io so che c'è sqlite.net che fa più o meno quello che i miei Tao fanno, ma probabilmente meglio, e ad un certo punto ho probabilmente convertire tutto il mio oggetti da utilizzare, ho solo bisogno di sapere per il bene di conoscere

Answer 1

se ho più accessi ai clienti (per non noi diciamo che io uso 4 foreach loop in seguito) sarà il metodo get_all essere chiamato 4 volte? o i risultati sono memorizzati alla prima esecuzione?

Ogni volta che si enumera l'enumeratore (utilizzando foreach nel tuo esempio), la query si ri-esecuzione, a meno che non si memorizza il risultato materializzato da qualche parte. Ad esempio, se sulla prima query faresti:

var customerSource = new CustomerDAO(); 
List<Customer> customerSource.Where(customer => customer.Code.Equals("code1")).ToList(); 

Quindi ora lavorerete con un in-memory List<Customer> senza eseguire la query più volte.

Al contrario, se ogni volta che si farebbe:

var filteredCustomers = customerSource.Where(customer => customer.Code.Equals("code1")) 
foreach (var customer in filteredCustomers) 
{ 
    // Do stuff 
} 

Poi per ogni enumerazione ti verrà exeucting detta interrogazione da capo.

è anche più efficiente (tempo saggio perché la memoria saggio è probabilmente non) per mantenere solo il get_all() e utilizzare LINQ per filtrare i risultati? Oppure usa la mia configurazione esistente che esegue in effetti

Questo dipende molto dal tuo caso d'uso. Immagina che tu stia usando LINQ su EF, e la tabella dei clienti ha un milione di righe, vuoi davvero portarle tutte in memoria e solo dopo filtrarle per usare un sottoinsieme di dati? Di solito sarebbe meglio una query filtrata completa.