[VB6] Fine supporto per “Windows 8”

Alla luce di quanto ho scritto in un post del 23 Marzo sulla mancanza di uno strumento di conversione da VB6 a VB 2010, c’è quest’altro post che inciderà pesantemente sui programmatori VB6:

http://news.softpedia.com/news/Visual-Basic-6-0-on-Windows-7-but-Not-on-Windows-8-105474.shtml

Stando a quanto viene dichiarato, non ci sono progetti di estendere il supporto di VB6 anche nella prossima versione di Windows, chiamata “Windows 8”.

Penso che ormai sia veramente l’ultima occasione per gli sviluppatori VB6 per passare a VB.NET, prima di uscire dal mercato…

Documentare il codice con commenti XML

La documentazione del codice è una delle principali attività che deve essere fatta durante lo sviluppo del codice stesso. Avere una buona documentazione direttamente nel codice, spesso, fornisce un miglior risultato rispetto alla documentazione cartacea, perché fornisce le informazioni esattamente nei punti dove servono ed evita un continuo “rimbalzare” dal codice alla carta.

In Visual Studio questo fatto assume un’importanza ancora maggiore: infatti esiste la possibilità di scrivere un tipo di commenti al codice (denominati “commenti XML”) che permettono di rendere visibili le informazioni anche per mezzo di IntelliSense, cioè quella tecnologia che permette di visualizzare delle informazioni man mano che scriviamo il codice, come nomi di namespace, di classi, di metodi, di attributi e di parametri, oltre che il loro uso. Vediamo come funziona.

Prendiamo ad esempio una semplice classe Class1 con un altrettanto semplice metodo test che accetta due parametri di tipo Integer. Il secondo parametro, inoltre, è un parametro opzionale con valore di default:

Public Class Class1
  Public Function test(ByVal a As Integer,
          Optional ByVal b As Integer = 2) As Integer
    Return (a + b)
  End Function
End Class

La funzione non fa altro che prendere i due argomenti e restituirne la somma. Il codice che utilizza questa classe è il seguente:

Public Class Form1
  Private Sub Button1_Click(ByVal sender As System.Object,
                          ByVal e As System.EventArgs) _
                          Handles Button1.Click
    Dim x As New Class1
    MessageBox.Show(x.test(1, 2).ToString)
  End Sub
End Class

 

Ovviamente si tratta di codice per gestire l’evento Click di un pulsante Button1, inserito in un form (Windows Forms).

Vediamo ora come si inserisce un commento alla Class1.

Per prima cosa commentiamo la Function test. E’ sufficiente posizionarci all’inizio della riga dove viene definita la Function e premere invio per creare uno spazio vuoto al di sopra della funzione. Poi ci spostiamo con il cursore nella riga vuota e digitiamo tre volte il carattere apice, ovvero ’’’.

A questo punto, apparirà automaticamente quanto segue:

  ''' <summary>
  ''' 
  ''' </summary>
  ''' <param name="a"></param>
  ''' <param name="b"></param>
  ''' <returns></returns>
  ''' <remarks></remarks>

 

All’interno del blocco <summary> … </summary> possiamo quindi inserire un commento sulla funzione, per esempio “Funzione per sommare due numeri Integer”.

Vedete anche che sono stati inseriti i blocchi <param …> … </param> per inserire i commenti ai parametri da passare alla funzione. Inseriamo rispettivamente i commenti “Primo numero intero” e “Secondo numero intero”. I blocchi <param> … </param> compaiono automaticamente solo in presenza di parametri e solo in numero uguale al numero di parametri stessi.

Poi, ancora, abbiamo il blocco <returns> … </returns> per inserire il commento sul parametro restituito dalla funzione. Inseriamo “Restituisce un valore Integer con la somma dei due parametri passati alla funzione”.

Infine c’è un blocco <remarks> … </remarks> dove possiamo inserire informazioni note aggiuntive sull’utilizzo della funzione, per esempio “Somma due numeri Integer”.

La pagina di MSDN che elenca tutti questi tag XML e anche altri è la seguente:

http://msdn.microsoft.com/en-us/library/ms172653(VS.80).aspx

Ecco come diventano il nostro commento XML e la relativa funzione:

Public Class Class1
  ''' <summary>
  ''' Funzione per sommare due numeri Integer
  ''' </summary>
  ''' <param name="a">Primo numero intero</param>
  ''' <param name="b">Secondo numero intero</param>
  ''' <returns>
  ''' Restituisce un valore Integer con la somma dei
  ''' due parametri passati alla funzione
  ''' </returns>
  ''' <remarks>Somma due numeri Integer</remarks>
  Public Function test(ByVal a As Integer,
          Optional ByVal b As Integer = 2) As Integer
    Return (a + b)
  End Function
End Class

Allo stesso modo possiamo commentare la classe. Prima di tutto creiamo una riga vuota prima della riga di definizione della classe Class1, poi, come abbiamo fatto prima, digitiamo i tre caratteri apice. Il risultato è il seguente:

''' <summary>
''' 
''' </summary>
''' <remarks></remarks>

Anche in questo caso possiamo inserire delle informazioni, questa volta per commentare la classe, per esempio così:

''' <summary>
''' Classe per effettuare operazioni numeriche
''' </summary>
''' <remarks>Contiene un test per la somma</remarks>

Ora vediamo cosa succede quando creiamo un oggetto derivato da tale classe e chiamiamo il metodo test.

Nel momento in cui selezioniamo Class1, IntelliSense ci mostra il commento a tale classe, così:

image

Allo stesso modo, scrivendo la chiamata al metodo test, otteniamo il seguente commento:

image

Infine, compilando i parametri da passare al metodo, vediamo questo commento:

image

… e questo:

image

[VS 2010 RC] Conversione progetti da VB6

In Visual Studio 2008 era disponibile la voce di menu File > Apri > Converti, per aprire una finestra di dialogo come questa:

 

image

 

Come potete vedere, nella finestra di dialogo era offerta la possibilità di convertire un progetto VB 6.0 in VB 2008.

In Visual Studio 2010 RC, la stessa finestra appare così:

 

image

 

Non c’è più, quindi, almeno nella edizione RC, la possibilità di convertire un progetto da VB 6.0. Per attuare tale conversione (ammesso che ciò abbia senso, visti i pessimi risultati che si ottengono con lo strumento messo a disposizione da Visual Studio), non si può fare altro che utilizzare una edizione di Visual Studio precedente (per esempio con VS 2005 o VS 2008) e poi da questa convertire il progetto a VS 2010.

Ovviamente questa finestra di dialogo è frutto di una versione non ancora definitiva. Sorge anche il dubbio sui motivi per cui sia stata inserita, vista la sua perfetta inutilità, con le opzioni attualmente disponibili (cioè nessuna!).

Vedremo nella release finale (RTM) se sarà confermata l’eliminazione del convertitore VB6–VB.NET e se sparirà questa finestra di dialogo o se sarà nuovamente introdotta all’ultimo momento.

La vera domanda, però, è: ma ne vale veramente la pena?

[VB 2010] Novità: continuazione implicita di linea

Come ho già illustrato il 19 Marzo a San Vito al Tagliamento, il Team di sviluppo ha voluto dare una nuova caratteristica a Visual Basic 2010 che semplifica la scrittura di codice, quando le istruzioni devono essere divise in più righe, e che migliora senz’altro la leggibilità del codice, soprattutto in alcuni contesti che vedremo.

Questa caratteristica è: rendere facoltativo il carattere “_”, cioè il carattere di underscore (sottolineatura). Nella maggior parte delle istruzioni, infatti, il carattere di continuazione di linea non è più necessario, sebbene sia ancora possibile inserirlo (non è vietato!).

Fortunatamente si è realizzato questo risultato senza dover introdurre un carattere di fine riga, come il “;” di C#.

Come funziona? E’ molto semplice: quando una istruzione si interrompe in una riga, viene esaminato l’ultimo carattere o l’ultima parola riservata presente nella riga stessa. Viene quindi considerata legata alla riga successiva, per esempio, nei seguenti casi:

– dopo una parentesi aperta: (ved. in seguito)

– dopo un punto:

image

– dopo la parola:       From

image

– dopo la decorazione di oggetti:   <CLSCompliant(True)>

image

– in una query LINQ

image

– in una espressione LINQ to XML

image

Un documento MSDN che tratta in modo completo questi casi lo trovate qui: http://msdn.microsoft.com/en-us/library/865x40k4(VS.100).aspx.

Questa caratteristica può piacere o meno, ma indipendentemente da ciò, è indubbio che è nelle query LINQ e nelle espressioni LINQ to XML che si vede maggiormente l’impatto sulla leggibilità del codice e sulla semplificazione del codice stesso:

Esiste un’eccezione: non è possibile dividere una riga appena prima della clausola Handles, perché viene segnalato come errore:

image

Vi piace o non vi piace? A me piace!   🙂

Retro-compatibilità di progetti Visual Studio

Tempo fa avevo pubblicato un post con il quale spiegavo come riportare un progetto o una soluzione dalla versione corrente (per esempio VB 2008) a una versione precedente (per esempio VB 2005).

In effetti il metodo funziona, ma solamente con progetti/soluzioni banali. Infatti, questo post spiega come mai non esiste ancora un supporto per la retrocompatibilità, nemmeno in Visual Studio 2010:

http://blogs.msdn.com/visualstudio/archive/2010/03/15/why-does-visual-studio-2010-convert-my-projects.aspx

In sostanza ci sono parecchie componenti che incidono nella configurazione di un progetto/soluzione e che rendono difficile riportare un progetto al passato. Il team si sta occupando di questo problema (definito “round-tripping”), ma il progetto è ancora nelle fasi iniziali e non è dato sapere quando arriverà a buon fine, anche se è probabile che questo avverrà non prima della prossima versione di Visual Studio (2012?).

Le organizzazioni che hanno diversi team di sviluppo e che vogliono mantenere i progetti a diversi livelli (VB 2008 e VB 2010), quindi, sono per il momento costrette a mantenere separati i team di sviluppo o a dover utilizzare delle macchine virtuali per i vari ambienti di sviluppo, con le diverse versioni dei software.

[Windows] Avviso di fine supporto

Ci sono in giro ancora molte vecchie installazioni di Windows e, purtroppo, le seguenti stanno terminando il supporto da parte di Microsoft:

  • Windows 2000 Professional e Windows 2000 Server (fine supporto 13 Luglio 2010, dopo 10 anni dal rilascio);
  • Windows XP con SP2 (fine supporto 13 Luglio 2010): si consiglia di installare il Service Pack 3 (SP3);
  • Windows Vista senza Service Pack (fine supporto 13 Aprile 2010): si consiglia di installare il Service Pack 2 (SP2).

L’installazione dei Service Pack citati vi darà la possibilità di mantenere il supporto e di usufruire di una maggiore sicurezza e protezione del sistema.

I collegamenti per scaricare i citati Service Pack sono i seguenti:

Service Pack 3 per Windows XP:

http://www.microsoft.com/downloads/details.aspx?FamilyID=68C48DAD-BC34-40BE-8D85-6BB4F56F5110&displaylang=en

Service Pack 2 per Windows Vista: http://www.microsoft.com/windows/windows-vista/default.aspx

Per maggiori informazioni, fate riferimento alla seguente pagina:

http://blogs.technet.com/lifecycle/archive/2010/02/24/end-of-support-for-windows-xp-sp2-and-windows-vista-with-no-service-packs-installed.aspx

Tiriamo le somme

Il 19 Marzo 2010 si è svolto l’evento “Community Tour – Visual Studio 2010” a San Vito al Tagliamento (PN) con la collaborazione tra DotNetWork e Microsoft Italia e con la importante partecipazione degli sponsor.

Tra gli argomenti trattati: le novità di Visual Studio 2010 (IDE ecc.), di Visual Basic 2010 e di Visual C# 2010, Entity Framework, Team Foundation Server e molto altro.

Per quanto mi riguarda è stato il mio primo “battesimo di fuoco” in qualità di speaker a un evento con così tanti partecipanti (circa 80, sala piena) e a fianco di Microsoft Italia.

A parte qualche “sbavatura” dovuta un po’ all’emozione e un po’ a qualche preoccupazione in famiglia (non ancora risolta) per la quale sono tornato a casa prima dell’inizio delle sessioni pomeridiane, sono molto soddisfatto del risultato!

La mia sessione riguardava le novità di Visual Basic 2010 e quindi le molte slide proiettate sullo schermo offrivano esempi di codice ed elenchi di nuove caratteristiche.

Mi pare che i presenti abbiano accolto con piacere le mie spiegazioni, anche perché ho visto un pubblico molto attento e interessato.

L’intera presentazione e l’applicazione con i sorgenti degli esempi saranno pubblicati sul portale di DotNetWork (http://www.dotnetwork.it) appena possibile, insieme alle altre presentazioni.

[VS 2010 RC] Patch di aggiornamento di alcuni bug

Chi ha avuto modo di iniziare a utilizzare la Release Candidate di Visual Studio 2010, si sarà trovato di fronte quasi sicuramente a degli inspiegabili crash e successivi riavvii di Visual Studio stesso.

Purtroppo questo problema deriva da alcuni bug dell’IDE che reagisce male ad alcuni eventi di IntelliSense.

Per fortuna Microsoft ha rilasciato delle “patch” che possono essere installate per risolvere questo problema. Le trovate su “Connect”:

VS10-KB980610-x86.exe

VS10-KB980920-x86.exe

Inoltre, potete trovare al seguente indirizzo un post di Scott Guthrie che spiega il problema.

.NET Framework in pillole

Assembly

Una tra le domande più frequenti dei nuovi programmatori in ambiente .NET è “Che cos’è un assembly?”.

Un assembly può essere visto da due punti di vista differenti, uno fisico e uno logico.

Dal punto di vista fisico, un assembly non è altro che un insieme di moduli eseguibili e non eseguibili (immagini, pagine HTML, file di risorsa ecc.).

Dal punto di vista logico, invece, un assembly è la più piccola unità riutilizzabile e distribuibile, con la stessa versione. Infatti le caratteristiche di un assembly sono principalmente:

  • tutti i tipi e gli elementi dei moduli utilizzati insieme devono essere inseriti nell’assembly
  • tutti gli elementi contenuti nell’assembly fanno parte della stessa versione
  • definisce quali sono i tipi visibili all’esterno del modulo in cui sono definiti, ma che non sono visibili all’esterno (vedi modificatore di accesso Friend).

Ma alla fine, come è fatto un assembly? Esternamente vediamo che si tratta di un file eseguibile (EXE) oppure di una libreria (DLL). Non una libreria da registrare nel registro di sistema di Windows, però: con il Framework .NET non esiste più il cosiddetto “inferno delle DLL” (DLL hell), cioè il rischio di danneggiare una o più applicazioni, installando una nuova versione di una DLL, per esempio con un nuovo programma.

Ne riparleremo.