What if IEnumerable<string> returns just one string

Question

I'm doing a simple Linq query on an XML file

IEnumerable<string> value = from item in myFile.Descendants("ProductName")
                            select (string)item;

Normally (If I have more than one row) I can iterate using a foreach loop :

foreach (string str in value)
{
    Console.WriteLine(str);
}

But what if I'm sure that I have just one item, And my method signature is :

public string getValue()
{
    return ?;
}

What should I return (If I want to remove the foreach loop) ?

Answer 1

If you are sure that there is always exactly one string, you can return value.Single().

Some more options:

• First()
• FirstOrDefault()
• SingleOrDefault()

It depends if you want to raise an exception if there are more than one element (use Single or SingleOrDefault), or no element at all (use First or Single).

If you always except exactly one element, I would stick with Single(), since it will throw an exception if there are zero or more than one element.

Answer 2

There are Single / SingleOrDefault and First / FirstOrDefault methods that can resolve an enumerable of elements down to one.

The Single method expects only one element and will exception if the result contains zero or more than one elements. Use SingleOrDefault to cope with zero as well as one.

The "First" pair can both handle more than one, but First again throws if there are no elements.

All of these methods come with an overload that allows you to specify conditions, negating the need to use a .Where call.

In your case:

string value = (from item in myFile.Descendants("ProductName")
                select (string)item)
               .SingleOrDefault();

When choosing between Single or First, use Single if you expect one element, use SingleOrDefault if you expect zero or one elements, and use First / FirstOrDefault (along with some sort of OrderBy) if you don't care how many elements are returned.

Also note, these methods use deferred execution, so once First is satisfied it stops iterating.