Valor máximo devuelto si consulta vacía

Sé que esta es una pregunta antigua y la respuesta aceptada funciona, pero esta pregunta respondió a mi pregunta sobre si un conjunto vacío de este tipo resultaría en una excepción o un resultado default(int).

La respuesta aceptada, sin embargo, si bien funciona, no es la solución ideal en mi humilde opinión, que no se da aquí. Por lo tanto, lo estoy proporcionando en mi propia respuesta para el beneficio de cualquiera que lo esté buscando.

El código original de la OP era:

int maxShoeSize = Workers.Where(x => x.CompanyId == 8).Max(x => x.ShoeSize);

Así es como lo escribiría para prevenir excepciones y proporcionar un resultado predeterminado:

int maxShoeSize = Workers.Where(x => x.CompanyId == 8).Max(x => x.ShoeSize as int?) ?? 0;

Esto hace que el tipo de retorno de la función Max sea int?, lo que permite el resultado null y luego el ?? reemplaza el resultado null con 0.

EDITAR
Solo para aclarar algo de los comentarios, Entity Framework actualmente no admite la palabra clave as, por lo que la forma de escribirla cuando se trabaja con EF sería:

int maxShoeSize = Workers.Where(x => x.CompanyId == 8).Max<[TypeOfWorkers], int?>(x => x.ShoeSize) ?? 0;

Dado que el [TypeOfWorkers] podría ser un nombre de clase largo y es tedioso para escribir, he añadido un método de extensión para ayudar.

public static int MaxOrDefault<T>(this IQueryable<T> source, Expression<Func<T, int?>> selector, int nullValue = 0)
{
    return source.Max(selector) ?? nullValue;
}

Esto solo maneja int, pero lo mismo podría hacerse para long, double, o cualquier otro tipo de valor que necesite. Usar este método de extensión es muy simple, simplemente pasa tu función de selector y opcionalmente incluye un valor para ser usado para null, que por defecto es 0. Así que lo anterior podría ser reescrito de la siguiente manera:

int maxShoeSize = Workers.Where(x => x.CompanyId == 8).MaxOrDefault(x => x.ShoeSize);

Esperemos que eso ayude a la gente aún más.

Max () no devolverá nada en ese caso.

Levantará InvalidOperationException ya que la fuente no contiene elementos.

int maxShoeSize = Workers.Where(x => x.CompanyId == 8)
                     .Select(x => x.ShoeSize)
                     .DefaultIfEmpty()
                     .Max();

Max lanzará el Sistema.InvalidOperationException "Sequence contains no elements"

class Program
{
    static void Main(string[] args)
    {
        List<MyClass> list = new List<MyClass>();

        list.Add(new MyClass() { Value = 2 });

        IEnumerable<MyClass> iterator = list.Where(x => x.Value == 3); // empty iterator.

        int max = iterator.Max(x => x.Value); // throws System.InvalidOperationException
    }
}

class MyClass
{
    public int Value;
}

int maxShoeSize=Workers.Where(x=>x.CompanyId==8)
    .Max(x=>(int?)x.ShoeSize).GetValueOrDefault();

(suponiendo que ShoeSize es de tipo int)

Si Workers es un DbSet o ObjectSet de Entity Framework, su consulta inicial arrojaría un InvalidOperationException, pero no se quejaría de una secuencia vacía, sino que se quejaría de que el valor materializado NULL no se puede convertir en un int.

NB: la consulta con DefaultIfEmpty()puede ser significativamente más lenta. En mi caso fue una simple consulta con .DefaultIfEmpty(DateTime.Now.Date).

Yo era demasiado perezoso para perfilar. Pero, obviamente, EF intentó obtener todas las filas y luego tomar el valor Max ().

Conclusión: a veces manejar InvalidOperationException podría ser la mejor opción.

Puedes probar esto:

int maxShoeSize = Workers.Where(x=>x.CompanyId == 8).Max(x => x.ShoeSize) ?? 0;

Puede usar un ternario dentro de .Max() para manejar el predicado y establecer su valor;

// assumes Workers != null && Workers.Count() > 0
int maxShoeSize = Workers.Max(x => (x.CompanyId == 8) ? x.ShoeSize : 0);

Tendría que manejar la colección Workers siendo null/empty si esa es una posibilidad, pero dependería de su implementación.

Puedes comprobar si hay algún trabajador antes de hacer el Max().

private int FindMaxShoeSize(IList<MyClass> workers) {
   var workersInCompany = workers.Where(x => x.CompanyId == 8);
   if(!workersInCompany.Any()) { return 0; }
   return workersInCompany.Max(x => x.ShoeSize);
}

Si esto es Linq a SQL, no me gusta usar Any() porque resulta en múltiples consultas a SQL server.

Si ShoeSize no es un campo nullable, entonces usar solo el .Max(..) ?? 0 no funcionará, pero lo siguiente lo hará:

int maxShoeSize = Workers.Where(x = >x.CompanyId == 8).Max(x => (int?)x.ShoeSize) ?? 0;

No cambia absolutamente el SQL emitido, pero devuelve 0 si la secuencia está vacía porque cambia el Max() para devolver un int? en lugar de un int.