IT Experience

ASP.NET Razor creare un banner per NopCommerce

2011-08-11T16:47:00.001+02:00

Ho creato un semplice script in razor per umbraco, ma che può essere utilizzato anche in ASP.NET MVC che permette di ottenere un semplice banner con 4 prodotti tra quelli presenti in vetrina in un sito di e-commerce fatto con NopCommerce. Per funzionare però è necessario potersi connettere direttamente al database di nop.

@{

    var connStr = System.Configuration.ConfigurationManager.AppSettings["commerceDbDSN"];

    var t_prodotti = new System.Data.DataTable();

    var commerceAddress = "http://www.myecommerce.com";

    string sql =

        "SELECT TOP 4 " +

            "prod.ProductId, prod.ShortDescription, prod.SEName, pict.PictureID " +

        "FROM " +

            "Nop_Product as prod JOIN " +

            "Nop_ProductPicture as pict ON prod.ProductId = pict.ProductId " +

        "WHERE ShowOnHomePage = 1 and Deleted = 0 " +

        "ORDER BY NEWID()";

    (new System.Data.SqlClient.SqlDataAdapter(sql, connStr)).Fill(t_prodotti);

<div class="home-page-product-grid">

    <table>

        <tr>

            @foreach (System.Data.DataRow product in t_prodotti.Rows)

                string descrizione = string.Format("{0}", product["ShortDescription"]).Replace('"', '\'');

                string pagina = string.Format("{0}-{1}.aspx", product["ProductId"], product["SEName"]);

                string img = string.Format("{0:0000000}_125.jpeg", product["PictureId"]);

                <td class="item-box">

                    <div class="product-item">

                        <div class="picture">

                            <a title="@descrizione" href="@commerceAddress/prodotti/@pagina" target="_blank">

                                <img title="@descrizione" src="@commerceAddress/images/thumbs/@img" alt="@descrizione" style="border-width:0px;" />

                            </a>

                        </div>

                        <h2 class="product-title">

                            <a href="@commerceAddress/prodotti/@pagina" target="_blank">@descrizione</a>

                        </h2>

                    </div>

                </td>

        </tr>

    </table>

</div>

T-SQL selezionare record casuali

2011-08-11T16:30:00.001+02:00

Mi sono trovato recentemente nella necessita di creare un banner pubblicitario scegliendo casualmente alcuni prodotti tra quelli presenti in un e-commerce. Non essendoci un metodo nativo per il compito ho dovuto improvvisare :

SELECT TOP 4

    prod.ProductId, prod.ShortDescription, prod.SEName

FROM

    Nop_Product as prod

WHERE ShowOnHomePage = 1 and Deleted = 0

ORDER BY NEWID()

Gestire finestre ajax

2011-08-10T23:46:00.001+02:00

Capita ormai sempre più spesso di avere a che fare con ajax, è utile perciò creare qualche funzione helper, in grado di facilitare i compiti più comuni. Sfruttando la potenza di jquery e di jquery.ui ho scritto due semplici funzioni in grado di aprire e chiudere un dialog javascript caricando il contenuto tramite una chiamata :

var sm = new function () {

    this.ajaxDialog = function (src, data, title) {

        var dialog = $('<div class="smdialog"></div>');

        $('body').append(dialog);

        $(dialog).append("<img src='/Content/images/loading.gif' alt='loading' />");

        $(dialog).dialog({

            autoOpen: true,

            modal: true,

            title: 'Caricamento...',

            width: 'auto',

            position: 'center'

});

        $(dialog).load(

            src,

            data,

            function () {

                $(dialog).dialog({

                    autoOpen: true,

                    modal: true,

                    title: title,

                    width: 'auto',

                    position: 'center'

});

                $(dialog).dialog('open');

);

        return dialog;

    this.closeDialog = function (element) {

        var dialog = null;

        if ($(element).hasClass("smdialog"))

            dialog = $(element);

        else

            dialog = $(element).parent('.smdialog');

        dialog.dialog('close');

        dialog.remove();

adesso possiamo aprire una finestra di dialogo attraverso un link

<a href="javascript:void(0)" onclick="sm.ajaxDialog('/Product/Edit/@product.ProductId', null, '@product.Name')">Modifica</a>

per chiudere la finestra dobbiamo fare riferimento ad un qualsiasi elemento presente nella finestra o alla finestra stessa se abbiamo conservato il riferimento. Solitamente capita di voler chiudere la finestra dopo aver inviato i dati di un form, quindi :

$("#edit_form").ajaxForm({

    success: function () { sm.closeDialog('#edit_form'); }

});

Creare un helper in JavaScript

2011-08-10T18:58:00.001+02:00

Spesso si ha la necessità di raggruppare delle funzioni in namespace per evitare che si verifichino conflitti. Ma in javascript non esistono namespace e neanche classi con metodi statici. Per ottenere quello che vogliamo è possibile utilizzare la seguente sintassi :

   1:  var helper = new function () {

2:

   3:      this.saluta = function(nome) {

   4:          alert("Ciao " + nome);

   5:      }

6:

   7:  }

l’utilizzo è molto semplice, basta richiamare helper.saluta(‘Giuseppe’);. Ad esempio per eseguire la funzione saluta al caricamento della pagina :

   1:  $(function(){

   2:      helper.saluta('Giuseppe');

   3:  })

Utilizzare questo sistema permette di riutilizzare facilmente il codice in progetti diversi, senza preoccuparsi troppo di non creare conflitti con i nomi.

Entity Framework Code-First

2011-01-23T12:57:00.001+01:00

Finalmente una buona notizia dal fronte dell’accesso ai dati tramite .net framework. Tutti gli appassionati di linguaggi come python sanno quanto sia comodo poter definire il mapping ai dati tramite la definizione di classi (in .net si direbbe “Plain Old CLR Object” cioè POCO). Questa funzionalità ci permette di scrivere semplici classi che espongono proprietà che automaticamente verranno mappate del db. La cosa bella di tutto ciò è che dopo anni di file di configurazione in xaml e di editor che configurano le più svariale cose, si è deciso di utilizzare la filosofia “convention over configuration”, cioè basta strutturare le classi in un certo modo per definire automaticamente la struttura delle tabelle, ad esempio la chiave primaria sarà la proprietà che ha lo stesso nome della classe seguita da “ID”:

public class Cliente 
{
    public int ClienteID { get; set; }
}

ciò significa che le classi che andremo a scrivere o a leggere saranno tutte scritte con la stessa convenzione e di conseguenza, saranno più comprensibili. Questo è il link con l'elenco delle convenzioni da stampare e appendere in ufficio .

Vi consiglio di leggere il post del grande Scott Guthrie, con gli esempi pratici.

Ora manca solo di sfruttare l’indentazione per definire i blocchi come fa python…

Test di connessione a Postgresql

2011-01-18T22:41:00.001+01:00

Testata la connettività tramite ssl ad un server postgresql su ubuntu server 10.10 virtualizzato con virtualbox nel sistema operativo host windows 7 professional connessi tra loro tramite rete virtuale con bridge alla lan fisica. Test eseguito da un applicativo .net, in debug con visual studio 2010, che sfrutta la mia libreria DataHelper che si connette tramite il driver ado.net Npgsql... FUNZIONA!

Un consiglio per chi volesse provarci, non provate la connessione diretta solo host, non funziona!

Adesso non mi resta che testare il tutto su internet... speriamo bene.

[Compact .Net] Memorizzare impostazioni su file

2009-09-14T14:11:00.001+02:00

La stragrande maggioranza degli applicativi che scriviamo, necessita di memorizzare valori permanentemente. Il modo più semplice per ottenere questo risultato è di salvare i dati all'interno di un file. I file, pero, possono essere utilizzati in decine di modi differenti e il framework, nella sua enorme flessibilità, non fornisce un modo semplice per farlo. E utile in questi casi scrivere delle piccole classi che generamente chiamo (e non sono l'unico) helper, cioè delle classi "aiutanti" che fanno il lavoro sporco per noi. Queste classi sono in grado di fare solo un minimo di operazioni con una flessibilità spesso direttamente proporzionale al numero di metodi e proprietà pubbliche.
Inoltre, In piena mentalità OOP, è buona cosa progettare tale classe in modo che si possa ereditare da essa modificandone i valori costanti, sfruttando così al massimo le migliori qualità di questa tecnica, cioè la riutilizzabilità e la longevità del codice.
Posto quì una piccola classe "helper" in grado di adempiere al compito con molta semplicità :

using System;
using System.Data;
using System.IO;

class Settings
    {
        DataTable t_settings;

        protected virtual string filename
        { get { return "setts.xml"; } }
        protected virtual string filepath
        { get { return Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\my_app\"; } }

        private string get_absolute_filename()
        {
            return filepath + filename;
        }

        public string GetValue(string key)
        {
            string result = "";
            DataRow[] results = get_db().Select("property_name = '" + key + "'");
            if (results.Length > 0)
                result = results[0].Field("property_value");
            return result;
        }
        public void SetValue(string key, string value)
        {
            DataRow[] results = get_db().Select("property_name = '" + key + "'");
            if (results.Length > 0)
                results[0].SetField("property_value", value);
            else
            {
                DataRow r = get_db().NewRow();
                r.SetField("property_name", key);
                r.SetField("property_value", value);
                get_db().Rows.Add(r);
            }

            save();
        }
        public void Reload()
        { t_settings = null; }

        private void load()
        {
            t_settings = new DataTable();

            if (System.IO.File.Exists(get_absolute_filename()))
                t_settings.ReadXml(get_absolute_filename());
            else
                create_table();
        }
        private void create_table()
        {
            t_settings.TableName = "settings";
            t_settings.Columns.Add("property_name").Unique = true;
            t_settings.Columns.Add("property_value");
        }
        private DataTable get_db()
        {
            if (t_settings == null)
                load();
            return t_settings;
        }

        private void save()
        {
            DirectoryInfo di = new DirectoryInfo(filepath);
            if (!di.Exists) di.Create();

            get_db().WriteXml(get_absolute_filename(), XmlWriteMode.WriteSchema);
        }
}

L'utilizzo di questa classe è molto semplice : si istanzia e si richiamano i metodi GetValue e SetValue. La possibilità di salvare e ottentere solo stringhe ci costringe a serializzare i valori prima di passarli alla classe, riducendo così la possibilità di errori di conversione. Naturalmente poi, la classe può essere ereditata modificando il nome del file e/o il percorso di salvataggio, e aggiungendo altre properietà o metodi :

using System;

class GeneralSettings : Settings
    {
        protected override string filename
        { get { return "general.xml"; } }

        public string ServerAddress
        {
            get { return GetValue("server_address"); }
            set { SetValue("server_address", value); }
        }
    }

Quì, oltre che a cambiare il nome del file, ho creato una proprietà che salva e ottiene il valore di server_address riducendo così ancor di più la possibilità di errore, dovuto ad un errore di battitura.

[Compact .Net] Effettuare operazioni in background

2009-09-14T14:10:00.000+02:00

Molto spesso le nostre applicazioni si trovano in situazioni di inoperatività dovute magari all'attesa di scelte dell'utente. Questi momenti ci offrono la possibilità di prepararci all'esecuzione di task futuri che magari sappiamo già impiegheranno molto tempo ad eseguirsi.
Il problemi maggiori li abbiamo con lo scarso supporto al threading offerto dal compact framework, che per esempio non ci permette di conoscere lo stato di esecuzione del thread. A tal proposito ho scritto una piccola classe in grado di lanciare l'esecuzione di un metodo in un thread separato, di sapere se l'operazione si è conclusa, e se dovesse essere necessario, attenderne la conclusione. Questa classe è in grado di eseguire metodi che non prevedono parametri e non ritornano valori.

using System;
using System.Collections;
using System.Threading;

class LoaderClass
{
Hashtable thread_table = new Hashtable();
Hashtable action_table = new Hashtable();

public int Run(Action action)
{
Thread t = new Thread(new ThreadStart(methodRunner));
thread_table.Add(t.ManagedThreadId, t);
action_table.Add(t.ManagedThreadId, action);
t.Start();
return t.ManagedThreadId;
}

public bool WorkEnded(int thread_id)
{
return thread_table.ContainsKey(thread_id);
}

public void WaitForEnd(int thread_id)
{
if (thread_table.ContainsKey(thread_id))
{
Thread t;
try
{ t = (Thread)thread_table[thread_id]; }
catch
{ return; }

t.Join();
}
}

private void methodRunner()
{
int thread_id = Thread.CurrentThread.ManagedThreadId;

Action action = (Action)action_table[thread_id];
action();

action_table.Remove(thread_id);
thread_table.Remove(thread_id);
}
}

Con questa classe possiamo per esempio lanciare in anticipo il caricamento dei dati dal database senza disturbare i funzionamento dell'applicativo, e nel momento in cui avremo bisogno dei dati, attendere la conclusione del'operazione (se già non è terminata).

es.

//Nel form_load
LoaderClass loader = new LoaderClass();
thread_id = loader.Run(load_data);

//Quando avremo bisogno dei dati
loader.WaitForEnd(thread_id);
//utilizza i dati caricati

Linguaggi lato server: Php vs Asp.net

2008-12-22T02:14:00.001+01:00

Questo è sicuramente uno degli argomenti più discussi e controversi del web, che interessa molto ai neofiti, ma che non manca di coinvolgere i fan di uno o dell'altro linguaggio. Per quanto mi riguarda non credo che tifare per l'uno o per l'altro possa rappresentare un atteggiamento saggio, credo piuttosto che ognuno dei due linguaggi abbia i suoi punti di eccellenza e che quindi si possano definire dei contesti ideali.

Vorrei provare a tracciare delle distinzioni seguendo differenti punti di vista, il primo fra tutti è quello che riguarda un gran numero di persone che si affacciano al mondo web, cioè "quelli che fanno siti internet" (niente a che fare con web developer o designer, o comunque esperti di informatica). In questo caso credo che php possa ritenersi la scelta ideale, se non altro per la stragrande quantità di snippet di codice, classi o persino interi siti disponibili su internet. Un elemento importante però da definire è l'ambiente di sviluppo, che con php può rappresentare una vera e propria sfida. Essendo, infatti, opensource, php non ha un IDE ufficiale, ma ne esistono tanti (forse troppi) e sta ad ognuno poi trovare la sua configurazione più comoda, la mia è rappresentata da un editor (Komodo Edit) più un ambiente per il debug (easyphp). Ma la forza di php è nella facilità con cui chiunque può arricchire i propri siti con funzionalità più o meno importanti, basta creare una pagina html con un qualsiasi editor visuale e non appena contenti del risultato, inserirci del codice php come ad esempio: <?php echo date("l w F Y"); ?> che visulizza la data di oggi. Con asp.net tutto ciò risulterebbe un po' più complicato, soprattutto se consideriamo che i linguaggi con cui andremo a scrivere il nostro codice, sono linguaggi fortemente oop che richiedono quindi un minimo di esperienza di programmazione. C'è da dire però che asp.net ha dalla sua un ide tra i migliori in assoluto della quale esiste anche una versione gratuita (vwd). Riassumerei quindi questa prima parte con una semplice definizione : Php è più semplice da usare e da imparare rispetto ad Asp.net.

Il secondo punto di vista riguarda i team di sviluppo, che necessitano quindi di metodologie di sviluppo cooperativo. Php ha incluso solo nella sua ultima versione (5) la possibilità di programmare ad oggetti, questo credo rappresenti già un grosso deficit, visto che il 90% del codice su internet non è oop, e che soprattutto il linguaggio è stato concepito con una tipizzazione debole, vi posso assicurare, per chi non lo avesse già provato, che è molto frustrante ritrovarsi in una variabile in oggetto diverso da quello che ci espetteremmo, oppure, ancora peggio, il valore null causato da un errore di battitura mentre richiamavamo la variabile. In questo contesto chi veramente può dare il massimo di se è asp.net, che permette di progettare applicazioni enormi sfruttando le astrazioni possibili con i linguaggi orientati ad oggetti, che ci permettono di suddividere il lavoro in maniera ottimale. In oltre, come già detto prima, l'IDE fornisce grandi vantaggi, come ad esempio la definizione facilitata di riferimenti a web service. Se dovessimo riassumere ancor di più il concetto direi che Asp.net permette di sviluppare grandi applicazioni con più facilità rispetto a Php.

Dal punto di vista del designer, è importante che possa lavorare senza intralciare il lavoro degli sviluppatori o ancora meglio a prescindere se l'applicazione sia stata già sviluppata o meno. In questo caso Php non offre nessun argomentazione speciale se non l'utilizzo dei css propri dell'html, semplicemente, quindi, con Php si utilizzano le stesse tecniche (o quasi) che si utilizzano con le pagine html. Asp.net offre la possibilità di definire dei temi, che non avrebbero niente di particolarmente eccezionale, se non fosse per gli skin, che permettono di specificare le proprietà dei controlli server, e l'estrema facilità con cui una pagina può cambiar aspetto anche durante l'esecuzione, tutto ciò naturalmente includendo i fogli di stile. Morale : Qualche sforzo in più è stato fatto con asp.net, ma entrambi sono sostanzialmente simili.

Purtroppo non è possibile specificare quì quali sono tutte le caratteristiche di entrambi i linguaggi, sicuramente per chi è agli inizi, consiglierei il php data la sua semplicità e la quantità di materiale on-line, ma non potete considerarvi esperti se non li imparate entrambi. Quindi diffidate da chi afferma di sapere quale dei due sia il migliore, spesso certa gente è spinta più da ragioni politiche che altro, e se poi vi parla di prestazioni, le differenze sono ridicole, se proprio avete problemi di lentezza del sito provate a cambiare hosting (o a migliorare il codice :P ).

EasyWay: Smettere di fumare è facile se sai come farlo!

2008-11-15T02:57:00.001+01:00

Finalmente un post diverso dai soliti...

Questa volta vorrei scrivere del metodo easyway e di come sia realmente efficace. Chi mi conosce sa bene quanto io sia scettico, e potrebbe quindi testimoniarvi che se ora mi trovo quì a scrivere questo post, è perché questo metodo deve essere realmente valido. In effetti con me ha funzionato, ma soprattutto credo che possa funzionare con chiunque, e credo proprio che la pensi allo stesso modo la fondazione che lo porta avanti, visto che vi promette di rimborsare i costi (relativamente bassi), se non vi convince a smettere di fumare.

Il metodo è stato inventato da un certo Allen Carr che sosteneva di essere arrivato a fumare 100 sigarette al giorno per poi smettere di colpo, senza più aver voglia di fumare. Per quanto mi riguarda non faccio fatica a credere alle sue parole, dato che ho potuto effettivamente provarlo sulla mia pelle. In particolare ho provato a leggere il libro solo per curiosità, sempre con un occhio scettico, fino a che non ho compreso dove volesse arrivare. Quante volte mi ero detto di voler smettere di fumare, ma puntualmente non ci riuscivo, e ciò mi spaventava. Non riuscivo a capire come mai fosse così difficile, come mai ci ricadevo puntualmente, finché non mi è capitato di leggere il libro.

Il risultato di tutto ciò è che finalmente mi sento un non fumatore, e mi trovo a provar pena per chi ancora è schiavo del fumo. E' logico quindi che il minimo che possa fare è di consigliarvi di leggere il libro o di regalarlo a chi ne ha bisogno. Quì costa solo 8.50€... quindi provateci, anche solo per curiosità!

ADO.NET & MS Access: Ottenere l'id del nuovo record

2008-11-05T15:56:00.001+01:00

Alle volte può capitare di trovarsi in situazioni in cui non possiamo fare a meno di utilizzare un database access (magari perchè già esiste). Se vi trovate in questa situazione avrete già notato che se utilizzate access con ado.net, l'id della riga che avete appena creato non viene restituito. Per ovviare a questo fastidioso problema dovete intercettare l'evento onRowUpdate generato dal dataadapter che sta eseguendo l'update. In pratica un buon esempio può essere :

Public Shared Sub SaveTable(ByVal t As DataTable)

Dim da As New OleDbDataAdapter("SELECT * FROM " & t.TableName, getConnection)
Dim cb As New OleDbCommandBuilder(da)

cb.QuotePrefix = "["
cb.QuoteSuffix = "]"

    da.InsertCommand = cb.GetInsertCommand
    da.UpdateCommand = cb.GetUpdateCommand
    da.DeleteCommand = cb.GetDeleteCommand

AddHandler da.RowUpdated, New OleDbRowUpdatedEventHandler(AddressOf OnRowUpdated)

da.Update(t)

End Sub

Private Shared Sub OnRowUpdated(ByVal sender As Object, ByVal e As OleDbRowUpdatedEventArgs)

If e.StatementType = StatementType.Insert Then

Dim pk As String = e.Row.Table.PrimaryKey(0).ColumnName
Dim cmdNewID As New OleDbCommand("SELECT @@IDENTITY", e.Command.Connection)

e.Row(pk) = CInt(cmdNewID.ExecuteScalar)
e.Status = UpdateStatus.SkipCurrentRow

End If

End Sub

Ricordatevi di impostare il nome della tabella nel datatable al momento della creazione e soprattutto di impostare la chiave primaria.

J2ME & NetBeans 6.1: Visual MIDlet

2008-11-03T00:58:00.001+01:00

Mi sono trovato nella necessità di scrivere un'applicazione che potesse girare sulla maggioranza dei telefoni cellulari. Quale miglior occasione quindi di approfondire la conoscenza di java, certo Java Micro Edition non è esattamente il massimo dei framework, le funzionalità sono molto limitate, ma è pur sempre java.

Il primo passo è stato di trovare un IDE con funzioni avanzate per la scrittura del codice. Googlando in giro ho trovato i soliti fun dell'uno o dell'altro ide, ma infine da quello che sono riuscito a capire, i migliori (almeno di quelli open source) dovrebbero essere 2: Eclipse e NetBeans. Per quanto riguarda eclipse, in passato ho già avuto una brutta esperienza, oltre ad essere pesantuccio non è esattamente intuitivo, di conseguenza la scelta è caduta su NetBeans (che dal nome sembrerebbe esse più un editor html).

NetBeans si è rivelato un buon IDE, molto completo, con esempi, gestione del codice, refactoring... ovviamente però siamo lontani da visual studio, in particolare l'ntellisense di NetBeans non compare mai quando ne hai bisogno, e per un linguaggio case sensitive come java è un fastidio non da poco, un altra pecca è il caricamento alle volte estenuante. Molto potente, invece, è la gestione delle gui per MIDP, infatti tramite la classe 'Visual MIDlet', non solo abbiamo la possibilità di creare le form della nostra applicazione, ma anche di gestirne la navigazione in un modo a dir poco efficace.

NetBeans ci dà la possibilità di editare le 'visual MIDlet' in tre modalità, ognuna ad un livello differente.

Al livello più alto troviamo l'editor di flusso (flow) in cui possiamo creare le form, aggiungerci dei controlli, creare comandi e specificarne la funzione.

Proviamo a creare una piccola MIDlet di esempio (il solito hello wold). Alla creazione della classe troviamo già una form, selezionandola ne possiamo modificare le proprietà, in particolare modifichiamo il titolo e il nome dell'istanza rispettivamente in 'Finestra principale' e 'mainForm'. Nel grafico è presente un'altra entità 'mobile device', è lì che inizia e finisce la nostra applicazione, lasciamo quindi che alla partenza (started) la midlet visualizzi la nostra form. A questo punto non ci resta che disegnare l'aspetto di mainForm e per far ciò dobbiamo passare alla modalità screen.

Nella modalità screen abbiamo la possibilità di modificare una alla volta le form della nostra midlet. Tramite la drop-down-list a destra scegliamo la form da modificare (nel nostro caso ce ne sarà solo una), quì notiamo che NetBeans ha già inserito uno stringItem con il testo 'Hello, World!', ma quello che vogliamo noi è che la midlet stampi un saluto personalizzato all'utente. Eliminiamo quindi lo stringItem e inseriamo un textField, modificando la proprietà label in 'Come ti chiami?'. A questo punto dobbiamo decidere dove visualizzare il saluto, potremmo utilizzare un altro form, lo stesso textField oppure uno stringItem, ma decidiamo di utilizzare uno stringItem inserendolo nel form. Cancelliamo il testo della label e impostiamo un font facendo click sul pulsante con i tre puntini, scegliamo di visualizzare il testo in corsivo e di lasciare le altre impostazioni di default.

Ora passiamo alla modalità 'Source' per fare in modo che quando l'utente scriverà il suo nome riceverà un saluto del tipo 'Ciao Tizio'. Per catturare i 'cambiamenti' dei controlli doppiamo implementare l'interfaccia ItemStateListener e di conseguenza il metodo public void itemStateChanged(Item item). D'ora in avanti, ogni volta che un controllo subirà delle modifiche, verrà chiamato il metodo itemStateChanged, possiamo allora implementare il comportamento del metodo, specificando che se il controllo modificato è textField allora stringItem dovrà visualizzare 'Ciao ' + il testo digitato:

public void itemStateChanged(Item item){
    if (item==this.getTextField()){
        this.getStringItem().setText("Ciao " + this.getTextField().getString());
    }
}

dobbiamo in oltre registrare il listener per il form e lo facciamo alla creazione dell'istanza. Cerchiamo il metodo getMainForm, che viene creato automaticamente, e modifichiamo il codice facendo in modo che quando una nuova istanza della form viene creata, venga impostato anche il listener :

public Form getMainForm() {
    if (mainForm == null) {
        // write pre-init user code here
        mainForm = new Form("Finestra Principale", new Item[] { getTextField(), getStringItem() });
        mainForm.addCommand(getExitCommand());
        mainForm.setCommandListener(this);
        mainForm.setItemStateListener(this);
        // write post-init user code here
    }
    return mainForm;
}

Adesso eseguiamo il progetto con F6 e verifichiamo che l'applicazione funzioni... funziona!

Ora manca solo la distribuzione, basta compilare il tutto con F11 che nella sottocartella 'dist' del nostro progetto vengano creati i files necessari sia 'jad' che 'jar'. In oltre ho notato che è disponibile anche una funzione che permette di uploadare i file direttamente sul cellulare, ma non l'ho potuta provate perchè il mio cellulare non era tra i modelli supportati...

Concludendo, devo dire che NetBeans è tutto sommato un buon IDE, se consideriamo che per creare questa applicazione di esempio abbiamo scritto in totale 4 righe di codice, tutto il resto è stato gestito da NetBeans. In oltre devo dire anche che oltre ai progetti J2ME supporta una varietà di altri progetti (Ruby, SOA, UML, JSP e altri), che possiede un po' tutte le principali funzionalità dei migliori IDE, che mi è parso stabile anche su win vista, ma che sembra occupare molte risorse di sistema e sopratutto lento all'avvio. Se dovessi dare un voto darei un bel 7 e mezzo.

Asp.Net & Javascript (Tips & Tricks): Debug degli script inseriti con RegisterClientScriptBlock

2008-10-10T11:07:00.001+02:00

Uno dei motivi che rende javascript un linguaggio odioso (almeno per me) e la tipizzazione debole delle variabili. Questa sua caratterisca rende molto difficile il debug, spesso le funzioni ritornano comunque un valore. Per non parlare poi se si stanno utilizzando webservice per memorizzare informazioni nel db, le varibili null vengono tranquillamente covertite in string (nella stringa 'undefined' precisamente) con la conseguenza di ritrovarci il database pieno di record errati.

Se lo script java viene scritto all'interno del markup html della pagina, possiamo inserire un breakpoint nella funzione da controllare, fruttando l'integrazione con Internet Explorer di Visual Studio, che ferma l'esecuzione del codice. Ma se lo script lo generiamo dinamicamente tramite codice gestito? Se lo script non genera errori gravi, quali ad esempio accesso ad una proprietà di una variabile quando questa è null oppure errori di sintassi, l'unico modo per capire se la funzione è corretta è di ricorrere a piccoli trucchi.

Se vogliamo essere certi del valore di una variabile in un determinato momento, possiamo utilizzare una div, chiamiamola 'debugDiv', e nella proprietà innerHtml scriverci il valore ricordandoci di specificare un'etichetta che ci permette di identificare il valore stampato.

Una tecnica simile può essere applicata anche ad applicazioni già pubblicate, la differenza però sta nel fatto che invece di stampare a video i risultati, utilizzeremo un piccolo webservice, che ci possiamo portare dietro da applicazione in applicazione, che registrerà le informazioni che vogliamo in un file xml o direttamente nel db.

Ma se nonostante tutte le info che riceviamo, non riusciamo ad capire dov'è il problema e quindi abbiamo bisogno di eseguire lo script riga dopo riga, il metodo più banale di tutti sta nel generare volutamente un'eccezzione, basta inserire la riga 'null.generaeccezione;' nello script, che vs interromperà l'esecuzione permettendovi di eseguire il debug step by step con la comodità di poter utilizzare la finestra immediata.

Javascript rappresenta un valore aggiunto per Asp.Net, ma non è l'unico modo di gestire le applicazioni sul client. Silverlight (o WPF), una delle innovazioni introdotte da Microsoft ormai da qualche anno, permette di fare cose eccezzionali con uno sforzo decisamente minore. Ma la strada per la sua totale compatibilità coi browser è ancora lunga, quindi per progetti grossi e che soprattutto interessano un'ampia varietà di utenti, non ci resta che ~~piangere~~ continuare a utilizzare Javascript.

ASP.NET & Javascript: Aprire un'popup e ottenere il valore selezionato

2008-09-13T13:03:00.001+02:00

Aprire un popup è un'operazione che deve essere effettuata lato client. E' necessario quindi integrare codice javascript alla nostra pagina asp.net.

<script language="javascript" type="text/javascript">

function selezionaCategoria() {

window.open('selcat.aspx', 'SelezionaCategoria', '', '');

}

</script>

possiamo utilizzare la funzione selezionaCategoria() per aprire la pagina selcat.aspx in una finestra popup :

<asp:HyperLink ID="selcatHyperLink" runat="server" NavigateUrl="javascript:selezionaCategoria()">Seleziona</asp:HyperLink>

Con queste istruzioni abbiamo creato una pagina che apre un popup in cui l'utente dovrebbe selezionare la categoria di interesse. Ma per completare l'operazione abbiamo bisogno che la finestra popup restituisca un valore, nel nostro caso in codice della categoria selezionata.

L'oggetto javascript window.opener è quello di cui abbiamo bisogno affinchè la finestra chiamata abbia accesso alla finestra chiamante. Nella pagina selcat.aspx dobbiamo quindi specificare di richiamare una funzione javascript presente nella finestra chimante:

window.opener.setCategoria('AA'); window.close();

setCategoria è una funzione javascript implementata in precedenza nella finestra chiamante. Molto probabilmente il codice della categoria selezionata dovrà essere inserito in un controllo server di asp.net che potrebbe avere un id client generato dinamicamente dal server. Questo ci obbliga a inserire il codice javascript nel codice gestito all'evento page_load :

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

If Not IsPostBack Then

Dim scr As String = "<script language='javascript'> function setCategoria(cat) {document.getElementById('" & categoriaTextBox.ClientID & "').innerText = cat;} </script>"

ClientScript.RegisterClientScriptBlock(Me.GetType, "SettaCategoria", scr)

End If

End Sub

In questo modo garantiamo che l'id client di categoriaTextBox sia quello esatto.

Allo stesso modo nella pagina selcat.aspx il controllo che richiama setCategoria potrebbe essere un controllo server come ad esempio un TreeView o un button che effettua un postback. Per permettere al server di eseguire sul client codice javascript, possiamo utilizzare ClientScript.RegisterStartupScript che esegue uno script di avvio sul client, in più abbiamo la possibilità di generare o ottenere il codice categoria sul server.

Protected Sub CategorieTreeView_SelectedNodeChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles CategorieTreeView.SelectedNodeChanged

ClientScript.RegisterStartupScript(Me.GetType, "RitorvaValore", "<script language='javascript'> window.opener.setCategoria('" & CategorieTreeView.SelectedValue & "'); window.close(); </script>")

End Sub

Linq To SQL e VB.net: GroupBy()

2008-07-25T08:57:00.000+02:00

Molto spesso, nella gestione di dati, abbiamo la necessità di raggruppare i risultati ottenuti, secondo alcuni criteri particolari. In Sql questo è possibile tramite la parola chiave Group By, seguito dal nome dai criteri secondo cui vogliamo ottenere il raggruppamento, ovviamente però, per conoscere in dettaglio quali campi sono stati raggruppati, è necessario effettuare un'operazione di join con la tabella sorgente.

In Linq è tutto molto più semplice, l'istruzione GroupBy(...) ci restituisce una lista di tabelle, ogni tabella è costituita da tutti gli elementi della tabella madre che hanno in comune la clausola di raggruppamento.

es. abbiamo questa tabella:

Vogliamo raggruppare i clienti per provincia:

Dim db As New myDataContext

dim clientiPerProvincia = db.Clienti.GroupBy(Function(c) c.Provincia)

il risultato che otteniamo è che in clientiPerProvincia abbiamo 4 tabelle

ognuna delle quali può essere raggiungibile, per esempio, con un istruzione For oppure direttamente col metodo ElementAt(...).

es.

dim primaProvinciaPrimoCliente as string = clientiPerProvincia.ElementAt(0).ElementAt(0).Cliente

Il primo ElementAt individua la tabella, il secondo il cliente.

oppure

For Each p In clientiPerProvincia 'scorre ogni tabella

Console.Writeline(p.key) 'key contiene la chiave del raggruppamento

For Each c In p 'scorre ogni cliente

Console.Writeline("--" & c.Cliente)

il risultato sarà :

TA
--A
--B
--E
BR
--C
LE
--D
--F
--G
BA
--H

Linq To SQL e vb.net: visualizzare e aggiornare dati del database e ottenere l'identità

2008-07-19T09:36:00.012+02:00

Linq è stata una delle intuizioni di Microsoft che ha cambiato maggiormente il modo di sviluppare applicazioni connesse a dati.
Tramite Linq è possibile utilizzare un linquaggio simile a SQL direttamente nel codice gestito vb.net o c#.

Per iniziare abbiamo bisogno di un tramite, un'nterfaccia che ci permetta di trasformare le istruzioni linq che scriveremo, in T-SQL. Linq To SQL mette a disposizione le classi DataContext, che hanno appunto questo scopo, tramite un tool per lo sviluppo visuale è possibile importare direttamente da esplora server le tabelle che vogliamo interfacciare, e la classe in runtime genererà dinamicamente le istruzioni SQL e si connetterà al database per eseguirle.

SELECT

A parte una leggera differenza nella posizione delle parole chiave, le istruzioni linq per la lettura di dati, hanno lo stesso funzionamento di una select scritta in SQL con la differenza che abbiamo a disposizione tutti i metodi e properietà del framework (conversioni, manipolazione stringhe, metodi personalizzati ...)

Dim clientiLeccesi = From c In DB.Clienti Where c.città = "Lecce" Select c

questa query permette di ritrovare tutti i clienti di Lecce.
Oltre a parole chiave nuove, una cosa che si può notare è che a dispetto di "Option Strict On" il tipo delle variabili non viene specificato. Questo miracolo è possibile grazie all'introduzione dei tipi anonimi, ma questa è un'altra storia (probabilmente saranno oggetto di un'altro post), quello che ci interessa sapere è che "clientiLeccesi" non contiene il risultato della query, ma la query stessa. In pratica l'istruzione "From" non viene eseguita durante la dichiarazione, ma nel momento in cui si accede ai valori di clientiLeccesi. Questa è una cosa da tener sempre presente, in quanto potremmo ottenere risultati diversi da quelli che ci aspetteremmo, se per esempio subito dopo la dichiarazione della query, andassimo a modificare i dati del db.

SELECT SINGOLA RIGA

Questa estensione di Linq ci permette di ottenere un singolo elemento dalla collezione

Dim idcliente As int32 = 12
Dim cliente = clienti.Single(Function(c) c.id = idcliente)

come possiamo notare, nella versione 9 di vb, sono state introdotte le Lambda Expression, che in questo caso ci permette di specificare quale cliente vogliamo ottenere.

INSERT INTO

In ogni operazione di modifica dei dati, le istruzioni non vengono eseguite fino a che non viene richiamato il metodo SubmitChanges() del dataContext. Così per inserire un nuovo cliente abbiamo:

Dim c = New clienti

c.Nome = "Paperone"
c.Cognome = "De Paperoni"
c.città = "Paperopoli"

DBDataContext.clienti.InsertOnSubmit(c)

DBDataContext.SubmitChanges()

a questo punto se id cliente e di tipo identity, e quindi viene generato automaticamente, subito dopo la chiamata SubmitChanges(), possiamo conoscere l'id semplicemente leggendolo :

label1.text = c.id

UPDATE

Per emodificare i dati, possiamo utilizzare le stesse tecniche che utilizzeremmo se il db fosse una classe in memoria (e in effetti il dataContex lo è).

dim c = clienti.Single(Function(c) c.id = idcliente)

c.nome = c.nome.ToUpper
c.cognome = "ROSSI"

DBDataContext.SubmitChanges()

le modifiche apportate a c vengono automaticamente riflesse al database durante la chiamata SubmitChanges()

DELETE

dim c = clienti.Single(Function(c) c.id = idcliente)

DBDataContext.DeleteOnSubmit(c)

DBDataContext.SubmitChanges()

L'eliminazione di dati avviene semplicemente richiamando il metodo DeleteOnSubmit(), naturalmente seguito da SubmitChanges()

Per questo post abbiamo finito, ma tratterò di nuovo quest'argomento in seguito, per ora spero che sia sufficente a colmare almeno in minima parte la carenza di info in rete sull'utilizzo di Linq con VB.net.