Cómo establecer enum en nulo

Tengo una enumeracion

string name;

public enum Color
{
  Red,
  Green,
  Yellow
}

Cómo establecerlo en NULL en carga.

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

Editado: Lo malo, no lo expliqué correctamente. Pero todas las respuestas relacionadas con nullable son perfectas. Mi situación es ¿Qué pasa si tengo / configuré la enumeración en una clase con otros elementos como nombre, etc.? Aquí está el escenario (el código 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; //???
        }
    }

}

Luego, usando las sugerencias a continuación, cambié el código anterior para que funcione con los métodos get y set. Solo necesito agregar "?" en la clase EnumTest durante la declaración de la variable enum privada y en el método 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; }
    }

}

Gracias a todos por las encantadoras sugerencias.

Puedes usar el "?" operador para un tipo anulable.

public Color? myColor = null;

O utilice la práctica estándar para enumeraciones que no pueden ser nulas al tener el PRIMER valor en la enumeración (también conocido como 0) como valor predeterminado. Por ejemplo en un caso de color Ninguno.

public Color myColor = Color.None;

Si esto es C #, no funcionará: las enumeraciones son tipos de valor y no pueden serlo null.

Las opciones normales son agregar un Nonemiembro:

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

Color color = Color.None;

... o para usar Nullable:

Color? color = null;

Haga que su variable sea anulable. Me gusta:

Color? color = null;

o

Nullable<Color> color = null;

Una enumeración es un tipo de "valor" en C # (significa que la enumeración se almacena como cualquier valor que sea, no como una referencia a un lugar en la memoria donde se almacena el valor en sí). No puede establecer tipos de valor en nulo (ya que nulo se usa solo para tipos de referencia).

Dicho esto, puede usar la Nullable<T>clase incorporada que envuelve los tipos de valores de modo que pueda establecerlos en nulo, verificar si es así HasValuey obtener su valor real Value. (Esos son ambos métodos en los Nullable<T>objetos.

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

También hay un atajo que puedes usar:

Color? color = null;

Eso es lo mismo que Nullable<Color>;

Estoy asumiendo c ++ aquí. Si usa C #, la respuesta es probablemente la misma, pero la sintaxis será un poco diferente. La enumeración es un conjunto de valores int. No es un objeto, por lo que no debería configurarlo como nulo. Establecer algo en nulo significa que está apuntando un puntero a un objeto para direccionar cero. Realmente no puedes hacer eso con un int. Lo que desea hacer con un int es establecerlo en un valor en el que normalmente no lo tendría para poder decir si es un buen valor o no. Entonces, configura tu color a -1

Color color = -1;

O bien, puede comenzar su enumeración en 1 y establecerla en cero. Si configura el color a cero como está ahora, lo configurará a "rojo" porque el rojo es cero en su enumeración.

Entonces,

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

¿No sería mejor asignar explícitamente el valor 0 a None constante? ¿Por qué?

Como el enumvalor predeterminado es igual a 0, si lo llama default(Color), se imprimirá None.

Debido a que está en la primera posición, la asignación del valor literal 0 a cualquier otra constante cambiaría ese comportamiento, también cambiar el orden de ocurrencia cambiaría la salida de default(Color)( https://stackoverflow.com/a/4967673/8611327 )

Color? color = null;

o puedes usar

Color? color = new Color?();

ejemplo donde asignar nulo no funcionará

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

para que pueda usar:

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