Sottili differenze tra C# e VB .NET #Part 2#

Questa informazione me la annoto perchè sicuramente utile. Avevo già parlato precedentemente delle sottili e a volte subdole differenze esistenti tra il linguaggio VB .NET  e C#, differenze che possono anche riguardare il comportamento di Visual Studio, quindi non strettamente legate a costrutti di programmazione o alla semplice sintassi.

Questa differenza però mi sorprende parecchio e non riesco a comprenderne a fondo il motivo. Presto detto: se si utilizza l’incremento automatico nel numero di versione in un assembly (per intenderci quando impostiamo questa riga

[assembly: AssemblyVersion("1.0.*")]

nel file AssemblyInfo, otteniamo un risultato differente a seconda se l’assembly è scritto in VB .NET o in C#. Se è scritto in VB .NET l’incremento automatico è operato solo alla prima build, mentre alle successive build sulla stessa istanza di Visual Studio il numero di versione resta invariato (se l’assembly viene ricompilato in una differente istanza di Visual Studio il numero di versione è incrementato).

Se, viceversa, l’assembly è scritto in C#, ogni build produce un incremento automatico del numero di versione. Appena mi è possibile proverò questa funzionalità, anche se la documentazione MSDN è abbastanza chiara.

Questo comportamento differente in funzione del linguaggio avrà anche una sua logica, ma non è sicuramente immediatamente chiara.

Inoltre, non condivido la motivazione che la documentazione MSDN produce per spiegare il tutto: poichè il numero di versione è inserito solo a titolo informativo in un assembly non firmato con uno strong name, il problema non si pone. Viceversa, se l’assembly deve essere dotato di strong name, viene sconsigliato l’uso dell’incremento automatico, in VB .NET chiaramente, perchè in C# non c’è alcuna controindicazione.

Inconsistenza operatori di confronto dei Nullable Types in C#

Il linguaggio C# offre un supporto decisamente migliore dei Nullable Types rispetto a VB .NET. Nonostante ciò, utilizzando gli operatori di confronto su un tipo Nullable, es. un intero, il risultato è a dir poco strano e può dar luogo a bug piuttosto subdoli.
Infatti, eseguendo il seguente codice:

int? a;
int? b;
a=null;
b=null;
Debug.WriteLine(a == b);
Debug.WriteLine(a != b);

l’uguaglianza dei due tipi nullable con entrambe le variabili impostate a null dà come risultato “true”, mentre  l’operatore  di disuguaglianza  sulle stesse variabili produce come risultato “false”. Sin qui il comportamento è coerente.

Questo codice invece:

produce in entrambi i casi un risultato pari a "false", risultato a prima vista strano, oserei quasi dire illogico.

In sostanza:

  • "a" è uguale a "b", ma "a" non è maggiore "oppure" uguale a "b".
  • "a" è uguale a "b", ma "a" non è minore "oppure" uguale a "b"

I commenti sono aperti.