L’algoritmo di Berger scritto in Vb.Net

45 Comments | Apr 13, 2012
L’algoritmo di Berger, ideato dallo scacchista austriaco Johann Berger , è un metodo procedurale per stilare un calendario (diviso in giornate) di un torneo sportivo svolto con il sistema del “girone all’italiana ” composto da un qualsiasi numero di concorrenti o squadre.

Ecco la traduzione in Vb.Net:

Private Function CreaCalendario(Squadre() As String) As String
Dim buffer As String = ""
Dim numero_squadre As Integer = Squadre.Length
Dim giornate As Integer = numero_squadre - 1
Dim casa(0) As String
Dim trasferta(0) As String
Array.Resize(casa, numero_squadre / 2)
Array.Resize(trasferta, numero_squadre / 2)
For i As Integer = 0 To (numero_squadre / 2) - 1
casa(i) = Squadre(i)
trasferta(i) = Squadre(numero_squadre - 1 - i)
Next
For i As Integer = 0 To giornate - 1
buffer &= "Giornata " & i + 1 & "
"
If i Mod 2 = 0 Then
For j As Integer = 0 To (numero_squadre / 2) - 1
buffer &= j + 1 & " " & trasferta(j) & " - " & casa(j) & ""
Next
Else
For j As Integer = 0 To (numero_squadre / 2) - 1
buffer &= j + 1 & " " & casa(j) & " - " & trasferta(j) & ""
Next
End If
Dim Pivot As String = casa(0)
Dim Riporto As String = trasferta(trasferta.Length - 1)
Array.ConstrainedCopy(trasferta, 0, trasferta, 1, trasferta.Length - 1)
trasferta(0) = casa(1)
Array.ConstrainedCopy(casa, 1, casa, 0, casa.Length - 1)
casa(casa.Length - 1) = Riporto
casa(0) = Pivot
Next
Return buffer
End Function

Luna Data Layer Code Generator for Vb.Net

28 Comments | Mar 15, 2012
Luna è un generatore di codice automatico per agevolare e standardizzare la scrittura delle classi che si occupano del salvataggio dei dati di una applicazione.

Il codice viene generato in linguaggio VB.Net (il codice in C# verrà implementato a breve) e può essere utilizzato sia in applicazioni Desktop che Web.

Tutto nasce dall' esigenza di scrivere in maniera ottimale e facilmente gestibile la parte più noiosa e ripetitiva di accesso ai dati, mantenendo uno standard facilmente comprensibile.

Non si deve incorporare nessun oggetto nel proprio progetto, e tutto il codice generato è facilmente modificabile o customizzabile dallo sviluppatore.

COME FUNZIONA?

Innanzitutto è necessario che la base dati dell'applicazione sia stata studiata e realizzata. Una volta fatto ciò, il database creato viene dato in input a Luna che si occuperà dell'effettiva creazione delle classi.

I componenti principali di Luna sono:
  • Struttura
  • Interprete
  • Convertitore

Struttura

Luna ha una sua struttura proprietaria logica di tabelle, campi e relazioni con cui mappare in memoria un database esistente in un formato standardizzato.

Interprete

E' presente un interprete specifico per ogni tipologia di base dati, quindi è virtualmente possibile supportare ogni tipo di base dati. L'interprete si occupa di collegarsi al database indicato, leggere la struttura di tabelle e relazioni e creare in memoria una struttura logica che lo ricalca 1 a 1 utilizzando le classi campo, tabella e relazione di Luna.

Convertitore

Una volta che la struttura di database è stata slegata dall'origine dati fisica, il convertitore si occupa di creare il codice che serve per interfacciarsi completamente con la base dati.

SORGENTI SUPPORTATE

Luna al momento supporta i database di tipo ACCESS (mdb e accdb) e SQL SERVER. Luna supporta inoltre un suo formato proprietario Luna Data Schema (*.lds). Ogni volta che si esegue una generazione di un qualsiasi progetto, nella cartella dei file generati da Luna e' presente il relativo file lds che permette di riaprire la struttura creata in maniera svincolata dal database originale.

ESEMPIO PRATICO

Luna crea il codice delle classi che rappresentano ogni tabella, il codice delle classi DAO che si occupano di interfacciare con il database gli oggetti logici e il codice SQL che potrebbe servire a replicare la struttura della base dati in un altro storage.

Veniamo alla pratica. Dunque iniziamo da una semplice base dati di prova contenente le tabelle Clienti e Telefoni collegate tra loro e cosi strutturate:



Step 1
In questa schermata è possibile selezionare l'origine dati su cui si andrà a lavorare. L'opzione Load View permette di utilizzare come sorgente per le classi non solo le tabelle ma anche le eventuali viste contenute all'interno del Database.

Nel nostro esempio dopo aver selezionato il tipo Database access e scelto il file, clicchiamo sul pulsante "Load DB";



Step 2
Nella schermata successiva ci verranno presentate tutte le tabelle [TABLE] o le eventuali viste [VIEW] che sono state trovate nella fonte dati selezionata. Per selezionare le tabelle che vogliamo generare basta mettere un segno di spunta sulla relativa casella.
Luna supporta la Pluralization, è sufficiente cambiare il nome della classe generata facendo doppio click sul relativo nodo nell'albero di destra. In questo esempio per la tabella Customers verrà generata la class Customer e cosi via. Selezioniamo tutto, cambiamo i nomi e clicchiamo sul pulsante "Create Code";



Cosa viene generato?
Innanzitutto Luna genera tre classi base, LunaBaseClass da cui ereditano tutte le altre classi create, LunaBaseClassEntity da cui ereditano tutte le altre classi entity e LunaBaseClassDAO da cui ereditano tutte le altre classi DAO. Inoltre viene creata una classe LunaSearchParameter di cui vedremo in seguito il funzionamento.

Dopodiche viene creata per ogni tabella una classe entity, una classe partial e una classe di accesso ai dati (DAO)

Classe Entity
La classe generata è un contenitore vuoto, che si integra con la relativa classe Partial e questo permette di accedere a tutti i metodi e le proprieta della classe Partial relativa, cosi organizzata:

#Region "Logic Field"
(vuota)
#End Region

#Region "Method"
(vuota)
#End Region

Viene poi creata una Classe Partial Tabella che eredita da LunaBaseClassEntity e che si integra con la relativa classe Entity, cosi organizzata:

#Region "Author"
...
End Region

#Region "Database Field Map"
(property con i campi della tabella gia pronti per la serializzazione opzionale)
End Region

#Region "Method"
Read(Id) as Tabella

Save(Tabella) as Integer (torna l'id inserito nel database)

SaveCascade(Tabella) as Integer (torna l'id inserito nel database)

#End Region

#Region "Embedded Class"
(property o liste di oggetti relazionate a questa classe)
#End Region

Viene infine creata una Classe TabellaDAO che eredita da LunaBaseClassDAO con i seguenti metodi:

Read(Id) as Tabella

Save(Tabella) as Integer (torna l'id inserito nel database)

SaveCascade(Tabella) as Integer (torna l'id inserito nel database)

Delete(Id)

Delete(Tabella)

GetAll()

Find()

ReadSerialize()

SaveSerialize()

Nell'esempio specifico:
  • Customer; mappatura della tabella Customers eredita da LunaBaseClassEntity
  • Phone; mappatura della tabella Phones eredita da LunaBaseClassEntity
  • CustomerGroup; mappatura della tabella CustomerGroups eredita da LunaBaseClassEntity
  • CustomersDAO; metodi di lettura, salvataggio, ricerca, lista ed eliminazione della classe Customer eredita da LunaBaseClassDAO
  • PhonesDAO; metodi di lettura, salvataggio, ricerca, lista ed eliminazione della classe Phone eredita da LunaBaseClassDAO
  • CustomerGroupsDAO; metodi di lettura, salvataggio, ricerca, lista ed eliminazione della classe CustomerGroup eredita da LunaBaseClassDAO



Analizziamo i vari metodi e proprietà generati:

Classi entity

Read(ID) - Questo metodo permette di leggere dal db un determinato oggetto in base al suo Id; all'interno viene istanziata la sua relativa classe DAO ed effettuate tutte le letture;
Save() - Questo metodo si occupa della persistenza dei dati, all'interno viene istanziata la relativa classe DAO che effettua il salvataggio. E' importante sapere che viene gestita l'effettiva modifica, infatti saranno effettuati solo i salvataggi degli oggetti nuovi o degli oggetti realmente modificati, per evitare un uso inutile del DB.
SaveCascade() - Questo metodo si occupa di salvare l'oggetto e tutti gli oggetti figli relativi;

Classi DAO

Read, Save e SaveCascade, sono gli stessi della classe entity. In più oltre ai metodi di cancellazione (Delete) abbiamo i metodi Find e GetAll che si occupano delle ricerche e ritornano una List(of Tabella) tipizzata.
Infine ci sono i metodi ReadSerialize e SaveSerialize che si occupano di leggere o scrivere su file una copia XML dell'oggetto che gli viene passato.



E ora che abbiamo il codice?
Ora la cosa piu semplice è cliccare sul pulsante Save e selezionare una cartella dove Luna salverà tutti i file che sono stati generati.

Poi avviamo Visual Studio e creiamo un progetto di prova di tipo Applicazione Windows Form e poi aggiungiamo nella stessa soluzione un progetto di tipo Libreria di Classi.
Innanzitutto nel progetto Windows Form aggiungiamo i riferimenti al progetto Libreria di classi. Nel progetto Libreria di classi clicchiamo su Aggiungi elemento esistente, selezioniamo tutti i file che sono stati salvati da Luna e il gioco è fatto. Oppure li trasciniamo direttamente dentro da Esplora Risorse con il drag and drop.

IMPORTANTE!!! Scrivete tutti i vostri metodi logici o personali e le proprietà custom nelle classi Entity, in modo che se dovete rigenerare il Database con Luna, non perderete nulla del codice aggiunto.



Connessione al db
La classe LunaBaseClassDAO da cui ereditano tutte le classi DAO ha tre costruttori della New:
  • New() da per scontato che ci sia una string di nome ConnectionString nei settings del progetto con la relativa stringa di connessione e si occupa da sola di crearsi la connessione (comodo per le Web Application);
  • New(Connection) accetta in input un oggetto di tipo connection;
  • New(ConnectionString) accetta in input una ConnectionString, passando una stringa vuota la BaseClass non apre la connessione(utile per i soli metodi di serializzazione);
La connessione è di tipo Shared quindi se in una procedura dovete istanziare vari oggetti e non volete usare la connection string vi basterà usare una sola dichiarazione New in cui specificate la connessione, nelle altre non sara' necessario.

Ovviamente nelle applicazioni desktop o con Connessione permanente basterà commentare le chiamate nella New() della LunaBaseClassDAO e commentare la dichiarazione della connessione _Cn rendendola pubblica, e tutto continuerà a funzionare.

Importante! Luna non si occupa di chiudere la connessione al Database. La funziona di chiusura viene inserita in ogni classe DAO ma non viene chiamata per lasciare allo sviluppatore la decisione su come gestire e quando chiudere la connessione.

Save

Per fare un inserimento nel nostro caso di un Cliente basterà scrivere:

Dim Cust As New Customer

Cust.CustomerName = "Homer Simpson"
Cust.Address = "Evergreen Terrace, 740"

Dim IdInserted As Integer = Cust.Save
If IdInserted = 0 Then MessageBox.Show("Error")

oppure

Dim Cust As New Customer

Cust.CustomerName = "Homer Simpson"
Cust.Address = "Evergreen Terrace, 740"

Dim MgrCust as new CustomersDAO

Dim IdInserted As Integer = MgrCust.Save(Cust)
If IdInserted = 0 Then MessageBox.Show("Error")

SaveCascade

Per fare un inserimento nel nostro caso di un Cliente con due telefoni basterà scrivere:

Dim Cust As New Customer

Cust.CustomerName = "Homer Simpson"
Cust.Address = "Evergreen Terrace, 740"

Dim Phone1 As New Phone
Phone1.PhoneNumber = "555.123"

Cust.ListPhone.Add(Phone1)

Dim Phone2 As New Phone
Phone2.PhoneNumber = "555.456"

Cust.ListPhone.Add(Phone2)

Dim Group As New CustomerGroup
Group.Read(2)

Cust.CustomerGroup = Group

Dim IdInserted As Integer = Cust.SaveCascade
If IdInserted = 0 Then MessageBox.Show("Error")

Tutti i metodi Save e SaveCascade ritornano l'Id appena inserito nel Database. Nell' esempio sopra il SaveCascade si occupa di salvare il nuovo Customer e di salvare i relativi oggetti Phone.

Ricerca

Per il cerca Luna crea in ogni classe DAO due metodi;

il metodo GetAll che torna una List (Of ClasseOggetto) di tutti gli oggetti di quella classe, a cui è possibile passare eventualmente un criterio di ricerca.

Il metodo Find invece ritorna una List (Of ClasseOggetto) in base a uno o più parametri di ricerca.

Il metodo si aspetta un Array di parametri e combina la ricerca in base a tutti i parametri che vengono passati.
I parametri sono oggetti di tipo LunaSearchParameter, vediamo due semplici esempi:

Cerchiamo tutti i telefoni di un determinato Customer

'IMPOSTIAMO IL PARAMETRO
Dim Par as new LunaSearchParameter("CustomerID",1)

Dim Mgr as New TelefoniDAO()
Dim ListPhone as List (Of Phone) = Mgr.Find(Par)

Cerchiamo tutti i telefoni di un determinato Customer che iniziano per 06

'IMPOSTIAMO IL PRIMO PARAMETRO NEL COSTRUTTORE
Dim Par as new LunaSearchParameter()
Par.FieldName = "CustomerID"
Par.Value = 1

'IMPOSTIAMO IL SECONDO PARAMETRO IN MODO ESPLICITO
Dim Par2 as new LunaSearchParameter("PhoneNumber","06%","LIKE")

Dim Mgr as New TelefoniDAO()
Dim ListPhone as List (Of Phone) = Mgr.Find(Par,Par2)


Classi figlie

In ogni classe vengono creati gli accessi agli oggetti delle classi figlie. In ogni caso si tratta di caricamenti pigri, ossia che vengono effettuati solo se effettivamente richiamati.

In caso di relazioni tra le classi di tipo 1 a 1 viene creato in ogni ClassePadre una property di tipo ClasseFiglio.

In caso di relazioni tra le classi di tipo 1 a N viene creata in ogni ClassePadre una List Of (ClasseFiglio).

Sia l'oggetto ClasseFiglio che la Lista di oggetti ClasseFiglio, sono caricati solo nel momento in cui realmente si accede ai metodi.

Questo è solo un semplice esempio, capire il funzionamento dei vari metodi creati è banale. La cosa importante è che non è stato necessario scrivere una riga di codice per interfacciarsi con la base dati.

IMPLEMENTAZIONI PROGRAMMATE

In ordine di importanza:
  • Ambito e transazioni distribuite
  • Le relazioni tra campi vengono lette solo da MS Access, sto scrivendo la parte che le rileva anche da MS Sql Server
  • Interprete per DB SQL Compact 4
  • Ampliare le informazioni mostrate sulle tabelle caricate dal Database
  • Interprete per DB Oracle
  • Interprete per DB Orient

DOWNLOAD

Luna è opensource e liberamente scaricabile e utilizzabile:

Codice Sorgente - http://www.diegolunadei.it/luna/lunasource.rar

Package Eseguibile - http://www.diegolunadei.it/luna/luna.rar

CONCLUSIONI e RIFERIMENTI

Mi sento di dire solo una cosa, non ho inventato nulla. Luna è semplicemente un tool gratuito che può aiutare lo sviluppatore nella stesura di codice ripetitivo per evitare errori e consentire una standardizzazione e pulizia del codice.
Scrivere codice manutenibile e facile da gestire anche da altri non è una cosa semplice, specie in grandi gruppi di lavoro. Inoltre interfacciarsi con il database per le operazioni standard diventa un operazione banale.

Per ogni riferimento, domanda, suggerimento o insulto potete trovarmi qui:

http://www.diegolunadei.it e qui d.lunadei@gmail.com

Un ultima cosa, Luna è un progetto in continua evoluzione quindi prendete la documentazione di questo tutorial come indicativa del funzionamento generale perchè mantenerla aggiornata è un lavorone. Per vedere cosa effettivamente crea vi consiglio di scaricare il package ed eseguire una generazione.

Luna: Vb.Net Data Layer Code Generator 3.0.12.18

62 Comments | Sep 08, 2011
Altro rilascio per Luna, versione 3.0.12.18.

In questa versione una grande modifica permette ora di riaprire un progetto generato in precedenza. Luna serializza la struttura che ha caricato dal db e tutte le varie modifiche fatte ai nomi delle classi e permette di riaprirle ed eventualmente modificarle, senza connettersi di nuovo alla fonte dati originale.

Indubbiamente una grossa comodità. In più un link diretto al canale twitter e al sito ufficiale.

I path per il download sono sempre gli stessi.

EXE – http://www.diegolunadei.it/luna/luna.rar

SOURCE CODE – http://www.diegolunadei.it/luna/lunasource.rar

TUTORIAL con ESEMPIO – http://www.diegolunadei.it/luna

Luna: Vb.Net Data Layer Code Generator 3.0.9.19

52 Comments | Apr 22, 2011


Innanzitutto voglio RINGRAZIARE tutte le persone che mi scrivono commenti e suggerimenti per migliorare Luna!.

Purtroppo il tempo per svilupparlo e' molto meno di quello che sarebbe necessario per metterci tutto quello che serve, comunque lo sviluppo va avanti.

Ho rilasciato la versione 3.0.9.19 con un bel po di fix e miglioramenti.

Nella prossima versione cercherò di includere il supporto alle relazioni di SQL Server (per ora vengono caricate solo da DB Access), il supporto a SQL Compact 4, il metodo di salvataggio in cascata SaveCascade, e il supporto a fonti dati diverse dalle Tabelle(stored procedure ad esempio o viste).

Infine sono cambiati i path per il download:

Codice Sorgente - http://www.diegolunadei.it/luna/lunasource.rar

Package Eseguibile - http://www.diegolunadei.it/luna/luna.rar

Tutorial con esempio - http://www.diegolunadei.it/luna

Luna: Vb.Net Data Layer Code Generator 3.0.6.18

438 Comments | Apr 19, 2011




Ho pubblicato il rilascio 3.0.6.18 di Luna Data Layer Code Generator. In questa versione oltre a qualche novità di contorno la cosa più importante è che ora è supportata la Pluralization.

In pratica ora è possibile specificare per ogni tabella il nome della classe che viene generata semplicemente sostituendola tramite l’interfaccia al nome di default che viene associato.

Ora sto lavorando al caricamento delle relazioni automatico da database MS SQL SERVER, mentre per DB Access è tutto gia funzionante. Per ogni relazione 1 a 1, 1 a N vengono generati all’interno della relativa classe padre gli oggetti o le liste figlie, con i relativi caricamenti.

Nella versione 3.0.7.46 inoltre sarà inserito un metodo di salvataggio in cascata che permetta di salvare l’intera struttura con relativi id collegati ecc ecc in modo da lavorare in memoria con una struttura logica e le strutture collegate senza preoccuparsi della persistenza, il metodo WriteCascade.

Per il tutorial completo e l’esempio in questione potete andare all’indirizzo:

http://www.diegolunadei.it/luna/index.htm

Luna: Vb.Net Data Layer Code Generator 3.0.4.18

111 Comments | Apr 08, 2011
Ho appena pubblicato online una release di Luna sostanzialmente completa delle funzionalità principali.

Allego uno schema delle classi generate in un tipico esempio e uno screenshoot.

Ormai è diventato un progetto svago/laboratorio e la cosa di questa versione che mi ha più divertito è stata la creazione della funzione di ricerca parametrica. Ancora è da migliorare e manca qualcosina ma era venuto il momento di fare un nuovo rilascio perche rispetto alla precedente versione sono stati fatti grandi passi avanti.

Per il tutorial completo e l’esempio in questione potete andare all’indirizzo:

http://www.diegolunadei.it/luna/index.htm

Per scaricare la versione 3.0.4.18 di Luna invece potete andare sempre all’indirizzo:

http://www.diegolunadei.it/luna



Luna: Vb.net code generator secondo rilascio e mini tutorial

242 Comments | Mar 29, 2011


Ho messo online il secondo rilascio di Luna, il generatore di codice che ho ideato io. Per scaricarlo il link è sempre lo stesso:

http://www.diegolunadei.it/luna

Per accedere al tutorial invece si deve andare qui:

http://www.diegolunadei.it/luna/index.htm

LUNA 3.0.1.19356

24 Comments | Mar 19, 2011

Era tanto che non postavo qualcosa sul blog... oggi torno a farlo perche ho pubblicato la prima versione di LUNA.

LUNA è uin generatore di codice che ho scritto io, una recensione piu generica la trovate sul mio sito (http://www.diegolunadei.it).

Di base è la prima versione pubblica... mancano ancora tante cose, e come spesso succede e' partito tutto piu per gioco che per usarlo veramente, anche se ora sinceramente lo uso davvero spesso.

Mancano ancora la generazione automatica della classi figlie in base alle foreign key ma diciamo che gia cosi mi da una grossa mano.

Ovviamente tutto e' migliorabile e va visto per quello che e'.. ci sono prodotti commerciali molto piu complessi con logiche anche completamente diverse (vedi ad esempio NHibernate che ha un approccio completamente differente).. Ma mi faceva piacere condividerlo con voi.

Trovate la descrizione dettagliata come detto sulla home del mio sito http://www.diegolunadei.it e potete scaricare l'exe da http://www.diegolunadei.it/luna

SmartBackUp

18 Comments | Sep 27, 2007
Era un po di tempo che non pubblicavo uno dei miei programmini di contorno lavoro...

Non so voi ma una delle cose che odio di più è fare i backup, ci vuole tempo.. sono noiosi da morire e hai sempre paura che poi qualcosa ti manca.

Ma purtroppo questo problema non l'ho risolto

Invece quello che credo sia consuetudine quando si lavora è avere una copia dei sorgenti su un hd portatile usb che ci portiamo sempre dietro (almeno per me è cosi).

Tenere allineate le due cose diventa un po noioso e cosi ecco che in una mezzagiornata tranquilla nasce SmartBackUp.

Il programma è semplicissimo, non serve nemmeno spiegarne il funzionamento.. comunque:

Gli date un percorso di origine (presumibilmente i file sul vostro disco rigido) e un percorso di destinazione (le copie sul vostro hd portatile) e lui sincronizza il secondo ambiente in base al primo. Copia solo i file cambiati, crea le directory nuove ecc ecc..

Ovviamente NON cancella mai nulla in nessun caso. Per accorgersi dei cambiamenti sui file si basa sulla data di ultima modifica.

Io lo uso da un po e devo dire che e' comodo perche invece di preoccuparmi di cosa e dove ho cambiato la sera attacco il mio hd  portatile sul pc e avvio la procedura di backup, e ci pensa lui a copiare solo quello che effettivamente ho modificato.

Es.

sul mio disco rigido c'e' la cartella Lavoro che ho anche sul mio disco portatile .. percio basta che la prima volta seleziono origine e destinazione e in pochi minuti ho aggiornato l'hd portatile

Da quando lo uso non ho mai notato malfunzionamenti ma se vi capitasse utilizzandolo di trovarne siete molto gentili se me lo segnalate. Ovviamente sono certo che ci sono mille e piu prodotti per fare questa operazione ma sono sempre convinto che nelle tante opzioni e nella maggiore flessibilita a volte si perde di rapidità d'uso e qui alla fine c'e' solo un pulsante.

Se volete lo potete scaricare da qui

www.diegolunadei.it/download/SmartBackUp.zip

Password manager 1.2

26 Comments | Sep 19, 2005
Dopo le recenti discussioni a riguardo e utilizzando gli utili consigli di Marcello, Igor e tutti gli altri ecco una nuova versione di questo programmino.

Le modifiche sono le seguenti:

- Non viene più salvata nessuna password master
- La password master (ora chiamata di decodifica) si inserisce nella form principale e decodifica on-fly le altre contenute nell'archivio.
- Per ogni nuova password inserita si sceglie con che chiave di decodica fare il salvataggio, niente vieta di usare chiavi di decodifica diverse a patto che ve le ricordiate :)
- Cliccando su una voce la password non viene più copiata automaticamente nella clipboard
- Cliccando con il tasto destro su una voce appare un menù contestuale che consente di copiare nella clipboard la login o la password

Chiaramente se usate chiavi di decodifica diverse alcune password nella lista appariranno sbagliate e altre giuste :)

Il link per scaricare il programma è sempre lo stesso:

clicca qui

P.S. Il programma alla partenza cancella il vecchio file bin ora non più necessario