transact - linq to sql vs entity framework

Linq a SQL cómo hacer "donde[columna] en(lista de valores)"

Question

Tengo una función en la que obtengo una lista de identificadores, y debo devolver una lista que coincida con una descripción asociada con el ID. P.ej:

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
}

Entonces, si estuviera creando el sql para esto, simplemente haría algo como lo siguiente (donde la cláusula in contiene todos los valores en el argumento codeIds):

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

En Linq to Sql, parece que no puedo encontrar el equivalente de la cláusula "IN". Lo mejor que he encontrado hasta ahora (que no funciona) es:

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

El problema es que no puedo generar dinámicamente una lista de cláusulas "O" para linq a sql, porque están configuradas en tiempo de compilación.

¿Cómo se logra una cláusula Where que verifica una columna en una lista dinámica de valores usando Linq a Sql?

Answer 1

Había estado usando el método en la respuesta de Jon Skeet, pero se me ocurrió otra usando Concat . El método Concat funcionó un poco mejor en una prueba limitada, pero es una molestia y probablemente solo me quede con Contains , o tal vez escriba un método de ayuda para hacer esto por mí. De cualquier manera, aquí hay otra opción si alguien está interesado:

El método

// 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
    );
}

Prueba de rendimiento

Esto no fue remotamente científico. Me imagino que la estructura de su base de datos y el número de ID que participan en la lista tendría un impacto significativo.

Configuré una prueba en la que hice 100 ensayos, cada uno de Concat y Contains donde cada ensayo incluyó la selección de 25 filas especificadas por una lista aleatoria de claves principales. He corrido esto una docena de veces, y la mayoría de las veces el método Concat sale entre un 5% y un 10% más rápido, aunque una vez el método Contains ganó solo con una pizca.

Answer 2

También puedes usar:

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;

Answer 3

Utilizar

where list.Contains(item.Property)

O en tu caso:

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

Pero también podrías hacer eso en notación de puntos:

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

Answer 4

 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();