Como posso retornar NULL de um método genérico em c #?

Eu tenho um método genérico com esse código (fictício) (sim, eu sei que IList tem predicados, mas meu código não está usando IList, mas alguma outra coleção, de qualquer maneira isso é irrelevante para a pergunta ...)

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.
}

Isso me dá um erro de compilação

"Não é possível converter nulo no parâmetro de tipo 'T' porque pode ser um tipo de valor. Considere usar 'padrão (T)'."

Posso evitar esse erro?

Duas opções:

• Return, o default(T)que significa que você retornará nullse T for um tipo de referência (ou um tipo de valor anulável), 0for int, '\0'for char, etc. ( Tabela de valores padrão (Referência de C #) )
• Restrinja T a ser um tipo de referência com a where T : classrestrição e retorne nullnormalmente

return default(T);

Você pode apenas ajustar suas restrições:

where T : class

Então, retornar nulo é permitido.

Adicione a restrição de classe como a primeira restrição ao seu tipo genérico.

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

1. Se você tiver um objeto, precisará digitar

   return (T)(object)(employee);

2. se você precisar retornar nulo.

   return default(T);

Abaixo estão as duas opções que você pode usar

return default(T);

ou

where T : class, IThing
 return null;

Sua outra opção seria adicionar isso ao final da sua declaração:

    where T : class
    where T: IList

Dessa forma, você poderá retornar nulo.

solução de TheSoftwareJedi funciona,

Também é possível arquivá-lo usando alguns tipos de valor e valores nulos:

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;
}

Siga a recomendação do erro ... e use user default(T)ou new T.

Você precisará adicionar uma comparação ao seu código para garantir que seja uma correspondência válida se você seguir esse caminho.

Caso contrário, considere potencialmente um parâmetro de saída para "correspondência encontrada".

Aqui está um exemplo de trabalho para valores de retorno Nullable Enum:

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

Outra alternativa para as 2 respostas apresentadas acima. Se você alterar o tipo de retorno para object, poderá retornar e null, ao mesmo tempo, converter o retorno não 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
}

Por uma questão de integridade, é bom saber que você também pode fazer isso:

return default;

Retorna o mesmo que return default(T);

Para mim, funciona como está. Onde exatamente está o 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


}