Como definir enum para null

Eu tenho um enum

string name;

public enum Color
{
  Red,
  Green,
  Yellow
}

Como configurá-lo para NULL no carregamento.

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

Editado: Meu mal, não expliquei direito. Mas todas as respostas relacionadas a anuláveis ​​são perfeitas. Minha situação é: E se, eu obtiver / definir o enum em uma classe com outros elementos como nome, etc. No carregamento da página, inicializo a classe e tento usar como padrão valores nulos. Aqui está o cenário (o código está em 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; //???
        }
    }

}

Em seguida, usando as sugestões abaixo, alterei o código acima para fazê-lo funcionar com os métodos get e set. Eu só preciso adicionar "?" na classe EnumTest durante a declaração da variável enum privada e no 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; }
    }

}

Obrigado a todos pelas sugestões adoráveis.

Você pode usar o "?" operador para um tipo anulável.

public Color? myColor = null;

Ou use a prática padrão para enumerações que não podem ser nulas, tendo o valor PRIMEIRO na enumeração (aka 0) como o valor padrão. Por exemplo, em um caso de cor Nenhum.

public Color myColor = Color.None;

Se for C #, não funcionará: enumerações são tipos de valor e não podem ser null.

As opções normais são adicionar um Nonemembro:

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

Color color = Color.None;

... ou para usar Nullable:

Color? color = null;

Torne sua variável anulável. Gostar:

Color? color = null;

ou

Nullable<Color> color = null;

Uma enumeração é um tipo de "valor" em C # (significa que a enumeração é armazenada como qualquer valor que seja, não como uma referência a um local na memória onde o valor em si é armazenado). Você não pode definir tipos de valor como nulos (já que nulo é usado apenas para tipos de referência).

Dito isto, você pode usar a Nullable<T>classe incorporada, que agrupa os tipos de valores, de forma que você possa configurá-los como nulos, verificar se eles HasValuesão reais Value. (Esses são os dois métodos nos Nullable<T>objetos.

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

Há também um atalho que você pode usar:

Color? color = null;

Isso é o mesmo que Nullable<Color>;

Estou assumindo c ++ aqui. Se você estiver usando c #, a resposta provavelmente será a mesma, mas a sintaxe será um pouco diferente. A enumeração é um conjunto de valores int. Não é um objeto, portanto você não deve defini-lo como nulo. Definir algo como nulo significa que você está apontando um ponteiro para um objeto para endereçar zero. Você realmente não pode fazer isso com um int. O que você quer fazer com um int é configurá-lo para um valor que normalmente não o teria, para que você possa dizer se é um bom valor ou não. Então, defina sua cor como -1

Color color = -1;

Ou, você pode iniciar seu enum em 1 e defini-lo como zero. Se você definir a cor para zero como está agora, você a definirá como "vermelho" porque vermelho é zero em sua enumeração.

Assim,

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

não seria melhor atribuir explicitamente o valor 0 a None constante? Por quê?

Como o enumvalor padrão é igual a 0, se você chamar, default(Color)ele será impresso None.

Como está na primeira posição, atribuir o valor literal 0 a qualquer outra constante alteraria esse comportamento, também a ordem de ocorrência mudaria a saída de default(Color)( https://stackoverflow.com/a/4967673/8611327 )

Color? color = null;

ou você pode usar

Color? color = new Color?();

exemplo em que atribuir nulo não funcionará

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

então você pode usar:

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