Linq'den SQL'e nasıl yapılır "nerede [sütun] (değerler listesi)" içinde

Kimliklerin bir listesini aldığım bir işlevim var ve id ile ilişkili bir açıklamayla eşleşen bir listeyi döndürmem gerekiyor. Örneğin:

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
}

Dolayısıyla, bunun için sql'yi kendim oluşturuyor olsaydım, aşağıdakine benzer bir şey yapardım (burada in cümlesi, codeIds argümanındaki tüm değerleri içerir):

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

Linq to Sql'de "IN" cümlesinin eşdeğerini bulamıyorum. Şimdiye kadar bulduğum en iyisi (işe yaramıyor):

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

Sorun şu ki, linq to sql için dinamik olarak bir "OR" cümleleri listesi oluşturamıyorum, çünkü bunlar derleme zamanında ayarlanmışlar.

Bir sütunu kontrol eden bir where cümlesinin Linq to Sql kullanarak dinamik bir değerler listesinde olduğunu nasıl başarabiliriz?

Kullanım

where list.Contains(item.Property)

Veya sizin durumunuzda:

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

Ama bunu noktalı gösterimle de yapabilirsiniz:

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

Ayrıca şunları da kullanabilirsiniz:

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;

Yöntemi Jon Skeet'in cevabında kullanıyordum ama kullanırken başka bir tane daha geldi Concat. ConcatYöntem sınırlı bir testtir biraz daha iyi bir performans, ama bir güçlük ve ben muhtemelen sadece sopa ile Contains, ya da belki benim için bunu yapmanın bir yardımcı yöntemini yazacağım. Her iki durumda da, ilgilenen varsa işte başka bir seçenek:

Yöntem

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

Performans testi

Bu uzaktan bilimsel değildi. Veritabanınızın yapısının ve listedeki kimliklerin sayısının önemli bir etkisi olacağını tahmin ediyorum.

Her denemede 100 deneme yaptığım Concatve Containsher denemenin rastgele seçilmiş birincil anahtarlar listesi tarafından belirlenen 25 satırı seçmeyi içerdiği bir test kurdum . Bunu yaklaşık bir düzine kez çalıştırdım ve çoğu zaman Concatyöntem% 5-10 daha hızlı çıkıyor, ancak bir kez Containsyöntem sadece bir smidgen tarafından kazanılıyor.

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

HashSet kullanarak bunu nasıl yapıyorum

        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 temelde neredeyse O (1) 'e yakın olduğundan karmaşıklığınız O (n) olarak kalır.