Comment puis-je retourner NULL à partir d'une méthode générique en C #?

J'ai une méthode générique avec ce code (factice) (oui, je sais que IList a des prédicats, mais mon code n'utilise pas IList mais une autre collection, de toute façon ce n'est pas pertinent pour la question ...)

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

Cela me donne une erreur de construction

"Impossible de convertir null en paramètre de type 'T' car il pourrait s'agir d'un type de valeur. Envisagez d'utiliser plutôt 'default (T)'."

Puis-je éviter cette erreur?

Deux options:

• Return, default(T)ce qui signifie que vous retournerez nullsi T est un type de référence (ou un type de valeur nullable), 0for int, '\0'for char, etc. ( tableau des valeurs par défaut (référence C #) )
• Limitez T à être un type de référence avec la where T : classcontrainte, puis revenez nullnormalement

return default(T);

Vous pouvez simplement ajuster vos contraintes:

where T : class

Le retour de null est alors autorisé.

Ajoutez la contrainte de classe comme première contrainte à votre type générique.

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

1. Si vous avez un objet, vous devez alors transtyper

   return (T)(object)(employee);

2. si vous devez retourner null.

   return default(T);

Voici les deux options que vous pouvez utiliser

return default(T);

ou

where T : class, IThing
 return null;

Votre autre option serait d'ajouter ceci à la fin de votre déclaration:

    where T : class
    where T: IList

De cette façon, cela vous permettra de retourner null.

solution de TheSoftwareJedi fonctionne,

vous pouvez également l'archiver en utilisant un couple de types valeur et 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;
}

Prenez la recommandation de l'erreur ... et soit utilisateur default(T)ou new T.

Vous devrez ajouter une comparaison dans votre code pour vous assurer qu'il s'agissait d'une correspondance valide si vous suivez cette route.

Sinon, envisagez potentiellement un paramètre de sortie pour "correspondance trouvée".

Voici un exemple de travail pour les valeurs de retour Nullable Enum:

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

Une autre alternative aux 2 réponses présentées ci-dessus. Si vous changez votre type de retour en object, vous pouvez retourner null, tout en castant le retour non nul.

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

Par souci d'exhaustivité, il est bon de savoir que vous pouvez également le faire:

return default;

Il renvoie le même que return default(T);

Pour moi, ça marche comme ça. Où est exactement le problème?

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


}