C# - comprobando si se inicializa una variable

Question

Quiero comprobar si una variable se inicializa en tiempo de ejecución, programáticamente. Para que las razones de esto sean menos misteriosas, consulte el siguiente código incompleto:

string s; 

if (someCondition) s = someValue; 
if (someOtherCondition) s = someOtherValue; 

bool sIsUninitialized = /* assign value correctly */; 

if (!sIsUninitialized) Console.WriteLine(s) else throw new Exception("Please initialize s."); 

Y complete el bit correspondiente.

Una solución hacky es inicializar s con un valor por defecto:

string s = "zanzibar"; 

Y a continuación, comprobar si ha cambiado:

bool sIsUninitialized = s == "zanzibar"; 

Sin embargo, lo que si someValue o someOtherValue resultan ser "Zanzíbar" ¿también? Entonces tengo un error. ¿Alguna mejor manera?

Answer 1

El código ni siquiera se compilará si el compilador sabe que una variable no se ha inicializado.

string s; 
if (condition) s = "test"; 
// compiler error here: use of unassigned local variable 's' 
if (s == null) Console.Writeline("uninitialized"); 

En otros casos se puede utilizar la palabra clave default si una variable no se haya inicializado. Por ejemplo, en el siguiente caso:

class X 
{ 
    private string s; 
    public void Y() 
    { 
     Console.WriteLine(s == default(string)); // this evaluates to true 
    } 
} 

Los documentation estados que predeterminado (T) dará null para los tipos de referencia, y 0 para los tipos de valor. Como se señaló en los comentarios, esto es realmente lo mismo que buscar nulo.

---

Todo esto oculta el hecho de que realmente debería inicializar variables, a null o lo que sea, cuando se declaran en primer lugar.

Answer 2

Puede mantener una bandera independiente que indica que la cadena se ha inicializado:

string s = null; 
bool init = false; 
if (conditionOne) { 
    s = someValueOne; 
    init = true; 
} 
if (conditionTwo) { 
    s = someValueTwo; 
    init = true; 
} 
if (!init) { 
    ... 
} 

Esto se hará cargo de situaciones en las que se asigna s, incluyendo los casos en los que se asigna null, cadena vacía, o "zanzibar".

Otra solución es hacer una cadena estática para denotar el valor "no inicializado", y usar Object.ReferenceEquals en lugar de == para verificar si ha cambiado. Sin embargo, el enfoque de variable bool expresa su intención mucho más explícitamente.

Answer 3

que recoger valores de inicialización que no se pueden utilizar, los valores típicos incluyen String.Empty, null, -1, y un generador de cadena aleatoria de 256 caracteres.

Answer 4

Sólo asignarle null por defecto, no un valor de cadena

Answer 5

con C# 2.0, usted tiene el operador aceptan valores NULL que le permite establecer un valor inicial de cero para los tipos de valor hasta ahora, teniendo en cuenta cosas tales como:

int? x = null; 

if (x.HasValue) 
{ 
    Console.WriteLine("Value for x: " + num.Value); 
} 

Que rendimientos: "Value for x: Null".

Answer 6

Aquí hay una manera:

string s; 
if (someCondition) { s = someValue; } 
else if (someOtherCondition) { s = someOtherValue; } 
else { throw new Exception("Please initialize s."); } 

Console.WriteLine(s) 

Esto podría ser preferible para comprobar si la cadena es nula, porque tal vez someValue es un método que a veces puede devolver null. En otras palabras, quizás nulo es un valor legítimo para inicializar la cadena.

Personalmente me gusta más que una bandera isInitialized. ¿Por qué introducir una variable de indicador adicional a menos que sea necesario? No creo que sea más legible.

Answer 7

En general, asigne el valor predeterminado a null o String.Empty. Para situaciones donde no se puede utilizar esos valores "vacías", definir una constante para representar a su valor inicializado específica de la aplicación:

const string UninitializedString = "zanzibar"; 

después hacer referencia a ese valor cada vez que desee inicializar o prueba para la inicialización:

string foo = UnininitializedString; 
if (foo == UninitiaizedString) { 
    // Do something 
} 

Recuerde que las cadenas son constantes inmutables en C#, por lo que en realidad solo hay una instancia de UninitializedString (por lo que la comparación funciona).