Key Guard

agosto 3, 2006

Questo programma permette di archiviare e gestire le vostre password. Dispone dell’opzioni di ‘sigillare’ il proprio contenuto con una main password, che sarà chiesta a ogni riavvio del programma. Fra le altre features:

  • Poter salvare il proprio database in formato txt, ini, html e xml;
  • C’è l’opzione di mettere una password anche per l’eliminazione delle altre password
  • Si può mostrare un’icona nella system tray e programmare il backup automatico ogni settimana
  • E’ incorporato anche un generatore di password

Download: Key Guard


Interfacce

luglio 27, 2006

In sostanza un’interfaccia non differisce molto da una classe astratta, anche se l’interfaccia è stata creata appositamente per costuituire lo scheletro di altre classi che la prenderanno come modello. La sintassi è questa:
Interface Nome
'membri non implementati
End Interface

Proprio come nella classe astratte, tutti i membri di un’interfaccia non contengono codice (ossia non sono implementati), ma forniscono solo lo schema che dovrà avere una classe che li implementa. Ad esempio, riprendiamo l’esempio delle bici delle classi astratte:
Interface IBiciletta
Sub Frena()
Sub Pedala(ByVal Forza As UInt16)
End Interface

Come è evidente, qui non c’è bisogno di usare tutti quelle parole riservate, MustInherit e MustOverride, che usavamo nelle classi astratte.
Ora, però, vediamo come si implementa effettivamente un’interfaccia:
Class MountainBike
Implements IBicicletta
Sub Frena() Implements IBicicletta.Frena
'codice
End Sub
Sub Pedala(ByVal Forza As UInt16) Implements IBiccletta.Pedala
'codice
End Sub
End Class

Bene, è tutto essenzialmente uguale, solo che di interfaccia, a differenza delle clasis astratte, se ne posso implementare più di una (mentre si può ereditare una sola classe ala volta).


Classi astratte

luglio 26, 2006

Le classi atratte sono una delle tante caratteristiche dei linguaggi OO (Object Oriented). In Vb.Net si dichiara una classe astratta apponendo l’attributo MustInherit (tra lo specificatore di accesso e la parola ‘Class’). MustInherit deriva dall’inglese e vuol dire ‘Deve ereditare’: quindi questa classe non può essere usata da sole, ma deve per forza essere ereditata da un’altra classe. Possiamo dire che costituisce lo ‘scheletro’ delle sue classi derivate. Infatti, se prendiamo un banale esempio, possiamo capire cosa sia e a cosa serva una classe astratta:
Ammettiamo di essere i sovrintendenti di una fabbrica dove vengono costruite e assemblate le biciclette. Ebbene, noi siamo a conoscienza che per costruirne una ci vuole, essenzialmente un telaio di metallo (non sottilizziamo tanto sul materiale…) e questo deve perciò essere un elemento comune a tutte le biciclette. Inoltre, ogni bicicletta, per essere tale ha bisogno di pedali, di ruote, di freni e di una catena che trasmetta il movimento rotatorio dei pedali alle ruote. Ma di bici esistono tanti modelli differenti: da corsa, mountain-bike, classiche, con i cambi multipli, a 5 ,6 o 7 marce ecc… Ecco: le classi astratte sono come il telaio delle biciclette, i suoi metodi sono i freni, le ruote, la catena e i pedali della bicilette, che ogni modello, poi, interpreta secondo le proprie esigenze. Finita la parentesi ciclistica, abbiamo capito che le classi astratte forniscono lo scheletro per altre classi. I suoi membri devono perciò essere dichiarati MustOverride, ossia che devono per forza essere modificati tramite overloading. Ogni classe derivate ridefinisce quei metodi a seconda delle proprie esigenze. Riprendendo l’esempio ciclistico:
Public MustInherit Class Bicicletta
'Queste procedure dovranno essere ridefinite
Public MustOverride Sub Frena()
Public MustOverride Sub Pedala(ByVal Forza As UInt16)
'Questa invece è standard per tutti
Public Sub Gira(ByVal Direazione As UInt16)
End Class
'La bici con cambio eredita dallo stampo base di una bicicletta,
'ma può cambiare marcia
Public MustInherit Class Bici_con_cambio
Inherits Bicicletta
Public NumeroMarce As Byte
Public MustOverride Sub CambiaMarcia(ByVal Marcia As Byte)
End Class
'La mountain-bike eredita dalla bici con cambio:
Public Class MountainBike
Inherits Bici_con_cambio
Public Sub New(ByVal Marce As Byte)
NumeroMarce = Marce
End Sub
'Questa procedure sono ora ridefinite
Public Overrides Sub Frena
'codice
End Sub
Public Overrides Sub Pedala(ByVal Forza As UInt16)
'codice
End Sub
Public Overrides Sub CambiaMarcia(ByVal Marcia As Byte)
'codice
End Sub
End Class
'La bici classica, invece, eredita solo da Bicicletta,
'poichè non dispone di un cambio
Public Class Bici_classica
Inherits Bicicletta
Public Overrides Sub Frena
'codice
End Sub
Public Overrides Sub Pedala(ByVal Forza As UInt16)
'codice
End Sub
End Class
Nell’esempio si vede che anche le classi astratte possono ereditare altre classi astratte


Operatori avanzati

luglio 26, 2006

Gli operatori che abbiamo visto fin’ora sono quelli classci che, bene o male, si possono trovare in molti linguaggi. Veniamo ora ad esaminare quelli più complessi che possono essere utili in situazioni un po’ più ‘particolari’.Operatori logici cortocircuito
Questi operatori sono chiamati ‘cortocircuito’ perchè, a differenza dei normali operatori logici (come Or, And, Xor e Not), non controllano tutta l’espressione nella sua interezza, ma si ‘interrompono’ quando incontrano una condizione vera. Essi sono AndAlso e OrElse. Ad esempio:
Module Module1
Sub Main()
Dim A As Int16 = 1
If A = 1 OrElse A = 65535 Then
Console.WriteLine("OK")
Else
Console.WriteLine("KO")
End If
End Sub
End Module

Ok: avremo scritto a console ‘OK’… Il fatto è che, una volta incontrata una condizione che viene verificata, ossia A = 1, perchè A è effettivamente uguale a 1, non c’è più bisogno di andare oltre ad analizzare, poichè si sa che ormai la condizione sarà comunque soddisfatta. In questo caso, se il controllo andasse avanti produrrebbe un errore di tipo MathOverflowError, ma fermandosi alla prima clausola, questo non succede.
Questo succede esattamante con AndAlso, solo che questo operatore si ferma quando incontra una condizione che NON è vera (infatti, per far sì che una condizione And sia soddisfatta devono essere vere tutte le condizione concatenate da quell’operatore): inutile proseguire, poichè il risultato sarebbe comunque falso, quindi esce dall’If o salta direttamente al blocco Else.

Operatori aritmetici avanzati
Sotanzialmente ce ne sono solo 2: ^, che è un operatore binario che eleva il primo termine al secondo (2 ^ 3 = 8 ), e \ (non /, attenzione!), anch’esso un operatore binario, che esegue un’operazione di divisione intera (quindi con risultato sempre intero).

Operatori di assegnamento avanzato
In questa sezione ce ne sono di più. Gli operatori di assegnamento (=, +=, -= e compagni bella) del Vb.Net permettono espressioni molto più complesse e flessibile rispetto a linguaggi procedurali come il Pascal. Quelli che abbiamo tralasciato sono:

  • x ^= y : eleva x a y e deposita il valore ottenuto in x
  • x \= y : esegue una divisione intera fra x e y e deposita il valore ottenuto in x
  • x &= y : concantena y a x (quindi y può essere sia una stringa che un numero, poichè & concatena sia stringhe che numeri; x, invece, può essere solo una stringa) e deposita il valore ottenuto in x
  • x <<= y : esegue uno spostamento dei bit di x a sinistra di y posti e deposita il valore ottenuto in x
  • x >>= y : esegue uno spostamento dei bit di x a destra di y posti e deposita il valore ottenuto in x

Operatori di shift su bit (spostamento di bit)
Per comprendere gli operatori di shift bisogna conoscere il codice binario, quindi vi rimando alla mia lezione sul codice binario nel corso di Pascal.

Operatori di confronto avanzati
Ci sono altri due operatori di confronto che non sono stati analizzati. Sono: Is e Like. Is è un operatore binario che restituisce vero se sia il primo elemento che il secondo fanno riferimento allo stesso oggetto (per coloro che provengono dal C, se entrambe le referenze degli elementi puntano allo stesso indirizzo di memoria), mentre Like è un po’ più complesso. Innanzitutto Like è anch’esso binario e funzione passando come primo elemento una stringa e come secondo un ‘pattern’, ossia una direttiva di ricerca, in questo caso. Ad esempio, se si vuo, sapere se una stringa contiene una lettere da ‘a’ a ‘f’ si fa in questo modo:
If Stringa Like "[a-f]" Then...
Oppure se si vuol sapere se una stringa contiene una lettere da e a g e finisce con una da h a z:
If Stringa Like "[e-g]*[h-z]" Then...


Opzioni di compilazione

luglio 26, 2006

Derivati dal vecchio, ma ancora utilizzatissimo, VB6 sono rimaste nel Vb.Net le opzioni per la compilazione. Queste istruzioni, marcate dalla parola chiave Option, consentono di modificare alcuni parametri relativi alla compilazione del sorgente.

Option Explicit
Le opzioni vanno scritto proprio all’inizio del sorgente, prima di qualsiasi direttiva o dichiarazione (anche prima di Imports). Scrivendo Option Explicit On si attiva questa opzione, che obbliga ad usare questa sintassi per dichiarare le variabili:
Dim Nome As Tipo
Il compilatore ha di default questa opzione attiva, infatti quando ci dimentichiamo di scrivere la parola riservata Dim per la dichiarazione di una variabile ci viene comunicato un errore.
Impostando, invece, Option Explicit Off, si può usare qualsiasi nome come una variabile, senza definirla… per farla breve, possiamo eseguire senza problemi questo codice:
Option Explicit Off
Module Module1
Sub Main()
'La variabile C viene utilizzata senza essere
'dichiarata con la sintassi standard,
'ma non viene segnalato nessun errore
C = "Ciao"
End Sub
End Module

Option Compare
Questa opzione viene usata per determinare come devono essere confrontate due stringhe e può assumere due valori: Text e Binary. Con il primo, si controlla soltanto che il testo di due stringhe sia uguale (ossia maiuscole e minuscole NON fanno differenza), mentre col secondo si confranta ogni byte della stringa, prendendo in considerazione i codici ASCII di ogni carattere (quindi maiuscole e minuscole SONO considerate differenti). Ad esempio:
Option Compare Text
Module Module1
Sub Main()
If "CIAO" = "ciao" Then
Console.WriteLine("Option Compare Text")
Else
Console.WriteLine("Option Compare Binary")
End If
Console.ReadKey()
End Sub
End Module

Ora, se facessimo correre il programma otterremmo un messaggio che dice ‘Option Compare Text’; se, invece, provassimo a cambiare e scrivere Option Compare Binary, otterremmo la scritta ‘Option Compare Binary’.

Option Strict
Abbiamo detto in uno dei capitoli della guida che il Vb.Net esegue spesso conversioni implicite di dati (ad esempio se assegnamo un valore Int16 a un Int64 la conversione è automatica): ebbene, imppostando Option Strict On, nessuna conversione implicita sarà consentita e verrà visualizzato un errore. Ad esempio, il seguente codice produrrà un errore:
Option Strict On
Module Module1
Sub Main()
Dim I As Int16 = 2
Dim D As Double = 4.0
I = D
End Sub
End Module


La guida

luglio 23, 2006

Troverete la guida a questo sito (in alternativa anche qui). Ci sono 59 capitoli in tutto.


Arkiviation

giugno 28, 2006

Questo programma permette di archiviare più files in un unico file d’archivio e di scompattarlo in seguito, con più opzioni. Purtroppo archivia soltanto i file testuali, ossia che sono composti di vero e proprio testo e non quelli complessi con caratteri extended (doc, wmv, mpg, mp3, xls eccetera), perchè si ferma a metà. Però con i file compatibili funziona a meraviglia.

Download: Arkiviation