Cómo comprobar null tupla c # 7 en consulta LINQ?

Solo para agregar una alternativa más para tratar con los tipos de valor y FirstOrDefault: use Where y lance el resultado al tipo nullable:

var result = Map.Where(w => w.a == 4 && w.b == 4)
   .Cast<(int a, int b, int c)?>().FirstOrDefault();

if (result == null)
   Console.WriteLine("Not found");
else
   Console.WriteLine("Found");

Incluso puede hacer un método de extensión de la misma:

public static class Extensions {
    public static T? StructFirstOrDefault<T>(this IEnumerable<T> items, Func<T, bool> predicate) where T : struct {
        return items.Where(predicate).Cast<T?>().FirstOrDefault();
    }
}

Entonces tu código original se compilará (suponiendo que reemplaces FirstOrDefault con StructFirstOrDefault).

Como lo escribió Panagiotis, no puedes hacerlo directamente... Usted podría "engañar" un poco:

var result = Map.Where(w => w.a == 4 && w.b == 4).Take(1).ToArray();

if (result.Length == 0)
    Console.WriteLine("Not found");
else
    Console.WriteLine("Found");

Se toma un elemento con el Where y se pone el resultado en una matriz de longitud 0-1.

Alternativamente puedes repetir la comparación:

var result = Map.FirstOrDefault(w => w.a == 4 && w.b == 4);

if (result.a == 4 && result.b == 4)
    Console.WriteLine("Not found");

Esta segunda opción no funcionará si estabas buscando

var result = Map.FirstOrDefault(w => w.a == 0 && w.b == 0);

En este caso el valor" predeterminado " devuelto por FirstOrDefault() ha a == 0 y b == 0.

O simplemente podría crear un "especial" FirstOrDefault() que tiene un out bool success (como los varios TryParse):

static class EnumerableEx
{
    public static T FirstOrDefault<T>(this IEnumerable<T> source, Func<T, bool> predicate, out bool success)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }

        if (predicate == null)
        {
            throw new ArgumentNullException(nameof(predicate));
        }

        foreach (T ele in source)
        {
            if (predicate(ele))
            {
                success = true;
                return ele;
            }
        }

        success = false;
        return default(T);
    }
}

Úsalo como:

bool success;
var result = Map.FirstOrDefault(w => w.a == 4 && w.b == 4, out success);

Otro posible método de extensión, ToNullable<>()

static class EnumerableEx
{
    public static IEnumerable<T?> ToNullable<T>(this IEnumerable<T> source) where T : struct
    {
        return source.Cast<T?>();
    }
}

Úsalo como:

var result = Map.Where(w => w.a == 4 && w.b == 4).ToNullable().FirstOrDefault();

if (result == null)

Tenga en cuenta que result es un T?, por lo que tendrá que hacer result.Value para usar su valor.

Si está seguro de que su conjunto de datos no incluirá (0, 0, 0), entonces como otros han dicho, puede verificar el valor predeterminado:

if (result.Equals(default(ValueTuple<int,int,int>))) ...

Si ese valor puede ocurrir, entonces puedes usar First y atrapar la excepción cuando no hay coincidencia:

class Program
{
    private static readonly List<(int a, int b, int c)> Map = 
        new List<(int a, int b, int c)>()
    {
        (1, 1, 2),
        (1, 2, 3),
        (2, 2, 4),
        (0, 0, 0)
    };

    static void Main(string[] args)
    {
        try
        {
            Map.First(w => w.a == 0 && w.b == 0);
            Console.WriteLine("Found");
        }
        catch (InvalidOperationException)
        {
            Console.WriteLine("Not found");
        }
    }
}

Alternativamente, puede usar una biblioteca, como mi propia biblioteca Succinc que proporciona un método TryFirst que devuelve un tipo "tal vez" de none si no coincide, o el elemento si coincide:

class Program
{
    private static readonly List<(int a, int b, int c)> Map = 
        new List<(int a, int b, int c)>()
    {
        (1, 1, 2),
        (1, 2, 3),
        (2, 2, 4),
        (0, 0, 0)
    };

    static void Main(string[] args)
    {
        var result = Map.TryFirst(w => w.a == 0 && w.b == 0);
        Console.WriteLine(result.HasValue ? "Found" : "Not found");
    }
}

Su cheque podría ser el siguiente:

if (!Map.Any(w => w.a == 4 && w.b == 4))
{
    Console.WriteLine("Not found");
}
else
{
    var result = Map.First(w => w.a == 4 && w.b == 4);
    Console.WriteLine("Found");
}

ValueTuple es el tipo subyacente utilizado para las tuplas de C#7. No pueden ser null ya que son tipos de valor. Sin embargo, puede probarlos por defecto, pero en realidad podría ser un valor válido.

Además, el operador de igualdad no está definido en ValueTuple, por lo que debe usar Equals(...).

static void Main(string[] args)
{
    var result = Map.FirstOrDefault(w => w.Item1 == 4 && w.Item2 == 4);

    if (result.Equals(default(ValueTuple<int, int, int>)))
        Console.WriteLine("Not found");
    else
        Console.WriteLine("Found");
}

La mayoría de las respuestas anteriores implican que el elemento resultante no puede ser predeterminado(T), donde T es su clase/tupla.

Una forma sencilla de evitar esto es usar un enfoque como el siguiente:

var result = Map
   .Select(t => (t, IsResult:true))
   .FirstOrDefault(w => w.t.Item1 == 4 && w.t.Item2 == 4);

Console.WriteLine(result.IsResult ? "Found" : "Not found");

Este ejemplo usa nombres de tupla implícitos en C# 7.1 (y paquete ValueTuple para C# 7), pero puede dar el nombre a sus elementos de tupla explícitamente si es necesario, o usar un simple Tuple<T1,T2> en su lugar.