domenica 28 giugno 2009

Addio Michael

 

Ho conosciuto Michael in una discoteca scozzese nel 1979 la disco si chiamava  "San  Francisco" chissà se esiste ancora ??? Comunque non l'ho conosciuto fisicamente ma solo artisticamente poichè in quella discoteca anche piu volte a sera mettevano su "off the wall " che posto qui nel blog.

poi nell'83 mentre facevo la stagione a lignano e uscito "Triller" ..che successo ricordo che avevo la cassettina i CD erano agli albori.

Nel 87 ricordo che le figlie di un collega di lavoro avevano preso il CD "Bad", grande successo.

Nel 91 nasceva la mia prima figlia e Michael usciva con Dangerous che bella "Black an White"

e a seguto tutti gli altri successi e sopratutto la canzone "You Are Not Alone " che mi piace moltissimo.

Caro Michael, siamo cresciuti si puo dire "assieme" ed ora ci lasci, non so che dire, hai lasciato in me una strana senzazione del tipo "ma è vero?", non posso credere alla tua morte.

Avrai sempre uno spazio nei miei ricordi, riposa in pace e scusami se alcune volte ti ho criticato.

giovedì 25 giugno 2009

Vacanze 2009 : Le Api (non di windows)

 

Dopo una breve passeggiata nel bosco raggiungiamo le arnie ai piedi di un monte.

100_0345

Elena con il burka !!

100_0346

per ora è meglio avere prudenza

100_0347

 

100_0348

Il sig.Giovanni ci spiega in parole chiare il mondo delle api, molto bello ho sentito cose che non avrei mai immaginato.

100_0349

Dice che prima di fare l'apicoltore ha dovuto farsi pungere dalle api per entrare ..diciamo " in confidenza"... ammazza!!

100_0350

 

100_0351

brrr......... no comment

100_0355

l'ape regina prima della marchiatura quest'anno 2009 il colore per la marchiatura è il verde (per tutto il mondo)

100_0356

Un'ape maschio  queste non pungono.

100_0357

 

100_0358

Grazie Sig. Giovanni (l'apicoltore)

Introduzione alle API Win32, Parte 5/6 - DevSpy.com

 

Introduzione alle API Win32, Parte 5/6

di Mastersgn, del 27 febbraio 2007 C/C++

Rafforziamo i concetti appresi nel precedente capitolo sui parametri della procedura di dialogo dlgProc e ripassiamo i tipi di dato già esaminati per completare la spiegazione sul funzionamento del controllo inserito nella finestra di dialogo.

I messaggi

Nel capitolo precedente abbiamo visto che il codice del messaggio WM_CLOSE viene inviato alla procedura del dialogo allo scatenarsi dell'evento di chiusura.

Ecco cos'è un messaggio nella sua definizione:

typedef struct MSG {
HWND hWnd; /* destinazione */
UINT message; /* codice del messaggio */
WPARAM wParam; /* 1° parametro */ 
LPARAM lParam; /* 2° parametro */
DWORD time; /* istante di spedizione */
POINT pt; /* coordinate del mouse */
} MSG;


Quando il sistema operativo "passa" un messaggio alla procedura di un dialogo, in pratica comunica le informazioni presenti in questa struttura dati. Ora conosciamo quindi il significato dei parametri di dlgProc, introdotta nella Parte 4.



Analizziamo le componenti della struttura:




  • HWND indica l'handle della destinazione del messaggio, cioè identifica il dialogo, controllo o finestra a cui e destinato il messaggio.


  • UINT è il codice del messaggio che può avere valore WM_CLOSE, WM_COMMAND, WM_PAINT, WN_INITDIALOG, ecc.


  • WPARAM ed LPARAM vedremo prossimamente come usarli, siccome il loro significato cambia a seconda del contesto (ovvero in relazione al tipo di messaggio) in cui vengono usati.


  • DWORD e POINT normalmente non sono usati, quindi non li affrontiamo.



Per ora, non ci interessa capire esattamente come vengono inviati i messaggi alla procedura del nostro dialogo, ma sappiamo che questa operazione avviene grazie al sistema operativo.



Se osserviamo i parametri della procedura del dialogo esaminati nello scorso articolo, notiamo che i parametri della procedura corrispondono alle prime quattro componenti della struttura MSG. Di conseguenza, quando il sistema invierà un messaggio (e per ora sarà sempre lui a farlo per noi) alla nostra procedura passerà le prime quattro componenti della struttura MSG come parametri di funzione.



Usiamo il file resource.h



Grazie alle nuove conoscenze che abbiamo acquisito, ora siamo in grado di capire meglio il contenuto del file resource.rc. La prima informazione che troviamo subito dopo l'inclusione della libreria windows.h è un identificatore. Il nome di questo identificatore ci comunica il suo scopo: si tratta di un valore costante che identifica il dialogo.



Scriviamo questo nel file resource.h:



#define IDD_DIALOG 1001
#define IDC_CONTROL 101


Abbiamo definito due costanti: soffermiamoci su IDD_DIALOG. Abbiamo assegnato il valore 1001 ma avremmo potuto impostare un qualunque altro valore. In questo tutorial, scegliamo 1001 solo per leggibilità. Solitamente assegneremo agli identificatori dei dialoghi valori da 1001 in poi (1001,1002,1003,..) mentre agli identificatori dei controlli valori da 101 in poi.



Ed i file resource.rc e main.c



Adesso andiamo a modificare il file resource.rc:



#include <windows.h>
#include "resource.h"

IDD_DIALOG DIALOG 20, 30, 180, 100
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Dialogo vuoto"
FONT 10, "Ms Sans Serif"
BEGIN
  CTEXT "Sono un esempio di controllo static",IDC_CONTROL,16,18,144,33
END


ed anche il file main.c:



#include <windows.h>
#include "resource.h"

BOOL CALLBACK dlgProc(HWND hwndDlg,UINT dlgMsg,WPARAM wParam,LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
DialogBoxParam(0,IDD_DIALOG,0,dlgProc,0);
return 0;
}

BOOL CALLBACK dlgProc(HWND hwndDlg,UINT dlgMsg,WPARAM wParam,LPARAM lParam)
{
switch(dlgMsg)
{
case WM_CLOSE:
EndDialog(hwndDlg,0);
return TRUE;
break;
}
return 0;
}


Abbiamo incluso il file resource.h sia nel main.c che in resource.rc. In questo modo, potremo usare le sue costanti da ambedue le parti. Inoltre, cambiando l'identificatore del dialogo da "MioDialogo" a IDD_DIALOG abbiamo modificato di conseguenza pure il secondo parametro di DialogBoxParam().



Notate che anche il controllo ha un suo identificatore: IDC_CONTROL.



Analizziamo il controllo



Soffermiamoci su questa porzione di codice:



BEGIN
  CTEXT "Sono un esempio di controllo static",IDC_CONTROL,16,18,144,33
END


Tra BEGIN ed END troviamo la definizione di un controllo static di classe CTEXT (ovvero Central Text; le altre classi disponibili sono LTEXT ed RTEXT). Questo controllo si occupa di scrivere la stringa inclusa tra i doppi apici sul nostro dialogo. Il controllo viene posizionato e dimensionato sul dialogo come indicato dagli ultimi quattro valori numerici (16, 18, 144, 33). Per il momento non abbiamo definito nessuno stile.



Già sappiamo che IDC_CONTROL è l'identificatore del controllo. Il nostro controllo è di tipo static, infatti visualizza solo un testo al centro del controllo.



Se volessimo creare un bordo attorno al testo visualizzato, potremmo impostare:



BEGIN
  CTEXT "Sono un esempio di controllo static",IDC_CONTROL,16,18,144,33,WS_BORDER
END


Ancora, potremmo "concatenare" più stili a nostra scelta (notate che gli stili devono assere separati dal carattere pipe "|"):



BEGIN
CTEXT "Sono un esempio di controllo static",IDC_CONTROL,16,18,144,33,WS_BORDER|SS_SUNKEN
END


Specificando SS_SUKEN daremo al bordo un aspetto incavo.



Per ottenere un elenco completo degli stili che si possono impostare su questi controlli static, potete consultare la documentazione MSDN (che abbiamo indicato nella prima lezione del tutorial ).



Il prossimo appuntamento



Anche i controlli possono inviare messaggi di notifica. Chiariremo questo concetto nel prossimo capitolo.




Introduzione alle API Win32, Parte 5/6 - DevSpy.com

Introduzione alle API Win32, Parte 4/6 - DevSpy.com

 

Introduzione alle API Win32, Parte 4/6

di Mastersgn, del 30 gennaio 2007 C/C++

Dopo aver creato una finestra di dialogo, introduciamo il concetto di evento e sviluppiamo la gestione di un particolare evento: la chiusura del dialogo. Infine, inseriamo un controllo nel dialogo come premessa alla lezione successiva.

Procedura del dialogo

Nell'articolo precedente abbiamo lasciato una domanda in sospeso: Perché non è possibile chiudere la finestra di dialogo? Prima di rispondere dobbiamo comprendere un particolare importante:

Quando interagiamo con un dialogo - ovvero lo ridimensioniamo, chiudiamo o clicchiamo su un controllo in esso presente - compiamo azioni chiamate eventi.

Ogni finestra possiede i propri eventi e, a fronte dell'attivazione di questi, può rispondere in determinati modi, che ovviamente saremo noi a decidere. Di conseguenza, quando chiudiamo il nostro dialogo in realtà inviamo un messaggio di chiusura della finestra alla procedura di gestione dell'evento: ogni dialogo dispone di una procedura per gestire i possibili eventi.

A questo punto è facile intuire che il dialogo creato nel precedente articolo non si chiudeva perchè non possedeva una propria procedura di gestione degli eventi, compreso la chiusura della finestra stessa.

Dunque, modificamo il codice del file main.c, come segue:

#include <windows.h>


BOOL CALLBACK dlgProc(HWND hwndDlg,UINT dlgMsg,WPARAM wParam,LPARAM lParam);


int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
DialogBoxParam(0,"MioDialogo",0,dlgProc,0);
return 0;
}


BOOL CALLBACK dlgProc(HWND hwndDlg,UINT dlgMsg,WPARAM wParam,LPARAM lParam)
{
switch(dlgMsg)
{
case WM_CLOSE:
EndDialog(hwndDlg,0);
return TRUE;
break;
}
return 0;
}


Compiliamo nuovamente l'applicazione: ora la finestra è in grado di chiudersi correttamente.



Procedure e messaggi



Incontriamo una funzione utilizzata, appunto, come procedura del dialogo per la gestione degli eventi. Analizziamone il prototipo:



BOOL CALLBACK dlgProc(HWND hwndDlg,UINT dlgMsg,WPARAM wParam,LPARAM lParam);



  • La funzione restituisce un tipo BOOL (valore 0 oppure 1) che può essere usato per conoscere l'esito della procedura.


  • dlgProc è il nome che abbiamo scelto per la propcedura.


  • Il parametro di tipo HWND (che chiamiamo hwndDlg) riceve l'handle del dialogo. Ci servirà nella procedura stessa (come primo parametro nella chiamata a EndDialog()).


  • UINT dlgMsg è il codice del messaggio. Viene passato alla procedura al verificarsi di un determinato evento (nel nostro caso WM_CLOSE per chiudere la finestra).


  • WPARAM ed LPARAM per ora li ingoriamo; li analizzeremo più avanti.



Adesso analizziamo il corpo della procedura:



switch(dlgMsg)
{
case WM_CLOSE:
EndDialog(hwndDlg,0);
return TRUE;
break;
}


Troviamo uno switch sulla variabile dlgMsg: nel caso in cui il codice del messaggio corrisponda a  WM_CLOSE, la procedura chiude il dialogo utilizzando la funzione EndDialog(). Dunque, a fronte dell'evento di chiusura del dialogo, il sistema spedisce un messaggio WM_CLOSE alla procedura di gestione, "chiedendo" al dialogo di chiudersi.



Funzione EndDialog()



BOOL EndDialog(
HWND hDlg,
int nResult
);



  • Al parametro di tipo HWND passiamo l'handle del dialogo da chiudere. Nel nostro caso hwndDlg (se stesso).


  • A int nResult passiamo 0 (zero), e non ce ne interessiamo ulteriormente.



Osserviamo nuovamente la funzione di creazione del dialogo:



 DialogBoxParam(0,"MioDialogo",0,dlgProc,0);


Al quarto parametro (DLGPROC lpDialogFunc), passiamo il nome della procudura del dialogo, dlgProc appunto.



Riassumendo



Ogni dialogo possiede una procedura interna per gestire gli eventi che si possono verificare, tra cui anche la chiusura del dialogo stesso.




  • Abbiamo visto che al verificarsi di un evento, il sistema invia alla procedura del dialogo il messaggio corrispondente a questo evento. Nel nostro caso si è trattato della chiusura della finestra, ma potrebbe trattarsi di qualsiasi altro evento, come il click su un controllo.


  • Osserviamo il corpo della procedura: nel caso in cui (istruzione switch) il codice del messaggio (in questa procedura l'abbiamo chiamato dlgMsg) corrisponda a WM_CLOSE (evento di chiusura), allora chiudiamo il dialogo attraverso la chiamata alla funzione EndDialog().


  • La costante WM_CLOSE è un valore predefinito dell'ambiente. Ne esite uno per definire ciascun evento.


  • Nell'istruzione di creazione del dialogo DialogBoxParam(0,"MioDialogo",0,dlgProc,0), il secondo parametro indica il dialogo così come è stato definito nel nostro file resource.rc, mentre il quarto parametro identifica la procedura dello stesso.



Come esercizio per consolidare il tutto vi consiglio di riscrivere un'altro progetto uguale a questo, ma con nome di variabili, funzioni, costanti e parametri diversi (ad eccezione, ovviamente, delle costanti di ambiente!).



Aggiungiamo un controllo static



A questo punto, per concludere l'esercizio, inseriamo un semplice controllo nel nostro dialogo. Modifichiamo il file resource.rc in questo modo:



#include <windows.h>

MioDialogo DIALOG 20, 30, 180, 100
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Dialogo vuoto"
FONT 10, "Ms Sans Serif"
BEGIN
  CTEXT "Sono un esempio di controllo static",101,16,18,144,33
END


Compilate il programma e vedrete il nuovo controllo all'interno della finestra. Nel prossimo appuntamento, vedremo come inviare e ricevere messaggi verso il controllo.




Introduzione alle API Win32, Parte 4/6 - DevSpy.com

Introduzione alle API Win32, Parte 3/6 - DevSpy.com

 

Articolo (versione 2) Introduzione alle API Win32, Parte 3/6

di Mastersgn, del 3 novembre 2006 C/C++

Cos'è un dialogo e come si configura tramite i file di risorsa. Creiamo un semplice dialogo modale con la funzione DialogBoxParam(), definendo alcuni elementi importanti che costituiranno la base per il prossimo articolo nel quale vedremo come inseririre un controllo nella finestra.

Dialoghi e controlli

Nel precedente articolo abbiamo appreso come mostrare un semplice messaggio all'utente. Ora aumentiamo la complessità del nostro esempio illustrando come presentare il messaggio "Ciao a tutti" all'interno di un dialogo (Dialog).

Un dialogo è una finestra predefinita di Windows che può contenere al suo interno vari controlli quali bottoni, immagini, controlli di input e diversi altri in grado di interagire con l'utente.

Il nostro scopo è di creare un dialogo intitolato "Un messaggio" al cui interno porremo un controllo: un campo di testo per visualizzare la scritta "Ciao a tutti".

Procediamo

Per partire, abbiamo bisogno di due file. Vediamo come procurarceli:

  1. Create un nuovo progetto come descritto in precedenza, cancellate il contenuto di main.c e successivamente cliccate su Progetto / nuova unità.
  2. Sarà creato un file Senza titolo 1. Createne un'altro, che sarà nominato Senza titolo 2. Rinominate sia il primo che il secondo file in resource.
  3. Salvate ora il primo file resource come resource.h ed il secondo come resource.rc, nella stessa cartella in cui avete salvato il progetto. Questi saranno i nostri file risorsa.

Ci ritoveremo con 3 file: main.c, resource.h e resource.rc.

A cosa servono i file di risorsa?

La creazione di un dialogo è gestita da un'apposita funzione che, in base ad una serie di parametri, determina le caratteristiche della finestra. Pensando a quanti attributi potremmo voler configurare in una finestra, è facile dedurre che sono potenzialmente troppi per essere passati tutti come parametri di funzione. Proprio a questo proposito, ci viene in aiuto il file risorsa appena creato.

Nel nostro file risorsa resource.rc  potremo "descrivere" un dialogo, cioè definirne l'aspetto, il contenuto, gli stili... quindi tutte le caratteristiche del dialogo stesso.

In effetti, vedremo come nel file risorsa resource.rc in qualche modo "disegneremo" il dialogo che poi verrà realmente creato attraverso una funzione nel codice del file main.c.

Useremo, invece, il file resource.h per definire tutte le costanti del progetto. In questo modo, miglioreremo la leggibilità del codice.

Il primo passo: configurare il file resource

E' arrivato il  momento di "disegnare" il dialogo nel file .rc. Eseguiremo questa operazione attraverso un linguaggio specializzato - con una propria semantica e sintassi - nella descrizione di dialoghi e di altre risorse Windows.

Copiate il seguente codice nel vostro file resource.rc:

#include <windows.h>

MioDialogo DIALOG 20, 30, 180, 100
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Un dialogo"
FONT 8, "Ms Sans Serif"
BEGIN
END


Osservate come nel codice venga inclusa la libreria windows.h, ma che tuttavia non si tratta di linguaggio C.



Analizziamo ciascuna riga di codice:



MioDialogo DIALOG 20, 30, 180, 100


MioDialogo è l'identificatore del dialogo, che come vedremo servirà indicare nella funzione di creazione. Per ora non ci soffermiamo su questo.



DIALOG indica, naturalmente, che stiamo gestendo un dialogo. I restanti quattro numeri interi costituiscono, nell'ordine, la coppia di coordinate X-Y dove sarà posizionato il dialogo e la dimensione W-H del dialogo.



STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU


Questa riga indica una serie di stili da attribuire al dialogo. Approfondiremo prossimamente l'elenco degli stili utilizzabili.



CAPTION "Un dialogo"


CAPTION specifica la stringa che verrà visualizzata nella barra del titolo di questo dialogo.



FONT 8, "Ms Sans Serif"


FONT imposta il carattere del testo utilizzato nel dialogo.



BEGIN
END


Tra BEGIN e END dovremo posizionare i controlli del dialogo. Il nostro primo dialogo rimarà vuoto, per cui questa porzione di codice rimane priva di istruzioni.



Il secondo passo: eseguire la funzione



Nel file main.c trascrivete il seguente codice:



#include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
DialogBoxParam(0, "MioDialogo", 0, 0, 0);
return 0;
}


Si tratta di codice che già conosciamo, tranne che per la nuova funzione DialogBoxParam che crea il dialogo. Analizziamo la sua definizione:



INT DialogBoxParam(      

HINSTANCE hInstance,
     LPCTSTR lpTemplateName,
     HWND hWndParent,
     DLGPROC lpDialogFunc,
     LPARAM dwInitParam
);


Passeremo i parametri hInstance, hWndParent, lpDialogFunc, dwInitParam tutti a 0 (zero). Possiamo ancora rimandare il loro studio ad un prossimo approfondimento. Al parametro lpTemplateName (come sappiamo il tipo LPCTSTR equivale a const char*) passeremo l'identificatore del dialogo: MioDialogo in questo caso.



Dato che non abbiamo utilizzato valori costanti, il file resource.h è rimasto ancora vuoto.



Avvio dell'applicazione



Compilate il codice e lanciate il programma: comparirà un dialogo vuoto.



Attenzione


Una volta avviato il programma, non sarà possibile chiudere il dialogo normalmente. Dovrete usare il Task Manager:




  • premete i tasti [Ctrl] + [Alt] + [Canc];


  • selezionate la linguetta Processi;


  • trovate il nome del vostro file eseguibile nell'elenco dei processi attivi (colonna Nome immagine) e selezionatelo;


  • premete il tasto [Termina processo] per chiudere la finestra.



Nel prossimo articolo daremo una spiegazione per la "non-chiusura" del dialogo e vedremo come inserire il primo controllo.




Introduzione alle API Win32, Parte 3/6 - DevSpy.com

Introduzione alle API Win32, Parte 2/6 - DevSpy.com

 

Introduzione alle API Win32, Parte 2/6

di Mastersgn, del 21 ottobre 2006 C/C++

Dopo le premesse del primo articolo del tutorial, siamo in grado di creare una piccola e basilare applicazione: visualizziamo un messaggio di "Hello World" in stile WinAPI tramite la funzione MessageBox().

Creare un nuovo progetto

Come detto in precedenza, facciamo riferimento all'IDE della Bloodshed: Dev-C++.

Facciamo click su Progetto, quindi selezioniamo Windows Application e come linguaggio il C. Scegliete il nome del progetto come preferite, premete OK per salvarlo e proseguite. Sarà creato un nuovo progetto al cui interno trovate il solo file main.c: cancellate il suo contenuto.

Ogniqualvolta compilate un progetto saranno compilati (e allo stesso tempo quindi linkati) tutti i file appartenenti ad esso.

Prima semplice applicazione

Iniziamo col creare una piccola applicazione. Per farci un'idea di come sia strutturato un programma WinAPI, scriviamo il codice necessario per visualizzare un messaggio di "Hello World".

Bene, prima di tutto trascrivete (se evitate il Copia&Incolla imparerete più rapidamente) il seguente codice nel vostro file main.c e compilate:

#include <windows.h>
#define WIN32_LEAN_AND_MEAN

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nCmdShow)
{

  MessageBox(0, "Hello World!!",
"Un messaggio", MB_OK);

return 0;
}


Osserviamo l'inclusione dell'header file  windows.h  e la definizione della macro WIN32_LEAN_AND_MEAN, già descritti nel primo articolo. Poi, al posto della solita funzione int main(int  argc,  char*  argv[])  ne troviamo un'altra:



int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)


Dato che questa istruzione Win32 è molto diversa, analizziamola meglio:




  • WINAPI indica una funzione che adotta la convenzione di chiamata standard di Windows.


  • HINSTANCE hInstance indica l'Handle del modulo eseguibile del programma. Di questo parametro torneremo a parlare più avanti, ma per ora non ha molta importanza.


  • HINSTANCE hPrevInstance ha sempre valore NULL nei programmi Win32. Era usato in Win16, mentre con Win32 va ignorato.


  • LPSTR lpCmdLine contiene l'intera riga di comando passata al nostro programma in un'unica stringa. E' l'equivalente dell'intero array argv[] del metodo main dello standard C. Non include il nome del programma. Per ora ignoramo anche questo parametro.


  • int nCmdShow può ricevere un valore intero. Trascuriamo anche quest'ultimo per il momento.



Rimandiamo tutto quanto non descritto in questa sede ad un successivo studio più approfondito.



Funzione MessageBox()


Ora occupiamoci di analizzare la funzione che visualizza il messaggio di Hello World:



int MessageBox(
  HWND hWnd,
  LPCTSTR lpText,
  LPCTSTR lpCaption,
  UINT uType
);



  • Il tipo HWND, handle di Windows, è un tipo opaco. Serve ad identificare una finestra (e non solo). In questo caso viene passato come zero, visto che il messaggio da inviare è visualizzato direttamente dalla finestra corrente. Più difficile da spiegarsi che da applicare, approfondiremo meglio più avanti questo tipo in quanto molto importante.


  • LPCTSTR lpText (come accennato nel primo articolo) prende un stringa costante e si impegna a non modificarla. In questo caso, al parametro passiamo la stringa da visualizzare come corpo del messeggio.


  • Utilizziamo LPCTSTR lpCaption come per il parametro precedente, ma in questo caso la stringa da passare verrà visualizzata come titolo del messaggio.


  • UINT uType, è un tipo unsigned int. Si tratta di un valore intero che indica il tipo di finestra di messaggio da mostrare. Ad esempio, nella nostra macro MB_OK visualizza un semplice messaggio senza icone con un solo bottone di OK.



Potremmo utilizzare molti altri valori per uType, ognuno dei quali determina un tipo di finestra differente. Ad esempio, tramite MB_YESNO potremmo visualizzare i due bottoni "Si" e "No". Queste vatianti sono usate per ottenere l'input dell'utente, ovvero quando l'utente deve fare una scelta. Vedremo più avanti come utilizzare diverse metodologie al riguardo. Per documentarvi sulle altre macro disponibili, consultate la MessageBox function.



Per finire incontriamo l'istruzione return 0, che termina la funzione.



D'ora in poi considereremo la funzione MessageBox() per appresa. Non ci resta che creare qualcosa di più sostanzioso e significativo nel prossimo articolo.




Introduzione alle API Win32, Parte 2/6 - DevSpy.com

mercoledì 24 giugno 2009

Vacanze 2009 : Giro mattutino

 

Questa mattina sono stato svegliato dal rintocco delle campane della Chiesa di Pieve, apro gli occhi e dalla finestra vedo un bel cielo limpido, montagne verdi e una leggera brezza accarezzava le punte delle betulle nel giardino della casa dove  alloggio.

100_0231 

Mi alzo è lascio gli altri dormire beatamente, mi vesto con felpa e k-way e scendo le scale, inforco la bici, dopo le prime pedalate sento un po di umido nel fondoschiena, probabilmente la sella bagnata hehehe.... va bè ; le gambe non abituate sono legnose e accusano il colpo alla prima leggera salita, il respiro incomincia a farsi affannoso ma so che mi godrò la discesa.

100_0281

Una guida del posto mi ha consigliato di andare a vedere una cascata ai piedi della montagna dentro il bosco vicino a Tiarno di sotto(TN).

100_0256

Arrivato a Tiarno fatico un po per ricordare il percorso, poi trovo le indicazioni, davanti a me una leggera salita poi la strada finisce e mi trovo davanti ad un sentiero con tanto di cartello di divieto, ma ricordo che la guida mi aveva detto che la cascata si trovava in una proprietà privata e proseguo costeggiando un torrente.

100_0275

Il sentiero si stringe sempre più e la vegetazione diventa sempre piu fitta  i raggi del sole filtrano tra i rami di abeti larici e faggi e altri alberi dei quali non conosco il nome.

100_0277

Un senso di umidità su di me sarà la mattina presto oppure il torrente, il fatto sta che fra poco mi sa che dovro scendere dalla bici per proseguire a piedi la salita si fa più ripida, piu avanti trovo un capitello con un Gesù crocefisso (vedi foto).

100_0258

Il rumore della cascata si fa sempre più intenso e capisco che dovrei essere quasi a destinazione.

100_0274

100_0261

Infatti dietro l'ultima curva trovo davanti a me una grande grotta dove da un foro fuoriusciva un'enorme quantità di acqua, purtroppo con l'oscurità le foto che ho scattato non mostrano la bellezza reale di questa cascata.

100_0269 100_0270

 

 

 

Resto a guardare per alcuni minuti in solitudine ascolto il fragore dell'acqua e rincorro i miei pensieri in questa mistica atmosfera (wow me venuta bene questa).

Mi risveglio dal torpore e mi rendo conto di non aver fatto ancora colazione risalgo in bici e riscendo lo scosceso sentiero (che figata!!), al paese mi fermo  in panificio prendo pane e croissant e giu verso Pieve (tutta discesa evvaiii).

La foto sotto la dedico alle mie colleghe d'ufficio, non so perchè, forse per l'ultima mangiata fatta insieme... ma quando l'ho vista mi sono venute in mente!!!

100_0289

Ciaoo Giuliano

venerdì 12 giugno 2009

Introduzione alle API Win32, Parte 1/6 - DevSpy.com

 

Introduzione alle API Win32, Parte 1/6

di Mastersgn, del 18 ottobre 2006 C/C++

Proponiamo ai lettori questo primo capitolo di introduzione alle WinApi a 32 bit, in modo da affrontare con più certezza il restante tutorial. Verranno chiariti concetti di base sui tipi di dati e faremo qualche considerazione sull'ambiente di sviluppo scelto. Per utenti che possiedono già esperianza, questa parte può essere saltata. Tuttavia, presentiamo alcune considerazioni sulla stesura del codice e dello stesso tutorial che si riveleranno utili nella lettura degli articoli successivi.

Introduzione

In questa guida impareremo ad usare le API (Application Programming Interfaces) di Microsoft Windows in modalità 32 bit. Il linguaggio di sviluppo scelto è il C, ma se utilizzate il C++ non incontrerete particolari difficoltà nel comprendere e seguire gli articoli (infatti, le chiamate alle funzioni sono le stesse). Piuttosto, è probabile che C++ vi offra qualche possibilità in più; per cui non dovrebbe esservi difficile modificare quelle piccole parti di codice che dovessero risultare non adeguate.

Requisiti software

Come IDE (Integrated Development Environment) useremo il Dev-C++ della Bloodshed, scaricabile gratuitamente dal sito del produttore (www.bloodshed.net/devcpp.html).

Se utilizzate un altro IDE/compilatore, anche in questo caso non dovrebbe cambiare molto. Sarà sufficiente indicare al compilatore dell'IDE che si sta compilando un'applicazione Windows GUI e non una CUI in generale. Dopodiché, siccome ogni ambiente ha le proprie particolarità, dovrete gestirle personalmente.

Siccome un programma per Windows32 normalmente ricorre alle "librerie di connessione" al sistema (specificamente almeno le tre "canoniche": kernel32.lib, gdi32.lib e user32.lib) potrebbe essere necessario installare il Platform SDK, scaricabile dal sito Microsoft.

Come usare questa guida

Questo tutorial sarà suddiviso in capitoli. Se avete la tentazione di saltare porzioni del tutorial, vi chiedo di avere pazienza e leggere comunque ogni articolo per intero. Questo perché in quelle parti che potreste saltare, potrebbero esserci proprio le risposte alle domande che vi porrete in seguito.

Se doveste trovare errori logici nel corso del tutorial o avete domande in merito, potete contattarmi via e-mail.

Cosa dovete aspettarvi

Win32 utilizza molte macro e typedef definite all'interno del file windows.h, che verrà sempre incluso. Quindi, soprattutto se siete agli inizi, potreste restare disorientati di fronte alla quantitità di nuovi tipi e costanti; ma col passare del tempo vi risulteranno sempre più familiari.

Ovviamente, programmando in C definiremo le variabili all'inizio di ogni blocco e non solo dove servono come si potrebbe fare in C++ (coloro che programmano in C++ saranno comunque liberi di farlo). Per la stessa ragione racchiuderemo i commenti tra /* e */ (mentre in C++ potrete usare i soliti commenti in linea, preceduti da //).

Per migliorare la leggibilità della guida, potrebbe accadere che faccia distinzione tra procedure e funzioni, anche se nel linguaggio C - come sapete - sono considerate tutte funzioni.

Ultima nota: molte delle funzioni che troverete in questo tutorial, sono spiegate più approfonditamente nella documentazione in linea di MSDN dedicata a questo argomento. Su MSDN, trovate spiegazioni accurate di tutte le funzioni, i tipi, le strutture e gli altri oggetti di cui faremo menzione.

Un breve sguardo sui tipi utilizzati

Per prima cosa, sarebbe oppurtuno spiegare a cosa corrispondono e come ragionare con diversi tipi di dati che useremo nei nostri esempi. Diamo quindi un'occhiata ai primi:

  • UINT     ->  unsigned int
  • LPSTR    ->  char*
  • PVOID    ->  void*
  • ULONG    ->  unsigned long
  • CHAR     ->  char
  • CONST    ->  const
  • INT      ->  int
  • LONG     ->  long
  • VOID     ->  void
  • WORD     ->  unsigned short
  • HANDLE   ->  PVOID
  • HMENU    ->  HANDLE
  • HRESULT  ->  LONG

Questi tipi sono i più basilari ed intuitivi. Vi invito ad analizzare sempre i nomi degli oggetti con cui avrete a che fare studiando le API, perchè impararli semplicemente a memoria come dato di fatto non sarebbe molto profittevole.

Come vedete, molti nomi sono identici ai tipi solitamente usati ma scritti in maiuscolo. Se preceduti dalla lettera U stanno a significare un tipo senza segno (unsigned). Analizzando LPSTR osserviamo subito che è un puntatore ad una stringa e che LP sta per long pointer. STR, invece, facile immaginarlo... Nello stesso modo se consideriamo PVOID, P sta per pointer e VOID per "vuoto". Se mettiamo una C per esempio all'interno di LPSTR, otteniamo LPCSTR, che sta ad indicare una costante; nel senso che è un puntatore ad una stringa costante che non verrà quindi modificata. Osservando HANDLE notiamo che corrisponde ad un PVOID; ci accorgeremo che molti di questi tipi saranno usati spesso. A sua volta HMENU corrisponde ad HANDLE, e così via per molti altri tipi.

Non è ancora il momento di analizzarli tutti. Penso che abbiate capito il modo in cui vengono gestiti in generale e col tempo ci farete l'abitudine. Tengo a precisare che molti tipi che non ho indicato qui, li spiegherò nel corso del tutorial (ma ci dovrete arrivare da soli ragionandoci). Se avete bisogno di maggiori delucidazioni sui tipi di dati, consultate il capitolo Windows Data Types nella referenza MSDN già citata.

Ultima cosa: può darsi che nel vostro codice siate abituati ad usare il solo char* al posto di un PCHAR. Per svariati motivi - sui quali non ci dilunghiamo in questa sede - ciò non è consigliabile. Perciò, nel codice degli esempi useremo sempre PCHAR.

Ultime considerazioni

Dovreste entrare nell'ottica di separare mentalmente le API dalla solita programmazione CUI, comprendendo bene che sono due cose diverse. Lasciando stare l'esattezza della mia affermazione, questo è utile per non confondersi (ed uno dei motivi a cui accennavo prima per i tipi).

Seconda cosa: non dovrete includere come libreria di I/O la stdio.h ma la windows.h (col classico #include <windows.h>). Quindi per ciascuna funzione di lettura/scrittura di cui dispone la prima libreria (tipo printf(), scanf()) ne saranno presenti una o più nella seconda. Quando definiremo la macro WIN32_LEAN_AND_MEAN (#define WIN32_LEAN_AND_MEAN) indicheremo di utilizzare solo le funzioni più comuni della libreria windows.h, accellerando la compilazione del nostro codice.

Bene, siamo finalmente pronti per iniziare con il codice vero e proprio, nel prossimo articolo.

Introduzione alle API Win32, Parte 1/6 - DevSpy.com

lunedì 8 giugno 2009

Le novità di Visual Basic 2010 - Il linguaggio, seconda parte

 

Le novità di Visual Basic 2010 - Il linguaggio, seconda parte
a cura di Alessandro Del Sole (requisiti: conoscenza intermedia del linguaggio Visual Basic 2008 )

Introduzione
Nel precedente articolo abbiamo iniziato a parlare delle novità del linguaggio Visual Basic 2010, sfruttando l'attuale Beta 1. Abbiamo anche detto che, trattandosi della prima Beta, potrebbero esserci delle modifiche in futuro ma che questa circostanza è abbastanza remota in quanto si tratta di innovazioni presenti fin dalla CTP di ottobre 2008. Le novità introdotte la volta scorsa sono le seguenti:

  • Auto-implemented properties
  • Implicit line continuation
  • Optional nullable parameters
  • Collection initializers
  • Array literals

In questo terzo articolo della mini-serie dedicata a Visual Basic 2010, proseguiremo la carrellata sulle novità relative al linguaggio e analizzeremo le novità un pochino più complesse, ma che senza dubbio rendono più potente il linguaggio stesso. Nell'area download di VB T&T è disponibile il progetto sorgente completo, a corredo di questo e del precedente articolo. Ovviamente, per poterlo utilizzare dovete aver installato la Beta 1 di Visual Studio 2010.

Espressioni lambda multi-linea e statement lambda
In Visual Basic 2010 il concetto delle espressioni lambda è stato ripreso e notevolmente potenziato. Rispetto alla versione 2008, infatti, è possibile utilizzare delle espressioni multilinea nonché la parola chiave Sub, oltre a Function, per poter generare delegati anonimi al volo che non restituiscano valori.

Facciamo un esempio ed ipotizziamo di voler ottenere l'elenco dei processi attivi sul sistema, il cui nome inizi con la lettera A. In Visual Basic 2008 avremmo potuto scrivere:

    'Sintassi VB 2008
Dim processes = Process.GetProcesses.Where(Function(p) p.ProcessName.StartsWith("A"))


Utilizziamo quindi una Function direttamente in linea, che restituisce un insieme di processi. In Visual Basic 2010 è stato fatto un grande progresso. Potremmo infatti trasformare la richiesta sopra evidenziata in questo modo:



    'Sintassi VB 2010
Dim processes = Process.GetProcesses.Where(Function(p)
Try
Return p.ProcessName.
StartsWith("A")
Catch ex As Win32Exception
'in caso di errore fai qualcosa
End Try
End Function)


Naturalmente VB 2010 consente anche la vecchia sintassi, ma ora permette di generare veri e propri metodi all'interno dei quali si possono inserire blocchi di codice anche complessi, secondo il classico stile Function.. End Function. Nell'esempio, poiché stiamo lavorando sui processi, è utile intercettare una Win32Exception che potrebbe verificarsi se un processo non consente l'accesso alle proprie informazioni. In questo modo, possiamo prevedere questo scenario, circostanza non consentita in VB 2008 all'interno della lambda.



Sempre rimanendo sull'esempio dei processi attivi, proviamo a scandire la collezione ottenuta per visualizzare il nome del processo. In Visual Basic 2010 è ora consentito scrivere quanto segue:



    processes.ToList.ForEach(Sub(p) Console.WriteLine(p.ProcessName))


Oltre a sfruttare un metodo ForEach della collezione List(Of T), notate come sia possible utilizzare una lambda che non restituisca nulla, attraverso la parola Sub, altra novità di VB definita Statement Lambda. Ovviamente, anche in questo caso è possibile suddividere l'espressione su più righe:



    processes.ToList.ForEach(Sub(p)
Console.WriteLine("Process name:")
Console.WriteLine(p.ProcessName)
Console.WriteLine()
End Sub)


Si tratta di una grande caratteristica che rende molto potente e versatile il nostro linguaggio, che potremo particolarmente apprezzare con LINQ per l'accesso ai dati.



Varianza generica: Covariance e Contravariance


La varianza generica è un concetto fortemente legato all'ereditarietà tra classi e comporta un discorso suddividibile in due parti: covarianza e controvarianza. Iniziamo con lo spiegare la covarianza. Immaginiamo di avere una lista di stringhe, come la seguente:



    'uso i collection initializer
Dim someStrings As New List(Of String) From {"This ", "is ", "a string"}


Com'è noto, String eredita da System.Object. Dovremmo quindi essere in grado di assegnare un elenco di stringhe anche a un elenco generico di Object. Tuttavia, questo fino a VB 2008 non era consentito. In Visual Basic 2010 invece possiamo scrivere:



    Dim variance As IEnumerable(Of Object) = someStrings


Questa assegnazione è ora lecita. E' però consentita solo nei confronti di IEnumerable(Of T), infatti, se provassimo a fare la stessa cosa nei confronti di una List(Of T) (nel nostro caso List(Of Object)), il compilatore solleverebbe un messaggio di errore e ci inviterebbe ad utilizzare IEnumerable.



Se ora provassimo a scandire la collezione variance (che contiene un elenco di Object), otterremmo effettivamente l'esatta concatenazione di stringhe:



    Dim builder As New StringBuilder
For Each s In variance
builder.Append(s)
Next
MessageBox.Show(builder.ToString)


La covarianza, quindi, ci consente di ottenere il risultato previsto dalle classi derivate nell'ambito di una collezione di oggetti di tipo astratto. La controvarianza, invece, 'ragiona' essenzialmente al contrario: da una classe derivata ci consente di sfruttare la classe astratta.



Ipotizziamo di avere un'applicazione Windows Forms in cui ci sia un pulsante, del quale vogliamo gestire gli eventi MouseClick e KeyUp. Tali eventi sono gestiti da metodi che ricevono, come argomenti, rispettivamente oggetti di tipo MouseEventArgs e KeyEventArgs. Entrambi questi ultimi, però, ereditano da System.EventArgs. Ciò posto, è possibile scrivere un gestore di evento unico, che sfrutti EventArgs, come nel modo seguente:



    AddHandler ContravarianceButton.MouseClick, AddressOf CommonHandler
AddHandler ContravarianceButton.KeyUp, AddressOf CommonHandler


  Private Sub CommonHandler(ByVal sender As Object, ByVal e As EventArgs)
MessageBox.Show("You did something!")
End Sub


Grazie alla controvarianza, quindi, abbiamo potuto sfruttare la classe astratta per gestire il comportamento di classi derivate. Potete verificare il funzionamento del codice facendo clic sul pulsante oppure premendo un tasto quando il pulsante stesso ha il focus.



Distribuzioni per Office senza assembly per l'interoperabilità primaria


Con l'attuale versione di .NET Framework, la 3.5 Service Pack 1, e dei linguaggi .NET, nel momento in cui facciamo riferimento ad assembly che ci consentono di interagire con le applicazioni della suite di Microsoft Office dobbiamo poi includere nelle nostre distribuzioni (ClickOnce o Windows Installer) anche gli assembly per l'interoperabilità primaria. Questo può non essere comodo sempre; infatti, includere tali assembly può essere dispendioso in termini di spazio, soprattutto se magari abbiamo utilizzato solo pochi oggetti di quel particolare assembly.



Con il .NET Framework 4.0, e quindi con Visual Basic 2010, è stata introdotta una brillante soluzione: è possibile omettere di includere gli assembly per l'interoperabilità con Office e far sì che, all'interno del nostro eseguibile, siano incorporati i soli oggetti di cui effettivamente facciamo utilizzo.



Supponiamo, a esempio, di avere un'applicazione con un riferimento all'assembly Microsoft.Office.Interop.Word.dll, per la creazione di oggetti utilizzabili da Microsoft Word. All'interno della nostra applicazione abbiamo questo codice, che istanzia un oggetto di tipo Microsoft.Office.Interop.Word.Document, corrispondente a un documento di Word:



    Dim WordDoc As New Microsoft.Office.Interop.Word.Document
'Segue codice di creazione del documento


Stiamo quindi utilizzando il solo oggetto Document. Includere nella nostra distribuzione anche il relativo assembly per l'interoperabilità può essere uno spreco in termini di spazio. Andiamo quindi in Solution Explorer e attiviamo la visualizzazione di tutti i file, quindi espandiamo l'elenco dei riferimenti. Selezioniamo l'assembly Microsoft.Office.Interop.Word.dll e, nella finestra delle proprietà, impostiamo la proprietà Embed Interop su True, come nella figura a destra.



Così facendo, l'assembly non verrà incluso nella distribuzione mentre, nel nostro assembly, verrà incorporata la definizione dell'oggetto Document e ciò che serve al suo utilizzo. Possiamo verificare che quanto detto è effettivamente vero utilizzando Microsoft IL Disassembler (figura sottostante):





Se invece facciamo utilizzo di molti tipi definiti nell'assembly, potrebbe essere conveniente includerlo nella distribuzione impostando la proprietà Embed Interop su False.



Interoperabilità con linguaggi dinamici


Visual Basic 2010, ma più in generale Visual Studio, offre il supporto al Dynamic Language Runtime, una nuova infrastruttura che consente, mediante late-binding, l'interoperabilità tra linguaggi di programmazione 'statici' come Visual Basic o C# e linguaggi 'dinamici', come IronPython per .NET che espongono, tra l'altro, funzionalità di scripting.



Grazie al DLR, quindi, è possibile fare uso di codice di un linguaggio dinamico all'interno del codice Visual Basic. Facciamo un esempio, prendendo in considerazione l'attuale versione di IronPython per .NET, implementazione del linguaggio Python realizzata da Microsoft e scaricabile dal sito CodePlex, la comunità per progetti open-source. IronPython, oltre ad una serie di documenti esplicativi, è distribuito con diversi file di codice di esempio. Ovviamente in questa sede non ci interessa introdurre IronPython, né imparare a utilizzarlo; piuttosto ci interessa capire come sia possibile utilizzarne il codice per futuri approfondimenti. Dopo aver scaricato e installato IronPython.NET, possiamo predisporre una piccola dimostrazione, per esempio creando un nuovo progetto per la Console. Fatto questo, aggiungiamo un riferimento agli assembly IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll, tutti locati nella cartella di installazione di IronPython.



A questo punto dobbiamo aggiungere al progetto il file di codice Python che intendiamo utilizzare nella nostra applicazione. Utilizzando il comando Project|Add existing item, andiamo a reperire il file chiamato First.py all'interno della cartella di installazione di IronPython. Questo file di codice Python definisce alcuni semplicissimi metodi e, come il nome lascia intendere, ha lo scopo di introdurre il linguaggio. Una volta aggiunto questo file al progetto, dobbiamo impostarne la proprietà Build Action su Copy Always all'interno della Finestra delle Proprietà.



Fatto questo, dobbiamo necessariamente impostare Option Strict su Off, poiché, come accennato all'inizio, questo tipo di lavoro si fa sfruttando il late-binding, tecnica non consentita da Option Strict On. Quindi aggiungiamo alcune direttive Imports, che ci permettono di abbreviare il richiamo ad alcune classi:



Imports IronPython
Imports IronPython.Hosting
Imports Microsoft.Scripting.Hosting


Il file First.py espone un metodo chiamato Sum, che restituisce il risultato della somma di due numeri. Quindi ipotizziamo di voler fare uso di questo metodo per mostrare il risultato di un'addizione. In primo luogo, iniziamo con lo scrivere il seguente codice:



  Sub Main()

'Tramite ScriptRuntime ottiene l'hosting di Python
Dim py As ScriptRuntime = Python.CreateRuntime

'late-binding: il metodo UseFile legge il contenuto
'del file di codice Python
Dim test As Object = py.UseFile("first.py")


Tramite l'oggetto py di tipo ScriptRuntime possiamo ottenere l'istanza del runtime Python. Py espone un metodo chiamato UseFile, che ci permette di specificare quale file di codice Python vogliamo utilizzare, nel nostro caso quello chiamato first.py. Il risultato della lettura è assegnato all'oggetto test che ci consente di utilizzare i membri definiti nel codice Python. Ad esempio, possiamo ottenere il risultato desiderato in questo modo:



    'invoca il metodo Add definito nel file Python
'e assegna il risultato
Dim sum As Object = test.add(2, 4)

'mostra il risultato convertito da Object a Int32
Console.WriteLine(CInt(sum))
Console.ReadLine()

End Sub


Se avviamo l'applicazione, otterremo il risultato corretto della somma dei numeri 2 e 4. Chiaramente, il Dynamic Language Runtime non funziona solo con IronPython ma anche con altri linguaggi, come ad esempio IronRuby, altra implementazione .NET creata da Microsoft.



Conclusioni


Visual Basic 2010 è un linguaggio molto potente, che raggiunge un livello di maturità senza precedenti. Le novità del linguaggio, la co-evoluzione con Visual C# e il miglioramento della coding experience ci consentono di sviluppare applicazioni potenti e versatili per tutte le tecnologie .NET, migliorando il nostro lavoro sia attraverso il linguaggio stesso sia attraverso la strumentazione di Visual Studio 2010. Potete come di consueto contattarmi al mio indirizzo di posta elettronica o visitare il mio blog.



Risorse utili


Riporto, anche in questo articolo, un elenco di link a risorse utili che vi serviranno per iniziare a prendere confidenza con Visual Studio 2010 Beta 1, partendo dai download fino alle risorse di apprendimento:






Le novità di Visual Basic 2010 - Il linguaggio, seconda parte

Le novità di Visual Basic 2010 - Il linguaggio, prima parte

 

Le novità di Visual Basic 2010 - Il linguaggio, prima parte
a cura di Alessandro Del Sole (requisiti: conoscenza intermedia del linguaggio Visual Basic 2008 )

Introduzione
Nel precedente articolo abbiamo introdotto le novità della Beta 1 di Microsoft Visual Studio 2010 a livello di ambiente integrato di sviluppo, osservando diverse nuove caratteristiche di pertinenza, in modo particolare, dell'editor di codice che, oltre ad essere ora basato su Windows Presentation Foundation, offre diversi strumenti per migliorare e semplificare la scrittura di codice.

In questo secondo articolo della mini-serie dedicata a Visual Basic 2010, inizieremo ad illustrare le novità dal punto di vista del linguaggio. In particolare, ci occuperemo di introdurre le novità un pochino più semplici (ma non per questo meno interessanti), mentre nel prossimo articolo parleremo di quelle un po' più complesse. Inizieremo così a capire come cambierà il modo di scrivere il nostro codice nella prossima versione del linguaggio e osserveremo come questa versione abbia raggiunto un elevato livello qualitativo.

Anche in questo caso è bene ricordare che, essendo allo stato attuale Microsoft Visual Studio 2010 offerto in Beta 1, potrebbe essere soggetto a modifiche prima del rilascio della sua versione definitiva, anche se le novità sintattiche non dovrebbero subire particolari modifiche, dal momento che sono state introdotte (e rimaste pressoché invariate) fin dalla prima CTP pubblica di ottobre 2008.

Inoltre, a corredo del prossimo articolo verrà fornito tutto il codice sorgente, scaricabile dall'area download.

Cosa occorre
Per poter proseguire nella lettura dell'articolo è necessario scaricare e installare Visual Studio 2010 Beta 1, disponibile nelle seguenti edizioni:

Una volta installato il tutto (altre indicazioni sono fornite nel primo articolo), possiamo iniziare a vedere qualche novità.

Il progetto per le prove
E' sufficiente creare un nuovo progetto per la Console (adatto per questo tipo di dimostrazione) in Visual Basic 2010, utilizzando il comando File|New project e selezionando il modello di progetto apposito nella finestra New project:

Assicuratevi che sia selezionata la versione 4.0 di .NET Framework e fate clic su OK, attendendo la generazione del nuovo progetto. Una volta che abbiamo il cursore pronto all'interno del modulo principale del progetto, possiamo iniziare con le novità.

Auto-implemented properties
Una delle novità più importanti del linguaggio è costituita dalle auto-implemented properties, ossia dalla nuova modalità di dichiarazione delle proprietà. Analogamente a quanto avviene in Visual C# già a partire dalla versione 2008, ora si può dichiarare una proprietà in una sola riga di codice:

    Public Property MiaProprieta As String


Questo equivale a scrivere il seguente codice Visual Basic 2008:



  Private _miaProprieta As String
Public Property MiaProprieta() As String
Get
Return _miaProprieta
End Get
Set(ByVal Value As String)
_miaProprieta = Value
End Set
End Property


E' quindi un modo molto più immediato e intuitivo di dichiarare proprietà. E' anche possibile eseguire l'assegnazione già in fase di dichiarazione:



  Public Property MiaProprieta As String = "Qualcosa"


Saremo poi in grado di utilizzare le proprietà nel modo consueto, non cambia assolutamente nulla, se non il fatto che ci risparmiamo di scrivere ogni volta blocchi di codice come quello sopra riportato. Ci sono essenzialmente due eccezioni a questa regola. La prima riguarda le proprietà a sola lettura, che funzionano ancora nel vecchio modo:



  Private _counter As Integer
Public ReadOnly Property Counter() As Integer
Get
Return _counter + 1
End Get
End Property


La seconda eccezione riguarda l'operazione di ridefinizione, nell'ambito di una classe derivata. A esempio, quando ereditiamo da una classe e vogliamo ridefinirne una proprietà, Visual Studio 2010 offrirà la seguente definizione:



  Public Overrides Property MiaProprieta() As String
Get
Return MyBase.MiaProprieta
End Get
Set(ByVal value As String)
MyBase.MiaProprieta = value
End Set
End Property


Questo ha un senso poiché potremmo voler modificare il comportamento della proprietà. Cosa, comunque, non sempre necessaria.



Implicit line continuation


La implicit line continuation, tradotto in continuazione implicita di linea, è una novità senza dubbio storica per Visual Basic. Infatti, ci consente di andare a capo all'interno delle linee di codice senza dover utilizzare il carattere underscore (_).



Questa novità, però, non influenza ogni ambito sintattico, ma solo alcuni specifici scenari. E' infatti possibile omettere di digitare il carattere undescore andando a capo tranquillamente nelle situazioni che ora illustriamo.




All'interno di una query LINQ:



    Dim query = From proc In Process.GetProcesses.AsEnumerable
Where (proc.ProcessName.StartsWith("A"))
Select proc


All'interno di una espressione incorporata in LINQ to Xml:



    Dim doc = <?xml version="1.0"?>
<Processes>
<%= From proc In query
Select <Process>
<Name <%= proc.ProcessName %>/>
</Process>
%>
</Processes>


Dopo le virgole e le parentesi graffe:



        Dim p As New List(Of Integer) From { 
1,
2,
3,
4}


Dopo il punto:



    Dim appDataDir As String = My.Computer.FileSystem.
SpecialDirectories.AllUsersApplicationData()


Nel decorare oggetti con attributi:



  <CLSCompliant(True)>
Class Test   End Class



Al di fuori di questi casi, la continuazione implicita di linea non è consentita. A esempio, l'istruzione Handles vuole la continuazione esplicita nel vecchio stile:



  Private Sub AnEventHandler(ByVal sender As Object, ByVal e As EventArgs) _
Handles anObject.Disposed   End Sub


Optional nullable parameters


Visual Basic 2010 offre il supporto ad argomenti di tipo Nullable(Of T) per i parametri opzionali all'interno dei metodi. A esempio, la firma del seguente metodo è ora valida:



  Private Sub DoSomething(ByVal someText As String,
Optional ByVal someNumber As Integer? = Nothing)

If someNumber Is Nothing Then
Console.WriteLine("Parameter is null")
End If

Console.ReadLine()
End Sub


È anche possibile inizializzare l'argomento direttamente nella firma.



Collection initializers


Dopo gli Object Initializers, introdotti con .NET Framework 3.5, che permettevano l'inizializzazione in-line dei membri di una classe direttamente in fase di istanza, con .NET Framework 4.0 vengono introdotti i Collection Initializers, una caratteristica che offre la stessa opportunità con le istanze delle collezioni.


Facciamo un esempio per capire meglio. Ipotizzando di voler istanziare una List(Of String) e popolarla con alcuni elementi, in Visual Basic 2008 dovremmo scrivere il seguente codice:



    Dim customList As New List(Of String)

With customList
.Add("One")
.Add("Two")
.Add("Three")
End With


In Visual Basic 2010, invece, possiamo scrivere:



    Dim customList As New List(Of String) From {"One", "Two", "Three"}


In sostanza, la parola chiave From seguita da una coppia di parentesi graffe contenenti i valori iniziali ci consente di istanziare e popolare una collection contestualmente alla sua istanza. Questo approccio vale per tutte le collezioni .NET, come ad esempio per i Dictionary(Of T, T):



    Dim customDictionary As New Dictionary(Of String, Integer) From
{{"One", 1}, {"Two", 2}, {"Three", 3}}


Chiaramente, questo tipo di tecnica può essere utilizzato non solo nei confronti di tipi primitivi, ma anche di classi proprie. Ipotizzando di avere una classe Customer, che rappresenta un cliente, così definita:



Class Customer

Property CustomerID() As String
Property CompanyName As String
Property ContactName As String

End Class


E supponendo di avere alcune istanze della predetta classe, esemplificate in questo modo:



    Dim alessandro As New Customer With {.CustomerID = "DELSO",
.CompanyName = "Del Sole S.p.A",
.ContactName = "Alessandro Del Sole"}

Dim diego As New Customer With {.CustomerID = "CATTA",
.CompanyName = "Cattaruzza S.r.l.",
.ContactName = "Diego Cattaruzza"}

Dim antonio As New Customer With {.CustomerID = "CATUC",
.CompanyName = "Catucci S.a.s.",
.ContactName = "Antonio Catucci"}

Dim renato As New Customer With {.CustomerID = "MARZA",
.CompanyName = "Marzaro S.n.c.",
.ContactName = "Renato Marzaro"}


Potremmo istanziare una collezione di qualunque tipo, purché generica nei confronti della classe Customer, popolandola direttamente in fase di istanza:



    Dim customerFriends As New ObservableCollection(Of Customer) From {antonio,
alessandro,
renato,
diego}


I più attenti avranno anche notato che nel codice sopra evidenziato si fa utilizzo di alcune novità di VB 2010, come le auto-implemented properties e la implicit line continuation.



Array Literals, array multidimensionali e jagged arrays


Visual Basic 2010 offre importanti novità anche dal punto di vista della manipolazione di array.


La prima novità, propedeutica alle altre, è quella degli Array Literals ossia l'inferenza del tipo degli elementi degli array. Consideriamo la seguente riga di codice Visual Basic 2008, che dichiara un array di interi:



    Dim intArray() As Integer = {1, 2, 3, 4}


In Visual Basic 2010, la stessa cosa si può fare in questo modo:



    Dim intArray() = {1, 2, 3, 4}


Il compilatore inferisce il tipo Integer


La seguente riga, dichiara un array di stringhe utilizzando la nuova modalità:



    Dim strArray = {"One", "Two", "Three", "Four"}


Il compilatore inferisce il tipo String.


Un'eccezione ovvia a questo particolare contesto si presenta nel momento in cui dichiariamo array misti. Considerate la seguente riga di codice:



    Dim varArray = {"One", 1}


Non funziona con Option Strict On, viene visualizzato un messaggio di errore circa l'impossibilità di inferire il tipo. Con Option Strict Off il compilatore inferisce Object.



L'introduzione degli array literals permette di dichiarare allo stesso modo due particolari tipologie di array: gli array multidimensionali e i cosiddetti jagged arrays. Dei primi facciamo il seguente esempio:



    Dim multiArray = {{1, 2}, {3, 4}}


Come vedete, la 'multidimensionalità' è data dal racchiudere coppie di parentesi graffe (contenenti i valori di interesse) all'interno di una coppia di altrettante graffe. Se vogliamo capire come Visual Basic interpreta la dichiarazione dell'array, ci basta passare col puntatore del mouse sopra la dichiarazione stessa per ottenere un tooltip descrittivo:





I jagged arrays, invece, sono array di array, ognuno dei quali può essere di tipo e dimensione diversi. L'inferenza del tipo serve proprio a rendere più facile la loro dichiarazione, come nel seguente esempio in cui si dichiara un array di array di interi:



    Dim jaggedArray = {({1, 2}), ({3, 4})}


Anche in questo caso, passando col puntatore del mouse sulla dichiarazione, si ottiene qualche informazione utile su come il compilatore interpreta la dichiarazione stessa:





Per accedere al contenuto di un jagged array utilizziamo le modalità a noi già note:



    Dim arr = jaggedArray(0)


La variabile arr è un array di interi che contiene i valori 1 e 2.



Conclusioni


Con i jagged arrays concludiamo il nostro primo contatto con le novità di Visual Basic 2010, di modo che possiate tirare il fiato e memorizzarle con calma. Nel prossimo articolo tratteremo molte cose interessanti, come la varianza generica, la distribuzione di applicazioni che sfruttano classi di Office senza assembly per l'interoperabilità, le espressioni lambda multi linea e la possibilità di sfruttare da codice VB altri linguaggi dinamici come IronPython.



Uno degli obiettivi che il Team di Visual Studio si è proposto è quello del miglioramento della coding experience. Le novità di Visual Basic, quindi, hanno proprio questa finalità oltre a rendere ancor più potente il linguaggio. Potete come di consueto contattarmi al mio indirizzo di posta elettronica o visitare il mio blog.



Risorse utili


Riporto, anche in questo caso, un elenco di link a risorse utili che vi serviranno per iniziare a prendere confidenza con Visual Studio 2010 Beta 1, partendo dai download fino alle risorse di apprendimento:






Le novità di Visual Basic 2010 - Il linguaggio, prima parte

Screencast - Visual Basic Tips & Tricks

 

Area Screencast

1) "Il data-binding drag'n'drop per WPF in Visual Studio 2010" - durata 36:27
Registrato il 06/06/2009 da Alessandro Del Sole

06/06/2009 [39480 kb] - Database - ver: VB.NET - Hits: 13

2) "Introduzione a Visual Studio 2010 - personalizzare la Start Page con WPF" - durata 13:58
Registrato il 20.05.2009 da Alessandro Del Sole

21/05/2009 [14089 kb] - Interfaccia utente - ver: VB.NET - Hits: 330

3) "Introduzione a Visual Basic 2010 - le novità del linguaggio - seconda parte" - durata 20:11
Registrato il 20.05.2009 da Alessandro Del Sole

21/05/2009 [15563 kb] - Documentazione - ver: VB.NET - Hits: 131

4) "Introduzione a Visual Basic 2010 - le novità del linguaggio - prima parte" - durata 22:18
Registrato il 19.05.2009 da Alessandro Del Sole

21/05/2009 [18256 kb] - Documentazione - ver: VB.NET - Hits: 168

5) Introduzione a Visual Studio 2010 - le novità dell'IDE" - durata 28:31
Registrato il 19.05.2009 da Alessandro Del Sole

20/05/2009 [19025 kb] - Sistema - ver: VB.NET - Hits: 141

6) "Introduzione al WPF Toolkit - il controllo DataGrid" - durata 35:17
Registrato il 04.04.2009 da Alessandro Del Sole

04/04/2009 [34071 kb] - Database - ver: VB.NET - Hits: 304

7) "Introduzione al WPF Toolkit - Controlli Calendar e DatePicker" - durata 24:48
Registrato il 02.04.2009 da Alessandro Del Sole

04/04/2009 [19581 kb] - Interfaccia utente - ver: VB.NET - Hits: 148

8) Creare e distribuire applicazioni Silverlight con Visual Basic 2008 per Windows Azure" - durata 19:34
Registrato il 16.03.2009 da Alessandro Del Sole

16/03/2009 [21307 kb] - Internet/Comunicazioni - ver: VB.NET - Hits: 267

9) "Creare e distribuire applicazioni Web con Visual Basic 2008 per Windows Azure" - durata 23:30
Registrato il 15.03.2009 da Alessandro Del Sole

16/03/2009 [22721 kb] - Internet/Comunicazioni - ver: VB.NET - Hits: 243

10) "Upgrade da SQL Server 2008 Express a Express with Advanced Services" - durata: 16:15 - registrato il 08.02.2009 da Alessandro Del Sole
08/02/2009 [14463 kb] - Database - ver: VB.NET - Hits: 520

11) Video introduttivo all'uso dei Live Meeting di Visual Basic Tips & Tricks
08/02/2009 [5342 kb] - Documentazione - ver: VB.NET - Hits: 1328

12) "ASP.NET Dynamic Data in VB 2008" - Terza parte. Durata: 16:15.
Registrato il 03.11.2008 da Alessandro Del Sole (vedi suo blog dd. 03/11/2008)

17/01/2009 [15087 kb] - Database - ver: VB.NET - Hits: 415

13) "ASP.NET Dynamic Data in VB 2008" - Seconda parte. Durata: 19:33.
Registrato il 03.11.2008 da Alessandro Del Sole (vedi suo blog dd. 03/11/2008)

17/01/2009 [17313 kb] - Database - ver: VB.NET - Hits: 355

14) "ASP.NET Dynamic Data in VB 2008" - Prima parte.
Registrato il 03.11.2008 da Alessandro Del Sole (vedi suo blog dd. 03/11/2008)

21/11/2008 [18881 kb] - Database - ver: VB.NET - Hits: 922

15) ADO.NET 2.0 - Primo contatto.
Registrato il 25.10.2008 da Mario De Ghetto (vedi suo blog dd. 25.10.2008)

21/11/2008 [12343 kb] - Database - ver: VB.NET - Hits: 975

16) .NET Framework Client Profile in .NET Framework 3.5 Service Pack 1.
Registrato il 22.10.2008 da Alessandro Del Sole (vedi suo blog dd. 22.10.2008)

21/11/2008 [23702 kb] - Sistema - ver: VB.NET - Hits: 501

17) La finestra XML Schema Explorer in Visual Basic 2008 Service Pack 1.
Registrato il 13.09.2008 da Alessandro Del Sole

21/11/2008 [27627 kb] - Interfaccia utente - ver: VB.NET - Hits: 434

18) Introduzione a LINQ to Entities in Visual Basic 2008.
Registrato il 14.05.2008 da Alessandro Del Sole

21/11/2008 [24218 kb] - Database - ver: VB.NET - Hits: 524

19) Il controllo LinqDataSource in ASP.NET con Visual Basic 2008.
Registrato il 05.05.2008 da Alessandro Del Sole

21/11/2008 [13532 kb] - Database - ver: VB.NET - Hits: 405

20) Utilizzare LINQ to SQL con database SQL Server 3.5 Compact Edition.
Registrato il 18.04.2008 da Alessandro Del Sole

21/11/2008 [14415 kb] - Database - ver: VB.NET - Hits: 442

21) Richiamare stored procedures in LINQ to SQL con Visual Basic 2008.
Registrato il 18.04.2008 da Alessandro Del Sole

21/11/2008 [8801 kb] - Database - ver: VB.NET - Hits: 434

22) Esportare dati in Excel con LINQ in Visual Basic 2008.
Registrato l'11.04.2008 da Alessandro Del Sole

21/11/2008 [26873 kb] - Database - ver: VB.NET - Hits: 473

23) Introduzione a LINQ to DataSets in Visual Basic 2008.
Registrato il 08.04.2008 da Alessandro Del Sole

21/11/2008 [19655 kb] - Database - ver: VB.NET - Hits: 421

24) Introduzione a LINQ to Xml in Visual Basic 2008 Quarta parte - Creare file XML con query ed embedded expression.
Registrato il 06.04.2008 da Alessandro Del Sole

21/11/2008 [7641 kb] - Database - ver: VB.NET - Hits: 386

25) Introduzione a LINQ to Xml in Visual Basic 2008 Terza parte - Eseguire query su file Xml esistenti.
Registrato il 06.04.2008 da Alessandro Del Sole

21/11/2008 [10451 kb] - Database - ver: VB.NET - Hits: 361

26) Introduzione a LINQ to Xml in Visual Basic 2008 Seconda parte - I valori XML letterali.
Registrato il 06.04.2008 da Alessandro Del Sole

21/11/2008 [7262 kb] - Database - ver: VB.NET - Hits: 309

27) Introduzione a LINQ to Xml in Visual Basic 2008 Prima parte - Utilizzo del namespace System.Xml.Linq.
Registrato il 06.04.2008 da Alessandro Del Sole

21/11/2008 [7388 kb] - Database - ver: VB.NET - Hits: 433

28) Introduzione a LINQ to SQL in Visual Basic 2008.
Registrato il 26.03.2008 da Alessandro Del Sole

21/11/2008 [35591 kb] - Database - ver: VB.NET - Hits: 418

29) Introduzione a LINQ to Objects in Visual Basic 2008 - Seconda Parte.
Registrato il 06.03.2008 da Alessandro Del Sole

20/11/2008 [10867 kb] - Miscellanea - ver: VB.NET - Hits: 341

30) Introduzione a LINQ to Objects in Visual Basic 2008 - Prima Parte.
Registrato il 05.03.2008 da Alessandro Del Sole

20/11/2008 [10056 kb] - Miscellanea - ver: VB.NET - Hits: 369

31) Introduzione alle novità del linguaggio Visual Basic 9.0.
Registrato il 05.03.2008 da Alessandro Del Sole

20/11/2008 [15591 kb] - Api - ver: VB.NET - Hits: 514

32) Applicazioni WPF con Microsoft Expression Blend e Visual Basic 2008 - Terza Parte.
Registrato il 28.02.2008 da Alessandro Del Sole

20/11/2008 [8808 kb] - Interfaccia utente - ver: VB.NET - Hits: 302

33) Applicazioni WPF con Microsoft Expression Blend e Visual Basic 2008 - Seconda Parte.
Registrato il 28.02.2008 da Alessandro Del Sole

20/11/2008 [15603 kb] - Interfaccia utente - ver: VB.NET - Hits: 326

34) Applicazioni WPF con Microsoft Expression Blend e Visual Basic 2008 - Prima Parte.
Registrato il 28.02.2008 da Alessandro Del Sole

20/11/2008 [11157 kb] - Interfaccia utente - ver: VB.NET - Hits: 330

35) Microsoft Expression Design, Expression Blend e Visual Basic 2008 con Windows Presentation Foundation.
Registrato il 28.02.2008 da Alessandro Del Sole

20/11/2008 [11903 kb] - Interfaccia utente - ver: VB.NET - Hits: 334

Visual Basic Tips & Tricks