Le cinque principali modifiche da VB 6 a VB.NET

Visual Basic 1.0 è stato un grave terremoto durante la programmazione. Prima di VB1, dovevi usare C, C ++ o qualche altro orribile ambiente di sviluppo per creare applicazioni Windows. I programmatori hanno trascorso letteralmente settimane disegnando semplicemente finestre su schermi con codice esigente, dettagliato, difficile da eseguire il debug. (La stessa cosa che puoi fare trascinando un modulo dalla barra degli strumenti in pochi secondi.) VB1 è stato un successo e milioni di programmatori hanno subito iniziato a usarlo.

Ma per realizzare la magia, Microsoft ha fatto alcuni importanti compromessi sull'architettura. In particolare, poiché VB1 ha creato i moduli e i controlli, non hanno permesso al programmatore di accedere al codice che lo ha fatto. O hai lasciato che VB creasse tutto o hai usato C ++.

VB da 2 a 6 hanno mantenuto questa stessa architettura. Microsoft ha fatto alcuni aggiornamenti molto intelligenti che hanno dato ai programmatori un controllo molto maggiore, ma alla fine i programmatori non sono ancora riusciti a integrare il loro codice con il codice VB. Era una scatola nera - e neanche nel buon modo OOP. Un altro modo di dire questo era che il programmatore non aveva accesso agli "oggetti" VB interni e un altro modo di dire che VB6 non era ancora completamente "orientato agli oggetti".

Nel frattempo, Java, Python e molti altri linguaggi di programmazione che erano orientati agli oggetti iniziarono ad apparire. Visual Basic si stava perdendo - alla grande! Questa è una situazione che Microsoft non tollera... e hanno deciso di risolvere il problema una volta per tutte. La soluzione è .NET.

Ma per fare le cose che .NET doveva fare, Microsoft decise che dovevano "rompere la compatibilità". Cioè, i programmi Visual Basic erano stati (con eccezioni molto lievi) "compatibili con le versioni precedenti" da VB1 fino a VB6. Un programma scritto in quella prima versione di VB verrebbe comunque compilato ed eseguito nella versione successiva. Ma con VB.NET, Microsoft ha scoperto che non potevano semplicemente rendere la lingua completamente OOP e mantenere la compatibilità verso l'alto.

Una volta presa questa decisione fondamentale, le porte dell'inondazione si aprirono su dieci anni di cambiamenti accumulati nella "lista dei desideri" e TUTTI entrarono nel nuovo VB.NET. Come si dice in Gran Bretagna, "In per un centesimo, in per una sterlina".

Senza ulteriori indugi, ecco il mio elenco personale delle cinque principali modifiche da VB6 a VB.NET in ordine inverso.

Wellllll... solo un ulteriore ritardo. Dal momento che stiamo cambiando da VB6, dove un array ha dichiarato Dim myArray (5) ha 6 elementi, ne abbiamo sei. È solo appropriato ...

(Rullo di tamburi prego ...)

"Award (5)", nostro 6 ° posto il premio va alla scelta dei groupies C: Modifiche alla sintassi di tipo C!

Ora puoi codificare a + = 1 invece di a = a + 1, salvando TRE INTERI TASTI!

Programmatori del mondo, gioite! VB è stato elevato al livello C e un'intera nuova generazione che cerca di imparare VB si avvicinerà un po 'di più alla confusione di massa che affronta gli studenti di C ++.

Ma aspetta! C'è più!

VB.NET ora presenta una "logica di cortocircuito" che ha introdotto per anni sottili bug nel codice C ++ per risparmiare preziosi nano-secondi di tempo del processore. La logica di corto circuito valuta solo più condizioni in un'istruzione logica, se necessario. Per esempio:

Dim R come booleano
R = Funzione1 () E Funzione2 ()

In VB6, entrambe le funzioni vengono valutate se ne hanno bisogno o meno. Con VB.NET, se Function1 () è falso, Function2 () viene ignorato poiché "R" non può essere True. Ma cosa succede se una variabile globale viene cambiata in Function2 () - solo per caso (direbbero i programmatori C ++, "by programmazione scadente ".) Perché il mio codice produce una risposta sbagliata qualche volta quando viene tradotto VB.NET? Questo potrebbe essere!

Per Provarepiù difficile, lo farà VB.NET Catturare un po 'di fortuna e Infine essere riconosciuto per la gestione degli errori "eccezionale".

VB6 ha avuto l'ultimo holdout GoTo: "On Error GoTo". Anche io devo ammettere che la gestione delle eccezioni strutturata "Try-Catch-Infine" in stile C ++ è un grande miglioramento, non solo un mezzo miglioramento.

Cosa, dici "On Error GoTo" è ancora in VB.NET? Wellll... Cerchiamo di non parlarne troppo.

5 ° posto la selezione è un premio di gruppo: I vari comandi cambiano! Devono condividere questo premio e ce ne sono molti. Microsoft ha risparmiato per dieci anni e si sono davvero liberati.

VB.NET non supporta più le funzioni VarPtr, ObjPtr e StrPtr che hanno recuperato l'indirizzo di memoria delle variabili. E non supporta VB6 LSet che è stato utilizzato per convertire un tipo definito dall'utente in un altro. (Da non confondere con VB6 LSet che fa qualcosa di completamente diverso - vedi sotto.)

Offriamo anche un affettuoso addio a Let, Is Missing, DefBool, DefByte, DefLng, DefCur, DefSng, DefDbl, DefDec, DefDate, DefStr, DefObj, DefVar e (il mio preferito!) GoSub.

Circle si è trasformato in GDI + DrawEllipse. Lo stesso vale per Line to DrawLine. Nel calcolo ora abbiamo Atan invece di Atn, Sign va per Sgn e Sqrt si adatta al grande gioco invece di Sqr.

Nell'elaborazione delle stringhe, anche se sono ancora disponibili se si fa riferimento a una compatibilità Microsoft spazio dei nomi, abbiamo PadRight per LSet di VB6 (di nuovo, completamente diverso da LSet di VB6, ovviamente) e PadLeft per RSet. (Ecco le tre sequenze di tasti che abbiamo salvato con "+ ="!)

E, naturalmente, dato che siamo OOP ora, non preoccuparti se Set di proprietà, Property Let e ​​Property Get non sono soddisfatti in VB.NET, puoi scommettere!

Infine, debug. Stampa diventa Debug. Scrivi o debug. Linea di scrittura. Solo i nerd stampano tutto comunque.

Questo non tocca nemmeno tutti i NUOVI comandi in VB.NET, ma dobbiamo fermare questa assurdità da qualche parte.

Nel 4 ° posto, noi abbiamo Modifiche alle chiamate di procedura!

Questo è il premio "bontà, purezza e virtù genuina" e rappresenta un sacco di duro lavoro di campagna da parte della fazione "niente più codice sciatto".

In VB6, se una variabile di parametro di procedura è un tipo intrinseco, allora è ByRef, a meno che non sia stato codificato ByVal esplicitamente, ma se non è codificato ByRef o ByVal e non è una variabile intrinseca, lo è ByVal... Capito?

In VB.NET, è ByVal a meno che non sia codificato da ByRef.

Il default di ByVal VB.NET, tra l'altro, impedisce anche che le modifiche alle variabili dei parametri nelle procedure vengano propagate involontariamente nel codice chiamante, una parte fondamentale della buona programmazione OOP.

Microsoft inoltre "sovraccarica" ​​VB.NET con una modifica dei requisiti per le parentesi nelle chiamate di procedura.

In VB6, le parentesi sono richieste intorno agli argomenti quando si effettuano chiamate di funzione, ma non quando si chiama una subroutine quando non si utilizza l'istruzione Call ma sono richieste quando si utilizza l'istruzione Call.

In VB.NET, le parentesi sono sempre richieste attorno a un elenco di argomenti non vuoto.

The Bronze Award - 3 ° posto, va a Le matrici sono basate su 0 anziché su 1!

È solo una modifica alla sintassi, ma questa modifica ottiene lo stato "podio medaglia" perché è votata, "molto probabilmente per rovinare la logica del programma". Ricorda, 3 ° posto È "Premio (2)" nella nostra lista. Se hai contatori e matrici nel tuo programma VB6 (e quanti non lo fanno), questo ti MESSA SU.

Per dieci anni, la gente ha chiesto: "Che cosa stava fumando Microsoft quando lo hanno fatto in questo modo?" E per dieci anni, i programmatori hanno una sorta di universalmente ignorato il fatto che esistesse un elemento myArray (0) che occupava solo spazio e non si abituava nulla... Fatta eccezione per quei programmatori che l'hanno usato e i loro programmi sono sembrati, intendo, semplicemente "strani".

Per I = da 1 a 5
MyArray (I - 1) = Qualunque cosa
Il prossimo

Intendo, VERAMENTE! ...

La medaglia d'argento di 2 ° posto va in onore di un vecchio amico che è stato lasciato cadere nel secchio della programmazione con il passaggio di VB6! Non parlo altro che Il tipo di dati variante.

Probabilmente nessun'altra singola caratteristica di "notNet" di Visual Basic rappresenta meglio la filosofia di "veloce, economico e sciolto". Questa immagine ha perseguitato VB fino all'introduzione di VB.NET. Sono abbastanza grande da ricordare l'introduzione di Visual Basic 3.0 da parte di Microsoft: "Oh Wow! Guarda qui! Con il nuovo tipo di dati Variant migliorato, non è necessario dichiarare variabili o niente. Puoi solo pensarli e codificarli. "

Microsoft ha cambiato la sua melodia abbastanza velocemente su quella e ha raccomandato di dichiarare le variabili con a tipo di dati specifico quasi immediatamente, lasciando molti di noi a chiedersi: "Se non puoi usare le varianti, perché li hai? "

Ma mentre siamo in tema di tipi di dati, dovrei menzionare che molti tipi di dati sono cambiati oltre a far cadere Variant nel cemento bagnato. C'è un nuovo tipo di dati Char e un tipo di dati Long che è 64 bit. Il decimale è molto diverso. Short e Integer non hanno più la stessa lunghezza.

E c'è un nuovo tipo di dati "Oggetto" che può essere nulla. Ho sentito qualcuno dire "Figlio della variante"?

Infine! La medaglia d'oro, 1 ° posto, il premio più alto che posso conferire va a ...

TA DAH!

VB.NET è finalmente completamente orientato agli oggetti!

Ora, quando vai in spiaggia, i programmatori C ++ non ti scalcheranno la sabbia in faccia e ruberanno il tuo (fidanzata / ragazzo - scegline uno). E tu puoi ancora codificare un saldo di prova di contabilità generale completo mentre stanno cercando di capire quali file di intestazione includere.

Per la prima volta, puoi codificare il più vicino possibile al chip e accedere a tutti gli interni del sistema che il tuo cuore desidera senza dover ricorrere a quelle brutte chiamate API Win32. Hai eredità, sovraccarico di funzioni, multithreading asincrono, garbage collection e qualunque cosa è un oggetto. La vita può andare meglio?

Ho sentito qualcuno dire che C ++ ha eredità multipla e .NET ancora no?

Brucia l'eretico!