What about a SingleOrNew() method instead of SingleOrDefault() in LINQ?

Question

The SingleOrDefault() method is great because it doesn't throw an exception if the collection you're calling it against is empty. However, sometimes what I want is to get a new object of some type if nothing exists. For example it would be great if I could do the following:

var client = db.Clients
    .Where(c => c.Name == "Some Client")
    .SingleOrNew<Client>();

This way I don't have to check if it's null and if it is create a new one, I always know that my client object will be something I can use right away.

Any ideas?

Answer 1

Really, you just want to use the null coalescing operator here. Example:

var client = db.Clients
    .Where(c => c.Name == "Some Client")
    .SingleOrDefault() ?? new Client();

This will return whatever SingleOrDefault returns, except that if SingleOrDefault returns null, the expression returns new Client() instead.

Edit: As John Skeet pointed out, this solution doesn't differentiate between the situation where there is no match and a null element is found, though clearly this is not necessarily a problem in many cases. An alternative is to create an extension method as follows.

public static T SingleOrNew<T>(this IEnumerable<T> query) where T : new()
{
    try
    {
        return query.Single();
    }
    catch (InvalidOperationException)
    {
        return new T();
    }
}

I would say this is probably the most elegant solution that works in the general case.

Answer 2

If all you want to accomplish is to override the default value (and return a new object), you may be able to do so by using the DefaultIfEmpty() Method before calling SingleOrDefault(). Something like:

var client = db.Clients
    .Where(c => c.Name == name)
    .DefaultIfEmpty(new Client { Name = name })
    .SingleOrDefault();

Answer 3

Would this do? EDIT Turns out that ?? won't work with the generic type.

public static class IEnumerableExtensions
{
    public static T SingleOrNew<T>( this IEnumerable<T> query ) where T : new()
    {
        var value = query.SingleOrDefault();
        if (value == null)
        {
            value = new T();
        }
        return value;
    }
}

Answer 4

Sounds like it could be done, yes. Can't say I remember having been in a situation where I'd use it myself, but it's easy enough to implement. Something like this:

public static T SingleOrNew<T>(this IEnumerable<T> source) where T : new()
{
    if (source == null)
    {
        throw new ArgumentNullException("source"); 
    }
    using (IEnumerator<T> iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
            return new T();
        }
        T first = iterator.Current;
        if (iterator.MoveNext())
        {
            throw new InvalidOperationException();
        }
        return first;
    }
}

I'll add it to the list of operators to include in MoreLinq...

Another, more general approach would be to provide a delegate which would only be evaluated if necessary (I need a better name here, admittedly):

public static T SingleOrSpecifiedDefault<T>(this IEnumerable<T> source,
     Func<T> defaultSelector)
{
    if (source == null)
    {
        throw new ArgumentNullException("source"); 
    }
    if (defaultSelector == null)
    {
        throw new ArgumentNullException("defaultSelector"); 
    }
    using (IEnumerator<T> iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
            return defaultSelector();
        }
        T first = iterator.Current;
        if (iterator.MoveNext())
        {
            throw new InvalidOperationException();
        }
        return first;
    }
}

Answer 5

Why don't you add it via an Extension method then? Sounds like it would be handy.