Visual Basic.NET vs C#

[Riddick]

Ho trovato qesto articolo girando sul web a casaccio xD, mi sembra molto interesante, anche perché da ciò che leggo, colui che ha scritto questo articolo non parla da solito "nabbo" ma parla da programmatore esperto.

Introduzione

Anni fa, quando fu presentato C# pensai di essere di fronte al linguaggio “definitivo”, semplice, veloce, potente. Forte della sua standardizzazione, C# poteva, forse, essere il linguaggio del futuro. A questo punto, “ruppi il mio salvadanaio” e acquistai due libroni (per la modica cifra di 110 Euro), interamente dedicati a questo linguaggio di programmazione.

Fortunatamente programmo da molti anni con Visual Basic, Visual C++ e PHP e ciò mi ha molto aiutato.

Allo studio di C# affiancai anche quello del nuovo Visual Basic.NET (studiando la sola documentazione ufficiale), ripromettendomi poi di esaminare l'uso di C++.NET non appena concluso il mio "studio comparato" tra VB e C#.

Durante l'apprendimento congiunto dei due linguaggi, non ho potuto fare a meno di paragonarli, per stabilire quale fosse il migliore, e su quale dovessi concentrare i miei sforzi.

Lo studio di C# non ha rappresentato un problema, così come per il nuovo VB.NET. In realtà lo scoglio più grande, non è la sintassi dei linguaggi, bensì l'acquisizione dell'enorme quantità di funzioni fornita dal framework di .NET, fortunatamente comune sia a C# sia a VB.

Dopo molto studio sono finalmente giunto ad una conclusione, ho infatti stabilito quale dei due è, a mio parere, il migliore e il più adatto per lo sviluppo con .NET.

In questo articolo cercherò di spiegare la mia scelta, mostrando quali sono alcuni dei motivi per i quali ritengo Visual Basic.NET, il più semplice e potente linguaggio oggi disponibile per la piattaforma .NET.

Attenzione : Per poter comprendere in maniera completa questo articolo occorre conoscere un minimo il Framework.NET, inoltre è indispensabile la conoscenza (anche minima) di una qualsiasi versione di VB oppure di C#.

La storia

In origine era il Basic, 'antico' linguaggio di programmazione per principianti. Poi, un bel giorno, arrivò Visual Basic.

Da molti punti di vista, si può dire che Visual Basic abbia fatto la storia dei linguaggi 'Visuali' e dei linguaggi di programmazione in genere. E' stato uno dei primi, se non il primo linguaggio a permettere il disegno dell'applicazione, integrando sapientemente l'ambiente di sviluppo con l'editor delle interfacce grafiche.

A Visual Basic si deve la nascita dei componenti VBX e forse, anche dei famigerati oggetti COM/OLE/ActiveX, giunti proprio con l'avvento di Visual Basic 4.

Come se non bastasse, Visual Basic è stato integrato in moltissimi software come linguaggio per la realizzazione di applicativi, il famoso VBA (Visual Basic for Application). Perfino prodotti Open Source come OpenOffice hanno un proprio ambiente di sviluppo, basato sul linguaggio Basic, che tenta di replicare, direi ottimamente, le funzionalità di VBA.

Non dimentichiamo il 'Windows Scripting Host', potente sistema di scripting con supporto per Visual Basic (chiamato Visual Basic Scripting) e Javascript, integrato in tutte le versioni di Windows a partire dalla versione 98. Inoltre come non parlare di 'Internet Explorer', che consente l'utilizzo di Visual Basic in sostituzione a Javascript.

Ricordo poi, per gli amanti di Linux, il progetto Gambas, simile a Visual Basic anche se non vuole esserne un clone. Ha il merito di introdurre un'ottima implementazione dello stile di sviluppo proprio di Visual Basic.

Attualmente, nonostante manchi una vera standardizzazione, Visual Basic è uno dei linguaggi più diffusi ed utilizzati, come si può constatare esaminando i dati forniti da TIOBE nel 'Programming Community Index' .

Dobbiamo sempre ricordare che, apprendere Visual Basic.NET significa avere le basi necessarie per utilizzare VBA (Word, Excel, AutoCAD, IntelliCAD ecc...), OpenOffice Basic, Visual Basic Scripting (con il Windows Scripting Host) e gli script VB in Internet Explorer.
In aggiunta a tutto ciò, saremo anche in grado di sfruttare uno qualsiasi degli altri ambienti basati sul linguaggio BASIC, che è alla base si Visual Basic stesso. Un esempio su tutti è FreeBasic , implementazione multipiattaforma del linguaggio originale, con molte librerie, gestione dell'interfaccia grafica (GTK, Windows nativa, WxWidget, ecc...), compilatore per la generazione di Veri file eseguibili!. Un gran bel lavoro nel pieno rispetto delle regole del "software libero".

Altri esempi possono essere rappresentati da :
Mono's VisualBasic.NET CompilersdlBasic;
sdlBasic, implementazione dedicata alla realizzazione di giochi 2D;
RealBasic, compilatore commerciale potente e facile da utilizzare;
e tanti altri ancora...

Praticamente un linguaggio inserito in una moltitudine di situazioni, semplice, veloce e potente.

Cosa dire invece di C#. Nato da poco, reso standard, è stato presentato come il principe dei linguaggi di programmazione ed è servito a Microsoft per scrivere gran parte delle librerie di .NET. Sintatticamente simile a C++ e Java, appare mirato a catturare i programmatori provenienti da questi linguaggi.

Presente sulla scena da alcuni anni, la sua diffusione ha raggiunto un discreto livello, questo grazie anche alla spinta di Microsoft, e sono state realizzate in C# diverse applicazioni, come ad esempio l'IDE SharpDevelop, oppure il software di fotoritocco Paint.NET

Purtroppo, parte delle mie aspettative sono state disattese, infatti trovo che C# non offra particolari innovazioni o semplificazioni, semplicemente replica cose già viste con altri sistemi e altri linguaggi, lo considero comunque un buon linguaggio.

Passiamo al Confronto

Veniamo ora al confronto vero e proprio tra Visual Basic.NET e C#. Di seguito cercherò di rispondere a questa domanda :

Perchè utilizzare Visual Basic.NET e non C# ?

In questo articolo esaminerò quelle caratteristiche che, a mio parere, rendono VB superiore a C#. Il tutto basandomi sui linguaggi disponibili con il .NET Framework 1.1.

Visual Basic.NET meglio di C#!

Le Istruzioni e il loro terminatore

Iniziamo con una preferenza molto personale. Osserviamo questa riga di codice C# :
C#
a = b + c;

Come si può notare l'istruzione termina con il carattere ';'. Infatti è proprio questo elemento che stabilisce la fine di un'istruzione e l'inizio della successiva, ciò significa che spazi, parentesi, ritorni a capo, non hanno alcuna importanza. Questo ci consente di riscrivere la precedente così :
C#
a
=
b
+
c
;

Queste linee in C# sono perfettamente legali. Naturalmente a nessuno verrebbe mai in mente di scrivere una cosa del genere, però è possibile sfruttare questa caratteristica, volontariamente o involontariamente, per rendere il codice assolutamente illeggibile e difficilmente manutenibile.

Al contrario, Visual Basic prevede, come terminatore, un carattere di fine riga (in realta i caratteri sono due CR+LF). In questo modo, non solo si evita l'inserimento accidentale di istruzioni su più righe ma, nel caso in cui si desideri dividere le istruzioni, permette di identificare in maniera molto chiara il punto nel quale avviene l'interruzione.

Osserviamo questa riga di codice Visual Basic :

VB.NET
a = b + c

In questo caso il ritorno a capo determina la conclusione dell'istruzione. Se però volessimo spezzarla su più righe :

VB.NET
a = _
b + c

Come si può notare, la divisione avviene tramite il carattere '_'. L'uso di questo carattere consente, a chi legge il codice, di identificare immediatamente le linee spezzate, rendendo così il sorgente più chiaro e meno ingannevole.

Lo stile senza parentesi

Anche in questo caso parliamo di chiarezza. Una delle caratteristiche che più apprezzo, quando leggo il codice di un programma è l'uniformità nello stile.

Con i linguaggi derivati da C, come ad esempio C#, posso scrivere :
C#
if (a > 1) {
...
} else {
...
} oppure
if (a > 1)
{
...
}
else
{
...
} oppure
if (a > 1)
{...}
else
{...}

Questa varietà, nonostante consenta di trovare lo stile che più ci aggrada, ci permette di scrivere codice poco uniforme al punto da rendere la lettura difficoltosa, soprattutto quando sono più persone che collaborano allo sviluppo del medesimo programma.

Al contrario Visual Basic.NET, ci aiuta nel rendere uniforme ciò che scriviamo. Infatti possiamo solo scrivere :

VB.NET
If (a > 1) Then
...
Else
...
End If

Tutto qui!

Pensiamo ora ad un codice molto lungo, nel quale si annidano, gli uni negli altri cicli e strutture come 'If', 'While', 'For', ecc... Nella mia cariera, più di una volta, mi è capitato di trovarmi di fronte a cose del genere (C/C++/C#) :
C#
...
}
}
}
}
}

Ovviamente ci si chiederà, cosa terminano queste parentesi ? Quale chiude l'If' ? Quale il 'While'? ecc...

Con i moderni editor di testo, si giunge presto alla risposta andando a ricercare la parentesi aperta corrispondente.

Con Visual Basic.NET questo problema si riduce al minimo, infatti :

VB.NET
...
End If
Next i
End While
End If
End Sub

Nonostante io abbia scritto un po di più, ho il vantaggio di capire quale costrutto termina, senza essere costretto a ricercare il suo inizio, addirittura nel caso del costrutto 'For..Next' conosco anche la viriabile sulla quale si sta agendo.

Il linguaggio Sensibile alle MAIUSCOLE/minuscole

Parliamo ora di MAIUSCOLE e minuscole. C# è un chiaro esempio di linguaggio 'case sensitive', ciò significa che chiamare la funzione 'miafun' è diverso che chiamare 'Miafun' o 'miaFun'.

Al contrario, per Visual Basic, chiamare una variabile 'miavar', 'Miavar' o 'MIAVar' non fa alcuna differenza. Questo comportamento, nonostante consenta di scrivere codice poco uniforme, ha il grande vantaggio di non costringere il programmatore a ricordare la sintassi esatta dei nomi di varibili, funzioni, metodi, proprietà, permettendo ad esempio, l'uso di editor non specializzati per scrivere il codice, oppure evitando inutili ricompilazioni dovute all'inserimento di una maiuscola al posto di una minuscola. Inoltre tale caratteristica rende VB un perfetto candidato ad essere anche un linguaggi di scripting.

In aggiunta a tutto ciò sussiste, nell'utilizzo pratico, un problema con C#.

La specifiche CLS (Common Language Specification) di .NET, prevedono che :
"Perché due identificatori vengano considerati distinti, occorre che non differiscano solo per la combinazione di caratteri maiuscoli o minuscoli."

Ciò significa che, se scrivo una classe con C#, la quale contiene due metodi, 'MetodoMio' e 'metodomio', questa potrà essere usata con altri linguaggi (es. Visual Basic.NET), ma il suo metodo 'MetodoMio' NON potrà mai essere richiamato.

Ovviamente, Visual Basic.NET non presenta questo inconveniente, impedendo la creazione di due metodi con lo stesso nome (ignorando maiuscole e minuscole)

Dichiarazione variabili ed operatore New

Una delle caratteristiche che più apprezzo di Visual Basic.NET è la sua 'descrittività'.

Osserviamo questo codice C# :
C#
Int valint;
String valstr;
Decimal valdec;
bool valbol;

E ora osserviamo il corrispondente Visual Basic.NET :
VB.NET
Dim valint as Integer
Dim valstr as String
Dim valdec as Decimal
Dim valbol as Boolean

Come si può notare, VB possiede una sintassi molto più descrittiva e chiara, anche per il neofita, al contrario, come per tutti i linguaggi derivati dal C, C# è molto più criptico.

In aggiunta a ciò, Visual Basic consente l'utilizzo dell'opzione 'Option Explicit Off' che permette di non dichiarare le variabili.

Ad esempio :
VB.NET
a = "roberto"
System.Console.WriteLine(a)

In questo caso, l'opzione 'Option Explicit Off' consente di utilizzare immediatamente la variabile 'a' senza alcuna dichiarazione. Omettendo l'impostazione di 'Option Explicit', verrà automaticamente impostata a 'On'.

Passiamo ora ad esaminare l'uso della parola chiave 'New' che permette di instanziare un'oggetto.

Per C# :
C#
ArrayList myAL = new ArrayList();

oppure

ArrayList myAL;
myAL = new ArrayList();
Per Visual Basic.NET :
VB.NET
Dim myAL As ArrayList = New ArrayList()

oppure

Dim myAL As ArrayList
myAL = New ArrayList()

oppure

Dim myAL As New ArrayList()

Visual Basic.NET, non solo permette l'uso di 'New' esattamente come C#, ma eredita dal vecchio Visual Basic 6, un terzo tipo di dichiarazione, più breve e più chiaro.

Inizializzazione automatica delle variabili

Siamo giunti ad una delle cose che preferisco di Visual Basic.NET, l'inizializzazione automatica delle varibili. Caratteristica presente in molti altri linguaggi (es.: PHP, Lisp, ecc...).

Osserviamo questo spezzone di codice VB :
VB.NET
Dim i as Integer
While (i < 10)
System.Console.WriteLine(i)
i+=1
End While

In questo caso il ciclo stamperebbe i numeri da 0 a 9, infatti, VB inizializza automaticamente le variabili all'atto della loro dichiarazione. Questo comportamente, non solo consente di scrivere meno, ma riduce anche il codice superfluo presente nei listati.

Con C# al contrario, il seguente codice :
C#
int i;
while (i < 10)
{
System.Console.WriteLine(i)
i++
}

Produce questo errore :
error CS0165: Utilizzo della variabile locale 'i' non assegnata.

Ciò è dovuto al fatto che 'i' deve essere, tassativamente, inizializzata (es. : int i=0.

Conversione dei tipi

La caratteristica che esamineremo ora, consente a Visual Basic.NET la conversione automatica tra tipi di dati che potrebbero comportare perdite di dati e tutte le conversioni tra tipi numerici e stringhe.

Utilizzando l'istruzione 'Option Strict Off' possiamo scrivere :
VB.NET
Dim a As String
Dim b As Integer

b = 3
a = b

In questo caso la conversione da Intero a Stringa è completamente automatica.

Al contrario utilizzando 'Option Strict On', sarà necessario utilizzare una conversione esplicita :
VB.NET
Dim a As String
Dim b As Integer

b = 3
a = CStr(b)

Al contrario in C# non esiste alcuna possibilità di scelta, tutte le conversioni devono essere solo ed esclusivamente Esplicite.

Array e ReDim

Sia Visual Basic.NET, sia C# consentono l'utilizzo di array a uno o più dimensioni.

Nonostante ciò VB possiede alcune caratteristiche, molto utili, che lo distinguono da C#.

Osserviamo questo codice :
VB.NET
Dim s(5) As String
s(5) = "Roberto"

Prima di tutto bisogna notare che, il numero racchiuso tra parentesi nella dichiarazione, rappresenta l'indice massimo utilizzabile e non, come in C#, il numero di elementi dell'array.

Ciò può sembrare strano ma, al contrario è molto logico. Infatti, in tutto il codice si fa riferimento sempre e soltano all'indice dell'array che si vuole leggere o impostare, di conseguenza perchè mai, durante la sua dichiarazione, dovrei utilizzare un indice che in realtà non esiste? Mi pare molto più comodo utilizzare l'indice dell'ultimo elemento valido dell'array. Ricordandomi che, comunque, l'elemento con indice minore è sempre il numero 0.

Altra caratteristica unica di VB è l'uso di REDIM, ad esempio :
VB.NET
Dim s(5) As String
...
ReDim s(10)

In questo caso, l'array 's' viene ridimensionato passando da 6 (0..5) a 11 (0..10) elementi. Dopo il ridimensionamento, 's' sarà un array completamente vuoto. La cosa interessante è però questa :
VB.NET
Dim s(5) As String
...
ReDim Preserve s(10)

Come nel precedente caso l'array 's' viene ridimensionato, con la differenza che, questa volta, gli elementi in esso contenuti non scompaiono ma vengono 'Preservati'. In pratica gli elementi presenti nel vecchio 's' vengono copiati all'interno del nuovo array.

Gli Operatori di Confronto

Anche in questo caso parliamo di chiarezza e leggibilità. Trovo infatti le espressioni di confronto, scritte in Visual Basic.NET, molto più chiare ed immediate, mentre C# presenta la sua solita sintassi criptica.

Ad Esempio, C# :
C#
if ((a < 1) && (b < 1)) //Operatore 'and' (&&)
if ((a < 1) ‌‌ (b < 1)) //Operatore 'or' (‌‌)
if !(a < 1) //Negazione booleana 'not' (!)
if (a == 1) // Uguale (==)
if (a != 1) // Diverso (!=)

e per Visual Basic.NET :
VB.NET
if ((a < 1) And (b < 1)) Then 'Operatore 'and'
if ((a < 1) Or (b < 1)) Then 'Operatore 'or'
if Not(a < 1) Then 'Negazione booleana 'not'
if (a = 1) Then 'Uguale (=)
if (a <> 1) Then 'Diverso (<>)

Confronto fra Stringhe

Può apparire strano ma anche il modo di confrontare due stringe pone VB.NET un gradino sopra C#.

In tutti i linguaggi di programmazione, se noi confrontassimo queste due stringhe :

"miastringa" "MiaStringa"

il programma ci direbbe che queste sono diverse. C# e VB.NET si comportano esattamente così.

Visual Basic.NET, nel corso degli anni ha dovuto adattarsi alle richieste degli sviluppatore ed è cresciuto molto. Durante questa evoluzione sono state introdotte molte istruzioni, una delle quali è 'Option Compare'.

Tale istruzione specifica il metodo di confronto delle stringhe, e può essere di tipo binario (Binary) o testuale (Text). Se non è presente 'Option Compare', viene utilizzato Binary come metodo di confronto predefinito.

Se ne deduce che inserendo 'Option Compare Text', il confronto tra le due stringhe precedenti ci dirà che queste sono identiche!

Infatti la modalità di confronto 'Text' prevede questo ordinamento :
(A=a) < ( À=à) < (B=b) < (E=e) < (Ê=ê) < (Z=z) < (Ø=ø)

Mentre 'Binary' :
A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø

L'opzione 'Option Compare' può essere utilizzata all'interno dei singoli file, ciò fornisce al programmatore una maggiore flessibilità.

L'utile With

Funzionalità presente nel solo Visual Basic.NET, l'istruzione With...End With consente di eseguire una serie di istruzioni su un oggetto specificato senza che sia necessario riqualificare il nome dell'oggetto.

Ad Esempio :
VB.NET
With Label1
.Height = 1000
.Width = 5000
.Text = "Questa è la mia Label"
End With

In questo modo si evita di riscrivere più volte il nome dell'oggetto, rendendo il codice più chiaro e privo di inutili ripetizioni.

La Cortocircuitazione

In C#, utilizzando istruzioni composte viene sempre impiegata una tecnica chiamata 'cortocircuitazione'. Questa consiste nell'eseguire solamente le parti necessarie, tralasciando ciò che è superfluo.

Per maggiore chiarezza, facciamo un esempio :
C#
if ( (a == 1) || (b == 2) )
{
...
}

La condizione valutata è composta da due parti, se la prima parte risultasse vera (a==1) C# NON valuterebbe mai la seconda parte ed eseguirebbe il codice interno al costrutto 'if'.

In Visual Basic.NET :
VB.NET
if ( (a = 1) Or (b = 2) ) then
...
End If

In questo caso, prima vengono valutate entrambe le parti della condizione, e subito dopo viene stabilito se eseguire o meno il codice interno.

Ciò non significa che VB.NET manchi della cortocircuitazione, al contrario permette al programmatore di scegliere quale metodo utilizzare. Infatti troviamo due nuovi operatori, 'AndAlso' e 'OrAlso', che permettono l'uso della tecnica in questione. Quindi, riscrivendo l'esempio :
VB.NET
if ( (a = 1) OrAlso (b = 2) ) then
... End If

L'aggiunta di questi operatori, oltre a consentire una compatibilità con il passato (VB6 e precedenti), permette una maggiore flessibilità rispetto ad altri linguaggi (es.: C#).

Select Case, Intervalli ed Espressioni Multiple

Sia in C# che in Visual Basic.NET è possibile disporre di un'istruzione che gestisce più selezioni trasferendo il controllo a una delle istruzioni 'case' presenti nel corpo.

Sto parlando di 'switch' (C#) e di 'Select Case' (VB.NET). Osserviamo questi esempi :
C#
switch(n)
{
case 1:
a = 1;
break;
case 2:
a = 2;
break;
default:
Console.WriteLine("N non valido.");
break;
}

VB.NET
Select N
Case 1
Console.WriteLine("N = 1")
Case 1 To 5
Console.WriteLine("N compreso fra 2 e 5")
Case 6, 7, 8
Console.WriteLine("N = 6 o 7 o 8")
Case Is > 8
Console.WriteLine("N > 8")
Case Else
Console.WriteLine("N non valido!")
End Select

In C# ogni espressione specificata nell'istruzione 'case' è un semplice valore, al contrario in VB.NET può essere un valore (stringa, intera, ecc..), può essere un intervallo (To), può essere una condizione (Is), addirittura è possibile combinare i vari tipi. Ad Esempio :
VB.NET
Case 1 To 4, 7 To 9, 11, 13, Is > 50

oppure

Case "mela", "a" To "z", ElementoTest

In questo caso Visual Basic.NET dimostra la sua estrema flessibilià, potenza, semplicità e soprattutto chiarezza nelle espressioni. C# invece rimane ancorato alle classiche strutture C/C++/Java senza introdurre alcun miglioramento significativo.

For Each

Entrambe i linguaggi dispongono di un'istruzione per permette di scorrere un'array o un'insieme di oggetti, esaminandone un'elemento alla volta.

In C# troviamo 'Foreach', mentre in VB.NET 'For Each'. Il loro funzionamente è molto simile, l'unica differenza risiede nella capacità di VB.NET di impostare la variabile nella quale, di volta in volta, vengono posti gli elementi analizzati.

Osserviamo questo esempio :
VB.NET
Dim Nazioni(20) As String
Dim NomeNazione As String

For Each NomeNazione In Nazioni
If NomeNazione = "" Then
NomeNazione = "Italia"
End If
System.Console.WriteLine(NomeNazione)
Next NomeNazione

Si osservi che la variabile 'NomeNazione' può essere modificata all'interno del 'For Each', questo senza intaccare i dati presenti nell'array esaminato. Tale interessante caratteristica è assente in C#, che di fatto segnala un errore.

La Gestione dell'Errore

In questo campo VB.NET e C# appaiono, ad una prima analisi, molto simili. Entrambe gestiscono gli errori con i costrutti 'throw', 'try-catch', 'try-finally', 'try-catch-finally'.

Ciò che li distingue e che semplifica la vita agli sviluppatori VB.NET è la presenza, in questo linguaggio, dell'istruzione 'On Error'. Derivata dalle precedenti versioni, 'On Error' consente di attivare una routine di gestione degli errori e di specificarne la posizione all'interno di una routine più ampia, permettendo inoltre di disattivare una routine di gestione degli errori precedentemente attivata.

Chi volesse utilizzare una gestione semplificata dell'errore, troverà in 'On Error' una valida soluzione.

Vista la varietà di usi che si possono fare di 'On Error', per gli esempi si consulti la documentazione ufficiale :
Microsoft MSDN

Le Funzioni

Molte cose ci sarebbero da dire sulle funzioni. VB.NET permette alcuni utilizzi non previsti da C#.

Prima di tutto, con Visual Basic.NET è superfluo indicare il valore ritornato dalle funzioni se questo è nullo ("" per le stringhe, 0 per i numeri, ecc...), infatti se si omette l'istruzione 'return', la funzione restituirà proprio 0, "", ecc... a seconda del tipo di dato.

Ad esempio :
VB.NET
Function TestFx (retA As Boolean) As Integer
Dim a As Integer

If (retA) Then
a = 1
Return a
End If
End Function

In questo caso, la funzione restituirà 0 se 'retA=False', altrimenti ritornerà 1.

L'uso sapiente di questo automatismo consente di minimizzare l'uso dell'istruzione 'Return', rendendo più semplice e scorrevole la lettura del codice, riuscendo a focalizzare l'attenzione sui dati più significativi.

Un'altra particolare caratteristica di Visual Basic.NET è quella di disporre di un sistema alternativo a 'Return'. All'interno delle funzioni è disponibile una variabile che possiede lo stesso nome della funzione, settando la quale, di fatto si imposta il valore da restituire.

Ad esempio, riscrivendo la funzione precedente :
VB.NET
Function TestFx (retA As Boolean) As integer
Dim a As Integer

If (retA) Then
a = 1
TestFx = a
End If
End Function

Per concludere il discorso, non bisogna dimenticare i parametri opzionali. E' infatti possibile definire alcuni parametri come opzionali, ciò permette la loro omissione nella chiamata della funzione.

Ad esempio :
VB.NET
Sub TestFx (par1 As Integer, _
Optional par2 as String = "", _
Optional par3 as Boolean = True)
...
End Sub

In questo esempio 'par2' e 'par3' sono dichiarati opzionali, ciò significa che all'atto della chiamata potremo, a nostra discrezione, indicare o meno i loro valori.

Il modificatore 'Optional', risulta particolarmente utile per semplificare l'uso di funzioni complesse senza dover ricorrere all'overloading. 'Optional' NON è presente in C# ma solo in VB.NET.

I Comandi Visual Basic

Come accade in molti altri linguaggi, Visual Basic.NET possiede una nutrita serie di funzioni, proprietà, metodi, tipi e costanti facenti parte della sua libreria di runtime. Queste, vanno ad aggiungersi alle classi proprie del framework di .NET.

L'uso delle funzioni interne di VB.NET consente, al programmatore, la semplificazione di molte operazione che altrimenti, dovrebbero essere svolte tramite l'uso delle classi del framework.

Per comprendere meglio l'utilità delle funzioni integrate nel runtime di VB.NET osserviamo quanto segue :
VB.NET
'Finestra di messaggio utilizzata attraverso le classi del framework
MessageBox.Show(Me, "Messaggio", "Titolo", MessageBoxButtons.YesNo, _
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1, _
MessageBoxOptions.RightAlign)

'Finestra di messaggio utilizzata attraverso le classi di runtime di VB.NET
MsgBox("Messaggio", vbYesNo Or vbQuestion Or _
vbDefaultButton1 Or vbMsgBoxRight, "Titolo")

Come si può notare l'utilizzo delle funzioni e delle costanti di runtime, semplifica enormemente l'istruzione rendendola molto più chiara ed immediata.

C#, nonostante sia in grado di utilizzare anche le funzioni proprie di VB.NET (in maniera decisamente più macchinosa), non dispone di una propria libreria di runtime.

Using e Imports

In .NET l'organizzazione dei programmi C#, VB, ed in genere qualsiasi altro linguaggio basato su questa piattaforma, si poggia sull'uso degli spazi dei nomi. Questi vengono utilizzati sia come sistema organizzativo "interno" che come sistema organizzativo "esterno", ovvero come un modo per presentare gli elementi del programma esposti ad altri programmi.

Per semplificare l'utilizzo degli spazi dei nomi (namespace) sono disponibili , in VB e C#, le direttive 'imports', per il primo, e 'using' per il secondo.

Così come in altri casi, anche questa volta Visual Basic.NET si pone un gradino sopra C#.

Sia la direttiva 'Using', sia 'Imports' consentono la creazione di un alias per uno spazio dei nomi e l'uso dei tipi in uno spazio dei nomi, evitando di dover qualificare l'uso di un tipo in tale spazio.

Senza queste istruzioni, per utilizzare l'oggetto 'Console' dovremo scrivere così :
C#
System.Console.WriteLine("Messaggio...");

VB.NET
System.Console.WriteLine("Messaggio...")

Al contrario utilizzando 'Using' e 'Imports', semplificheremmo il tutto :
C#
Using System

Console.WriteLine("Messaggio...");

VB.NET
Imports System

Console.WriteLine("Messaggio...")

Con Visual Basic.NET, e la sua 'Imports', possiamo anche fare di meglio. Infatti 'Imports' consente, non solo l'importazione di spazi di nomi ma anche di classi (come ad esempio la classe 'Console'). Questa importante caratteristica ci consente di far riferimento agli elementi di una classe senza doverla specificare.

Riscrivendo l'esempio precedente :
VB.NET
Imports System.Console

WriteLine("Messaggio...")

Questa possibilità, purtroppo, è completamente assente in C#.

I Moduli

In C# l'elemento principale è la Classe. Tutto è racchiuso al suo interno.

VB.NET si spinge oltre, infatti supporta pienamente le Classi (come C#), aggiungendo la possibilità di utilizzare i Moduli.

Questi rappresentano un tipo di riferimento simile alle classi, dalle quali si distinguono però per alcune caratteristiche significative. I loro membri sono, in modo implicito, di tipo 'Shared' (identico allo 'static' di C# )e il loro ambito è limitato allo spazio di dichiarazione dello spazio dei nomi in cui il modulo è dichiarato. A differenza delle classi, i moduli non possono essere instanziati, non supportano l'ereditarietà e non possono implementare interfacce. Un modulo può solamente essere dichiarato in uno spazio dei nomi.

Naturalmente, all'interno dello stesso progetto possono essere presenti più moduli.

Una cosa interessante è che i moduli possono essere esportati, esattamente come le classi, e utilizzati da altri linguaggi.

All'atto pratico un modulo può essere paragonato ad una libreria di variabili, proprietà, eventi, metodi e funzioni in genere.

I Membri Shared

Vengono chiamati metodi condivisi. Sono disponibili sia in C# (usando il modificatore 'Static'), sia in VB.NET (usando il modificatore 'Shared').

Questi metodi non agiscono su una specifica istanza di un tipo e possono essere richiamati direttamente dal tipo anziché attraverso una particolare istanza.

Facciamo un esempio di metodo condiviso :
C#
Class Test
{
private int x;

public static int fxCondivisa()
{
return x;
}
}

Class App
{
public static void Main()
{
int valx;
Test t = New Test();

valx = Test.fxCondivisa();
valx = t.fxCondivisa(); //ERRORE!!!
}
}

VB.NET
Class Test
Private x As Integer

Shared Function fxCondivisa() As Integer
return x
End Function
End Class

Shared Sub Main()
Dim valx As Integer
Dim t As New Test()

valx = Test.fxCondivisa()
valx = t.fxCondivisa()
End Sub

Ciò che VB.NET è in grado di fare, e C# no, è utilizzare i membri 'shared' attraverso l'istanza degli oggetti e non solo attraverso il tipo. Si può in pratica affermare che gli elementi 'shared' sono parte effettiva sia del tipo, sia delle sue istanze.

Avviare i Programmi

Con .NET, l'avvio di un programma avviene attraverso il metodo 'Main'. Indipendentemente dal linguaggio, il metodo 'Main' viene richiamato immediatamente all'avvio del software. Si può dire che 'tutto parte da qui'.

Esistono diversi tipi di dichiarazione per il metodo 'Main', che solitamente risiede all'interno di una Classe. Vediamo un piccolo esempio :
C#
class AppClass
{
public static int Main(string[] args)
{
...
return 0;
}
}

VB.NET
Class AppClass

Function Main(ByVal Args() As String) As Integer
...
return 0;
End Function
End Class

In entrambe i casi, 'Main' si trova all'interno di una classe e riceve, come parametro, l'elenco degli argomenti passati all'eseguibile.

Oltre ai normali utilizzi, Visual Basic.NET aggiungie una interessante caratteristica.

Con VB.NET è possibile evitare l'uso di una classe sostituendola con un semplice modulo :
VB.NET
Module AppMod

Function Main(ByVal Args() As String) As Integer
...
return 0;
End Function
End Module

Questo consente un approccio procedurale alla programmazione, utile soprattutto per piccoli software, dove la struttura generale ha una rilevanza marginale. Comodo per la crezione di semplici librerie di funzioni e intuitivo per il programmatore alle prime armi.

Proprietà

La definizione delle proprietà all'interno delle classi è fondamentale per la gestione degli oggetti. VB.NET e C# consentono un completo controllo su questo importante aspetto.

Come spesso accade, Visual Basic.NET aggiunge una possibilità in più. Con questo linguaggio è infatti possibile definire delle proprietà dotate di parametri. Ad Esempio :
VB.NET
Imports System

Module TestVB

Class clTest
Private strValore As String

Property valore() As String
Get
Return strValore
End Get

Set (ByVal value As String)
strValore = value
End Set
End Property

Property valore(ByVal tipo as string) as string
Get
Return strValore
End Get

Set (ByVal value As string)
strValore = value + " " + tipo
End Set
End Property
End Class

Sub Main()
Dim testObj As New clTest

'proprietà semplice
testObj.valore = "Roberto"
Console.WriteLine(testObj.valore)

'proprietà con parametro
testObj.valore("Rossi") = "Roberto"
Console.WriteLine(testObj.valore)

End Sub
End Module

Alcuni mi hanno fatto notare che questa caratteristica è presente anche in C#. In realtà non è così. C# consente di utilizzare gli indicizzatori. Questi sono membri che consentono di indicizzare un oggetto come se si trattasse di una matrice. In questo caso però si va ad agire su tutto sull'oggetto e non sulla singola proprietà. E' sottointesto che VB.NET possiede anche questa capacità.

Late Binding

Sia C#, sia VB.NET consentono, durante l'esecuzione di un programma di instanziare un'oggetto dinamicamente e indipendentemente dal suo tipo, potendone ricavare ed utilizzare metodi, proprietà ed eventi. Ciò avviene attrave l'utilizzo della tecnica di Riflessione.

In pratica si ha un'oggetto di tipo 'generico' che può essere assegnato ad un tipo X e quindi, è possibile utilizzare metodi, proprieta ed eventi proprio del tipo X.

Vista la complessità dell'argomento, rimando alla documentazione ufficiale ( La Riflessione).

VB.NET possiede la capacità di utilizzare l'associazione tardiva (Late Binding), che in pratica si affianca al sistema di riflessione e semplifica enormemente l'utilizzo dinamico degli oggetti.

Vediamo un esempio :
VB.NET
Imports System

Module TestVB

Class clTest
Private strValore As String

Public Sub SetValore (ByVal dato As String)
strValore = dato
Console.WriteLine(dato)
End Sub
End Class

Sub Main()
Dim testObj As Object 'tipo generico

testObj = New clTest
testObj.SetValore("Esempio...")
End Sub

End Module

Come si può intuire, utilizzare un oggetto di tipo generico (Object), e poi utilizzarlo come se fosse stato convertito in un tipo specifico (clTest), riduce la quantità di codice scritto, rendendo più chiaro e lineare il listato.

Ora applichiamo questa potente funzione di Visual Basic.NET per utilizzare un'istanza di 'Internet Explorer' :
VB.NET
Imports Microsoft.VisualBasic

Module TestVB
Sub Main()
Dim ieObj As Object 'tipo generico

ieObj = CreateObject("InternetExplorer.Application")

ieObj.MenuBar = false
ieObj.Visible = true
ieObj.Navigate("http://rsoftware.altervista.org")
End Sub
End Module

Quest'ultimo utilizzo del 'late binding', associato agli oggetti ActiveX, permette il rapido e semplice riutilizzo di una moltitudine di componenti e applicazione già esistenti (es.: Excel, Word, OpenOffice, AutoCAD ecc...).

Putroppo il 'Late Binding' NON è presente in C#.

Overloading dei Membri nelle Classi

Esistono alcune cose nei linguaggi di programmazioni che mi lasciano molto perplesso.

C#, nuovissimo linguaggio "super moderno", porta con se una triste caratteristica, legata all'ereditarietà.

Osserviamo :
C#
using System;

class AppMain {

public static void Main() {

Derivata objDerivato = new Derivata();
clTest objTest = new clTest();

objDerivato.FunzioneInterna(objTest);
}

}

class clTest
{
//Classe per Test
}

class Principale
{
public virtual void FunzioneInterna (clTest oggetto)
{
Console.WriteLine("Esecuzione FunzioneInterna(clTest) in Classe Principale");
}
}

class Derivata : Principale
{
public override void FunzioneInterna (clTest oggetto)
{
Console.WriteLine("Esecuzione FunzioneInterna(clTest) in Classe Derivata");
}
public void FunzioneInterna (object oggetto)
{
Console.WriteLine("Esecuzione FunzioneInterna(object) in Classe Derivata");
}
}

Il risultato prodotto al prompt dei comandi :

Esecuzione FunzioneInterna(object) in Classe Derivata

Esaminando il codice si vede, charamente, che l'oggetto objTest (di tipo clTest), passato al metodo FunzioneInterna della classe Derivata, esegue "FunzioneInterna(object oggetto)". La cosa strana è che, all'interno della classe Derivata è presente un'altro metodo FunzioneInterna che accetta esattamente il tipo di dato di objTest (tipo clTest). Perchè non viene richiamato questo metodo, visto che è decisamente più compatibile con il dato passato ? Ma?!?! Non mi capacito.

Evidentemente C# porta con se l'eredità di C++ che funziona esattamente allo stesso modo.

Visual Basic.NET al contrario, si comporta esattamente come vorrebbe la logica. Osserviamo lo stesso esempio :
VB.NET
Imports System

Module TestVB

Sub Main()
Dim objDerivato As New Derivata
Dim objTest As New clTest

objDerivato.FunzioneInterna(objTest)
End Sub

End Module

Class clTest
'Classe per Test
End Class

Class Principale
Public Overridable Sub FunzioneInterna(oggetto As clTest)
Console.WriteLine("Esecuzione FunzioneInterna(clTest) in Classe Principale")
End Sub
End Class

Class Derivata : Inherits Principale
Public Overloads Overrides Sub FunzioneInterna (oggetto As clTest)
Console.WriteLine("Esecuzione FunzioneInterna(clTest) in Classe Derivata")
End Sub

Public Overloads Sub FunzioneInterna (oggetto As Object)
Console.WriteLine("Esecuzione FunzioneInterna(object) in Classe Derivata")
End Sub
End Class

Il risultato prodotto al prompt dei comandi :

Esecuzione FunzioneInterna(clTest) in Classe Derivata

Logicamente, passando l'oggetto objTest (tipo clTest) al metodo FunzioneInterna presente nella classe Derivata, viene richiamato il metodo più compatibile con il tipo di dato utilizzato.

Considerazioni Finali

Per concludere, ecco la fatidica domanda. Usare Visual Basic.NET o C#?

Secondo il mio parere, dipende da quali conoscenze di base si hanno e da quali progetti si vogliono realizzare.

Se non si hanno esperienze di programmazione, la strada migliore è quella di VB.NET. Più intuitivo e semplice, può sfruttare completamente le funzionalità di .NET.

Se si proviene da vecchie versioni di Visual Basic, e non si vuole perdere tempo per nulla, la scelta più sensata è VB.NET.

Se si programma in Java, passando a C# si semplifica la migrazione, avendo quest'ultimo una sintassi in stile C++.

Conoscendo C/C++ la questione è più complessa. Da un lato la migrazione a C# sarebbe più semplice, però bisogna considerare che C++ consente l'utilizzo del Framework .NET senza bisogno di cambiare linguaggio. Ciò, dal mio punto di vista, significa che chi sviluppa con C++ avrebbe maggiori vantaggi a continuare su questa strada aggiungendo le conoscenze sulle librerie .NET. Inoltre non dimentichiamoci che, comunque, l'uso di C/C++ è ancora indispensabile in una moltitudine di casi, soprattutto quando si vogliono realizzare applicazioni particolarmente pesanti (es.: software di CAD), magari da far girare du PC non molto potenti, o più semplicemente se si desidera integrare particolari procedure (Es.: codice assembler). Si tenga anche presente che C/C++ è l'unico linguaggio a poter compilare i software senza la necessita di installare il Framework.NET.

Per gli utilizzatori di altri linguaggi (es.: Delphi, Lisp, ecc...), soprattutto quelli che non possiedono una sintassi simile a C/C++, e che desiderano sviluppare con i prodotti Microsoft, VB.NET rappresenta la scelta più azzeccata, sufficientemente semplice, descrittivo, chiaro e con tutta la potenza di .NET.

Se si desidera sviluppare software per Linux, la scelta attualmente appare obbligata, C#. I due progetti principali di porting di .NET su Linux, comprendono solo compilatori C# e C. Nello specifico sto parlando di :

Mono
DotGNU

Bisogna però dire che sono già in preparazione compilatori Visual Basic.NET anche per questi progetti. Ad esempio, il progetto Mono prevede l'introduzione del compilatore VB.NET già nell'anno in corso (2005).

Infine parliamo di prestazioni. Questa volta Microsoft ha detto il vero. A parità di funzioni utilizzate, che il software venga sviluppato con Visual Basic.NET o C#, le prestazioni non cambiano di una 'virgola'.

Chi volesse fornire il suo contributo con, critiche, suggerimenti, aggiunte, segnalazioni di errore, ecc... può farlo cliccando qui.

Copyright e autorizzazione:

Copyright 2005-2009 Roberto Rossi

Web : Gli ospiti non possono vedere link nei messaggi. Registrati QUI per vedere i link.

La copia di questo articolo e la sua distribuzione sono permessi in qualsiasi forma senza il pagamento di diritti di autore a patto che l'indicazione del copyright e questa indicazione siano riportate.

[KillerZ]

Se devo dire la mia, questo si sbaglia alla grande, non ho niente contro il visual basic, ma certe dichiarazione che fa.....
Non credo sia un confronto equo perchè parla in modo soggettivo e non oggettivo.
Ad esempio dice che è meglio senza case sensitive, invece a me piace perchè posso dichiarare 2 variabili con lo stesso nome ma scritto diversamente.
Oppure le parentesi, io preferisco annidarli non dichiarare end if, end while.....

Secondo me non è una giusta comparazione. Inoltre se devo dire la mia, Visual Basic è più da principianti per il linguaggio semplice, mentre C# è più complicato e come dice lui criptico.

[Riddick]

Hai fatto bene a dire la tua....

Comunque visual basic non è un linguaggio solo per principianti... perché tra il visual basic e il c# oltre a queste differenze non ci passa nulla, io pensavo che il c# era più veloce ma è del tutto sbagliato, in quanto usano tutte e due i linguaggi lo stesso framework.

Qui ovviamente, ci sono anche pareri oggettivi ma molti anche soggettivi, uno come si trova meglio cosi lavora, però di differenze concrete non ci sono, sono la stessa cosa, cambia solo la sinstassi, quindi quello che puoi fare con il C# lo puoi fare anche in visual basic.

Quindi se il visual bsic è da principianti anche il C# è da principianti, perché oltre alla sinstassi (come già detto) non cambia nulla (cosa che io non pensavo fino a 2/4 settimane fa in quanto ho sempre espresso le miei opinioni basandomi su ciò che facevo e vedevo).

Diciamo che il C# ha una sinstassi più "professionale" confronto al visual basic, che alcuni la possono definire scomoda, altri comoda e cosi via.

[KillerZ]

Ecco bravo, il tuo commento è oggettivo. Ma io non ho detto che il visual basic è da principianti per la varietà e le caratteristicher che propone nel framework ma è da principianti per la sintassi, mentre il C# è più complicato sintatticamente...
Ad ogni la scelta del linguaggio non cambia il modo di esecuzione del programma ma cambia a seconda del programmatore che utilizza il linguaggio a suo piacimento.

[steve]

Non ho finito di leggere l'articolo, ma sono in disaccordo con quasi tutto quello che ho letto...
Inoltre su certe cose sembra anche disinformato: dice che in c# il corto circuito tra operatori avviene sempre, ma non è vero (tralasciando quello che reputo un errore di battitura: OrAlso in realtà è OrElse). Certo che se ha più informazioni di vb.net che di c# è ovvio che, anche volendo, non riuscirebbe a definire il c# migliore o uguale alla sua controparte.
Se non sbaglio (premetto di non essere adeguatamente informato su questi due linguaggi) a differenza di vb.net, essendo il c# derivato dal c, permette di lavorare sugli indirizzi di memoria. Ma non mi pare che venga menzionato nell'articolo.

(08-03-2011 12:24 PM)Riddick Ha scritto: Gli ospiti non possono vedere link nei messaggi. Registrati QUI per vedere i link.Quindi se il visual bsic è da principianti anche il C# è da principianti, perché oltre alla sinstassi (come già detto) non cambia nulla (cosa che io non pensavo fino a 2/4 settimane fa in quanto ho sempre espresso le miei opinioni basandomi su ciò che facevo e vedevo).

Diciamo che il C# ha una sinstassi più "professionale" confronto al visual basic, che alcuni la possono definire scomoda, altri comoda e cosi via.

Non è solo questione di sintassi. vb.net non insegna un corretto modo di programmare, ci sono troppe cose che fa da solo senza che tu sappia niente, ad esempio: la conversione dei tipi o l'incorporazione del namespace di vb6 (c# permette di farle queste cose, ma sotto specifico comando).
Sono comodità controproducenti per un programmatore alle prime armi, e sono inutilità per un programmatore un po' più esperto.

[Riddick]

steve non c'è nulla che non sia in vb.net, c# e vb.net usano lo stesso framework. E questo non l'ho letto solo da questo blog (altrimenti sarebbe assurdo basandosi solo su questo articolo), se cambia qualcosa, sono solo cose soggetive. Poi ovviamente se gli altri dicono ..... questo non lo so xD, io di certo non consco il vb.net e c# come costui che ha creato questo articolo o come altri articoli scritti da altri programmatori esperti.

[steve]

Usano lo stesso framework, ma il linguaggio è un altro.
A grandi linee è un po' come dire: non c'è differenza tra python + pyogre e c++ + ogre, usano lo stesso framework.

È vero che gran parte delle feautures sono gestite dal framework, tuttavia i linguaggi sono diversi e hanno alcune caratteristiche diverse (anche se devono necessariamente avere caratteristiche simili visto che usano lo stesso framework).

[Riddick]

Bhe ti devo contradire di nuovo XD, e lo faccio con insistenza lo sai il perché ? perché qualunque articolo che ha messo a confronto questi due linguaggi, ha sempre parlato esclusivamente di sinstassi, se fanno cosi credo che un motivo ci sia... vedi anche Gli ospiti non possono vedere link nei messaggi. Registrati QUI per vedere i link.

Poi: pyogre, python etc.. sono tutt'altra cosa.

[steve]

Non esattamente. Potrei farti lo stesso esempio di prima citandoti wxwidgets, qt, o altri framework.

Prova ad esempio a tradurmi questo in visual basic.net
int* puntatore;

[Riddick]

(09-03-2011 01:11 AM)steve Ha scritto: Gli ospiti non possono vedere link nei messaggi. Registrati QUI per vedere i link.int* puntatore;

Dovrebbe essere cosi:

Codice:

Dim puntatore As Pointer(Of Integer)

[steve]

Ho provato a compilare: Tipo Pointer non definito

[Riddick]

Allora ho sbagliato, non ho usato vb.net e sinceramente non li ho mai presi in considerazione (lo so, lo devo fare xD)

[DIABLO ROSSO]

secondo me il c# i programmi vengono meglio vb e programmazione basica si chiama pure visual basic(basic= basico)