Come posso restituire NULL da un metodo generico in C #?

Ho un metodo generico con questo codice (fittizio) (sì, sono consapevole che IList ha predicati, ma il mio codice non utilizza IList ma un'altra raccolta, comunque questo è irrilevante per la domanda ...)

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

Questo mi dà un errore di compilazione

"Impossibile convertire null per digitare il parametro 'T' perché potrebbe essere un tipo di valore. Prendi invece in considerazione l'uso di 'default (T)'."

Posso evitare questo errore?

Due opzioni:

• Restituisce il default(T)che significa che tornerai nullse T è un tipo di riferimento (o un tipo di valore nullable), 0per int, '\0'per char, ecc. ( Tabella dei valori predefiniti (Riferimento C #) )
• Limitare T in modo che sia un tipo di riferimento con il where T : classvincolo e quindi ritorna nullnormalmente

return default(T);

Puoi semplicemente regolare i tuoi vincoli:

where T : class

Quindi è consentito restituire null.

Aggiungi il vincolo di classe come primo vincolo al tuo tipo generico.

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

1. Se hai un oggetto, allora devi digitare

   return (T)(object)(employee);

2. se è necessario restituire null.

   return default(T);

Di seguito sono le due opzioni che è possibile utilizzare

return default(T);

o

where T : class, IThing
 return null;

L'altra opzione sarebbe quella di aggiungere questo alla fine della dichiarazione:

    where T : class
    where T: IList

In questo modo ti consentirà di restituire null.

soluzione di TheSoftwareJedi funziona,

inoltre puoi archiviarlo usando coppia di valori e tipi nullable:

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

Prendi la raccomandazione dell'errore ... e l'utente default(T)o new T.

Dovrai aggiungere un confronto nel tuo codice per assicurarti che fosse una corrispondenza valida se segui quel percorso.

Altrimenti, considera potenzialmente un parametro di output per "match found".

Ecco un esempio funzionante per i valori di ritorno di Numble Enum:

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

Un'altra alternativa a 2 risposte presentate sopra. Se si modifica il tipo restituito in object, è possibile restituire null, mentre allo stesso tempo eseguire il cast di ritorno non nullo.

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

Per completezza, è bene sapere che potresti fare anche questo:

return default;

Restituisce lo stesso di return default(T);

Per me funziona così com'è. Dov'è esattamente il 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


}