ASP.NET

[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!!!

Dynamic Data Controls for ASP.NET

Simone Belia — Mon, 15 Oct 2007 10:35:27 GMT

Microsoft ha messo a disposizione da poco tempo un'estensione di ASP.NET chiamata Dynamic Data Controls.
Questa estensione non è altro che una libreria di controlli che collegandosi ad un DB ne recupera lo schema e genera a runtime tutte le pagine che sono necessarie al dataentry e la visualizzazione delle tabelle.

L'estensione potete trovarla a questo indirizzo: http://www.asp.net/downloads/futures/

Ancora una volta le scelte che fa Microsoft mi fatto restare a bocca aperta. Stanno lavorando moltissimo su LINQ e l'EF eppure tirano fuori un set di controlli che vanno completamente contro al DDD.

[Pensiero] :-)
...valà, non dirmi che anche i dipendenti Ms hanno il vicino rompi che gli dice...."dai fammi un programmino per la gestione dei miei dvd...tanto per te che ci capisci è un attimo".
Se questo fosse, allora mi scuso e ringrazio!!

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

Tutto dinamico.....ma ora c'è AJAX

Simone Belia — Mon, 01 Oct 2007 15:01:49 GMT

Chi è che non si è mai trovato difronte alla problematica di Web User Control caricati dinamicamente? (la risposta dovrebbe essere "chi non lavora con ASP.NET"....ma fate finta che non ho detto nulla) :)

In ogni caso, la problematica è sempre la stessa:

dobbiamo stare attenti a quando questi vengono creati in quanto se aggiungo uno o più eventi ai controlli caricati a runtime questi non vengono catturati se non ho lo WUC presente entro il Page_Load.

Poco male....visto la miriade di post che ci sono al riguardo e che per un verso e per un altro fanno tutti lo stesso giro.

La cosa però si complica se oltre ad utilizzare questa metodologia si vuole anche utilizzare AJAX ed un controllo File Upload aggiunto a runtime.

La tecnologia AJAX infatti non riesce a fare upload di file in modo asincontrono e proprio per questo è buona norma mettere il controllo FileUpload all'esterno di un UpdatePanel, così da avere un postback completo.
Se però il controllo deve essere per forza dentro un UpdatePanel si può traquillamente inserire un Trigger nel pannello al fine di permettere il Postback completo quando si usa il FileUpload.

Nel mio caso avevo dei pulsanti che inserivano dei WUC a runtime richiamando un metodo ed impostando il ViewState con le informazioni essenziali per ricreare i controlli al successivo postback. Nel Page_Load controllavo il ViewState e se questo non era vuoto ricreavo i WUC (così da permettere agli stessi di intercettare l'evento) e tutto andava che era una meraviglia.

Aggiungendo AJAX però tutto ciò non funzionava come volevo, in quanto ogni volta che richiamavo un evento asincrono dei controlli creati a runtime, il trigger che diceva di fare un Postback completo al controllo FileUpload andava a farsi friggere.
Dopo una mezza giornata di testate contro il muro o provato a fare una cosa.....ho creato l'override del metodo CreateChildControls ed ho inserito qua dentro la "ricreazione" dei controlli così da anticipare il Page_Load.

Ora tutto funziona......ma quanto ci sarebbe da dire rispetto all'ordine di richiamo dei metodi e degli eventi del Framework.

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