Use First when you know that there is one or more items in the collection. Use Single when you know that there is exactly one item in the collection. If you don't know those things, then don't use those methods. Use methods that do something else, like FirstOrDefault(), SingleOrDefault() and so on.
You could, for example, say:
int? first = sequence.Any() ? (int?) sequence.First() : (int?) null;
which is far less gross than
int? first = null;
try { first = sequence.First(); } catch { }
But still not great because it iterates the first item of the sequence twice. In this case I would say if there aren't sequence operators that do what you want then write your own.
Continuing with our example, suppose you have a sequence of integers and want to get the first item, or, if there isn't one, return null. There isn't a built-in sequence operator that does that, but it's easy to write it:
public static int? FirstOrNull(this IEnumerable<int> sequence)
{
foreach(int item in sequence)
return item;
return null;
}
or even better:
public static T? FirstOrNull<T>(this IEnumerable<T> sequence) where T : struct
{
foreach(T item in sequence)
return item;
return null;
}
or this:
struct Maybe<T>
{
public T Item { get; private set; }
public bool Valid { get; private set; }
public Maybe(T item) : this()
{ this.Item = item; this.Valid = true; }
}
public static Maybe<T> MyFirst<T>(this IEnumerable<T> sequence)
{
foreach(T item in sequence)
return new Maybe(item);
return default(Maybe<T>);
}
...
var first = sequence.MyFirst();
if (first.Valid) Console.WriteLine(first.Item);
But whatever you do, do not handle those exceptions you mentioned. Those exceptions are not meant to be handled, they are meant to tell you that you have bugs in your code. You shouldn't be handling them, you should be fixing the bugs. Putting try-catches around them is hiding bugs, not fixing bugs.
UPDATE:
Dave asks how to make a FirstOrNull that takes a predicate. Easy enough. You could do it like this:
public static T? FirstOrNull<T>(this IEnumerable<T> sequence, Func<T, bool> predicate) where T : struct
{
foreach(T item in sequence)
if (predicate(item)) return item;
return null;
}
Or like this
public static T? FirstOrNull<T>(this IEnumerable<T> sequence, Func<T, bool> predicate) where T : struct
{
foreach(T item in sequence.Where(predicate))
return item;
return null;
}
Or, don't even bother:
var first = sequence.Where(x=>whatever).FirstOrNull();
No reason why the predicate has to go on FirstOrNull. We provide a First() that takes a predicate as a convenience so that you don't have to type the extra "Where".
UPDATE: Dave asks another follow-up question which I think might be "what if I want to say sequence.FirstOrNull().Frob().Blah().Whatever() but any one of those along the line could return null?"
We have considered adding a null-propagating member-access operator to C#, tentatively notated as .? -- that is, you could say
x = a.?b.?c.?d;
and if a, b, or c returned null, then the result would be to assign null to x.
Obviously we did not actually implement it for C# 4. It is a possible work item for hypothetical future versions of the language, but not very high priority, so I wouldn't get my hopes up.
(Remember, all of Eric's musings about hypothetical features of unannounced products that do not exist and might never ship and maybe don't even have anyone working on them at all are for entertainment purposes only.)
Note that C# does have a null coalescing operator:
(sequence.FirstOrNull() ?? GetDefault()).Frob().Blah().Whatever()
means "If FirstOrNull returns non-null use it as the receiver of Frob, otherwise call GetDefault and use that as the receiver". An alternative approach would be to again, write your own:
public static T FirstOrLazy<T>(this IEnumerable<T> sequence, Func<T> lazy)
{
foreach(T item in sequence)
return item;
return lazy();
}
sequence.FirstOrLazy(()=>GetDefault()).Frob().Blah().Whatever();
Now you get the first item if there is one, or the result of a call to GetDefault() if there is not.