Con la nascita di VB .Net, finalmente Basic è diventato un linguaggio orientato a oggetti e non più una sua simulazione. Forse più volte avrete sentito dire che in ambito di OOP (Object Oriented Programming, appunto programmazione orientata a oggetti) tutto è un oggetto. Ma cosa significa ciò?
Partiamo da un oggetto concreto: un piano cottura. Parlando di un piano cottura cosa possiamo dire? Prima di tutto esso dovrà essere fabbricato, poi possiamo dire che avrà alcune caratteristiche quali il numero di fornelli, la data di produzione, l'essere connesso alla rete del metano (o anche l'essere acceso) o meno e molte altre. Possiamo inoltre dire che è in grado di compiere alcune azioni come accendersi, spegnersi, variare la potenza della fiamma e così via. Infine ad esso possiamo associare una serie di cose che possono accadere e in relazione alle quali è necessario eseguire alcune azioni, ad esempio potrebbe accadere che il fuoco si spenga, con il rischio di una perdita di gas, che va quindi prevenuta.
Vediamo come sarebbe il nostro oggetto Fornello in Visual Basic.

Class PianoCottura
    
    [...]

    'Costruiamo (fabbrichiamo) il piano cottura specificando il numero di fornelli
    Sub New(Fornelli As Integer)
        [...]
    End Sub

    'Proprietà che restituisce il numero di fornelli
    'Non può essere modificata
    ReadOnly Property NumeroFornelli() As Integer
        [...]
    End Property

    'Proprietà che restituisce la data di fabbricazione
    'Non può essere modificata
    ReadOnly Property DataFabbricazione() As Date
        [...]
    End Property

    'Proprietà che restituisce se si è connessi alla rete del metano o meno
    'Permette di connettere e disconnettere il piano cottura [si veda Accendi()]
    Property ConnessoReteMetano() As Boolean
        [...]
    End Property

    'Proprietà che restituisce se il piano cottura ha qualche fornello acceso o meno
    'Non può essere modificata [Accendi() utilizza infatti 
    'la variabile interna blnAcceso direttamente]
    ReadOnly Property Acceso() As Boolean
        [...]
    End Property

    'Metodo che imposta la variabile interna [non modificabile al di fuori dell'oggetto] blnAcceso
    'su True ["accende" il fornello], controllando però prima di essere connessi alla rete del metano
    'e in caso negativo, effettua il collegamento impostando la proprietà ConnessoReteMetano su True
    Sub Accendi()
        [...]
    End Sub

    'Metodo che spegne il fornello semplicemente impostando la variabile interna blnAccesso su False.
    Sub Spegni()
        [...]
    End Sub

    'Metodo che imposta la potenza della fiamma su quella specificata e restituisce quella precedente
    Function ImpostaPotenzaFiamma(NuovaPotenza As Integer) As Integer
        [...]
    End Function

    'Evento che verrà richiamato in caso di spegnimento anomalo della fiamma
    Event SpegnimentoAnomaloFuoco()

End Class

Come si può intuire leggendo qua e là. Vi sono alcune corrispondenze tra ciò che abbiamo sopra elencato e la loro trasposizione in codice. Prima di tutto bisogna notare la parola chiave Class: essa indica che stiamo creando una classe (chiamata PianoCottura), ovvero un modello di oggetto che verrà poi istanziato (costruito e caricato in memoria effettivamente) e utilizzato.
Avevamo detto che il piano cottura doveva essere fabbricato, questa funzione nella nostra classe è svolta da Sub New(), ovvero una porzione di codice che (in genere) carica in memoria tutto ciò che è necessario e provvede a modificare alcune impostazioni dell'oggetto su valori di default (predefiniti), ad esempio inizialmente saremo connessi alla rete del metano. Esso riceve un parametro, che specifica come deve essere costruito il nostro piano cottura, Fornelli, valore numerico che indica quanti fornelli deve avere. Non è indispensabile il costruttore (appunto Sub New()) ma è quasi sempre inevitabile.
Poi avevamo parlato di caratteristiche, che in Visual Basic possono essere viste come proprietà (si vedano dunque tutte le porzioni di codice che iniziano con la parola chiave Property); alcune di esse possono essere modificate mentre altre no (a seconda che sia stata preposta la parola chiave ReadOnly a Property), difatti non deve essere possibile per l'utente finale modificare il numero di fornelli disponibili (Property NumeroFornelli()) o la data di fabbricazione (Property DataFabbricazione()) mentre deve poter stabilire se il suo piano cottura è connesso o no alla rete del metano (Property ConnessoReteMetano()). La proprietà indicante se un fornello è acceso o meno (Property Acceso()) invece è nel nostro caso modificabile attraverso Accendi() e Spegni() (come vedremo tra poco) ma non direttamente, dunque essa indica solamente lo stato del fornello.
Abbiamo poi dei metodi, ovvero le azioni che il piano cottura può fare (parole chiavi Sub e Function): Accendi() e Spegni() sono solo delle azioni che non richiedono nulla di particolare (l'utente deve solo girare la manopola fino a quando la fiamma non appare, oppure girarla finché non è completamente spenta), mentre ImpostaPotenzaFiamma() richiede quale nuovo valore di potenza (non è ora importante cosa si intenda per potenza e come è misurata) bisogna assegnare al fornello, infatti un ipotetico utente dovrebbe calibrare quanto girare la manopola per ottenere l'effetto desiderato: per questo motivo riceve il parametro numerico NuovaPotenza. Inoltre ImpostaPotenzaFiamma(), non è una Sub ma una Function, dunque un metodo che restituisce qualche cosa, nel nostro caso potrebbe essere il precedente valore della fiamma. Il fatto che restituisca qualche cosa significa che quando il metodo verrà chiamato darà come risposta un risultato (per chiarimenti si veda il codice che utilizza la classe PianoCottura poco avanti).
Infine abbiamo un evento (parola chiave Event) chiamato SpegnimentoAnomaloFuoco(), esso dovrà essere gestito dall'utente attraverso la parola chiave Handles come vedremo tra poco.

Proponiamo di seguito un semplice programma console che fa uso della nostra classe PianoCottura.

Module Main
    'Dichiara un oggetto PianoCottura specificando che ne gestirà anche gli eventi
    Dim WithEvents MioPianoCottura As PianoCottura
    Sub Main()
        'Variabili che verrano utilizzate
        Dim intPotenzaPrecedente As Integer

        'Costruisce il piano cottura
        MioPianoCottura = New PianoCottura(5)
        'Imposta la potenza su 300 e stampa il valore precedente
        intPotenzaPrecedente = MioPianoCottura.ImpostaPotenzaFiamma(300)
        Console.WriteLine("La vecchia potenza era: " & intPotenzaPrecedente)
        'Disconnette dalla rete del metano
        MioPianoCottura.ConnessoReteMetano = False
        'Accende un fornello (e riconnette alla rete del metano)
        MioPianoCottura.Accendi()
        'Attende la pressione di un tasto
        Console.Read()
    End Sub

    'Gestisce l'evento SpegnimentoAnomaloFuoco() della classe PianoCottura (istanziata in MioPianoCottura)
    Sub MioPianoCottura_SpegnimentoAnomaloFuoco() Handles MioPianoCottura.SpegnimentoAnomaloFuoco
        'Segnala il problema
        Console.WriteLine("Si è spento in maniera anomala il fornello!")
        'Spegna il fornello
        MioPianoCottura.Spegni()
    End Sub
End Module

Prima di tutto si noti la dichiarazione del nostro oggetto MioPianoCottura che istanzierà (crea l'oggetto partendo dal modello della classe) PianoCottura. Esso è preceduto da WithEvents, che indica che ne verranno gestiti gli eventi (come SpegnimentoAnomaloFuoco()).
La classe PianoCottura viene effettivamente istanziata con la chiamata di New (MioPianoCottura = New PianoCottura(5)). In seguito vengono eseguite alcune chiamate sull'oggetto.
Infine vi è la Sub MioPianoCottura_SpegnimentoAnomaloFuoco() che viene richiamata quando viene invocato l'evento  SpegnimentoAnomaloFuoco per via della sintassi Handles MioPianoCottura.SpegnimentoAnomaloFuoco.