Utilizzando il Framework ero psicologicamente preparato a non trovare tutto quello che cercavo perchè non avrebbe senso personalizzare troppo ma piuttosto avrei dovuto estendere gli oggetti che utilizzavo, il tutto devo dire in modo abbastanza rapido e efficace.
Per alcune cose pero', pensavo tra me e me, sarebbe stato carino averle gia' integrate, ed ecco che qualcosa sia dal punto di vista dei controlli che degli oggetti stessi del Framework, sono riuscito a trovarla. In questi articolo diamo un'occhiata ad alcune cose che evrei voluto trovare e finalmente le ho trovate...

Adoro la Barra degli Indirizzi di Internet Explorer
La prima cosa che ho fatto con l'oggetto ComboBox 1.x è stato estenderlo per avere l'effetto "intellisense" mentre scrivo, ovvero quello che fa la barra degli indirizzi di Internet Explorer.
Il codice faceva l'override del keyUp e tirava fuori i valori nella combo che cominciavano per, esempio:


Protected Overrides Sub OnKeyUp(ByVal e As System.Windows.Forms.KeyEventArgs)
'--- se premo i tasti che non servono allora non faccio nulla
If ((e.KeyCode = Keys.Back) Or _
(e.KeyCode = Keys.Left) Or _
(e.KeyCode = Keys.Right) Or _
(e.KeyCode = Keys.Up) Or _
(e.KeyCode = Keys.Delete) Or _
(e.KeyCode = Keys.Down) Or _
(e.KeyCode = Keys.PageUp) Or _
(e.KeyCode = Keys.PageDown) Or _
(e.KeyCode = Keys.Home) Or _
(e.KeyCode = Keys.ShiftKey) Or _
(e.KeyCode = Keys.End)) Then Return


Dim zTxt As String = Me.Text
Dim zInd As Integer = FindString(zTxt) '--- se lo trovo torna >=0
If (zInd > -1) Then
Me.SelectedIndex = zInd '--- seleziono anche l'elemento che trovo
Me.SelectionStart = zTxt.Length '--- mi sposto e seleziono il testo che ce dopo
Me.SelectionLength = Items(zInd).ToString().Length
Me.DroppedDown = qApri
End If
End Sub


Questo codice nella versione 2.0 non serve perche si puo' utilizzare le propieta AutoComplete (anche a Design Time):


comboBox1.AutoCompleteSource = AutoCompleteSource.ListItems;
comboBox1.AutoCompleteMode = AutoCompleteMode.SuggestAppend;






L'effetto ovviamente è lo stesso ma direi molto piu comodo e inoltre da notare che vale anche per la TextBox e si puo' pescare non solo dagli Items, ma anche dai collegamenti di Internet Explorer,e cartelle dell'hard disk....


E se volessi l'audio?
Per suonare un file audio con la 1.1 bisogna ricorrere all'uso di API particolari per accedere al Device dell'audio con codice veramente scomodo, del tipo:


[DllImport("winmm.dll", CharSet=CharSet.Ansi)]
private static extern bool PlaySound(IntPtr szFileName, IntPtr hmod, int fdwSound);


Finalmente è stato aggiunto un controllo che permetta la riproduzione di file audio (controllo "SoundPlayer") al quale basta impostare il percorso del file e dire di suonarlo:


soundPlayer1.SoundLocation = "f:\\temp\\miofile.wav";
soundPlayer1.Play();



A me non interessa il codice che deriva dalla progettazione visuale...
Quando apro Visual Studio .NET e comincio a disporre oggetti sulla Form spesso lo faccio tramite design percio' mediamente non mi interesso del codice generato in utomatico dall'ambiente.
Non appena passo al codice e dichiaro variabili etc.. percio', la prima cosa che faccio è creare la regione che riguarda tutti i controlli della form, per avere a colpo d'occhio soltanto il codice scritto da me.
Tutto questo adesso viene fatto in automatico (grazie al "partial") perche il codice della progettazione visuale viene automaticamente scritto nel file "formdesigner.cs" che poi al momento della compilazione viene linkato al resto dell'applicazione.


ProgressBar nella StatusBar
Un'altra cosa molto carina che ho trovato utile implementare per alcuni progetti è una ProgressBar all'interno della StatusBar (anche qui "IE like" anche se spesso l'avanzamento e' fasullo...)
Cosa fare se non costruire ad hoc un controllo che eredita dalla StatusBar del Framework, aggiungendogli la ProgressBar che poi deve essere gestita tramite propieta' pubbliche.
La versione 2.0 ci viene in aiuto e ci dà la possibilita di aggiungere un Item di tipo non solo "StatusStripPanel" standard ma anche il tipo "ToolStripProgressbar", ComboBox, TextBox che poi sono poi "raggiungibili" come se fossero normali oggetti del form:



e anche la Toolbar adesso diventa finalmente in stile Office di Default (cosa che mediamente puo andare bene a tutti ormai ;-) estendendo la tipologia di bottoni da aggiungere, quando prima si doveva ricorrere ad assembly di terze parti.





Per non parlare di alcune vere e proprie "chicche" tipo la possibilita' di raggruppare gli Items nella ListBox, la MaskEditBox e finalmente il componente WebBrowser inserito di standard e "wrappato" in modo migliore.
Dal punto di vista delle classi che si usano da codice qualche novità che aspettavo è arrivata da parte di ADO.NET.

DataTable in XML, finalmente!
Quella che ho cercato subito e non so come mai si sia aspettato cosi tanto per farla, e' certamente la serializzazione della DataTable che ora diventa come il DataSet.
Questo significa che anche la DataTable adesso gode delle comodita' di lettura/scrittura di file/stream Xml con i metodi ReadXml/WriteXml che prima si aveva solo con tutto il DataSet.
Vantaggio che si nota immediatamente quando si utilizzano Web Services che fanno query o operazioni ui dati e si deve passare sempre per il DataSet, non che sia impossibile ma sicurmente meno "pulito".
Inoltre adesso si puo' scegliere il tipo di serializzazione anche in binario per prestazioni soprattuto per chi usa il .NET Remoting.

Non solo Interfacce al db per supportarne di differenti...
Per quanto riguarda la connessione al database io mi sono sempre trovato a scrivere programmi che supportassero varie tipologie di database tipicamente Access e SQL Server ma ultimamente anche MySQL.
Cosa fare in questo caso per non cambiare tutto il codice? Beh, l'unica cosa direi è affidarsi ad una classe fatta da me che mi esponga i metodi che utilizzo tipicamente quando devo leggere e scrivere dati, assolutamente indipendenti dalla tipologia di database, ma che all'interno lavori con oggetti tipizzati.
Ovvero io creo un oggetto che instanziato lavora con interfacce comuni tipo IDbConnection ,IDbDataAdapter, IDbCommand etc...le quali a seconda dei parametri diventano poi i relativi oggetti esatti. Ad esempio per fare la connessione:


string zCnStr = StringaConnessione(...

IDbConnection zCn = null;
switch(pTipo)
{
case TipoDb.Sql:
zCn = new SqlConnection(zCnStr);
break;

case TipoDb.Mdb:
zCn = new OleDbConnection(zCnStr);
break;

case TipoDb.MySql:
zCn= new MySqlConnection(zCnStr);
break;
}

....


Basta un po' di pazienza e del buon codice e la trasparenza si ottiene, ma bisogna tener presente che se in futuro si supportano altri database, si devono modificare molte parti della classe.
Inoltre al suo interno sono obbligato a lavorare con l'oggetto di tipo IDbConnection, e quindi mi trovo a perdere alcuni metodi:



Adesso invece finalmente le classi che riguardano il database ereditano tutte da delle classi base che appartengono al namespace System.Data.Common che ad esempio per la connesione e' DbConnection che supporta maggiori proprietà e metodi:



Proprio per la connessione in particolare ho trovato molto utile il metodo GetSchema dato che nel caso di SQLdovevo aggirare l'ostacolo con query abbastanza complicate...

La stessa cosa vale ovviamente per i Dbdatadapter,Dbcommand etc...

Direi che nel mio caso dove ho dovuto progettare una classe abbastanza complessa per rendere questo problema trasparente al programma è un notevole risparmio di tempo! Purtroppo al momento non lo fanno le classi per MySQL (tipicamente uso ByteFX o MySQLDriverCS) ma sono fiducioso che appena sara' rilasciato in RTM il Framework 2.0 anche gli altri si adatteranno a questa ottima struttura ;-)

Per quanto riguarda ASP.NET devo ancora andare a fondo ma ho gia' visto cose strabilianti come le Master Pages, i Menu e le TreeView, il SiteMap, i controli per gli utenti (login,account etc..), gli Styles etc... e sono convinto che man mano che esploro il Framework 2.0 ne trovero' altre che mi invoglieranno sempre di piu a passare a questa versione il prima possibile... ;-)