这可以通过单个LINQ查询实现吗？

Question

Suppose I have a given object of type IEnumerable<string> which is the return value of method SomeMethod() , and which contains no repeated elements. I would like to be able to "zip" the following lines in a single LINQ query:

IEnumerable<string> someList = SomeMethod();

if (someList.Contains(givenString))
{
    return (someList.Where(givenString));
}
else
{
    return (someList);
}

Edit: I mistakenly used Single instead of First . Corrected now.

I know I can "zip" this by using the ternary operator, but that's just not the point. I would just list to be able to achieve this with a single line. Is that possible?

Answer 1

这将返回具有给定字符串的项目或所有项目（如果列表中不存在）：

someList.Where(i => i == givenString || !someList.Contains(givenString))

Answer 2

What is wrong with the ternary operator?

someList.Any(s => s == givenString) ? someList.Where(s => s == givenString) : someList;

It would be better to do the Where followed by the Any but I can't think of how to one-line that.

var reducedEnumerable = someList.Where(s => s == givenString);

return reducedEnumerable.Any() ? reducedEnumerable : someList;

Answer 3

The nature of your desired output requires that you either make two requests for the data, like you are now, or buffer the non-matches to return if no matches are found. The later would be especially useful in cases where actually getting the data is a relatively expensive call (eg: database query or WCF service). The buffering method would look like this:

static IEnumerable<T> AllIfNone<T>(this IEnumerable<T> source, 
                                   Func<T, bool> predicate)
{
    //argument checking ignored for sample purposes
    var buffer = new List<T>();
    bool foundFirst = false;
    foreach (var item in source)
    {
        if (predicate(item))
        {
            foundFirst = true;
            yield return item;
        }
        else if (!foundFirst)
        {
            buffer.Add(item);
        }
    }

    if (!foundFirst)
    {
        foreach (var item in buffer)
        {
            yield return item;
        }
    }
}

The laziness of this method is either that of Where or ToList depending on if the collection contains a match or not. If it does, you should get execution similar to Where . If not, you will get roughly the execution of calling ToList (with the overhead of all the failed filter checks) and iterating the result.

Answer 4

It is not possible to change the return type on the method, which is what you're asking. The first condition returns a string and the second condition returns a collection of strings.

Just return the IEnumerable<string> collection, and call Single on the return value like this:

string test = ReturnCollectionOfStrings().Single(x => x == "test");