C# - verifica dell'inizializzazione di una variabile

Question

Voglio verificare se una variabile è inizializzata in fase di esecuzione, a livello di programmazione. Per rendere meno misteriose le ragioni, vedere il seguente codice 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."); 

E completare il bit pertinente.

Una soluzione hacky è di inizializzare s con un valore di default:

string s = "zanzibar"; 

E poi verificare se è cambiato:

bool sIsUninitialized = s == "zanzibar"; 

Tuttavia, quello che se someValue o someOtherValue capita di essere "Zanzibar" anche? Allora ho un bug. Qualche modo migliore?

Answer 1

Il codice non viene nemmeno compilato se il compilatore sa che una variabile non è stata inizializzata.

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

In altri casi è possibile utilizzare la parola chiave default se una variabile non sia stato inizializzato. Ad esempio, nel seguente caso:

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

Le documentation stati che predefinito (T) darà null per tipi di riferimento, e 0 per tipi di valori. Quindi, come sottolineato nei commenti, questo è proprio lo stesso che controllare null.

---

Tutto questo oscura il fatto che si dovrebbe davvero inizializzare le variabili, a null o qualsiasi altra cosa, al momento del primo dichiarati.

Answer 2

È possibile mantenere una bandiera separato che indica che la stringa è stato inizializzato:

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

Questo si prenderà cura di situazioni in cui è assegnato s, inclusi i casi in cui è assegnato null, stringa vuota, o "zanzibar".

Un'altra soluzione consiste nel creare una stringa statica per indicare il valore "non inizializzato" e utilizzare Object.ReferenceEquals anziché == per verificare se è stata modificata. Tuttavia, l'approccio variabile bool esprime il tuo intento in modo molto più esplicito.

Answer 3

prendo valori di inizializzazione che non possono essere utilizzati, valori tipici includono String.Empty, null, -1, e un generatore stringa casuale di 256 caratteri.

Answer 4

Basta assegnare null per impostazione predefinita, non è un valore stringa

Answer 5

Con C# 2.0, avete l'operatore Nullable che permette di impostare un valore iniziale di null per i tipi di valore fino ad ora, permettendo cose come:

int? x = null; 

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

Quali rese: "Valore x: Null".

Answer 6

Ecco un modo:

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

Console.WriteLine(s) 

Questo potrebbe essere preferibile per verificare se la stringa è nulla, perché forse someValue è un metodo che a volte può restituire null. In altre parole, forse null è un valore legittimo per inizializzare la stringa su.

Personalmente mi piace questo meglio di un flag isInitialized. Perché introdurre una variabile di flag extra a meno che non sia necessario? Non penso sia più leggibile.

Answer 7

In generale, assegnare il valore predefinito a null o String.Empty. Per le situazioni in cui non è possibile utilizzare questi valori "vuoti", definire una costante per rappresentare il vostro valore non inizializzato specifico dell'applicazione:

const string UninitializedString = "zanzibar"; 

quindi fare riferimento a tale valore ogni volta che si desidera inizializzare o il test per l'inizializzazione:

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

Ricorda che le stringhe sono costanti immutabili in C#, quindi c'è solo una istanza di UninitializedString (che è il motivo per cui il confronto funziona).