¿Cómo puedo devolver NULL de un método genérico en C #?

Tengo un método genérico con este código (ficticio) (sí, sé que IList tiene predicados, pero mi código no está usando IList sino alguna otra colección, de todos modos esto es irrelevante para la pregunta ...)

static T FindThing<T>(IList collection, int id) where T : IThing, new()
{
    foreach T thing in collecion
    {
        if (thing.Id == id)
            return thing;
    }
    return null;  // ERROR: Cannot convert null to type parameter 'T' because it could be a value type. Consider using 'default(T)' instead.
}

Esto me da un error de compilación

"No se puede convertir nulo al parámetro de tipo 'T' porque podría ser un tipo de valor. Considere usar 'default (T)' en su lugar".

¿Puedo evitar este error?

Dos opciones:

• Retorno, lo default(T)que significa que devolverá nullsi T es un tipo de referencia (o un tipo de valor anulable), 0para int, '\0'para char, etc. ( Tabla de valores predeterminados (Referencia de C #) )
• Restrinja T para que sea un tipo de referencia con la where T : classrestricción y luego regrese nullcomo normal

return default(T);

Simplemente puede ajustar sus restricciones:

where T : class

Luego, devolver nulo está permitido.

Agregue la restricción de clase como la primera restricción a su tipo genérico.

static T FindThing<T>(IList collection, int id) where T : class, IThing, new()

1. Si tiene un objeto, entonces necesita escribir

   return (T)(object)(employee);

2. si necesita devolver nulo.

   return default(T);

A continuación se encuentran las dos opciones que puede usar

return default(T);

o

where T : class, IThing
 return null;

Su otra opción sería agregar esto al final de su declaración:

    where T : class
    where T: IList

De esa manera te permitirá volver nulo.

solución de TheSoftwareJedi funciona,

También puede archivarlo usando un par de valores y tipos anulables:

static T? FindThing<T>(IList collection, int id) where T : struct, IThing
{
    foreach T thing in collecion
    {
        if (thing.Id == id)
            return thing;
    }
    return null;
}

Tome la recomendación del error ... y ya sea usuario default(T)o new T.

Tendrás que agregar una comparación en tu código para asegurarte de que sea una coincidencia válida si sigues esa ruta.

De lo contrario, considere potencialmente un parámetro de salida para "coincidencia encontrada".

Aquí hay un ejemplo de trabajo para los valores de retorno de Nullable Enum:

public static TEnum? ParseOptional<TEnum>(this string value) where TEnum : struct
{
    return value == null ? (TEnum?)null : (TEnum) Enum.Parse(typeof(TEnum), value);
}

Otra alternativa a las 2 respuestas presentadas anteriormente. Si cambia su tipo de retorno a object, puede regresar null, al mismo tiempo que emite el retorno no nulo.

static object FindThing<T>(IList collection, int id)
{
    foreach T thing in collecion
    {
        if (thing.Id == id)
            return (T) thing;
    }
    return null;  // allowed now
}

Para completar, es bueno saber que también podrías hacer esto:

return default;

Devuelve lo mismo que return default(T);

Para mí funciona como es. ¿Dónde está exactamente el problema?

public static T FindThing<T>(this IList collection, int id) where T : IThing, new()
{
    foreach (T thing in collection)
    {
        if (thing.Id == id)
            return thing;
        }
    }

    return null; //work
    return (T)null; //work
    return null as T; //work
    return default(T); //work


}