Garantire inizializzazione delle variabili C#

Question

Considerate questo codice:

public string Variable1 { get; set;} 
public int Variable2 { get; set;} 

public void Function() 
{ 
// Has been Variable1 Initialized? 
} 

All'interno della funzione, voglio sapere se un valore è stato inviato al Variabile1 & Variabile2, prima della chiamata di funzione,

anche se i valori di default sono stati inviati, che è ok (null per stringa & 0 per int)

Answer 1

considerare l'utilizzo di un semplice involucro come questo:

public struct AssignableProperty<T> 
{ 
    private T _value; 

    public T Value 
    { 
     get { return _value; } 
     set 
     { 
      WasAssigned = true; 
      _value = value; 
     } 
    } 

    public bool WasAssigned { get; private set; } 

    public static implicit operator AssignableProperty<T>(T data) 
    { 
     return new AssignableProperty<T>() { Value = data }; 
    } 

    public static bool operator ==(AssignableProperty<T> initial, T data) 
    { 
     return initial.Value.Equals(data); 
    } 

    public static bool operator !=(AssignableProperty<T> initial, T data) 
    { 
     return !initial.Value.Equals(data); 
    } 

    public override string ToString() 
    { 
     return Value.ToString(); 
    } 
} 

Allora il vostro sguardo class'll in questo modo:

public class Test 
{ 
    public AssignableProperty<string> Variable1 { get; set; } 
    public AssignableProperty<int> Variable2 { get; set; } 

    public void Function() 
    { 
     if(Variable1.WasAssigned&&Variable2.WasAssigned) 
      //do stuff 
    } 
} 

Si può andare oltre e aggiungere eccezioni tiro o un contratto di getter, quindi se qualcuno proverà ad accedere al valore non inizializzato, genererà un'eccezione o mostrerà un avviso

Answer 2

Alcune basi di valore di default in C#:

Quando viene creata un'istanza di una classe (o una struct), tutti i campi vengono inizializzati al rispettivo valore predefinito.

Per i tipi di riferimento, sarà null. Per i tipi di valore, sarà equivalente a 0. Questo è facilmente spiegabile in quanto la gestione della memoria assicura che la nuova memoria allocata sia inizializzata a 0x0 byte.

Le proprietà automatiche nascondono il campo generato, ma ce n'è uno. Quindi valgono le stesse regole.

Ora per rispondere alla tua domanda, il modo migliore per assicurarsi che i valori sono inizializzati è quello di fare un costruttore con un parametro per ogni campo/proprietà e per nascondere il costruttore di default senza parametri:

public Yourtype(String param1, Int32 param2) 
{ 
    this.Variable1 = param1; 
    this.Variable2 = param2; 
} 

private Yourtype() { } 

Altre alternative sono descritte nelle risposte @Sean e @Alex se solo un sottoinsieme di proprietà/campi deve essere inizializzato/controllato. Ma questo nasconde un overhead (uno bool per ogni proprietà/campo e qualche riferimento indiretto).

Answer 3

Bene, si può semplicemente fare un controllo su entrambe le variabili per vedere se hanno un valore assegnato a li nella funzione

public void Function() 
{ 

    if (String.IsNullOrEmpty(Variable1) && Variable2 ==0) 
    { 
     // Variables are not assigned 
    } 

} 

Answer 4

Per i tipi di riferimento che sarà necessario aggiungere una bandiera:

string m_Variable1; 
bool m_IsVariable1Set; 

public string Variable1 
{ 
    get{return m_Variable1;} 
    set{m_IsVariable1Set = true; m_Variable1 = value;} 
} 

Per i tipi di valore è possibile utilizzare un valore nullable

int? m_Variable2; 

int Variable2 
{ 
    get{return m_Variable2.GetValueOrDefault();} 
    set{m_Variable2 = value;} 
} 

Che si può quindi verificare se è stato impostato utilizzando m_Variable2.HasValue.