Indscinble, i null sono uno dei peggiori incubi degli sviluppatori e causano un numero elevato di errori al momento dell’applicazione. La mancanza di strumenti per trattarli rende appropriatamente la coesistenza con le pecore nere dei possibili valori da applicare a una variabile. In questo articolo nel manuale .NET cercheremo di lanciare un po ‘di luce e dirti le soluzioni che la tecnologia ci offre di vivere con i valori nulli.
ed è che con poco che hai sviluppato , certo che tu abbia mai incontrato il difficile compito di assegnare un valore nullo a una variabile di tipo valore (int, float, char …) dove non si adatta più che usare trucchi difficili da eseguire, tracce e documenti. Ad esempio, data una classe di classe con una proprietà di tipo intera chiamata Età, cosa succede se prendiamo un oggetto di detta classe da un database se il campo non era obbligatorio in questo?
a priori, facile: Quando si legge dal database controlliamo se è nullo, e in tal caso assegniamo alla proprietà del valore della classe -1. Buona patch, senza dubbio.
Tuttavia, optare in generale da questa idea presenta diversi inconvenienti. Innanzitutto, per essere fedele alla realtà, se vorremmo memorizzare di nuovo questo oggetto nel database, è necessario effettuare il cambio inverse, cioè per verificare se l’età è -1 e in tal caso, salva nel campo un null.
Secondo, fissato che stiamo portando agli artifici di classe che non hanno senso nel dominio del problema da risolvere, nell’entità a cui rappresenta. Guardandolo un po ‘da lontano, qual è il significato di un’età negativa in una persona entità? Nessuna.
In terzo luogo, c’è un problema di coerenza nelle consultazioni. Se ho una raccolta di persone in memoria (eseguita, ad esempio usando tipi generici) e voglio sapere che coloro che sono definiti dall’età, dovrei verificare per ogni elemento se la loro età della proprietà è valsa la pena -1; Tuttavia, quando si esegue la stessa query nel database è necessario chiedere il valore nullo sul campo corrispondente.
true è che potremmo anche portare il concetto al database il concetto “-1 significa null” in Il campo di età, ma … non spruzzeremmo la struttura dei dati con una particolarità (e la limitazione) del linguaggio di programmazione utilizzato? Un’altra idea bizzarra potrebbe essere quella di introdurre un’età su una stringa e problemi risolti: le catene, essendo un tipo di riferimento possono contenere null senza problemi, tuttavia è necessario riconoscere che le ordinazioni sarebbero regolarmente; -)
di Ultimo, e se invece di età, dove chiaramente non ci possono essere negativi, stavamo parlando della classe StoryTeller e della sua proprietà Dartal? Qui è chiaramente visto che usare i negativi non è una risorsa valida.
soluzioni, a parte il commentato, c’è per tutti i gusti. Potrebbe, ad esempio, aggiungere una proprietà booleana parallela che indicava se il campo di età è null (un lavoro extra, specialmente senza diverse proprietà, questi valori sono) o incapsulano l’età all’interno di una classe che incorpora il trattamento logico di questo null.
In ogni caso, le possibili soluzioni sono lavoratori, a volte complessi, e soprattutto, troppo artificiale per essere qualcosa di ogni giorno come è un semplice campo nullo.
consapevole di esso, c # I progettisti hanno già preso in considerazione nella sua versione 2.0 una caratteristica interessante: tipi NULLABILI o tipi cancellabili, un meccanismo che consente al NULL nelle nostre vite in modo non traumatico.
La riga successiva ha generato un errore in Compilazione, che ha detto, e non ha mancato ragione, che “non può essere convertito null in ‘int’ perché è un tipo di valore”:
int s = null;
Da C # 2.0, è possibile effettuare le seguenti operazioni:
int? s;
s = null;
s = 1;
Osservare l’interrogatorio con il tipo, che è l’indicazione che la variabile S è intera, ma supporta anche un valore null.
Dentro, funziona come segue: INT? È un alias del sistema di tipo generico. Nutrible. In effetti, potremmo usare indistintamente uno dei due modi per esprimerlo. Internamente una struttura viene creata con due proprietà di sola lettura: hasvalue, che restituisce se la variabile in questione ha valore e valore, che contiene il valore stesso.
Resta inteso che una variabile con havelue uguale a False contiene il valore nullo, e se proviamo ad accedervi attraverso il valore, verrà lanciata un’eccezione.
Tuttavia, il vantaggio principale che hanno è che siano usati come se fosse un tipo di valore tradizionale. I tipi cancellabili si comportano praticamente come loro e offrono gli stessi operatori, anche se devono tenere conto delle loro particolarità, come si può vedere nel seguente codice:
int?A = 1;
INT? B = 2;
INT? Intnulo = Null;
Bool? Sì = true;
Bool? No = falso;
bool? Nisinino = null;
Console.Writeline (A + B); // 3
Console.Writeline (A + INTNULO); // niente, è null
console.Writeline (A * Intnulo); // niente, è nullo
console.Writeline (se & NO); // falso
console.Writelline (se & NO); // true
console.Writelline (sì & nisinino); // niente, è null
console.Writelline (non & nisinino); // falso
console.Writeline (SI | Nisinino); // true
console.Writeline (No | nisinino); // niente, è null
possiamo creare tipi cancellabili di qualsiasi tipo di framework: int?, galleggiante?, doppio ?, char?, ecc.
E infatti, come tipi di valore che sono, possiamo anche farlo con enumerazioni. Il seguente esempio non sarebbe corretto:
State State1 = Status.Correct;
State State2 = NULL;
La seconda riga provoca l’errore nella compilazione “NULL non può essere convertito in “consoleplicazione1.program.state” perché è un tipo di valore. ” Logico, è lo stesso di se avessimo tentato di assegnare il dannato valore nullo a un numero intero.
Può causare un leggero disagio per la gestione dei valori “indeterminati”, dal momento che saremo richiesti, ad esempio Utilizzare un altro membro dell’enumerazione per rappresentare questo valore, come nel seguente codice in Visual Basic .NET:
stato enum pubblico a indeterminato = 0 corretto = 1
errato = 2
ENUM ENUM
Tuttavia, ci sono momenti in cui è più interessante poter avere un valore nullo come opzione per le variabili del tipo della nostra enumerazione. Per fare ciò, possiamo usare la stessa sintassi che abbiamo visto in precedenza:
‘vb.net
Dim Status1 come nullable (di stato) = stato.Correct
State2 = Nothing Nothing // C #
stato? Stato1 = stato.Correct; Status? STATE2 = NULL;