Esistono più modi di influire sulla compilazione di un sorgente e di modificare il comportamento del compilatore verso le sue parti. Alcuni di questi "modi" consistono nel modificare le opzioni di compilazione, che si suddividuono in quattro voci principali: Explicit, Compare, Infer e Strict. Per attivare o disattivare ognuna di esse, è possibile usare delle direttive speciali poste in testa al codice o accedere alla finestra dell'ambiente di sviluppo relativa alla compilazione. Nel secondo caso, basterà che clicchiate, dal menù principale, Project > [NomePrgetto] Properties; dalle proprietà, scegliete la seconda scheda cliccando sull'etichetta Compile sulla sinistra:

Da questo pannelo potrete anche decidere il comportamento da adottare verso certe circostanze di codice, ossia se trattarle come warning, errori, o se non segnalarle neppure.

Option Explicit

Quando Explicit è attiva, tutte le variabili devono essere esplicitamente dichiarate prima del loro uso: d'altra parte, questa è sempre stata la prassi che abbiamo adottato fin dall'inizio del corso e non ci sono particolari motivi per combiarla. Quando l'opzione è disattivata, ogni nome sconosciuto verrà trattato come una nuova variabile e creato al momento. Ecco un esempio in cui disattivo Explicit da codice:

Option Explicit Off

Module Module1
    Sub Main()
        'La variabile Stringa non viene dichiarata, ma è
        'lecito usarla e non viene comunicato alcun errore
        Stringa = "Ciao"

        'Stessa cosa per la variabile I, che non è stata
        'dichiarata da nessuna parte
        For I = 1 To 20
            Console.WriteLine(Stringa)
        Next

        Console.ReadKey()
    End Sub
End Module

Le direttive per l'attivazione/disattivazione di un'opzione di compilazione devono trovarsi sempre in cima al sorgente, anche prima di ogni altra direttiva Imports, e hanno una sintassi pressoché costante:

Option [Nome] On/Off

Anche se è possibile disattivare Explicit, è fortemente sconsigliato farlo: può produrre molti più danni che benefici. È pur vero che si usa meno codice, ma questo diventa anche meno comprensibile, e gli errori di battitura possono condannarvi a settimane di insonnia. Ad esempio:

Option Explicit Off

Module Module1
    Sub Main()
        Stringa = "Ciao"

        For I = 1 To 20
            If I > 10 Then
                Strnga = I
            End If
            Console.WriteLine(Stringa)
        Next

        Console.ReadKey()
    End Sub
End Module

Il codice dovrebbe, nelle vostre intenzioni, scrivere "Ciao" solo 10 volte, e poi stampare 11, 12, 13, eccetera... Tuttavia questo non succede, perchè avete dimenticato una "i" e il compilatore non vi segnala nessun errore a causa della direttiva Option; non riceverete neppure un warning del tipo "Unused local variable", perchè la riga in cui è presente Strnga consiste in un assegnamento. Errori stupidi possono causare grandi perdite di tempo.

Option Compare

Questa opzione non assume i valori On/Off, ma Binary e Text. Quando Compare è impostata su Binary, la comparazione tra due stringhe viene effettuata confrontando il valore dei singoli bytes che la compongono e, perciò, il confronto diventa case-sensitive (maiuscole e minuscole della stessa lettera sono considerate differenti). Se, al contrario, è impostata su Text, viene comparato solo il testo che le stringhe contengono, senza fare distinzioni su lettere maiuscole o minuscole (case-insensitive). Eccone un esempio:

Option Compare Text
Module Module1
  Sub Main()
    If "CIAO" = "ciao" Then
      Console.WriteLine("Option Compare Text")
    Else
      Console.WriteLine("Option Compare Binary")
    End If
    Console.ReadKey()
  End Sub
End Module 

Scrivendo "Binary" al posto di "Text", otterremo un messaggio differente a runtime!

Option Strict

Questa opzione si occupa di regolare le conversioni implicite tra tipi di dato differenti. Quando è attiva, tutti i cast impliciti vengono segnalati e considerati come errori: non si può passare, ad esempio, da Double a Integer o da una classe base a una derivata:

Option Strict On
Module Module1
    Sub Main()
        Dim I As Int32
        Dim P As Student

        'Conversione implicita da Double a Int32: viene
        'segnalata come errore
        I = 4.0
        'Conversione implicita da Person a Student: viene
        'segnalata come errore
        P = New Person("Mario", "Rossi", New Date(1968, 9, 12))

        Console.ReadKey()
    End Sub
End Module

Per evitare di ricevere le segnalazioni di errore, bisogna utilizzare un operatore di cast esplicito come CType. Generalmente, Strict viene mantenuta su Off, ma se siete particolarmente rigorosi e volete evitare le conversioni implicite, siete liberi di attivarla.

Option Infer

Questa opzione di compilazione è stata introdotta con la versione 2008 del linguaggio e, se attivata, permette di inferire il tipo di una variabile senza tipo (ossia senza clausola As) analizzando i valori che le vengono passati. All'inizio della guida, ho detto che una variabile dichiarata solo con Dim (ad esempio "Dim I") viene considerata di tipo Object: questo è vero dalla versione 2005 in giù, e nella versioni 2008 e successive solo se Option Infer è disattivata. Ecco un esempio:

Option Infer Off

Module Module1
    Sub Main()
        'Infer è disattivata: I viene considerata di
        'tipo Object
        Dim I = 2

        'Dato che I è Object, può contenere
        'qualsiasi cosa, e quindi questo codice non genera
        'alcun errore
        I = "ciao"

    End Sub
End Module

Provando ad impostare Infer su On, non otterrete nessuna segnalazione durante la scrittura, ma appena il programma sarà avviato, verrà lanciata un'eccezione di cast, poiché il tipo di I viene dedotto dal valore assegnatole (2) e la fa diventare, da quel momento in poi, una variabile Integer a tutti gli effetti, e "ciao" non è convertibile in intero.