Linq to SQL come fare "dove [colonna] in (elenco di valori)"

Ho una funzione in cui ottengo un elenco di ID e devo restituire un elenco corrispondente a una descrizione associata all'ID. Per esempio:

public class CodeData
{
    string CodeId {get; set;}
    string Description {get; set;}
}

public List<CodeData> GetCodeDescriptionList(List<string> codeIDs)
    //Given the list of institution codes, return a list of CodeData
    //having the given CodeIds
}

Quindi, se stessi creando lo sql per questo, farei semplicemente qualcosa di simile al seguente (dove la clausola in contiene tutti i valori nell'argomento codeIds):

Select CodeId, Description FROM CodeTable WHERE CodeId IN ('1a','2b','3')

In Linq a Sql non riesco a trovare l'equivalente della clausola "IN". Il migliore che ho trovato finora (che non funziona) è:

 var foo = from codeData in channel.AsQueryable<CodeData>()
           where codeData.CodeId == "1" || codeData.CodeId == "2"
           select codeData;

Il problema è che non posso generare dinamicamente un elenco di clausole "OR" da linq a sql, perché sono impostate in fase di compilazione.

Come si realizza una clausola where che controlla che una colonna sia in un elenco dinamico di valori utilizzando Linq to Sql?

Uso

where list.Contains(item.Property)

O nel tuo caso:

var foo = from codeData in channel.AsQueryable<CodeData>()
          where codeIDs.Contains(codeData.CodeId)
          select codeData;

Ma potresti anche farlo in notazione punto:

var foo = channel.AsQueryable<CodeData>()
                 .Where(codeData => codeIDs.Contains(codeData.CodeId));

Potresti anche usare:

List<int> codes = new List<int>();

codes.add(1);
codes.add(2);

var foo = from codeData in channel.AsQueryable<CodeData>()
          where codes.Any(code => codeData.CodeID.Equals(code))
          select codeData;

Avevo usato il metodo nella risposta di Jon Skeet, ma un altro mi è venuto in mente usando Concat. Il Concatmetodo ha funzionato leggermente meglio in un test limitato, ma è una seccatura e probabilmente continuerò a seguirlo Contains, o forse scriverò un metodo di supporto per farlo per me. Ad ogni modo, ecco un'altra opzione se qualcuno è interessato:

Il metodo

// Given an array of id's
var ids = new Guid[] { ... };

// and a DataContext
var dc = new MyDataContext();

// start the queryable
var query = (
    from thing in dc.Things
    where thing.Id == ids[ 0 ]
    select thing 
);

// then, for each other id
for( var i = 1; i < ids.Count(); i++ ) {
    // select that thing and concat to queryable
    query.Concat(
        from thing in dc.Things
        where thing.Id == ids[ i ]
        select thing
    );
}

Test della prestazione

Questo non era neanche lontanamente scientifico. Immagino che la struttura del database e il numero di ID coinvolti nell'elenco avrebbero un impatto significativo.

Ho impostato un test in cui ho eseguito 100 prove ciascuna Concate in Containscui ciascuna prova prevedeva la selezione di 25 righe specificate da un elenco casuale di chiavi primarie. L'ho eseguito circa una dozzina di volte e la maggior parte delle volte il Concatmetodo risulta più veloce del 5-10%, anche se una volta il Containsmetodo ha vinto solo per un po '.

 var filterTransNos = (from so in db.SalesOrderDetails
                    where  ItemDescription.Contains(ItemDescription)
                            select new { so.TransNo }).AsEnumerable();    


listreceipt = listreceipt.Where(p => filterTransNos.Any(p2 => p2.TransNo == p.TransNo)).ToList();

Ecco come lo faccio usando HashSet

        HashSet<String> hs = new HashSet<string>(new String[] { "Pluto", "Earth", "Neptune" });
        String[] arr =
        {
            "Pluto",
            "Earth",
            "Neptune",
            "Jupiter",
            "Saturn",
            "Mercury",
            "Pluto",
            "Earth",
            "Neptune",
            "Jupiter",
            "Saturn",
            "Mercury",
            // etc.
        };
        ICollection<String> coll = arr;

        String[] arrStrFiltered = coll.Where(str => hs.Contains(str)).ToArray();

HashSet è fondamentalmente quasi O (1) quindi la tua complessità rimane O (n).