FirstOrDefault: valor predeterminado que no sea nulo

Según tengo entendido, en Linq el método FirstOrDefault()puede devolver un Defaultvalor de algo distinto de nulo. Lo que no he resuelto es qué tipo de cosas que no sean nulas pueden ser devueltas por este método (y similar) cuando no hay elementos en el resultado de la consulta. ¿Hay alguna forma particular de que esto se pueda configurar para que, si no hay un valor para una consulta en particular, se devuelva algún valor predefinido como valor predeterminado?

Caso general, no solo para los tipos de valor:

static class ExtensionsThatWillAppearOnEverything
{
    public static T IfDefaultGiveMe<T>(this T value, T alternate)
    {
        if (value.Equals(default(T))) return alternate;
        return value;
    }
}

var result = query.FirstOrDefault().IfDefaultGiveMe(otherDefaultValue);

De nuevo, esto no se puede decir si hay era algo en su secuencia, o si el primer valor es el valor predeterminado.

Si te importa esto, podrías hacer algo como

static class ExtensionsThatWillAppearOnIEnumerables
{
    public static T FirstOr<T>(this IEnumerable<T> source, T alternate)
    {
        foreach(T t in source)
            return t;
        return alternate;
    }
}

y usar como

var result = query.FirstOr(otherDefaultValue);

aunque, como señala el Sr. Steak, esto podría hacerse igual de bien .DefaultIfEmpty(...).First().

Según tengo entendido, en Linq el método FirstOrDefault () puede devolver un valor predeterminado de algo que no sea nulo.

No. O, más bien, siempre devuelve el valor predeterminado para el tipo de elemento ... que es una referencia nula, el valor nulo de un tipo de valor anulable o el valor natural "todos ceros" para un tipo de valor no anulable.

¿Hay alguna forma particular de que esto se pueda configurar para que, si no hay un valor para una consulta en particular, se devuelva algún valor predefinido como valor predeterminado?

Para los tipos de referencia, solo puede usar:

var result = query.FirstOrDefault() ?? otherDefaultValue;

Por supuesto, esto también le dará el "otro valor predeterminado" si el primer valor está presente, pero es una referencia nula ...

Puede usar DefaultIfEmpty seguido de Primero :

T customDefault = ...;
IEnumerable<T> mySequence = ...;
mySequence.DefaultIfEmpty(customDefault).First();

De la documentación para FirstOrDefault

[Devuelve] predeterminado (TSource) si la fuente está vacía;

De la documentación por defecto (T) :

la palabra clave predeterminada, que devolverá nulo para los tipos de referencia y cero para los tipos de valor numérico. Para las estructuras, devolverá cada miembro de la estructura inicializado a cero o nulo, dependiendo de si son tipos de valor o de referencia. Para los tipos de valores anulables, default devuelve un System.Nullable, que se inicializa como cualquier estructura.

Por lo tanto, el valor predeterminado puede ser nulo o 0 dependiendo de si el tipo es una referencia o un tipo de valor, pero no puede controlar el comportamiento predeterminado.

Copiado del comentario de @sloth

En lugar de YourCollection.FirstOrDefault(), podría usar, YourCollection.DefaultIfEmpty(YourDefault).First()por ejemplo.

Ejemplo:

var viewModel = new CustomerDetailsViewModel
    {
            MainResidenceAddressSection = (MainResidenceAddressSection)addresses.DefaultIfEmpty(new MainResidenceAddressSection()).FirstOrDefault( o => o is MainResidenceAddressSection),
            RiskAddressSection = addresses.DefaultIfEmpty(new RiskAddressSection()).FirstOrDefault(o => !(o is MainResidenceAddressSection)),
    };

También puedes hacer esto

    Band[] objects = { new Band { Name = "Iron Maiden" } };
    first = objects.Where(o => o.Name == "Slayer")
        .DefaultIfEmpty(new Band { Name = "Black Sabbath" })
        .FirstOrDefault();   // returns "Black Sabbath" 

Esto usa solo linq - yipee!

En realidad, uso dos enfoques para evitar NullReferenceExceptioncuando estoy trabajando con colecciones:

public class Foo
{
    public string Bar{get; set;}
}
void Main()
{
    var list = new List<Foo>();
    //before C# 6.0
    string barCSharp5 = list.DefaultIfEmpty(new Foo()).FirstOrDefault().Bar;
    //C# 6.0 or later
    var barCSharp6 = list.FirstOrDefault()?.Bar;
}

Para C # 6.0 o posterior:

Use ?.o ?[para probar si es nulo antes de realizar un acceso de miembro Documentación de operadores condicional nulo

Ejemplo: var barCSharp6 = list.FirstOrDefault()?.Bar;

C # versión anterior:

Úselo DefaultIfEmpty()para recuperar un valor predeterminado si la secuencia está vacía. Documentación de MSDN

Ejemplo: string barCSharp5 = list.DefaultIfEmpty(new Foo()).FirstOrDefault().Bar;

En lugar de YourCollection.FirstOrDefault(), podría usar, YourCollection.DefaultIfEmpty(YourDefault).First()por ejemplo.

Acabo de tener una situación similar y estaba buscando una solución que me permitiera devolver un valor predeterminado alternativo sin ocuparme de él cada vez que lo necesito. Lo que solemos hacer en caso de que Linq no admita lo que queremos es escribir una nueva extensión que se encargue de ello. Eso fue lo que hice. Esto es lo que se me ocurrió (aunque no probado):

public static class EnumerableExtensions
{
    public static T FirstOrDefault<T>(this IEnumerable<T> items, T defaultValue)
    {
        foreach (var item in items)
        {
            return item;
        }
        return defaultValue;
    }

    public static T FirstOrDefault<T>(this IEnumerable<T> items, Func<T, bool> predicate, T defaultValue)
    {
        return items.Where(predicate).FirstOrDefault(defaultValue);
    }

    public static T LastOrDefault<T>(this IEnumerable<T> items, T defaultValue)
    {
        return items.Reverse().FirstOrDefault(defaultValue);
    }

    public static T LastOrDefault<T>(this IEnumerable<T> items, Func<T, bool> predicate, T defaultValue)
    {
        return items.Where(predicate).LastOrDefault(defaultValue);
    }
}

Sé que ha pasado un tiempo, pero agregaré a esto, basado en la respuesta más popular, pero con una pequeña extensión, me gustaría compartir lo siguiente:

static class ExtensionsThatWillAppearOnIEnumerables
{
    public static T FirstOr<T>(this IEnumerable<T> source, Func<T, bool> predicate, Func<T> alternate)
    {
        var thing = source.FirstOrDefault(predicate);
        if (thing != null)
            return thing;
        return alternate();
    }
}

Esto me permite llamarlo en línea como tal con mi propio ejemplo con el que estaba teniendo problemas:

_controlDataResolvers.FirstOr(x => x.AppliesTo(item.Key), () => newDefaultResolver()).GetDataAsync(conn, item.ToList())

Entonces, para mí, solo quería que un resolutor predeterminado se usara en línea, puedo hacer mi verificación habitual y luego pasar una función para que no se instancia una clase, incluso si no se usa, ¡es una función para ejecutar cuando sea necesario!

Usar en DefaultIfEmpty()lugar de FirstOrDefault().