Tips

[UPDATE] NHibernate complex queries

Simone Belia — Tue, 16 Oct 2007 14:37:24 GMT

Pochi giorni fa avevo scritto un post su come creare degli oggetti che incapsulassero le informazioni per filtrare dei dati in NH (e non solo).

Questo post non è altro che una piccolissima aggiunta con l'implementazione di una classe che rappresenta l'ordine dei risultati della query.

Il concetto è quello di avere una classe che contenga il campo da ordinare e la direzione di ordinamento (espressa tramite un enum).

public class OrderField
{
     private string _field = string.Empty;
     private OrderDirection _direction = OrderDirection.Asc;

     public string Field
     {
         get { return _field; }
         set { _field = value; }
     }

     public OrderDirection Direction
     {
         get { return _direction; }
         set { _direction = value; }
     }

     public OrderField(string field, OrderDirection direction)
     {
         _field = field;
         _direction = direction;
     }
}

public enum OrderDirection
{
Asc,
Desc
}

Visto che potrebbero verificarsi numerosi casi in cui un solo campo non basta ai fini dell'ordinamento, ho pensato fosse utile implementare una collezione che dasse la possibilità di recuperare in un colpo tutta la stringa di ordinamento.

public class OrderFieldList: List<OrderField>
{
      public override string ToString()
      {
          StringBuilder sb = new StringBuilder("");
          if (this.Count >= 0)
          {
              sb.Append("ORDER BY ");
              foreach (OrderField of in this)
              {
                  sb.AppendFormat("{0} {1},", of.Field, of.Direction.ToString());
              }

              sb.Remove(sb.Length-1, 1);
          }

          return sb.ToString();
      }
}

...e per finire la sua implementazione ai fini pratici è:

string hql = "select c from Customer c where c.Country = :country"

OrderFieldList ofl = new OrderFieldList();
ofl.Add(new OrderField("BirthDate", OrderDirection.Desc));
ofl.Add(new OrderField("LastName", OrderDirection.Asc));

hql += ofl.ToString();

//..........
//..........
//..........

....a presto!!!

ASP.NET AJAX File Download

Simone Belia — Fri, 12 Oct 2007 12:55:53 GMT

Molte volte è necessario permettere agli utenti di scaricare dei file dalle nostre applicazioni ASP.NET, in maniera un pò più elaborata del semplice link alla risorsa. Mettete per esempio che il file da scaricare non esista, ma viene generato durante il postback, oppure mettete che per sicurezza i file stanno all'interno di una cartella del server non raggiungibile tramite Http.

Le metodologie per venire incontro a queste problematiche sono state documentate tantissime volte, ma se voglio utilizzarle con AJAX si devono utilizzare dei trucchetti, proprio perchè, come per l'upload di file, AJAX non permette il download asincrono delle risorse....

In questo post troverete uno di questi trucchetti...e spero che vi faccia comodo come lo ha fatto a me!!! :-)

Il trucchetto consiste di crearsi un HttpHandler che si occupi di recuperare la risorsa e che la restituisca sottoforma di stream nella Response. Logicamente l'handler potendo accedere al contesto e quindi il QueryString e quant'altro potrà effettuare tutti suoi controlli di sicurezza prima di restituire il file.....non me ne vogliano...ma in poche parole non fate come loro :-)

Successivamente nelle pagine dove è presente uno scriptmanager ed uno o più updatepanel si dovrà aggiungere questo frammento di codice JavaScript:

function GetFile(parm)
{
   var iframe = document.createElement("iframe");
   iframe.src = "Downloader.ashx?id=" + parm;
   iframe.style.display = "none";
document.body.appendChild(iframe);
}

Il Javascript non fa altro che creare un tag iframe, impostare come src il nostro handler ed aggiungerlo alla pagina. In questa maniera noi possiamo tranquillamente aggiungere ad un bottone che si occupa di scaricare il file il seguente codice:

ScriptManager.RegisterClientScriptBlock(UpdatePanel1, UpdatePanel1.GetType(), "download", "GetFile('5648752168497');", true);

che "dice" allo scriptmanager della pagina di eseguire la funzione Javascript GetFile passandogli come parametro (in questo esempio un numerone di prova) un qualcosa che vi permetta di capire quale file scaricare.

Il codice di esempio lo potete scaricare da qui

3rd parties components....che uso

Simone Belia — Sun, 16 Sep 2007 13:46:06 GMT

Sviluppare applicazioni, "inventandosi ogni volta la ruota" per fare una funzionalità piuttosto che un'altra è un bagno di sangue........proprio per questo penso che il 99% delle applicazioni che vengono sviluppate fanno largo uso di components sviluppati da terze parti.

Visto che sono un grande amante del "gratuito" qua sotto vi riporto un elenco di quelli che utilizzo io più di frequente in quasi tutti i miei progetti Web.

Intelligencia UrlRewriting (http://urlrewriter.net/)
Excentrics World Controls (http://www.eworldui.net/)
CarlosAg Excel Xml Writer (http://www.carlosag.net/Tools/ExcelXmlWriter/Default.aspx)
SharpZipLib (http://www.icsharpcode.net/OpenSource/SharpZipLib/) (forse non c'era bisogno di metterlo! :-) )

....poi vabbè ce n'è qualcuno a pagamento.....ma quando "ce vò ce vò":

BarCode Generator (http://www.aspose.com/wiki/default.aspx/Aspose.BarCode/ProductOverview.html)
Pdf Generator (http://www.aspose.com/wiki/default.aspx/Aspose.Pdf/ProductOverview.html)

E voi? quali usate?

Operazioni Lunghe con ASP.NET e AJAX

Simone Belia — Thu, 13 Sep 2007 11:10:35 GMT

Diverse volte mi è capitato di dover eseguire operazioni batch abbastanza lunghe su delle Web Application che duravano anche qualche minuto.

L'utente che quindi premeva il fatidico pulsante "Start" non poteva utilizzare nessuna altra sezione dell'applicazione poichè avrebbe interroto inevitabilmente l'operazione in corso.
Dopo tante richieste da parte di questi utenti ho deciso di documentarmi meglio e, leggendo di qua e prendendo spunto di la sono riuscito a creare un paio di classi che permettono di eseguire le operazioni lunghe "dietro le quinte" permettendo agli utenti di continuare a lavorare.

Se poi consideriamo il fatto che AJAX ci sta dando una grossa mano per rendere più "vere" le Web Application allora siamo a cavallo. :-)

L'implementazione si riassume in due classi Task.cs e SampleTask.cs.

TASK.CS

public abstract class Task
{
     protected bool _running = false;
    public bool Running
    {
        get { return _running; }
    }

    protected Exception _exception = null;
    public Exception Exception
    {
        get { return _exception; }
    }

    public void StartTask()
    {
        lock (this)
        {
            if (!_running)
            {
                _running = true;
                Thread tTask = new Thread(new ThreadStart(Process));
                tTask.Start();
            }
        }
    }

    public virtual void StopTask()
    {
        this._running = false;
    }

    public virtual void Process() { }

}

Questa classe è astratta poichè fornisce l'implementazione base di tutte le eventuali operazioni che richiedo un certo tempo di esecuzione.

SAMPLETASK.CS

public class SampleTask : Task
{
    public SampleTask() { }

    private int _step = 0;
    public int Step
    {
        get { return _step; }
    }

    public override void Process()
    {
        try
        {
            for (int i = 0; i < 100; i++)
            {
                if (this.Running)
                {
                    _step = i;
                    System.Threading.Thread.Sleep(200);

                    //if (i>20)
                    //    throw new ArgumentException("Exception occurred");
                }
                else
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            _exception = e;
        }
        finally
        {
            _running = false;
        }
    }

    public override void StopTask()
    {
        base.StopTask();
    }

}

Questa classe invece rappresenta la vera operazione che deve essere eseguita.
In pratica quando quando viene richiamato StartTask il codice non fa altro che creare un nuovo Thread per eseguire il metodo Process().
Come si vede la classe SampleTask.cs espone una proprietà pubblica Step che identifica il punto dove è arrivato il lavoro, e se dovessero essere sollevate delle eccezioni non fa altro che riempire il field _exception che viene esposto tramite una proprietà dalla classe base.

Il fatto che l'operazione viene eseguita su un altro thread ecco che abbiamo risolto il primo problema....ovvero che una volta che l'utente lancia l'operazione puo continuare a lavorare su altre parti dell'applicazione.

Il secondo problema invece era quello di capire a che punto era arrivata l'operazione.
Nel progetto che troverete in allegato ci sono due pagine una Default.aspx ed una Pagina2.aspx.....la default è la pagina che realmente fa tutto mentre la pagina2 l'ho messa solo per simulare un'altra sezione utilizzata dall'utente.

Nella default.aspx ho messo questo codice

<asp:ScriptManager ID="ScriptManager1" runat="server" />
        <asp:UpdatePanel ID="upTask" runat="server">
            <ContentTemplate>
                <asp:Timer ID="Timer1" runat="server" Interval="1000" Enabled="False" OnTick="Timer1_Tick">
                </asp:Timer>
                <asp:Button ID="btnStart" runat="server" Text="Start" OnClick="btnStart_Click" />
                <asp:Button ID="btnStop" Visible="false" runat="server" Text="Stop" OnClick="btnStop_Click" /><br />
                <asp:Label ID="lblStep" runat="server"></asp:Label>
            </ContentTemplate>
        </asp:UpdatePanel>

All'interno dell'UpdatePanel sono presenti due bottoni Start e Stop una label per visualizzare i messagi di avanzamento del lavoro ed un ajax timer che ci permetterà ogni secondo di controllare lo stato del Task.

private SampleTask _task = null;
    protected void Page_Load(object sender, EventArgs e)
    {
        _task = Cache["TASK"] as SampleTask;
        if (_task != null)
        {
            if (_task.Running)
            {
                TaskRunning();
            }
            else
            {
                TaskNotRunning();
            }
        }
    }

    protected void TaskRunning()
    {
        Timer1.Enabled = true;
        btnStart.Visible = false;
        btnStop.Visible = true;
    }

    protected void TaskNotRunning()
    {
        Timer1.Enabled = false;
        btnStart.Visible = true;
        btnStop.Visible = false;
        lblStep.Text = string.Format("Task inattivo");

        if (_task.Exception != null)
        {
            lblStep.Text = _task.Exception.Message;
        }

    }

    protected void btnStart_Click(object sender, EventArgs e)
    {
        _task = new SampleTask();
        Cache["TASK"] = _task;
        _task.StartTask();
        TaskRunning();
    }

    protected void btnStop_Click(object sender, EventArgs e)
    {
        _task.StopTask();
        Cache.Remove("TASK");
        TaskNotRunning();
        lblStep.Text = string.Format("Task interrotto");
    }

    protected void Timer1_Tick(object sender, EventArgs e)
    {
        lblStep.Text = string.Format("Operazioni concluse: {0}", _task.Step);
    }

come si vede nel codebehind della pagina viene registrato in Cache la classe e viene controllata ad ogni Caricamento della pagina se la classe SampleTask è presente o meno nella cache comportandosi di conseguenza.

Il progetto di esempio lo potete scaricare da qui