I linguaggi .NET sono orientati agli oggetti e così lo è anche VB.NET. Questo approccio alla programmazione ha avuto molto successo negli ultimi anni e si basa fondamentalmente sui concetti di astrazione, oggetto e interazione fra oggetti. A loro volta, questi ultimi costituiscono un potente strumento per la modellizzazione e un nuovo modo di avvicinarsi alla risoluzione dei problemi. La particolare mentalità che questa linea di sviluppo adotta è favorevole alla rappresentazione dei dati in modo gerarchico, e per questo motivo il suo paradigma di programmazione - ossia l'insieme degli strumenti concettuali messi a disposizione dal linguaggio e il modo in cui il programmatore concepisce l'applicativo - è definito da tre concetti cardine: l'ereditarietà, il polimorfismo e l'incapsulamento. Molto presto arriveremo ad osservare nel particolare le caratteristiche di ognuno di essi, ma prima vediamo di iniziare con l'introdurre l'entità fondamentale che si pone alla base di tutti questi strumenti: la classe.

Come dicevo, una caratteristica particolare di questa categoria di linguaggi è che essi sono basati su un unico importantissimo concetto fondamentale: gli oggetti, i quali vengono rappresentati da classi. Una classe non è altro che la rappresentazione - ovviamente astratta - di qualcosa di concreto, mentre l'oggetto sarà una concretizzazione di questa rappresentazione (per una discussione più approfondita sulla differenza tra classe e oggetto, vedere capitolo A7). Ad esempio, in un programma che deve gestire una videoteca, ogni videocassetta o DVD è rappresentato da una classe; in un programma per la fatturazione dei clienti, ogni cliente e ogni fattura vengono rappresentati da una classe. Insomma, ogni cosa, ogni entità, ogni relazione - perfino ogni errore - trova la sua rappresentazione in una classe.
Detto questo, viene spontaneo pensare che, se ogni cosa è astratta da una classe, questa classe dovrà anche contenere dei dati su quella cosa. Ad esempio, la classe Utente dovrà contenere informazioni sul nome dell'utente, sulla sua password, sulla sua data di nascita e su molto altro su cui si può sorvolare. Si dice che tutte queste informazioni sono esposte dalla classe: ognuna di esse, inoltre, è rappresentata quello che viene chiamato membro. I membri di una classe sono tutti quei dati e quelle funzionalità che essa espone.
Per essere usabile, però, una classe deve venire prima dichiarata, mediante un preciso codice. L'atto di dichiarare una qualsiasi entità le permette di iniziare ad "esistere": il programmatore deve infatti servirsi di qualcosa che è già stato definito da qualche parte, e senza di quello non può costruire niente. Con la parola "entità" mi riferisco a qualsiasi cosa si possa usare in programmazione: dato che le vostre conoscenze sono limitate, non posso che usare dei termini generici e piuttosto vaghi, ma in breve il mio lessico si farà più preciso. Nella pratica, una classe si dichiara così:

Class [NomeClasse]
    '...
End Class

dove [NomeClasse] è un qualsiasi nome che potete decidere arbitrariamente, a seconda di cosa debba essere rappresentato. Tutto il codice compreso tra le parole sopra citate è interno alla classe e si chiama corpo; tutte le entità esistenti nel corpo sono dei membri. Ad esempio, se si volesse idealizzare a livello di codice un triangolo, si scriverebbe questo:

Class Triangolo
    '...
End Class

Nel corpo di Triangolo si potranno poi definire tutte le informazioni che gli si possono attribuire, come la lunghezza dei lati, la tipologia, l'ampiezza degli angoli, eccetera...

Nonostante il nome, i moduli non sono niente altro che dei tipi speciali di classi. La differenza sostanziale tra i due termini verrà chiarita molto più avanti nella guida, poiché le vostre attuali competenze non sono sufficienti a un completo apprendimento. Tuttavia, i moduli saranno la tipologia di classe più usata in tutta la sezione A.

Possiamo definire classi e moduli come unità funzionali: essi rappresentano qualcosa, possono essere usate, manipolate, istanziate, dichiarate, eccetera... Sono quindi strumenti attivi di programmazione, che servono a realizzare concretamente azioni e a produrre risultati. I namespace, invece, appartengono a tutt'altro genere di categoria: essi sono solo dei raggruppamenti "passivi" di classi o di moduli. Possiamo pensare a un namespace come ad una cartella, entro la quale possono stare files, ma anche altre cartelle, ognuna delle quali raggruppa un particolare tipo di informazione. Ad esempio, volendo scrivere un programma che aiuti nel calcolo geometrico di alcune figure, si potrebbe usare un codice strutturate come segue:

Namespace Triangoli
    Class Scaleno
    '...
    End Class
    
    Class Isoscele
    '...
    End Class
    
    Class Equilatero
    '...
    End Class
End Namespace

Namespace Quadrilateri
    Namespace Parallelogrammi
        Class Parallelogramma
        '...
        End Class
        
        Namespace Rombi
            Class Rombo
            '...
            End Class
            
            Class Quadrato
            '...
            End Class
        End Namespace
    End Namespace
End Namespace 

Come si vede, tutte le classi che rappresentano tipologie di triangoli (Scaleno, Isoscele, Equilatero) sono all'interno del namespace Triangoli; allo stesso modo esiste anche il namespace Quadrilateri, che contiene al suo interno un altro namespace Parallelogrammi, poiché tutti i parallelogrammi sono quadrilateri, per definizione. In quest'ultimo esiste la classe Parallelogramma che rappresenta una generica figura di questo tipo, ma esiste ancora un altro namespace Rombi: come noto, infatti, tutti i rombi sono anche parallelogrammi.
Dall'esempio si osserva che i namespace categorizzano le unità funzionali, dividendole in insiemi di pertinenza. Quando un namespace si trova all'interno di un altro namespace, lo si definisce nidificato: in questo caso, Paralleloogrammi e Rombi sono namespace nidificati. Altra cosa: al contrario della classi, gli spazi di nomi (italianizzazione dell'inglese name-space) non possiedono un "corpo", poiché questo termine si può usare solo quando si parla di qualcosa di attivo; per lo stesso motivo, non si può neanche parlare di membri di un namespace.