Comment définir enum sur null

J'ai une énumération

string name;

public enum Color
{
  Red,
  Green,
  Yellow
}

Comment le définir sur NULL au chargement.

name = "";
Color color = null; //error

Édité: Mon mal, je ne l'ai pas expliqué correctement. Mais toutes les réponses liées à nullable sont parfaites. Ma situation est que se passe-t-il si, j'ai obtenu / défini l'énumération dans une classe avec d'autres éléments comme nom, etc. Au chargement de la page, j'initialise la classe et j'essaie de mettre par défaut les valeurs à null. Voici le scénario (le code est en C #):

namespace Testing
{
    public enum ValidColors
    {
        Red,
        Green,
        Yellow
    }

    public class EnumTest
    {
        private string name;
        private ValidColors myColor;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public ValidColors MyColor
        {
            get { return myColor; }
            set { myColor = value; }
        }

    }

    public partial class _Default : System.Web.UI.Page
    {       
        protected void Page_Load(object sender, EventArgs e)
        {
            EnumTest oEnumTest = new EnumTest();
            oEnumTest.Name = "";
            oEnumTest.MyColor = null; //???
        }
    }

}

Ensuite, en utilisant les suggestions ci-dessous, j'ai changé le code ci-dessus pour le faire fonctionner avec les méthodes get and set. J'ai juste besoin d'ajouter "?" dans la classe EnumTest lors de la déclaration de la variable enum privée et dans la méthode get / set:

public class EnumTest
{
    private string name;
    private ValidColors? myColor; //added "?" here in declaration and in get/set method

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public ValidColors? MyColor
    {
        get { return myColor; }
        set { myColor = value; }
    }

}

Merci à tous pour les belles suggestions.

Vous pouvez soit utiliser le "?" opérateur pour un type Nullable.

public Color? myColor = null;

Ou utilisez la pratique standard pour les énumérations qui ne peuvent pas être nulles en ayant la valeur FIRST dans l'enum (aka 0) comme valeur par défaut. Par exemple dans un cas de couleur Aucun.

public Color myColor = Color.None;

Si c'est C #, cela ne fonctionnera pas: les énumérations sont des types valeur et ne peuvent pas être null .

Les options normales sont d'ajouter un Nonemembre:

public enum Color
{
  None,
  Red,
  Green,
  Yellow
}

Color color = Color.None;

... ou à utiliser Nullable:

Color? color = null;

Rendez votre variable nullable. Comme:

Color? color = null;

ou

Nullable<Color> color = null;

Une énumération est un type «valeur» en C # (signifie que l'énumération est stockée sous quelque valeur qu'elle soit, et non comme une référence à un endroit en mémoire où la valeur elle-même est stockée). Vous ne pouvez pas définir les types valeur sur null (car null est utilisé pour les types référence uniquement).

Cela étant dit, vous pouvez utiliser la Nullable<T>classe intégrée qui encapsule les types de valeur de sorte que vous pouvez les définir sur null, vérifier si elle HasValueet obtenir sa valeur réelle Value. (Ce sont les deux méthodes sur les Nullable<T>objets.

name = "";
Nullable<Color> color = null; //This will work.

Il existe également un raccourci que vous pouvez utiliser:

Color? color = null;

C'est la même chose que Nullable<Color>;

Je suppose que c ++ ici. Si vous utilisez c #, la réponse est probablement la même, mais la syntaxe sera un peu différente. L'énumération est un ensemble de valeurs int. Ce n'est pas un objet, vous ne devriez donc pas le définir sur null. Définir quelque chose sur null signifie que vous pointez un pointeur vers un objet vers l'adresse zéro. Vous ne pouvez pas vraiment faire ça avec un int. Ce que vous voulez faire avec un int est de le définir sur une valeur à laquelle vous ne l'auriez pas normalement afin que vous puissiez tél si c'est une bonne valeur ou non. Alors, définissez votre couleur sur -1

Color color = -1;

Ou, vous pouvez démarrer votre énumération à 1 et la définir sur zéro. Si vous définissez la couleur à zéro telle qu'elle est actuellement, vous la définissez sur "rouge" car le rouge est zéro dans votre énumération.

Alors,

enum Color {
red =1
blue,
green
}
//red is 1, blue is 2, green is 3
Color mycolour = 0;

ne serait-il pas préférable d'attribuer explicitement la valeur 0 à la None constante? Pourquoi?

Parce que la enumvaleur par défaut est égale à 0, si vous l'appeliez, default(Color)elle serait imprimée None.

Parce qu'il est en première position, attribuer la valeur littérale 0 à toute autre constante changerait ce comportement, changer également l'ordre d'occurrence modifierait la sortie de default(Color)( https://stackoverflow.com/a/4967673/8611327 )

Color? color = null;

ou vous pouvez utiliser

Color? color = new Color?();

exemple où l'affectation de null ne fonctionnera pas

color = x == 5 ? Color.Red : x == 9 ? Color.Black : null ; 

afin que vous puissiez utiliser:

 color = x == 5 ? Color.Red : x == 9 ? Color.Black : new Color?();