C# renvoi d'un Enum? à partir d'une statique de la méthode d'extension

J'ai ajouté des méthodes d'extension pour les cordes pour rendre le travail avec quelques énumérations plus facile.

public static Enum ToEnum<T>(this string s)
{
    return (Enum)Enum.Parse(typeof(T), s);
}

public static bool IsEnum<T>(this string s)
{
    return Enum.IsDefined(typeof(T), s);
}

Remarque: en raison de limitations de type générique contraintes, je dois écrire les méthodes comme ci-dessus. J'aimerais utiliser T ToEnum(ce string s) où T: Enum pour éviter la fonte après avoir fait l'appel ... mais pas faire.

En tout cas, j'ai pensé qu'il serait agréable d'étendre ce concept un peu pour revenir Enum? dans les cas où une signature de méthode peut accepter divers nullable enums.

public static Enum? ToEnumSafe<T>(this string s)
{
    return (IsEnum<T>(s) ? (Enum)Enum.Parse(typeof(T), s) : null);
}

Cependant, ce n'est pas dû à des erreurs de compilation.

error CS0453: The type 'System.Enum' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'System.Nullable<T>'

Je dois admettre que je suis un peu confus, ici comme Enum? doit être légitime de la valeur de retour, non?. J'ai essayé quelque chose de similaire, mais à la fin avec la même erreur.

public static T? ToEnumSafe<T>(this string s)
{
    return (IsEnum<T>(s) ? (T)Enum.Parse(typeof(T), s) : null);
}

J'ai même décidé de le réécrire les méthodes pour enlever les génériques et je reçois plus de la même chose:

public static bool IsEnum(this string s, Type T)
{
    return Enum.IsDefined(T, s);
}
public static Enum? ToEnumSafe(this string s, Type T)
{
    return (IsEnum(s, T) ? (Enum)Enum.Parse(T, s) : null);
}

Ai-je raté quelque chose de vraiment stupide ici?

Ahh oui. Aujourd'hui, je vois mon erreur stupide. Enum est dérivé de ValueType qui lui-même est un Type de Référence que sa dérivée à partir de l'objet. Je pense que je dois avoir moins de matière grise dans le temps ;0 la confusion de La partie est qu'il n'y a rien qui empêche l'utilisation d'un béton de type enum -- ne pas faire sur une plus générique de mise en œuvre: public enum Test { a, b }; public static de la classe Testeur { public static Test? GetTest() { return (true == true ? (Test?)Test.un : null); } } Merci à tous les intervenants.

OriginalL'auteur Ethan J. Brown | 2009-10-12

  1. 5

    Essayer:

    public static T? ToEnumSafe<T>(this string s) where T : struct
{
    return (IsEnum<T>(s) ? (T?)Enum.Parse(typeof(T), s) : null);
}
    Comment feriez-vous si vous voulais igore le cas? c'est à dire passer de "singe" avec l'enum de recherche de type "Singe" à l'aide de votre code?
    a une surcharge qui prend Type, string, et un booléen cas de la sensibilité d'une opération.
    Enfin, c'était ce que je cherchais. Merci

    OriginalL'auteur Mehrdad Afshari

  2. 3

    Vous pouvez réellement faire un peu mieux que cela - avec un peu de travail.

    Bien que C# ne supporte pas les contraintes génériques-à-dire que T doit être un type enum, le CLR ne. J'ai un projet appelé Sans Contrainte Mélodie qui est une bibliothèque de "choses utiles à faire avec un enum." Je le soupçonne déjà débrouille avec ce que vous voulez (tant que vous ne devez utiliser les noms de l'enum, pas la chaîne des représentations des valeurs entières). Bien qu'il n'a pas IsDefined(string), il n'ont TryParse qui fera le même travail.

    Voir ce blog pour plus de détails.

    Pourquoi Enum? n'est pas un type de retour valide - System.Enum lui-même est un type de référence (tout comme System.ValueType), donc c'est déjà nullable. Vous ne pouvez utiliser ? avec non nullable types de valeur.

    J'ai été googler pour le lien vers UnconstrainedMelody. Heureusement, vous êtes venu autour juste au bon moment 🙂
    Génial... c'est une bibliothèque que je n'avais pas rencontré. Sera de le vérifier.
    Le lien vers le blog est valide maintenant.
    Fixe. J'espère qu'il y aura une masse de remplacement à un certain point, mais je ne suis pas sûr de la plans de.

    OriginalL'auteur Jon Skeet

  3. 0
    public static Enum ToEnum<T>(this string s)
{
    return (Enum)Enum.Parse(typeof(T), s);
}

    devrait être

    public static T ToEnum<T>(this string s)
{
    return (T)Enum.Parse(typeof(T), s);
}

    pouvez aussi fixer les suivantes

    public static Enum? ToEnumSafe<T>(this string s)
{
    return (IsEnum<T>(s) ? (Enum)Enum.Parse(typeof(T), s) : null);
}

    à

    public static T? ToEnumSafe<T>(this string s)
    where T : struct
{
    return (IsEnum<T>(s) ? (T?)Enum.Parse(typeof(T), s) : null);
}
    return (IsEnum<T>(s) ? (T)Enum.Parse(typeof(T), s) : null); ne compile pas.
    shoot manqué un '?'

    OriginalL'auteur Dave

  4. 0

    Un Enum est pas de Type distinct .Net, il est juste un espace réservé pour un béton de type de valeur (int dans le cas où vous n'avez pas spécifié autrement).

    Cela signifie que vous ne pouvez pas l'avoir comme type de déclaration à tous (indépendamment de la statique de l'extension de la méthode ou pas).

    Oui, vous pouvez. Système.Enum est un type valide en soi, mais c'est un type de référence plutôt qu'un type de valeur, d'où l'expression "Enum?" ne fonctionne pas.
    Permet de bien dire que vous ne pouvez pas l'avoir comme type pour le but de l'auteur original voulais qu'il se. Parce que d'autres que les trucs qu'il hérite de ValueType et de ses interfaces, il n'a pas non statique des méthodes ou des propriétés.

    OriginalL'auteur Foxfire