Linq to SQL如何做“（值列表中）[列]的位置”

我有一个获取ID列表的函数，我需要返回一个与ID关联的描述匹配的列表。例如：

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
}

因此，如果我自己为此创建sql，则只需执行以下操作（其中in子句包含codeIds参数中的所有值）：

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

在Linq to Sql中，我似乎找不到等效的“ IN”子句。到目前为止，我发现最好的（不起作用）是：

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

问题是，我无法为linq to sql动态生成“ OR”子句的列表，因为它们是在编译时设置的。

如何使用Linq to Sql完成在动态值列表中检查列的where子句？

用

where list.Contains(item.Property)

或您的情况：

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

但是您也可以用点表示法来做到这一点：

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

您还可以使用：

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;

我一直在使用Jon Skeet的答案中的方法，但是使用出现了另一个方法Concat。Concat在有限的测试中，该方法的性能稍好一些，但这很麻烦，我可能会坚持使用Contains，或者我会写一个辅助方法来帮助我。无论哪种方式，如果有人感兴趣，这是另一个选择：

方法

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

性能测试

这不是遥不可及的科学。我想您的数据库结构和列表中涉及的ID数量将产生重大影响。

我设置了一个试验，其中我做的每100次试验Concat和Contains其中，每个试验包括选择由主键的随机化列表中指定的25行。我已经运行了大约12次，大多数情况下该Concat方法的速度提高了5-10％，尽管该Contains方法仅次于smidgen赢得了。

 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的方法

        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基本上接近O（1），因此您的复杂度仍然为O（n）。