Articoli

Introducing Silverlight

Giorgio — Fri, 23 Jul 2010 09:39:04 GMT

Current revision posted to Articoli by Giorgio on 23/07/2010 11:39:04

Introducing Silverlight

Inserito sotto: Silverlight

Silverlight è una tecnologia di Microsoft, cross-platform e cross-browser, per lo sviluppo delle RIA (Rich Internet Applications). Esso permette di definire interfacce utente e animazioni per pagine Web molto accattivanti grazie alla possibilità di poter integrare tra di loro il linguaggio XAML e la potenza del .NET Framework per la parte di code behind con C# o con VB.Net.

In realtà Silverlight non fornisce tutte le potenzialità del .NET Framework, ma la necessaria porzione di funzionalità di cui si può aver bisogno per lo sviluppo di applicazioni web. Anche il CLR (Common Language Runtime) di Silverlight non è lo stesso del framework .NET, ma è un piccolo plug-in cross-browser (6Mb per la versione 4.0 del runtime) che si può scaricare gratuitamente da internet. Inoltre, nel caso in cui non fosse mai stato installato il runtime, sarà scaricato automaticamente, previa autorizzazione, al primo accesso fatto in una pagina web sviluppata con silverlight. Il plug-in è funzionante sia sotto Windows sia sotto MAC ed è in alcuni casi supportato da apparecchiature mobile che utilizzano come sistema operativo Windows Mobile o Symbian^1 (S60 5a edizione per cellulari quali N97, N97 mini o 5800 Xpressmusic)e (quando usciranno i nuovi smartphone che lo monteranno, anche se per ora ci si può smanettare un po’) Windows Phone, mentre per Linux bisogna scaricare l’implementazione open source del CLR, Moonlight, sviluppato dal team di Mono.

Ancora più fondamentale è che Silverlight, a differenza di altre tecnologie quali Asp.net o Asp.net MVC, è client-side, quindi le applicazioni sviluppate con essa sono installate direttamente sul client, di conseguenza, considerando uno scenario in cui non avvengono richieste al server, i tempi di risposta della stessa sono più rapidi, dal momento che qualsiasi tipo di operazione viene effettuata direttamente nel browser del client. Tutto questo non da problemi dal punto di vista della sicurezza perche' silverlight gira in una sandbox.<o:p></o:p>

La prima versione fu presentata il 4 settembre del 2007, ma se volessimo fissare una milestone fondamentale per l’inizio dell’ascesa del progetto Silverlight, potremmo identificarla con il 21 dicembre 2006, giorno in cui Microsoft rilasciò una tecnologia che risultava essere un sottoinsieme della già più conosciuta Windows Presentation Foundation. Proprio per questo motivo la prima release di Silverlight fu chiamata WPF/E (WPF Everywhere).

Questa versione di Silverlight ancora non era fornita del CLR, ma esponeva i dati con delle API simili al DOM, fornendo così la possibilità di programmarne l’interazione con javascript. Questa prima versione includeva anche un encoder di formati video e una prima versione dell’interprete per il linguaggio XAML.

Nella release 1.1 fu introdotta una prima versione del runtime, il vero è proprio cuore di questa versione si componeva di tre parti:

· il presentation core che conteneva l’integrazione dei browser, l’interprete del linguaggio XAML e il supporto ai media,

· la Base Class Library, grazie alla quale, quindi, si aveva la possibilità di usare una parte delle classi base del .NET Framework con qualsiasi linguaggio da esso supportato,

· e “last but not least” il già citato CLR.

Questo cuore di silverlight era attorniato da tre framework quali presentation framework, traducendo semplicemente dall’inglese e per dirlo in parole povere, tutto ciò che riguardava la parte di presentazione, il data framework e le interrogazioni dei dati, e il comunications framework per l’interfacciamento delle applicazioni con l’esterno (es. I server).

Il runtime di Silverlight fece Il salto di qualità con la presentazione della versione 2.0 (rilasciata il 14 ottobre 2008), nonostante fosse considerata la naturale evoluzione di Silverlight 1.1, il miglioramento del CLR e alcune introduzioni la rendevano molto più completa e funzionale rispetto al predecessore, e, come se non bastasse, anche se vennero fatte queste modifiche, la dimensione del plug-in continuò a rimanere notevolmente “light”, solo 4,6Mb rispetto ai 4Mb della versione 1.1.

Quasi un anno dopo, per essere più precisi il 9 luglio 2009, Microsoft rilasciava la terza versione di Silverlight, ancora una volta colma d’innovazioni. Con questa release Microsoft, grazie alle migliorie nel campo del supporto a flussi streaming (Smooth Streaming ^*), cerca di opporsi in maniera decisa a Flash.

Questa piattaforma supportava anche il “Perspective 3-D”, una modalità di implementazione 3D limitata ad una visualizzazione prospettica degli elementi, ed introduceva effetti grafici da poter applicare singolarmente ad ogni elemento discendente da “UIElement” (Pixel shader effects), furono migliorate le performance video grazie ad un maggiore sfruttamento della GPU, fu aggiunta la possibilità di modificare le immagini bitmap, potendo anche modificare singolarmente i pixel, furono aggiunti anche di nuovi effetti per le animazioni, nuovi controlli, e il navigation framework per permettere la navigazione tra diverse pagine xaml, fu introdotto anche il “Binding Element to Element” ^*, il quale permetteva di bindare la proprietà di un oggetto recuperandone il valore da un altro, e il “Binding Validation”, un sistema che consentiva di intercettare le eccezioni sollevate nel caso in cui al variare del valore dei dati essi risultavano non congrui con i tipi di valori consentiti , furono inserite delle nuove API del namespace System.Windows.Messaging che consentono la comunicazione tra più oggetti Silverlight nella pagina (Local connection), ed infine una delle introduzioni più importanti, la possibilità di creare delle “Out of Browser Application” ^*, applicazioni di silverlight che possono essere avviate direttamente dal desktop.

Il progetto Silverlight è arrivato alla versione 4.0, quest’ultima è stata rilasciata il 15/04/2010 in concomitanza alla presentazione di Visual Studio 2010 e del framework 4.0.

Questa più recente relaese della piattaforma introduce migliorie per lo sviluppo di applicazioni “Out of Browser”, l’aggiunta del supporto alla stampa, quindi l’introduzione dell’oggetto “PrintDocument” e l’uso dell’evento “PrintPage”. Sono stati introdotti nuovi controlli quali la “RichTextBox”, che permette di renderizzare il testo e di gestirne la formattazione, con la possibilità di integrare elementi come immagini e altri oggetti, e l’oggetto “WebBrowser” per la navigazione tra le pagine web, il “Paragraph” per la formattazione del testo, che può contenere diversi oggetti, tra i quali il più interessante è “InlineUIContainer”, che permette di inserire dei controlli all’interno del testo. E’stato anche introdotto l’evento RightMouseButtonDown per il click del tasto destro del mouse e la proprietà AllowDrop per la gestione di trascinamento sul controllo UIElement.

Altre novità assolute di Silverlight 4.0 sono la classe NetworkCredential, per l’accesso a risorse protette da username e password, e la proprieta IpMulticast per l’invio di messaggi contemporaneamente con il trasferimento di pacchetti tramite il protocollo UDP con una connessione uno a molti. E ancora, è stato introdotto il supporto alla Webcam e al microfono.

Infine è giusto fare anche una piccola citazione, “piccola” perché l’argomento sarà ripreso nei prossimi articoli, al MEF (Managed Extensibility Framework), il framework per lo sviluppo di applicazioni componibili dinamicamente, che è stato integrato nel Framework .NET 4.0, e che Silverlight 4.0 supporta.

Il fatto che sia stato integrato il MEF in Silverlight 4.0, ha fatto in modo che venissero accostati sempre più Silverlight e il design pattern M-V-VM (Model-View-ViewModel), questo perché con Silverlight, come anche per WPF, lo sviluppo di applicazioni componibili dinamicamente richiede obbligatoriamente l’uso di M-V-VM. Sembra scontato dire, comunque, che questo design pattern poteva essere tranquillamente usato con Silverlight anche prima della release 4.0.

Non mi resta altro, per questo primo articolo, se non lasciarvi i riferimenti per scaricare i tools di sviluppo di Silverlight 4.0 in Visual Studio 2010 (la release candidate 2), la sdk di Silverlight 4.0, il runtime e i WCF RIA Services per Silverlight 4.0 (la release candidate 2) dal link:

Silverlight 4.0 developer tools and runtime

*Questo argomento sarà ripreso negli articoli successivi

Introducing Silverlight

Giorgio — Fri, 23 Jul 2010 09:35:16 GMT

Revision 2 posted to Articoli by Giorgio on 23/07/2010 11:35:16

Introducing Silverlight

Inserito sotto: Silverlight

Nella release 1.1 fu introdotta una prima versione del runtime, il vero è proprio cuore di questa versione si componeva di tre parti:

· il presentation core che conteneva l’integrazione dei browser, l’interprete del linguaggio XAML e il supporto ai media,

· la Base Class Library, grazie alla quale, quindi, si aveva la possibilità di usare una parte delle classi base del .NET Framework con qualsiasi linguaggio da esso supportato,

· e “last but not least” il già citato CLR.

Il progetto Silverlight è arrivato alla versione 4.0, quest’ultima è stata rilasciata il 15/04/2010 in concomitanza alla presentazione di Visual Studio 2010 e del framework 4.0.

Silverlight 4.0 developer tools and runtime

*Questo argomento sarà ripreso negli articoli successivi<o:p></o:p>

Introducing Silverlight

Giorgio — Fri, 23 Jul 2010 09:33:44 GMT

Revision 1 posted to Articoli by Giorgio on 23/07/2010 11:33:44

Nella release 1.1 fu introdotta una prima versione del runtime, il vero è proprio cuore di questa versione si componeva di tre parti:

· il presentation core che conteneva l’integrazione dei browser, l’interprete del linguaggio XAML e il supporto ai media,

· la Base Class Library, grazie alla quale, quindi, si aveva la possibilità di usare una parte delle classi base del .NET Framework con qualsiasi linguaggio da esso supportato,

· e “last but not least” il già citato CLR.

Il progetto Silverlight è arrivato alla versione 4.0, quest’ultima è stata rilasciata il 15/04/2010 in concomitanza alla presentazione di Visual Studio 2010 e del framework 4.0.

Silverlight 4.0 developer tools and runtime

*Questo argomento sarà ripreso negli articoli successivi<o:p></o:p>

Resizing e generazione di thumbnail avanzata

ilNero — Thu, 08 Apr 2010 20:13:18 GMT

Current revision posted to Articoli by ilNero on 08/04/2010 22:13:18

Resizing e generazione di thumbnail avanzatadi immagini

Introduzione

Uno dei metodi più comodi e più utilizzati per ottenere thumbnail di immagini dinamicamente è il metodo GetThumbnailImage() dell'oggetto Image presente nel namespace System.Drawing, come ripreso anche da Turibbio in uno dei suoi post.

L'utilizzo di questo metodo pone però alcune limitazioni, come lo stesso msdn afferma:

Il metodo GetThumbnailImage garantisce migliori risultati quando le dimensioni dell'immagine di anteprima richiesta sono pari a circa 120x120 pixel. Se si richiede un'immagine di anteprima di grandi dimensioni, ad esempio 300x300, da un oggetto Image che dispone di un'anteprima incorporata, è possibile che si verifichi una notevole perdita di qualità dell'immagine dell'anteprima. Potrebbe essere consigliabile ridimensionare l'immagine principale, anziché ridimensionare l'anteprima incorporata, chiamando il metodo DrawImage. (1)

Qualche considerazione nata dalla mia esperienza di web developer: il più delle volte mi è capitato di dover gestire thumbnail che fossero in qualche modo uniformi nelle dimensioni e nel colore di sfondo. Ho deciso di affrontare entrambi gli aspetti in modo da approcciare il problema nella sua variegata casistica.

Ho affrontato il problema suddividendolo in due blocchi.
Dapprima viene curato l'aspetto legato al contenitore dell'immagine di output: è' possibile immaginarlo come il livello di sfondo dell'immagine risultante.
Successivamente viene curato il ridimensionamento dell'immagine e come questa viene disegnata rispetto al contenitore.
Utilizzare la procedura proposta in questo post per effettuare il ridimensionamento dell'immagine in input prevederà dunque la definizione delle dimensioni di larghezza ed altezza desiderate del container, e delle dimensioni di larghezza ed altezza desiderate dell'immagine ridimensionata, le quali non sempre e non necessariamente devono combaciare. Per questo motivo, ho definito quattro membri e relative proprietà:

private int _imageWidth;
private int _imageHeight;
private int _containerWidth;
private int _containerHeight;

public int Width
{
    get { return _imageWidth; }
    set { _imageWidth = value; }
}
public int Height
{
    get { return _imageHeight; }
    set { _imageHeight = value; }
}
public int ContainerWidth
{
    get { return _containerWidth; }
    set { _containerWidth = value; }
}
public int ContainerHeight
{
    get { return _containerHeight; }
    set { _containerHeight = value; }
}

Il modo in cui queste quattro dimensioni interagiscono tra di loro è definito dall'enumerazione

 
public enum ScaleMode
{
    FitContainer,
    FitImage,
    FitAuto,
    NoFit
}

dove:

FitContainer: forza il ridimensionamento in modo da adeguarsi alle dimensioni specificate per il contenitore. L'immagine di output avrà le dimensioni specificate per il contenitore.
FitImage: effettua il ridimensionamento in base alle dimensioni specificate per imageWidth e imageHeight, forzando il contenitore ad adeguarsi a queste dimensioni
FitAuto: esegue un ridimensionamento calcolando in automatico le dimensioni dell'immagine risultante all'interno del contenitore. L'immagine di output avrà le dimensioni specificate per il contenitore.
NoFit: non adegua il ridimensionamento al contenitore. Esegue il ridimensionamento sull'immagine in base alle dimensioni specificate, effettuando un taglio dell'immagine qualora questa superi le dimensioni del contenitore. L'immagine di output avrà le dimensioni specificate per il contenitore. E' possibile gestire la modalità di taglio con le strutture seguenti:

 
public enum Position
{
    TopLeft,
    TopCenter,
    TopRight,
    MiddleLeft,
    MiddleCenter,
    MiddleRight,
    BottomLeft,
    BottomCenter,
    BottomRight,
    Undefined
}

private int _offsetX;
private int _offsetY;
private Position _drawingPosition;

public int OffsetX
{
    get { return _offsetX; }
    set { _offsetX = value; }
}
public int OffsetY
{
    get { return _offsetY; }
    set { _offsetY = value; }
}
public Position DrawingPosition {
    get { return _drawingPosition; }
    set { _drawingPosition = value; }
}

L'enumerazione Position definisce in che modo l'immagine viene allineata rispetto al container. E se proprio questo non bastasse è possibile valorizzare le variabili OffsetX e OffsetY che consentono di avere uno scostamento rispetto all'origine (l'angolo superiore sinistro del contenitore).

A queste modalità operative si aggiunge il controllo sul ridimensionamento proporzionale, come si vedrà in seguito.

Per quanto riguarda invece la definizione del colore di sfondo, ho definito due variabili, la prima è il colore vero e proprio, la seconda l'intensità del canale alfa/trasparenza. Questi due valori vengono combinati nel metodo GetBackground() che inoltre effettua un controllo sulla coerenza del valore di Alpha, che ammette valori compresi tra 0 e 255.

 
private Color _backgroundColor;
private int _alpha;

public Color BackgroundColor
{
    get { return _backgroundColor; }
    set { _backgroundColor = value; }
}
public int Alpha
{
    get { return _alpha; }
    set { _alpha = value; }
}

private SolidBrush GetBackground()
{
    int alphaCheck = 255;
    if (_alpha < 0)
        alphaCheck = 0;
    else if (_alpha > 255)
        alphaCheck = 255;
    else
        alphaCheck = _alpha;
    return new SolidBrush(Color.FromArgb(alphaCheck, _backgroundColor));
}

Vediamo ora come utilizzare il metodo DrawImage, come suggerito in msdn.

 
public Image Resize(Image image)
{
    // Temp variables
    int newContainerWidth = _containerWidth;
    int newContainerHeight = _containerHeight;
    int newImageWidth = _imageWidth;
    int newImageHeight = _imageHeight;
    int newPositionX = 0;
    int newPositionY = 0;

    GetNewSizes(image, ref newContainerWidth, ref newContainerHeight, ref newImageWidth, ref newImageHeight);
    GetPositions(ref newPositionX, ref newPositionY, newContainerWidth, newContainerHeight, newImageWidth, newImageHeight);

    Bitmap retObj = new Bitmap(newContainerWidth, newContainerHeight);
    retObj.SetResolution(_horizontalResolution, _verticalResolution);

    Graphics g = Graphics.FromImage(retObj);
    g.CompositingMode = _compositingMode;
    g.CompositingQuality = _compositingQuality;
    g.SmoothingMode = _smoothing;
    g.InterpolationMode = _interpolation;
    
    g.FillRectangle(GetBackground(), 0f, 0f, newContainerWidth, newContainerHeight);
    g.DrawImage(image, newPositionX + _offsetX, newPositionY + _offsetY, newImageWidth, newImageHeight);
    g.Dispose();
    return (Image)retObj;
}

Come si osserva dal codice, vengono definite una serie di variabili temporanee che saranno popolate successivamente da due metodi di supporto che vengono richiamati per effettuare i dovuti controlli sulle dimensioni del container e dell'immagine e definire quindi i valori finali che saranno utilizzati durante il processo di resizing dell'immagine.

private void GetProportionalSizes(Image image, ref int imageWidth, ref int imageHeight)
{
    bool exceedWidth = image.Width > imageWidth ? true : false;
    bool exceedHeight = image.Height > imageHeight ? true : false;

    if (exceedWidth & exceedHeight)
    {
        int horizontalSurplus = image.Width - _imageWidth;
        int verticalSurplus = image.Height - _imageHeight;

        if (horizontalSurplus > verticalSurplus)
        {
            imageWidth = _imageWidth;
            imageHeight = imageWidth * image.Height / image.Width;
        }
        else
        {
            imageHeight = _imageHeight;
            imageWidth = imageHeight * image.Width / image.Height;
        }
    }
    else
    {
        if (exceedWidth)
        {
            imageWidth = _imageWidth;
            imageHeight = imageWidth * image.Height / image.Width;
        }
        else
        {
            imageHeight = _imageHeight;
            imageWidth = imageHeight * image.Width / image.Height;
        }
    }
}

Il metodo GetProportionalSizes() calcola le dimensioni finali dell'immagine in modo da effettuare un ridimensionamento proporzionale ed evitare così il fastidioso effetto di stretching delle immagini. Nella serie di if-else innestate viene eseguito un controllo sulla coerenza della proporzioni in base alle dimensioni dell'immagine originale e delle dimensioni desiderate.

Infatti il primo controllo si occupa di verificare quale delle due dimensioni (orizzontale o verticale) richieste eccede rispetto alla dimensione dell'immagine originale. Se entrambe eccedono, viene verificata quale delle due dimensioni eccede maggiormente di modo che il calcolo proporzionale venga fatto su questa. Il discorso è analogo qualora solo una delle due dimensioni ecceda rispetto alle dimensioni dell'immagine originale. Il terzo caso, non contemplato nel corpo del metodo, è il caso in cui nessuna delle due dimensioni richieste per il ridimensionamento ecceda le dimensioni originali: in questo caso le dimensioni richieste sono superiori a quella dell'immagine originale, assumendo l'assenza di ridimensionamento, ed evitando quindi il calcolo delle dimensioni proporzionali.

 private void CheckContainerSizes(ref int imageWidth, ref int imageHeight)
{
    bool exceedWidth = imageWidth > _containerWidth ? true : false;
    bool exceedHeight = imageHeight > _containerHeight ? true : false;

    if (exceedWidth & exceedHeight)
    {
        int horizontalSurplus = imageWidth - _containerWidth;
        int verticalSurplus = imageHeight - _containerHeight;

        if (horizontalSurplus > verticalSurplus)
        {
            imageWidth = _containerWidth;
            imageHeight = imageWidth * _containerHeight / _containerWidth;
        }
        else
        {
            imageHeight = _containerHeight;
            imageWidth = imageHeight * _containerWidth / _containerHeight;
        }
    }
    else
    {
        if (exceedWidth)
        {
            imageWidth = _containerWidth;
            imageHeight = imageWidth * _containerHeight / _containerWidth;
        }
        else
        {
            imageHeight = _containerHeight;
            imageWidth = imageHeight * _containerWidth / _containerHeight;
        }
    }

    // Change required size for auto fit
    _imageWidth = imageWidth;
    _imageHeight = imageHeight;
}

Il metodo CheckContainerSizes() viene richiamato nel solo caso in cui la modalità operativa scelta sia FitAuto, ovvero quando viene richiesto che l'immagine venga ridimensionata nel rispetto delle dimensioni del container, senza andare oltre queste. Leggendo il corpo di questo metodo, si nota che è praticamente identico al corpo del metodo GetProportionalSizes(), ma ha una differenza importante: oltre ad effettuare le verifiche del caso, è in grado di reimpostare le dimensioni di ridimensionamento richieste affinchè soddisfino il criterio operativo scelto.

public void Save(Image image, ImageFormat format, string outputFile)
{
    if (format == ImageFormat.Jpeg)
    {
        ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
        EncoderParameters encoderParams = new EncoderParameters(1);
        encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, _jpegCompression);
        image.Save(outputFile, info[1], encoderParams);
    }
    else
    {
        image.Save(outputFile, format);
    }
}

Il metodo Save() consente di salvare su filesystem l'immagine precedentemente ridimensionata (o qualunque altra immagine precedentemente istanziata, visto che tra i parametri di input c'è "image").
Si nota però che nel caso venga richiesto di salvare in formato Jpeg, è possibile controllare il grado di compressione dell'immagine jpeg risultante, semplicemente instanziando e valorizzando l'oggetto EncoderParameters e passandolo in input ad uno specifico overload del metodo Save() dell'oggetto Image.

Tra i vari membri presenti, opportunamente mappati su proprietà, ne spiccano cinque che consentono di avere un controllo dell'output piuttosto avanzato:

private InterpolationMode _interpolation;
private CompositingMode _compositingMode;
private CompositingQuality _compositingQuality;
private SmoothingMode _smoothing;
private PixelOffsetMode _pixelOffsetMode;

public InterpolationMode Interpolation
{
    get { return _interpolation; }
    set { _interpolation = value; }
}
public CompositingMode CompositingMode
{
    get { return _compositingMode; }
    set { _compositingMode = value; }
}
public CompositingQuality CompositingQuality
{
    get { return _compositingQuality; }
    set { _compositingQuality = value; }
}
public SmoothingMode Smoothing
{
    get { return _smoothing; }
    set { _smoothing = value; }
}
public PixelOffsetMode PixelOffset
{
    get { return _pixelOffsetMode; }
    set { _pixelOffsetMode = value; }
}

InterpolationMode

L'InterpolationMode è, in questo contesto, di importanza vitale. Specifica infatti 'algoritmo utilizzato quando le immagini vengono scalate o ruotate. Questi le possibili scelte:

Default: Specifica la modalità predefinita.
Low: Specifica un'interpolazione di bassa qualità.
High: Specifica un'interpolazione di elevata qualità.
Bilinear: Specifica l'interpolazione bilineare. Non viene effettuata alcuna operazione di prefiltraggio. Questa modalità non è adatta per la compattazione di un'immagine al di sotto del 50% delle dimensioni originali.
Bicubic: Specifica l'interpolazione bicubica. Non viene effettuata alcuna operazione di prefiltraggio. Questa modalità non è adatta per la compattazione di un'immagine al di sotto del 25% delle dimensioni originali.
NearestNeighbor: Specifica l'interpolazione più simile.
HighQualityBilinear: Specifica l'interpolazione bilineare di elevata qualità. Viene effettuata un'operazione di prefiltraggio per assicurare una compattazione di elevata qualità.
HighQualityBicubic: Specifica l'interpolazione bicubica di elevata qualità. Viene effettuata un'operazione di prefiltraggio per assicurare una compattazione di elevata qualità. Questa modalità produce le immagini trasformate di qualità più elevata.

CompositingMode

Il CompositingMode specifica il modo in cui i colori di origine vengono combinati con i colori dello sfondo. E' possibile assegnare uno dei due valori:

SourceOver: quando viene eseguito il rendering di un colore, tale colore viene miscelato con il colore dello sfondo. La miscela di colori viene determinata dal componente alpha del colore di cui viene eseguito il rendering.
SourceCopy: quando viene eseguito il rendering di un colore, tale colore sovrascrive il colore dello sfondo.

CompositingQuality

La CompositingQuality specifica il livello di qualità da utilizzare durante la composizione. Questi sono i valori ammissibili:

Default: qualità predefinita.
HighSpeed: alta velocità, bassa qualità.
HighQuality: composizione di elevata qualità e ridotta velocità.
GammaCorrected: viene utilizzata la correzione gamma.
AssumeLinear: vengono assunti i valori lineari.

SmoothingMode

Lo SmoothingMode specifica se e come viene applicato l'anti-aliasing. Anche i questo caso abbiamo una serie di valori ammissibili:

Default: Specifica l'assenza di antialias.
HighSpeed: Specifica l'assenza di antialias.
HighQuality: Specifica il rendering con antialias.
None: Specifica l'assenza di antialias.
AntiAlias: Specifica il rendering con antialias.

PixelOffsetMode

Il PixelOffsetMode specifica la modalità di offset dei pixel durante l'esecuzione del rendering, in modo da controllare la qualità del rendering finale. Questi i valori ammissibili:

Default: Specifica la modalità predefinita.
HighSpeed: Specifica un rendering di elevata velocità e ridotta qualità.
HighQuality: Specifica un rendering di elevata qualità e ridotta velocità.
None: Specifica l'assenza di offset di pixel.
Half: Specifica l'offset dei pixel in base a unità - .5, sia in senso orizzontale che verticale, per ottenere un anti-aliasing di elevata velocità.

g.FillRectangle(GetBackground(), 0f, 0f, newContainerWidth, newContainerHeight);
g.DrawImage(image, newPositionX + _offsetX, newPositionY + _offsetY, newImageWidth, newImageHeight);

Definiti tutti i parametri di disegno ed effettuati i calcoli sul ridimensionamento, sono le due chiamate finali a generare l'immagine di output. Nella prima, il metodo FillRectangle, in uno dei suoi overload (2), disegna il livello di sfondo. Su di questo, la chiamata successiva, DrawImage, anch'essa in uno dei suoi overload (3), disegna l'immagine ridimensionata.

Il codice sorgente

 
#region Using directives
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
#endregion

namespace DotNetCampania.Imager
{
    public class ImageProcessor
    {
        #region Enums
        public enum ScaleMode
        {
            FitContainer,
            FitImage,
            FitAuto,
            NoFit
        }

        public enum Position
        {
            TopLeft,
            TopCenter,
            TopRight,
            MiddleLeft,
            MiddleCenter,
            MiddleRight,
            BottomLeft,
            BottomCenter,
            BottomRight,
            Undefined
        }
        #endregion

        #region Members
        private int _imageWidth;
        private int _imageHeight;
        private int _containerWidth;
        private int _containerHeight;
        private ScaleMode _scale;
        private Position _drawingPosition;
        private bool _proportional;
        private InterpolationMode _interpolation;
        private CompositingMode _compositingMode;
        private CompositingQuality _compositingQuality;
        private SmoothingMode _smoothing;
        private PixelOffsetMode _pixelOffsetMode;
        private Color _backgroundColor;
        private int _alpha;

        private int _offsetX;
        private int _offsetY;

        private ImageFormat _outputImageFormat;
        private long _jpegCompression;
        private float _horizontalResolution;
        private float _verticalResolution;
        #endregion

        #region Properties
        public int Width
        {
            get { return _imageWidth; }
            set { _imageWidth = value; }
        }
        public int Height
        {
            get { return _imageHeight; }
            set { _imageHeight = value; }
        }
        public int ContainerWidth
        {
            get { return _containerWidth; }
            set { _containerWidth = value; }
        }
        public int ContainerHeight
        {
            get { return _containerHeight; }
            set { _containerHeight = value; }
        }
        public Position DrawingPosition
        {
            get { return _drawingPosition; }
            set { _drawingPosition = value; }
        }
        public bool Proportional
        {
            get { return _proportional; }
            set { _proportional = value; }
        }
        public InterpolationMode Interpolation
        {
            get { return _interpolation; }
            set { _interpolation = value; }
        }
        public CompositingMode CompositingMode
        {
            get { return _compositingMode; }
            set { _compositingMode = value; }
        }
        public CompositingQuality CompositingQuality
        {
            get { return _compositingQuality; }
            set { _compositingQuality = value; }
        }
        public SmoothingMode Smoothing
        {
            get { return _smoothing; }
            set { _smoothing = value; }
        }
        public PixelOffsetMode PixelOffset
        {
            get { return _pixelOffsetMode; }
            set { _pixelOffsetMode = value; }
        }
        public Color BackgroundColor
        {
            get { return _backgroundColor; }
            set { _backgroundColor = value; }
        }
        public int Alpha
        {
            get { return _alpha; }
            set { _alpha = value; }
        }
        public int OffsetX
        {
            get { return _offsetX; }
            set { _offsetX = value; }
        }
        public int OffsetY
        {
            get { return _offsetY; }
            set { _offsetY = value; }
        }
        public ImageFormat OutputImageFormat
        {
            get { return this._outputImageFormat; }
            set { _outputImageFormat = value; }
        }
        public long JPEGCompression
        {
            get { return _jpegCompression; }
            set { _jpegCompression = value; }
        }
        public float HorizontalResolution
        {
            get { return _horizontalResolution; }
            set { _horizontalResolution = value; }
        }
        public float VerticalResolution
        {
            get { return _verticalResolution; }
            set { _verticalResolution = value; }
        }
        public ScaleMode Scale
        {
            get { return _scale; }
            set { _scale = value; }
        }
        #endregion

        #region Constructor(s)
        public ImageProcessor()
        {
            _imageWidth = default(int);
            _imageHeight = default(int);
            _containerWidth = default(int);
            _containerHeight = default(int);
            _drawingPosition = Position.Undefined;
            _interpolation = InterpolationMode.HighQualityBicubic;
            _compositingMode = CompositingMode.SourceOver;
            _compositingQuality = CompositingQuality.HighQuality;
            _smoothing = SmoothingMode.HighQuality;
            _pixelOffsetMode = PixelOffsetMode.HighQuality;

            _proportional = true;
            _alpha = 255;
            _backgroundColor = Color.White;

            _offsetX = 0;
            _offsetY = 0;
            _scale = ScaleMode.FitAuto;

            _outputImageFormat = ImageFormat.Jpeg;
            _jpegCompression = 80L;
            _horizontalResolution = 72f;
            _verticalResolution = 72f;
        }
        #endregion

        #region Public methods
        public Image Resize(Image image)
        {
            // Temp variables
            int newContainerWidth = _containerWidth;
            int newContainerHeight = _containerHeight;
            int newImageWidth = _imageWidth;
            int newImageHeight = _imageHeight;
            int newPositionX = 0;
            int newPositionY = 0;

            GetNewSizes(image, ref newContainerWidth, ref newContainerHeight, ref newImageWidth, ref newImageHeight);
            GetPositions(ref newPositionX, ref newPositionY, newContainerWidth, newContainerHeight, newImageWidth, newImageHeight);

            Bitmap retObj = new Bitmap(newContainerWidth, newContainerHeight);
            retObj.SetResolution(_horizontalResolution, _verticalResolution);

            Graphics g = Graphics.FromImage(retObj);
            g.CompositingMode = _compositingMode;
            g.CompositingQuality = _compositingQuality;
            g.SmoothingMode = _smoothing;
            g.InterpolationMode = _interpolation;
            g.PixelOffsetMode = _pixelOffsetMode;
            
            g.FillRectangle(GetBackground(), 0f, 0f, newContainerWidth, newContainerHeight);
            g.DrawImage(image, newPositionX + _offsetX, newPositionY + _offsetY, newImageWidth, newImageHeight);
            g.Dispose();
            return (Image)retObj;
        }

        public void Save(Image image, ImageFormat format, string outputFile)
        {
            if (format == ImageFormat.Jpeg)
            {
                ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
                EncoderParameters encoderParams = new EncoderParameters(1);
                encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, _jpegCompression);
                image.Save(outputFile, info[1], encoderParams);
            }
            else
            {
                image.Save(outputFile, format);
            }
        }
        #endregion

        #region Private support methods
        private void GetNewSizes(Image image, ref int containerWidth, ref int containerHeight, ref int imageWidth, ref int imageHeight)
        {
            switch (_scale)
            {
                case ScaleMode.NoFit:
                    if (_proportional)
                    {
                        GetProportionalSizes(image, ref  imageWidth, ref  imageHeight);
                    }
                    break;
                case ScaleMode.FitAuto:
                    CheckContainerSizes(ref imageWidth, ref imageHeight); 
                    if (_proportional)
                        GetProportionalSizes(image, ref  imageWidth, ref  imageHeight);
                    break;
                case ScaleMode.FitContainer:
                    imageWidth = containerWidth;
                    imageHeight = containerHeight;
                    break;
                case ScaleMode.FitImage:
                    if (_proportional)
                        GetProportionalSizes(image, ref  imageWidth, ref  imageHeight);
                    containerWidth = imageWidth;
                    containerHeight = imageHeight;
                    break;
            }
        }

        private void GetPositions(ref int positionX, ref int positionY, int containerWidth, int containerHeight, int imageWidth, int imageHeight) {
            switch (_drawingPosition) {
                case Position.BottomCenter:
                    positionX = (int)((containerWidth / 2) - (imageWidth / 2));                    
                    positionY = containerHeight - imageHeight;
                    break;
                case Position.BottomLeft: 
                    positionX = 0;
                    positionY = containerHeight - imageHeight;
                    break;
                case Position.BottomRight: 
                    positionX = containerWidth - imageWidth;
                    positionY = containerHeight - imageHeight;
                    break;
                case Position.MiddleCenter: 
                    positionX = (int)((containerWidth / 2) - (imageWidth / 2));
                    positionY = (int)((containerHeight / 2) - (imageHeight / 2));
                    break;
                case Position.MiddleLeft:
                    positionX = 0;
                    positionY = (int)((containerHeight / 2) - (imageHeight / 2));
                    break;
                case Position.MiddleRight: 
                    positionX = containerWidth - imageWidth;
                    positionY = (int)((containerHeight / 2) - (imageHeight / 2));
                    break;
                case Position.TopCenter: 
                    positionX = (int)((containerWidth / 2) - (imageWidth / 2));
                    positionY = 0;
                    break;
                case Position.TopLeft:
                    positionX = 0;
                    positionY = 0;
                    break;
                case Position.TopRight: 
                    positionX = containerWidth - imageWidth;
                    positionY = 0;
                    break;
            }
        }

        private void CheckContainerSizes(ref int imageWidth, ref int imageHeight)
        {
            bool exceedWidth = imageWidth > _containerWidth ? true : false;
            bool exceedHeight = imageHeight > _containerHeight ? true : false;

            if (exceedWidth & exceedHeight)
            {
                int horizontalSurplus = imageWidth - _containerWidth;
                int verticalSurplus = imageHeight - _containerHeight;

                if (horizontalSurplus > verticalSurplus)
                {
                    imageWidth = _containerWidth;
                    imageHeight = imageWidth * _containerHeight / _containerWidth;
                }
                else
                {
                    imageHeight = _containerHeight;
                    imageWidth = imageHeight * _containerWidth / _containerHeight;
                }
            }
            else
            {
                if (exceedWidth)
                {
                    imageWidth = _containerWidth;
                    imageHeight = imageWidth * _containerHeight / _containerWidth;
                }
                else
                {
                    imageHeight = _containerHeight;
                    imageWidth = imageHeight * _containerWidth / _containerHeight;
                }
            }

            // Change required size for auto fit
            _imageWidth = imageWidth;
            _imageHeight = imageHeight;
        }

        private void GetProportionalSizes(Image image, ref int imageWidth, ref int imageHeight)
        {
            bool exceedWidth = image.Width > imageWidth ? true : false;
            bool exceedHeight = image.Height > imageHeight ? true : false;

            if (exceedWidth & exceedHeight)
            {
                int horizontalSurplus = image.Width - _imageWidth;
                int verticalSurplus = image.Height - _imageHeight;

                if (horizontalSurplus > verticalSurplus)
                {
                    imageWidth = _imageWidth;
                    imageHeight = imageWidth * image.Height / image.Width;
                }
                else
                {
                    imageHeight = _imageHeight;
                    imageWidth = imageHeight * image.Width / image.Height;
                }
            }
            else
            {
                if (exceedWidth)
                {
                    imageWidth = _imageWidth;
                    imageHeight = imageWidth * image.Height / image.Width;
                }
                else
                {
                    imageHeight = _imageHeight;
                    imageWidth = imageHeight * image.Width / image.Height;
                }
            }
        }

        private SolidBrush GetBackground()
        {
            int alphaCheck = 255;
            if (_alpha < 0)
                alphaCheck = 0;
            else if (_alpha > 255)
                alphaCheck = 255;
            else
                alphaCheck = _alpha;
            return new SolidBrush(Color.FromArgb(alphaCheck, _backgroundColor));
        }
        #endregion
    }
}

Download

Riferimenti

Riferimento a .NET Framework - Metodo Image.GetThumbnailImage [http://msdn.microsoft.com/it-it/library/system.drawing.image.getthumbnailimage.aspx]
Graphics.FillRectangle Method (Brush, Rectangle) [http://msdn.microsoft.com/en-us/library/yysstebh.aspx
Metodo Graphics.DrawImage (Image, Int32, Int32, Int32, Int32) [http://msdn.microsoft.com/it-it/library/dbsak4dc(v=VS.80).aspx]

Resizing e generazione di thumbnail avanzata di immagini

ilNero — Thu, 08 Apr 2010 20:11:21 GMT

Revision 1 posted to Articoli by ilNero on 08/04/2010 22:11:21

Introduzione

L'utilizzo di questo metodo pone però alcune limitazioni, come lo stesso msdn afferma:

private int _imageWidth;
private int _imageHeight;
private int _containerWidth;
private int _containerHeight;

public int Width
{
    get { return _imageWidth; }
    set { _imageWidth = value; }
}
public int Height
{
    get { return _imageHeight; }
    set { _imageHeight = value; }
}
public int ContainerWidth
{
    get { return _containerWidth; }
    set { _containerWidth = value; }
}
public int ContainerHeight
{
    get { return _containerHeight; }
    set { _containerHeight = value; }
}

Il modo in cui queste quattro dimensioni interagiscono tra di loro è definito dall'enumerazione

 
public enum ScaleMode
{
    FitContainer,
    FitImage,
    FitAuto,
    NoFit
}

dove:

FitContainer: forza il ridimensionamento in modo da adeguarsi alle dimensioni specificate per il contenitore. L'immagine di output avrà le dimensioni specificate per il contenitore.
FitImage: effettua il ridimensionamento in base alle dimensioni specificate per imageWidth e imageHeight, forzando il contenitore ad adeguarsi a queste dimensioni
FitAuto: esegue un ridimensionamento calcolando in automatico le dimensioni dell'immagine risultante all'interno del contenitore. L'immagine di output avrà le dimensioni specificate per il contenitore.
NoFit: non adegua il ridimensionamento al contenitore. Esegue il ridimensionamento sull'immagine in base alle dimensioni specificate, effettuando un taglio dell'immagine qualora questa superi le dimensioni del contenitore. L'immagine di output avrà le dimensioni specificate per il contenitore. E' possibile gestire la modalità di taglio con le strutture seguenti:

 
public enum Position
{
    TopLeft,
    TopCenter,
    TopRight,
    MiddleLeft,
    MiddleCenter,
    MiddleRight,
    BottomLeft,
    BottomCenter,
    BottomRight,
    Undefined
}

private int _offsetX;
private int _offsetY;
private Position _drawingPosition;

public int OffsetX
{
    get { return _offsetX; }
    set { _offsetX = value; }
}
public int OffsetY
{
    get { return _offsetY; }
    set { _offsetY = value; }
}
public Position DrawingPosition {
    get { return _drawingPosition; }
    set { _drawingPosition = value; }
}

A queste modalità operative si aggiunge il controllo sul ridimensionamento proporzionale, come si vedrà in seguito.

 
private Color _backgroundColor;
private int _alpha;

public Color BackgroundColor
{
    get { return _backgroundColor; }
    set { _backgroundColor = value; }
}
public int Alpha
{
    get { return _alpha; }
    set { _alpha = value; }
}

private SolidBrush GetBackground()
{
    int alphaCheck = 255;
    if (_alpha < 0)
        alphaCheck = 0;
    else if (_alpha > 255)
        alphaCheck = 255;
    else
        alphaCheck = _alpha;
    return new SolidBrush(Color.FromArgb(alphaCheck, _backgroundColor));
}

Vediamo ora come utilizzare il metodo DrawImage, come suggerito in msdn.

 
public Image Resize(Image image)
{
    // Temp variables
    int newContainerWidth = _containerWidth;
    int newContainerHeight = _containerHeight;
    int newImageWidth = _imageWidth;
    int newImageHeight = _imageHeight;
    int newPositionX = 0;
    int newPositionY = 0;

    GetNewSizes(image, ref newContainerWidth, ref newContainerHeight, ref newImageWidth, ref newImageHeight);
    GetPositions(ref newPositionX, ref newPositionY, newContainerWidth, newContainerHeight, newImageWidth, newImageHeight);

    Bitmap retObj = new Bitmap(newContainerWidth, newContainerHeight);
    retObj.SetResolution(_horizontalResolution, _verticalResolution);

    Graphics g = Graphics.FromImage(retObj);
    g.CompositingMode = _compositingMode;
    g.CompositingQuality = _compositingQuality;
    g.SmoothingMode = _smoothing;
    g.InterpolationMode = _interpolation;
    
    g.FillRectangle(GetBackground(), 0f, 0f, newContainerWidth, newContainerHeight);
    g.DrawImage(image, newPositionX + _offsetX, newPositionY + _offsetY, newImageWidth, newImageHeight);
    g.Dispose();
    return (Image)retObj;
}

private void GetProportionalSizes(Image image, ref int imageWidth, ref int imageHeight)
{
    bool exceedWidth = image.Width > imageWidth ? true : false;
    bool exceedHeight = image.Height > imageHeight ? true : false;

    if (exceedWidth & exceedHeight)
    {
        int horizontalSurplus = image.Width - _imageWidth;
        int verticalSurplus = image.Height - _imageHeight;

        if (horizontalSurplus > verticalSurplus)
        {
            imageWidth = _imageWidth;
            imageHeight = imageWidth * image.Height / image.Width;
        }
        else
        {
            imageHeight = _imageHeight;
            imageWidth = imageHeight * image.Width / image.Height;
        }
    }
    else
    {
        if (exceedWidth)
        {
            imageWidth = _imageWidth;
            imageHeight = imageWidth * image.Height / image.Width;
        }
        else
        {
            imageHeight = _imageHeight;
            imageWidth = imageHeight * image.Width / image.Height;
        }
    }
}

 private void CheckContainerSizes(ref int imageWidth, ref int imageHeight)
{
    bool exceedWidth = imageWidth > _containerWidth ? true : false;
    bool exceedHeight = imageHeight > _containerHeight ? true : false;

    if (exceedWidth & exceedHeight)
    {
        int horizontalSurplus = imageWidth - _containerWidth;
        int verticalSurplus = imageHeight - _containerHeight;

        if (horizontalSurplus > verticalSurplus)
        {
            imageWidth = _containerWidth;
            imageHeight = imageWidth * _containerHeight / _containerWidth;
        }
        else
        {
            imageHeight = _containerHeight;
            imageWidth = imageHeight * _containerWidth / _containerHeight;
        }
    }
    else
    {
        if (exceedWidth)
        {
            imageWidth = _containerWidth;
            imageHeight = imageWidth * _containerHeight / _containerWidth;
        }
        else
        {
            imageHeight = _containerHeight;
            imageWidth = imageHeight * _containerWidth / _containerHeight;
        }
    }

    // Change required size for auto fit
    _imageWidth = imageWidth;
    _imageHeight = imageHeight;
}

public void Save(Image image, ImageFormat format, string outputFile)
{
    if (format == ImageFormat.Jpeg)
    {
        ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
        EncoderParameters encoderParams = new EncoderParameters(1);
        encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, _jpegCompression);
        image.Save(outputFile, info[1], encoderParams);
    }
    else
    {
        image.Save(outputFile, format);
    }
}

Tra i vari membri presenti, opportunamente mappati su proprietà, ne spiccano cinque che consentono di avere un controllo dell'output piuttosto avanzato:

private InterpolationMode _interpolation;
private CompositingMode _compositingMode;
private CompositingQuality _compositingQuality;
private SmoothingMode _smoothing;
private PixelOffsetMode _pixelOffsetMode;

public InterpolationMode Interpolation
{
    get { return _interpolation; }
    set { _interpolation = value; }
}
public CompositingMode CompositingMode
{
    get { return _compositingMode; }
    set { _compositingMode = value; }
}
public CompositingQuality CompositingQuality
{
    get { return _compositingQuality; }
    set { _compositingQuality = value; }
}
public SmoothingMode Smoothing
{
    get { return _smoothing; }
    set { _smoothing = value; }
}
public PixelOffsetMode PixelOffset
{
    get { return _pixelOffsetMode; }
    set { _pixelOffsetMode = value; }
}

InterpolationMode

L'InterpolationMode è, in questo contesto, di importanza vitale. Specifica infatti 'algoritmo utilizzato quando le immagini vengono scalate o ruotate. Questi le possibili scelte:

Default: Specifica la modalità predefinita.
Low: Specifica un'interpolazione di bassa qualità.
High: Specifica un'interpolazione di elevata qualità.
Bilinear: Specifica l'interpolazione bilineare. Non viene effettuata alcuna operazione di prefiltraggio. Questa modalità non è adatta per la compattazione di un'immagine al di sotto del 50% delle dimensioni originali.
Bicubic: Specifica l'interpolazione bicubica. Non viene effettuata alcuna operazione di prefiltraggio. Questa modalità non è adatta per la compattazione di un'immagine al di sotto del 25% delle dimensioni originali.
NearestNeighbor: Specifica l'interpolazione più simile.
HighQualityBilinear: Specifica l'interpolazione bilineare di elevata qualità. Viene effettuata un'operazione di prefiltraggio per assicurare una compattazione di elevata qualità.
HighQualityBicubic: Specifica l'interpolazione bicubica di elevata qualità. Viene effettuata un'operazione di prefiltraggio per assicurare una compattazione di elevata qualità. Questa modalità produce le immagini trasformate di qualità più elevata.

CompositingMode

Il CompositingMode specifica il modo in cui i colori di origine vengono combinati con i colori dello sfondo. E' possibile assegnare uno dei due valori:

SourceOver: quando viene eseguito il rendering di un colore, tale colore viene miscelato con il colore dello sfondo. La miscela di colori viene determinata dal componente alpha del colore di cui viene eseguito il rendering.
SourceCopy: quando viene eseguito il rendering di un colore, tale colore sovrascrive il colore dello sfondo.

CompositingQuality

La CompositingQuality specifica il livello di qualità da utilizzare durante la composizione. Questi sono i valori ammissibili:

Default: qualità predefinita.
HighSpeed: alta velocità, bassa qualità.
HighQuality: composizione di elevata qualità e ridotta velocità.
GammaCorrected: viene utilizzata la correzione gamma.
AssumeLinear: vengono assunti i valori lineari.

SmoothingMode

Lo SmoothingMode specifica se e come viene applicato l'anti-aliasing. Anche i questo caso abbiamo una serie di valori ammissibili:

Default: Specifica l'assenza di antialias.
HighSpeed: Specifica l'assenza di antialias.
HighQuality: Specifica il rendering con antialias.
None: Specifica l'assenza di antialias.
AntiAlias: Specifica il rendering con antialias.

PixelOffsetMode

Il PixelOffsetMode specifica la modalità di offset dei pixel durante l'esecuzione del rendering, in modo da controllare la qualità del rendering finale. Questi i valori ammissibili:

Default: Specifica la modalità predefinita.
HighSpeed: Specifica un rendering di elevata velocità e ridotta qualità.
HighQuality: Specifica un rendering di elevata qualità e ridotta velocità.
None: Specifica l'assenza di offset di pixel.
Half: Specifica l'offset dei pixel in base a unità - .5, sia in senso orizzontale che verticale, per ottenere un anti-aliasing di elevata velocità.

g.FillRectangle(GetBackground(), 0f, 0f, newContainerWidth, newContainerHeight);
g.DrawImage(image, newPositionX + _offsetX, newPositionY + _offsetY, newImageWidth, newImageHeight);

Il codice sorgente

 
#region Using directives
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
#endregion

namespace DotNetCampania.Imager
{
    public class ImageProcessor
    {
        #region Enums
        public enum ScaleMode
        {
            FitContainer,
            FitImage,
            FitAuto,
            NoFit
        }

        public enum Position
        {
            TopLeft,
            TopCenter,
            TopRight,
            MiddleLeft,
            MiddleCenter,
            MiddleRight,
            BottomLeft,
            BottomCenter,
            BottomRight,
            Undefined
        }
        #endregion

        #region Members
        private int _imageWidth;
        private int _imageHeight;
        private int _containerWidth;
        private int _containerHeight;
        private ScaleMode _scale;
        private Position _drawingPosition;
        private bool _proportional;
        private InterpolationMode _interpolation;
        private CompositingMode _compositingMode;
        private CompositingQuality _compositingQuality;
        private SmoothingMode _smoothing;
        private PixelOffsetMode _pixelOffsetMode;
        private Color _backgroundColor;
        private int _alpha;

        private int _offsetX;
        private int _offsetY;

        private ImageFormat _outputImageFormat;
        private long _jpegCompression;
        private float _horizontalResolution;
        private float _verticalResolution;
        #endregion

        #region Properties
        public int Width
        {
            get { return _imageWidth; }
            set { _imageWidth = value; }
        }
        public int Height
        {
            get { return _imageHeight; }
            set { _imageHeight = value; }
        }
        public int ContainerWidth
        {
            get { return _containerWidth; }
            set { _containerWidth = value; }
        }
        public int ContainerHeight
        {
            get { return _containerHeight; }
            set { _containerHeight = value; }
        }
        public Position DrawingPosition
        {
            get { return _drawingPosition; }
            set { _drawingPosition = value; }
        }
        public bool Proportional
        {
            get { return _proportional; }
            set { _proportional = value; }
        }
        public InterpolationMode Interpolation
        {
            get { return _interpolation; }
            set { _interpolation = value; }
        }
        public CompositingMode CompositingMode
        {
            get { return _compositingMode; }
            set { _compositingMode = value; }
        }
        public CompositingQuality CompositingQuality
        {
            get { return _compositingQuality; }
            set { _compositingQuality = value; }
        }
        public SmoothingMode Smoothing
        {
            get { return _smoothing; }
            set { _smoothing = value; }
        }
        public PixelOffsetMode PixelOffset
        {
            get { return _pixelOffsetMode; }
            set { _pixelOffsetMode = value; }
        }
        public Color BackgroundColor
        {
            get { return _backgroundColor; }
            set { _backgroundColor = value; }
        }
        public int Alpha
        {
            get { return _alpha; }
            set { _alpha = value; }
        }
        public int OffsetX
        {
            get { return _offsetX; }
            set { _offsetX = value; }
        }
        public int OffsetY
        {
            get { return _offsetY; }
            set { _offsetY = value; }
        }
        public ImageFormat OutputImageFormat
        {
            get { return this._outputImageFormat; }
            set { _outputImageFormat = value; }
        }
        public long JPEGCompression
        {
            get { return _jpegCompression; }
            set { _jpegCompression = value; }
        }
        public float HorizontalResolution
        {
            get { return _horizontalResolution; }
            set { _horizontalResolution = value; }
        }
        public float VerticalResolution
        {
            get { return _verticalResolution; }
            set { _verticalResolution = value; }
        }
        public ScaleMode Scale
        {
            get { return _scale; }
            set { _scale = value; }
        }
        #endregion

        #region Constructor(s)
        public ImageProcessor()
        {
            _imageWidth = default(int);
            _imageHeight = default(int);
            _containerWidth = default(int);
            _containerHeight = default(int);
            _drawingPosition = Position.Undefined;
            _interpolation = InterpolationMode.HighQualityBicubic;
            _compositingMode = CompositingMode.SourceOver;
            _compositingQuality = CompositingQuality.HighQuality;
            _smoothing = SmoothingMode.HighQuality;
            _pixelOffsetMode = PixelOffsetMode.HighQuality;

            _proportional = true;
            _alpha = 255;
            _backgroundColor = Color.White;

            _offsetX = 0;
            _offsetY = 0;
            _scale = ScaleMode.FitAuto;

            _outputImageFormat = ImageFormat.Jpeg;
            _jpegCompression = 80L;
            _horizontalResolution = 72f;
            _verticalResolution = 72f;
        }
        #endregion

        #region Public methods
        public Image Resize(Image image)
        {
            // Temp variables
            int newContainerWidth = _containerWidth;
            int newContainerHeight = _containerHeight;
            int newImageWidth = _imageWidth;
            int newImageHeight = _imageHeight;
            int newPositionX = 0;
            int newPositionY = 0;

            GetNewSizes(image, ref newContainerWidth, ref newContainerHeight, ref newImageWidth, ref newImageHeight);
            GetPositions(ref newPositionX, ref newPositionY, newContainerWidth, newContainerHeight, newImageWidth, newImageHeight);

            Bitmap retObj = new Bitmap(newContainerWidth, newContainerHeight);
            retObj.SetResolution(_horizontalResolution, _verticalResolution);

            Graphics g = Graphics.FromImage(retObj);
            g.CompositingMode = _compositingMode;
            g.CompositingQuality = _compositingQuality;
            g.SmoothingMode = _smoothing;
            g.InterpolationMode = _interpolation;
            g.PixelOffsetMode = _pixelOffsetMode;
            
            g.FillRectangle(GetBackground(), 0f, 0f, newContainerWidth, newContainerHeight);
            g.DrawImage(image, newPositionX + _offsetX, newPositionY + _offsetY, newImageWidth, newImageHeight);
            g.Dispose();
            return (Image)retObj;
        }

        public void Save(Image image, ImageFormat format, string outputFile)
        {
            if (format == ImageFormat.Jpeg)
            {
                ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
                EncoderParameters encoderParams = new EncoderParameters(1);
                encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, _jpegCompression);
                image.Save(outputFile, info[1], encoderParams);
            }
            else
            {
                image.Save(outputFile, format);
            }
        }
        #endregion

        #region Private support methods
        private void GetNewSizes(Image image, ref int containerWidth, ref int containerHeight, ref int imageWidth, ref int imageHeight)
        {
            switch (_scale)
            {
                case ScaleMode.NoFit:
                    if (_proportional)
                    {
                        GetProportionalSizes(image, ref  imageWidth, ref  imageHeight);
                    }
                    break;
                case ScaleMode.FitAuto:
                    CheckContainerSizes(ref imageWidth, ref imageHeight); 
                    if (_proportional)
                        GetProportionalSizes(image, ref  imageWidth, ref  imageHeight);
                    break;
                case ScaleMode.FitContainer:
                    imageWidth = containerWidth;
                    imageHeight = containerHeight;
                    break;
                case ScaleMode.FitImage:
                    if (_proportional)
                        GetProportionalSizes(image, ref  imageWidth, ref  imageHeight);
                    containerWidth = imageWidth;
                    containerHeight = imageHeight;
                    break;
            }
        }

        private void GetPositions(ref int positionX, ref int positionY, int containerWidth, int containerHeight, int imageWidth, int imageHeight) {
            switch (_drawingPosition) {
                case Position.BottomCenter:
                    positionX = (int)((containerWidth / 2) - (imageWidth / 2));                    
                    positionY = containerHeight - imageHeight;
                    break;
                case Position.BottomLeft: 
                    positionX = 0;
                    positionY = containerHeight - imageHeight;
                    break;
                case Position.BottomRight: 
                    positionX = containerWidth - imageWidth;
                    positionY = containerHeight - imageHeight;
                    break;
                case Position.MiddleCenter: 
                    positionX = (int)((containerWidth / 2) - (imageWidth / 2));
                    positionY = (int)((containerHeight / 2) - (imageHeight / 2));
                    break;
                case Position.MiddleLeft:
                    positionX = 0;
                    positionY = (int)((containerHeight / 2) - (imageHeight / 2));
                    break;
                case Position.MiddleRight: 
                    positionX = containerWidth - imageWidth;
                    positionY = (int)((containerHeight / 2) - (imageHeight / 2));
                    break;
                case Position.TopCenter: 
                    positionX = (int)((containerWidth / 2) - (imageWidth / 2));
                    positionY = 0;
                    break;
                case Position.TopLeft:
                    positionX = 0;
                    positionY = 0;
                    break;
                case Position.TopRight: 
                    positionX = containerWidth - imageWidth;
                    positionY = 0;
                    break;
            }
        }

        private void CheckContainerSizes(ref int imageWidth, ref int imageHeight)
        {
            bool exceedWidth = imageWidth > _containerWidth ? true : false;
            bool exceedHeight = imageHeight > _containerHeight ? true : false;

            if (exceedWidth & exceedHeight)
            {
                int horizontalSurplus = imageWidth - _containerWidth;
                int verticalSurplus = imageHeight - _containerHeight;

                if (horizontalSurplus > verticalSurplus)
                {
                    imageWidth = _containerWidth;
                    imageHeight = imageWidth * _containerHeight / _containerWidth;
                }
                else
                {
                    imageHeight = _containerHeight;
                    imageWidth = imageHeight * _containerWidth / _containerHeight;
                }
            }
            else
            {
                if (exceedWidth)
                {
                    imageWidth = _containerWidth;
                    imageHeight = imageWidth * _containerHeight / _containerWidth;
                }
                else
                {
                    imageHeight = _containerHeight;
                    imageWidth = imageHeight * _containerWidth / _containerHeight;
                }
            }

            // Change required size for auto fit
            _imageWidth = imageWidth;
            _imageHeight = imageHeight;
        }

        private void GetProportionalSizes(Image image, ref int imageWidth, ref int imageHeight)
        {
            bool exceedWidth = image.Width > imageWidth ? true : false;
            bool exceedHeight = image.Height > imageHeight ? true : false;

            if (exceedWidth & exceedHeight)
            {
                int horizontalSurplus = image.Width - _imageWidth;
                int verticalSurplus = image.Height - _imageHeight;

                if (horizontalSurplus > verticalSurplus)
                {
                    imageWidth = _imageWidth;
                    imageHeight = imageWidth * image.Height / image.Width;
                }
                else
                {
                    imageHeight = _imageHeight;
                    imageWidth = imageHeight * image.Width / image.Height;
                }
            }
            else
            {
                if (exceedWidth)
                {
                    imageWidth = _imageWidth;
                    imageHeight = imageWidth * image.Height / image.Width;
                }
                else
                {
                    imageHeight = _imageHeight;
                    imageWidth = imageHeight * image.Width / image.Height;
                }
            }
        }

        private SolidBrush GetBackground()
        {
            int alphaCheck = 255;
            if (_alpha < 0)
                alphaCheck = 0;
            else if (_alpha > 255)
                alphaCheck = 255;
            else
                alphaCheck = _alpha;
            return new SolidBrush(Color.FromArgb(alphaCheck, _backgroundColor));
        }
        #endregion
    }
}

Download

Riferimenti

Riferimento a .NET Framework - Metodo Image.GetThumbnailImage [http://msdn.microsoft.com/it-it/library/system.drawing.image.getthumbnailimage.aspx]
Graphics.FillRectangle Method (Brush, Rectangle) [http://msdn.microsoft.com/en-us/library/yysstebh.aspx
Metodo Graphics.DrawImage (Image, Int32, Int32, Int32, Int32) [http://msdn.microsoft.com/it-it/library/dbsak4dc(v=VS.80).aspx]

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 20:05:05 GMT

Current revision posted to Articoli by ilNero on 08/04/2010 22:05:05

CSS e Javascript minification con ASP.NET

Chiunque abbia a che fare con la programmazione web si sarà reso conto che l'utilizzo dei CSS, così come l'utilizzo di framework javascript come jQuery, sia ormai praticamente uno standard de-facto.
Per quanto riguarda i framework Javascript, questi vengono rilasciati costantemente sia in versione 'sources' che in versione 'minified', lasciando però la scelta del minifier da utilizzare esclusivamente ai creatori/mantainer del framework.
Purtroppo ho la smania di tenere costantemente tutto sotto controllo, ragion per cui negli ultimi mesi ho cominciato a studiare i vari software che operano la minification.
Sul web se ne trovano diversi:

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

Dopo diversi test e diverse rilasci in produzione di fogli di stile e codice javascript minimizzato con questo tool, posso affermare di non aver mai riscontrato incompatibilità o problemi di sorta.
L'unico grande difetto di questo tool è il suo essere un tool da riga di comando, il che si traduce in una serie di step da eseguire in pre-produzione.
Se da un lato, le modifiche a queste tipologie di file, sono rare, una volta raggiunta la fase di rilascio, è pur vero che piccole migliorie vengono sempre apportate dopo il rilascio di una applicazione web.
Stanco quindi di aprire frequentemente il prompt dei comandi, ho cercato una soluzione da inglobare direttamente nei progetti web, che riuscisse a minimizzare on-the-fly i CSS e i JS.

Animato dall'esigenza e dalla scoperta di questo porting per .NET YUI Compresso for .NET, ho buttato giù questo semplice HttpHandler, capace di riconoscere le richieste giuste e rispondere con la versione minimizzata del file richiesto.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

L'handler va ovviamente mappato nel web.config. Devo però fornire una doverosa annotazione: nel mio caso ho mappato le estensioni *.js.axd e *.css.axd. Questa scelta mi obbliga a dover fare attenzione nelle pagine .aspx o .html che creo, in quanto i riferimenti ai fogli di stile ed ai file javascript devono finire con questa estensione per essere processati. In un contesto di hosting condiviso (leggi Aruba), dove non ho possibilità di intervento sulle estensioni mappate in IIS, questa mi sembrava la scelta migliore. In contesti di maggior libertà di mapping delle estensioni in IIS, sarebbe bastato mappare le estensioni .css e .js sull'engine di ASP.NET, e mappare le stesse estensioni sull'handler.

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 20:04:27 GMT

Revision 9 posted to Articoli by ilNero on 08/04/2010 22:04:27

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 20:02:31 GMT

Revision 8 posted to Articoli by ilNero on 08/04/2010 22:02:31

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 19:56:44 GMT

Revision 7 posted to Articoli by ilNero on 08/04/2010 21:56:44

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 18:35:09 GMT

Revision 6 posted to Articoli by ilNero on 08/04/2010 20:35:09

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi , mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 11:03:02 GMT

Revision 5 posted to Articoli by ilNero on 08/04/2010 13:03:02

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 11:02:08 GMT

Revision 4 posted to Articoli by ilNero on 08/04/2010 13:02:08

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 11:01:46 GMT

Revision 3 posted to Articoli by ilNero on 08/04/2010 13:01:46

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 10:57:56 GMT

Revision 2 posted to Articoli by ilNero on 08/04/2010 12:57:56

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 10:57:01 GMT

Revision 1 posted to Articoli by ilNero on 08/04/2010 12:57:01

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

        using System;
        using System.Collections.Generic;
        using System.IO;
        using System.Linq;
        using System.Text;
        using System.Web;
        using Yahoo.Yui.Compressor;

        namespace DotNetCampania.Web.Handlers
        {
            public class YUICompressor : IHttpHandler
            {
                private const int DEFAULT_CACHE_DURATION = 1440;
                private bool useCache = true;
                private bool noCompression = false;

                public bool IsReusable { get { return true; } }
                
                public void ProcessRequest(HttpContext context)
                {
                    bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
                    bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
                    context.Response.ContentType = "text/plain";
                    string filePath = GetFilePath();
                    string fileExtension = Path.GetExtension(filePath);
                    if (File.Exists(filePath))
                    {
                        context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
                        switch (fileExtension)
                        {
                            case ".css":
                                context.Response.ContentType = "text/css";
                                if (!this.noCompression) 
                                    CompressCSS(filePath);
                                else
                                    HttpContext.Current.Response.WriteFile(filePath);
                                break;
                            case ".js" :
                                context.Response.ContentType = "application/x-javascript";
                                if (!this.noCompression)
                                    CompressJavaScript(filePath);
                                else
                                    HttpContext.Current.Response.WriteFile(filePath);
                                break;
                            default :
                                context.Response.StatusCode = 404;
                                break;
                        }
                    }
                    else
                    {
                        context.Response.StatusCode = 404;
                    }
                    context.Response.Flush();
                    context.Response.End();
                }
                
                private string GetFilePath()
                {
                    string filePath = HttpContext.Current.Request.Url.AbsolutePath;
                    filePath = filePath.TrimEnd(".axd".ToCharArray());
                    filePath = HttpContext.Current.Server.MapPath(filePath);
                    return filePath;
                }

                private void CompressCSS(string filePath)
                {
                    if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
                    {
                        HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
                        return;
                    }
                    object fileLock = new object();
                    lock (fileLock)
                    {
                        StreamReader sr = new StreamReader(filePath, true);
                        string compressed = CssCompressor.Compress(sr.ReadToEnd());
                        HttpContext.Current.Response.Write(compressed);
                        if (this.useCache)
                            HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
                        sr.Close();
                    }
                }

                private void CompressJavaScript(string filePath)
                {
                    if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
                    {
                        HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
                        return;
                    }
                    object fileLock = new object();
                    lock (fileLock)
                    {
                        StreamReader sr = new StreamReader(filePath, true);
                        string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
                        HttpContext.Current.Response.Write(compressed);
                        if (this.useCache)
                            HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
                        sr.Close();
                    }
                }
            }
        }

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

Progetto GeRi – Parte 3

Alessandro Forte — Wed, 07 Apr 2010 18:53:50 GMT

Current revision posted to Articoli by Alessandro Forte on 07/04/2010 20:53:50

Il terzo articolo di questa miniserie sullo sviluppo di un applicativo “enterprise” verterà sull’architettura dell’applicativo.

The Architecture – L’Architettura
GeRi è una piattaforma software che nasce con lo scopo di gestire tutte le attività, dirette e indirette, connesse ad una centro assistenza.
Analizziamo di seguito alcune scelte di tipo architetturale, prima di passare direttamente alla fase di design dell’applicativo.

SOA - Service Oriented Application.
Come è stato evidenziato nei precedenti articoli, la nostra piattaforma deve essere in grado di “agganciarsi” a servizi di fornitori esterni per espletare alcune operazioni.
Un esempio su tutti è la necessità di inviare messaggi SMS.
Ma oltre ad usufruire di servizi esterni, la nostra piattaforma deve essere anche in grado di erogare servizi, acquisendo e garantendo quindi un certo grado di flessibilità con il mondo dell’integrazione.
Erogare/esporre servizi, significa anche permettere facilmente a sistemi esterni (magari realizzati con linguaggi e tecnologie differenti) in prima istanza di dialogare con il nostro sistema, e in seconda istanza di implementare moduli di integrazione con la nostra piattaforma.
Ad esempio non è da ritenersi rara la possibilità di “integrazione” del nostro sistema con sistemi di fatturazione di terze parti.
Per questo motivo ritengo valido scegliere un’architettura di tipo SOA ovvero “Orientata ai Servizi”.

Architectural View
Avendo ben chiaro il contesto architetturale nel quale intendiamo realizzare la nostra applicazione, analizziamo di seguito alcune scelte su come organizzare l’architettura dell’applicativo.

L’applicazione sarà organizzata secondo una classica architettura di tipo N-Tier.
Ma cos’è un applicazione N-Tier?
Una architettura di tipo N-Tier indica una particolare architettura software che prevede la suddivisione del sistema in N diversi livelli (logici e fisici) che svolgono funzionalità diverse (opzionalmente su nodi diversi della rete).
Ad esempio esiste il livello per la gestione dell’interfaccia utente (UI Layer), quello per la logica funzionale (Business Layer) e quello per la gestione della persistenza dei dati (Data Access Layer).
In questo modo, ciascuno degli N livelli può essere modificato o sostituito indipendentemente dagli altri.
Nella maggior parte dei casi, si intende anche che i diversi livelli siano distribuiti su diversi nodi di una rete anche eterogenea.
Questo è alla base della distinzione tra Layer e Tier.

Un Layer indica un raggruppamento logico delle funzionalità
Un Tier indica un raggruppamento fisico delle funzionalità

Un esempio tipico di architettura N-Tier, dove N=3, detta appunto three-tier prevede, per esempio:

un Tier di presentazione identificato da un PC dedicato all'interfaccia utente grafica (su cui persiste quindi il layer di presentazione o UI Layer)
un Tier di Business Logic indentificato da una workstation o un application server per l’esecuzione di business logic
un Tier di Database indentificato da un database server o un mainframe per la gestione dei dati.

In merito alla nostra applicazione avremo quindi i seguenti Layers :

Data Access Layer (da ora in poi DAL) è il livello di interazione con la base di dati, dove si effettuano le connessioni e si eseguono query di selezione, inserimento, aggiornamento o cancellazione.
Business Layer (da ora in poi BL) è il livello che ha la responsabilità di gestire le richieste utente ricevute attraverso l’Uil o SL, di effettuare il routing di queste richieste agli appropriati elementi di business, di processare i risultati dell'elaborazione e ritornare i dati necessari all’Uil o SL per la successiva presentazione all'utente.
Service Layer (da ora in poi SL) è il livello che svolge la funzione di “collante” tra il BL e l’UiL ed è caratterizzato da un numero di servizi che espongono al “mondo esterno” le funzionalità business.
User Interface Layer (da ora in poi UiL) è il livello che si occupa della presentazione e della logica di interazione con l'utente, interagendo con il BL per l'accesso ai servizi richiesti.

Organizzati nei seguenti Tiers :

Database Tier, ovvero il livello fisico su cui deployeremo il nostro Database.
Application Server Tier, ovvero il livello fisico su cui deployeremo il BL e il SL.
Presentation Tier, ovvero il livello fisico su cui deployeremo l’interfaccia grafica della nostra applicazione.

Ritengo concluso il terzo articolo della serie, che è servito a delineare l’aspetto architetturale su cui si fonda la soluzione da implementare.
Scopo del prossimo articolo sarà quello di “creare gli use cases” e quindi "disegnare il nostro Core".
Non mi resta quindi che finire con il classico :
See u in the next episode

(Fonte : Alessandro Forte - http://www.alessandroforte.it/)

Starting on Windows Mobile

Liccardi Antonio — Tue, 16 Feb 2010 10:37:01 GMT

Current revision posted to Articoli by Liccardi Antonio on 16/02/2010 11:37:01

Starting on Windows Mobile

Inserito sotto: windows mobile guida tutorial articoli

Si può dire con tutta certezza che ormai le vacanze sono finite. Nonostante la notte immagini ancora il sapore in bocca degli arancini al ragù, penso sia arrivato il momento di rimboccarsi le maniche e ricominciare con gli articoli dedicati al mondo di Windows Mobile.

Nelle prossime settimane pubblicherò 15 articoli che tratteranno l’argomento, con l’intento di finire questa prima panoramica orientativamente con l’inizio del 2010. Nel corso di questi articoli saranno affrontate tematiche basilari, proprie del .Net Compact Framework, ma anche argomenti abbastanza avanzati, come la persistenza dei dati, le P/Invoke, la localizzazione, la sicurezza e la gestione delle eccezioni, Gesture API. Non mi resta che darvi un elenco degli articoli (suscettibile a variazioni):

I fondamenti del .Net Compact Framework
Sviluppo di una semplice applicazione
GUI
Persistenza dei dati con SqlServer Compact Edition
Memorizzazione dei file
GUI
Applicazioni Client/Server e HttpRequest
P/Invoke
Gestione delle eccezioni
Gestione della sicurezza
Globalizzazione e Localizzazione
.Net Compact Framework Graphics
Le novità di Windows Mobile 6.5
Strumenti utili allo sviluppatore di applicazioni mobile
Widget
Gesture API

Non ho ancora deciso la modalità di pubblicazione degli articoli. Sicuramente per quelli in cui c’è molta teoria, creerò degli articoli di testo. Per quelli invece in cui occorre vedere da vicino codice e configurazione, penso che il webcast sia più adatto.

Non mi resta che dirvi di restare sintonizzati!

Enjoy it && keep coding!

Starting on Windows Mobile

Liccardi Antonio — Tue, 05 Jan 2010 23:55:00 GMT

Revision 5 posted to Articoli by Liccardi Antonio on 06/01/2010 00:55:00

Starting on Windows Mobile

Inserito sotto: windows mobile guida tutorial articoli

I fondamenti del .Net Compact Framework
Sviluppo di una semplice applicazione
Persistenza dei dati con SqlServer Compact Edition
Memorizzazione dei file
GUI
Applicazioni Client/Server e HttpRequest
P/Invoke
Gestione delle eccezioni
Gestione della sicurezza
Globalizzazione e Localizzazione
.Net Compact Framework Graphics
Le novità di Windows Mobile 6.5
Strumenti utili allo sviluppatore di applicazioni mobile
Widget
Gesture API

Non mi resta che dirvi di restare sintonizzati!

Enjoy it && keep coding!

Starting on Windows Mobile

Liccardi Antonio — Mon, 14 Sep 2009 20:42:35 GMT

Revision 4 posted to Articoli by Liccardi Antonio on 14/09/2009 22:42:35

Starting on Windows Mobile

Inserito sotto: windows mobile guida tutorial articoli

[[articoli:I

I fondamenti del .Net Compact Framework|http://dotnetcampania.org/wikis/articoli/i-fondamenti-del-net-compact-framework.aspx]]Framework

Sviluppo di una semplice applicazione

Persistenza dei dati con SqlServer Compact Edition

Memorizzazione dei file

GUI

Applicazioni Client/Server e HttpRequest

P/Invoke

Gestione delle eccezioni

Gestione della sicurezza

Globalizzazione e Localizzazione

.Net Compact Framework Graphics

Le novità di Windows Mobile 6.5

Strumenti utili allo sviluppatore di applicazioni mobile

Widget

Gesture API

Non ho ancora deciso la modalità di pubblicazione degli articoli. Sicuramente per quelli in cui c’è molta teoria, creerò degli articoli di testo. Per quelli invece in cui occorre vedere da vicino codice e configurazione, penso che il webcast sia più adatto.

Non mi resta che dirvi di restare sintonizzati!

Enjoy it && keep coding!

Starting on Windows Mobile

Liccardi Antonio — Mon, 14 Sep 2009 20:41:46 GMT
Revision 3 posted to Articoli by Liccardi Antonio on 14/09/2009 22:41:46

Starting on Windows Mobile

Inserito sotto: windows mobile guida tutorial articoli

Si può dire con tutta certezza che ormai le vacanze sono finite. Nonostante la notte immagini ancora il sapore in bocca degli arancini al ragù, penso sia arrivato il momento di rimboccarsi le maniche e ricominciare con gli articoli dedicati al mondo di Windows Mobile.

Nelle prossime settimane pubblicherò 15 articoli che tratteranno l’argomento, con l’intento di finire questa prima panoramica orientativamente con l’inizio del 2010. Nel corso di questi articoli saranno affrontate tematiche basilari, proprie del .Net Compact Framework, ma anche argomenti abbastanza avanzati, come la persistenza dei dati, le P/Invoke, la localizzazione, la sicurezza e la gestione delle eccezioni, Gesture API. Non mi resta che darvi un elenco degli articoli (suscettibile a variazioni):

I

[[articoli:I fondamenti del .Net Compact FrameworkFramework|http://dotnetcampania.org/wikis/articoli/i-fondamenti-del-net-compact-framework.aspx]]

Sviluppo di una semplice applicazione

Persistenza dei dati con SqlServer Compact Edition

Memorizzazione dei file

GUI

Applicazioni Client/Server e HttpRequest

P/Invoke

Gestione delle eccezioni

Gestione della sicurezza

Globalizzazione e Localizzazione

.Net Compact Framework Graphics

Le novità di Windows Mobile 6.5

Strumenti utili allo sviluppatore di applicazioni mobile

Widget

Gesture API

Non ho ancora deciso la modalità di pubblicazione degli articoli. Sicuramente per quelli in cui c’è molta teoria, creerò degli articoli di testo. Per quelli invece in cui occorre vedere da vicino codice e configurazione, penso che il webcast sia più adatto.

Non mi resta che dirvi di restare sintonizzati!

Enjoy it && keep coding!

Starting on Windows Mobile

Liccardi Antonio — Wed, 02 Sep 2009 08:33:48 GMT
Revision 2 posted to Articoli by Liccardi Antonio on 02/09/2009 10:33:48

Starting on Windows Mobile

Inserito sotto: windows mobile guida tutorial articoli

Si può dire con tutta certezza che ormai le vacanze sono finite. Nonostante la notte immagini ancora il sapore in bocca degli arancini al ragù, penso sia arrivato il momento di rimboccarsi le maniche e ricominciare con gli articoli dedicati al mondo di Windows Mobile.

Nelle prossime settimane pubblicherò 15 articoli che tratteranno l’argomento, con l’intento di finire questa prima panoramica orientativamente con l’inizio del 2010. Nel corso di questi articoli saranno affrontate tematiche basilari, proprie del .Net Compact Framework, ma anche argomenti abbastanza avanzati, come la persistenza dei dati, le P/Invoke, la localizzazione, la sicurezza e la gestione delle eccezioni, Gesture API. Non mi resta che darvi un elenco degli articoli (suscettibile a variazioni):

I fondamenti del .Net Compact Framework

Sviluppo di una semplice applicazione

Persistenza dei dati con SqlServer Compact Edition

Memorizzazione dei file

GUI

Applicazioni Client/Server e Http RequestHttpRequest

P/Invoke

Gestione delle eccezioni

Gestione della sicurezza

Globalizzazione e Localizzazione

.Net Compact Framework Graphics

Le novità di Windows Mobile 6.5

Strumenti utili allo sviluppatore di applicazioni mobile

Widget

Gesture API

Non ho ancora deciso la modalità di pubblicazione degli articoli. Sicuramente per quelli in cui c’è molta teoria, creerò degli articoli di testo. Per quelli invece in cui occorre vedere da vicino codice e configurazione, penso che il webcast sia più adatto.

Non mi resta che dirvi di restare sintonizzati!

Enjoy it && keep coding!

Starting on Windows Mobile

Liccardi Antonio — Tue, 01 Sep 2009 16:57:33 GMT
Revision 1 posted to Articoli by Liccardi Antonio on 01/09/2009 18:57:33

Si può dire con tutta certezza che ormai le vacanze sono finite. Nonostante la notte immagini ancora il sapore in bocca degli arancini al ragù, penso sia arrivato il momento di rimboccarsi le maniche e ricominciare con gli articoli dedicati al mondo di Windows Mobile.

Nelle prossime settimane pubblicherò 15 articoli che tratteranno l’argomento, con l’intento di finire questa prima panoramica orientativamente con l’inizio del 2010. Nel corso di questi articoli saranno affrontate tematiche basilari, proprie del .Net Compact Framework, ma anche argomenti abbastanza avanzati, come la persistenza dei dati, le P/Invoke, la localizzazione, la sicurezza e la gestione delle eccezioni. Non mi resta che darvi un elenco degli articoli (suscettibile a variazioni):

I fondamenti del .Net Compact Framework

Sviluppo di una semplice applicazione

Persistenza dei dati con SqlServer Compact Edition

Memorizzazione dei file

GUI

Applicazioni Client/Server e Http Request

P/Invoke

Gestione delle eccezioni

Gestione della sicurezza

Globalizzazione e Localizzazione

.Net Compact Framework Graphics

Le novità di Windows Mobile 6.5

Strumenti utili allo sviluppatore di applicazioni mobile

Widget

Gesture API

Non ho ancora deciso la modalità di pubblicazione degli articoli. Sicuramente per quelli in cui c’è molta teoria, creerò degli articoli di testo. Per quelli invece in cui occorre vedere da vicino codice e configurazione, penso che il webcast sia più adatto.

Non mi resta che dirvi di restare sintonizzati!

Enjoy it && keep coding!

Sviluppo di una semplice applicazione

Liccardi Antonio — Wed, 06 Jan 2010 11:21:51 GMT
Current revision posted to Articoli by Liccardi Antonio on 06/01/2010 12:21:51

Sviluppo di una semplice applicazione

Inserito sotto: windows mobile first app

Qualche mese fa ho postato un webcast in cui illustravo come realizzare una semplice applicazione per Windows Mobile.

L’intento di questo articolo è quello di approfondire ciò che si è detto nel webcast.

Gli strumenti

Ciò che ci occorre è una copia di Visual Studio 2005 standard o maggiore (le versioni express non sono supportate!), a cui si dovranno aggiungere le installazioni dei relativi SDK per Windows Mobile. Oltre a questo deve essere poi installato sulla macchina l’Active Sync o maggiore.

L’installazione di Visual Studio consente di installare anche una serie di tools (come i .net Remote Tools) che aiutano gli sviluppatori nel testare le proprie applicazioni.

Non si può fare a meno di citare anche gli emulatori che non solo aiutano il testing delle applicazioni su diverse tipologie di device (ma anche di OS), ma consentono gli sviluppatori di avere un valido strumento di supporto nello sviluppo (es. gli emulatori consentono di ricreare determinate situazioni tipo una chiamata, la ricezione di un sms…).

Mi pare giusto a questo punto lasciare un pò di link:

- Visual Studio;

- Windows Mobile 6.0 SDK / Windows Mobile 6.5 DTK;

- ActiveSync 4.5 / Centro gestione dispositivi Windows Mobile 6.1 per Vista;

La prima applicazione

Creare una nuova applicazione per dispositivi Windows Mobile con Visual Studio è davvero semplice. Una volta aperto l’IDE basta fare click su Nuovo –> Progetto, e scegliere tra le varie tipologie Smart Device e poi selezionare la tipologia di progetto che si vuole creare, nel nostro caso Applicazione Dispositivo:

Dopo che Visual Studio ha creato tutta la struttura del progetto ci troviamo davanti (a seconda della disposizione degli elementi dell’IDE) la seguente schermata:

Vediamo in particolare la struttura del progetto creato dal Visual Studio:

Abbiamo una serie di file/cartelle create in automatico. Da notare in primis c’è il Program.cs che rappresenta il l’entry-point principale dell’applicazione. Aprendo il file notiamo del codice che consente di far partire l’applicazione:

Naturalmente se decidiamo di cambiare il nome del form principale dobbiamo agire nell’unica riga di codice presente nel Main().

Oltre al file Program.cs abbiamo un form predefinito, Form1.cs, che rappresenta la nostra prima schermata dell’applicazione. In tale form abbiamo la possibilità di trascinare controlli, ed abbiamo anche un MainMenu da impostare per la nostra applicazione.

Altri elementi predefiniti del progetto sono la cartella Riferimenti, che come in altre tipologie di progetto, rappresenta la cartella di “reference” alle librerie del .Net Framework, e la cartella Properties, che include un file di risorse e l’AssemblyInfo.cs, che serve per definire informazioni riguardante l’assembly generato dall’applicazione.

A questo punto non ci resta che aggiungere qualche controllo al nostro form e scrivere anche qualche riga di codice nella parte di code-behind relativa ai controlli che abbiamo aggiunto e premere F5 per testarla.

Testing e debugging dell’applicazione

Testare la propria applicazione per dispositivi mobile è come testare una semplice applicazione Web: basta premere F5 e attendere che Visual Studio setti l’ambiente di esecuzione. Unica differenza è però la scelta della piattaforma di destinazione. Uno sviluppatore può scegliere la tipologia di dispositivo in cui l’applicazione verrà deployata e verificare la corretta esecuzione della stessa. In questo ambito uno sviluppatore può scegliere se usare gli emulatori installati sulla macchina di sviluppo o se testare l’applicazione direttamente sul dispositivo fisico. In quest’ultimo caso, Visual Studio effettuerà una copia dell’applicazione nel dispositivo fisico e dopo eseguirà l’applicazione stessa.

Anche per il debugging la situazione resta la stessa. Si hanno a disposizione i ben noti breakpoint, che gli sviluppatori possono sistemare nei punti critici dell’applicazione per verificarne il corretto funzionamento.

Packaging e deploying dell’applicazione

Una volta terminato lo sviluppo della propria applicazione, si può procedere con la creazione di un pacchetto di installazione della stessa. I pacchetti di installazione di software per dispositivi Windows Mobile vengono chiamati CAB (il nome deriva da cabinet e portano l’estensione .cab). I file CAB non sono altri degli archivi eseguibili, che possono contenere al loro interno tutti i file correlati alla nostra applicazione (es.: dll, file di risorse, dipendenze…).

Creare un CAB è semplice. Basta aggiungere alla propria soluzione un nuovo progetto, e selezionare nella finestra che si apre, la sezione ‘Installazione e distribuzione’ sotto la voce ‘Altri tipi di progetto’. Nel riquadro sulla destra compaiono diverse tipologie di progetto disponibili, e tra quelle presenti occorre selezionare ‘Progetto Cab per Smart Device’.

Una volta aggiunto il progetto, vi comparirà la seguente schermata, in cui è necessario aggiungere i file relativi alla vostra applicazione.

In questa schermata occorre selezionare la Cartella Applicazione e dopo aver cliccato con il pulsante destro, vi si aprirà un menù contestuale in cui dovrete selezionare le voci: Aggiungi –> Output Progetto.

Vi si aprirà la seguente schermata:

dove occorrerà selezionare Output Primario per aggiungere l’output della nostra applicazione al pacchetto di installazione. Oltre all’output primario, possono essere aggiunti diversi file al CAB, come file di dipendenze, chiavi di registro, file di risorse, collegamenti ai menù di avvio. La modalità resta sempre la stessa (ovvero Aggiungi –> …).

Fatto questo, occorrerà compilare la soluzione e nella cartella relativa alla stessa, sarà presente una nuova cartella relativa al file CAB e, in base alla configurazione di compilazione utizzata (debug/release), sarà presente una sottocartella che conterrà 3 files:

1)Un file CAB (la nostra applicazione : ) );

2)Un file INF (che contiene informazioni riguardanti la cartella di destinazione e i requisiti di sistema per eseguire l’applicazione);

3)Un file di log (che contiene informazioni relative alla procedura di packaging).

Per incrementare la fiducia degli utenti nei confronti della nostra applicazione, è anche possibile firmare il proprio CAB con un certificato rilasciato da un ente appropriato.

A questo punto non resta che trasferire la nostra applicazione al dispositivo! Enjoy it!

it's all about development...

Sviluppo di una semplice applicazione

Liccardi Antonio — Tue, 05 Jan 2010 23:53:51 GMT
Revision 4 posted to Articoli by Liccardi Antonio on 06/01/2010 00:53:51

Sviluppo di una semplice applicazione

Inserito sotto: windows mobile first app

Qualche mese fa ho postato un webcast in cui illustravo come realizzare una semplice applicazione per Windows Mobile.

L’intento di questo articolo è quello di approfondire ciò che si è detto nel webcast.

Gli strumenti

Ciò che ci occorre è una copia di Visual Studio 2005 standard o maggiore (le versioni express non sono supportate!), a cui si dovranno aggiungere le installazioni dei relativi SDK per Windows Mobile. Oltre a questo deve essere poi installato sulla macchina l’Active Sync o maggiore.

L’installazione di Visual Studio consente di installare anche una serie di tools (come i .net Remote Tools) che aiutano gli sviluppatori nel testare le proprie applicazioni.

Non si può fare a meno di citare anche gli emulatori che non solo aiutano il testing delle applicazioni su diverse tipologie di device (ma anche di OS), ma consentono gli sviluppatori di avere un valido strumento di supporto nello sviluppo (es. gli emulatori consentono di ricreare determinate situazioni tipo una chiamata, la ricezione di un sms…).

Mi pare giusto a questo punto lasciare un pò di link:

- Visual Studio;

- Windows Mobile 6.0 SDK / Windows Mobile 6.5 DTK;

- ActiveSync 4.5 / Centro gestione dispositivi Windows Mobile 6.1 per Vista;

La prima applicazione

Creare una nuova applicazione per dispositivi Windows Mobile con Visual Studio è davvero semplice. Una volta aperto l’IDE basta fare click su Nuovo –> Progetto, e scegliere tra le varie tipologie Smart Device e poi selezionare la tipologia di progetto che si vuole creare, nel nostro caso Applicazione Dispositivo:

Dopo che Visual Studio ha creato tutta la struttura del progetto ci troviamo davanti (a seconda della disposizione degli elementi dell’IDE) la seguente schermata:

Vediamo in particolare la struttura del progetto creato dal Visual Studio:

Abbiamo una serie di file/cartelle create in automatico. Da notare in primis c’è il Program.cs che rappresenta il l’entry-point principale dell’applicazione. Aprendo il file notiamo del codice che consente di far partire l’applicazione:

Naturalmente se decidiamo di cambiare il nome del form principale dobbiamo agire nell’unica riga di codice presente nel Main().

Oltre al file Program.cs abbiamo un form predefinito, Form1.cs, che rappresenta la nostra prima schermata dell’applicazione. In tale form abbiamo la possibilità di trascinare controlli, ed abbiamo anche un MainMenu da impostare per la nostra applicazione.

Altri elementi predefiniti del progetto sono la cartella Riferimenti, che come in altre tipologie di progetto, rappresenta la cartella di “reference” alle librerie del .Net Framework, e la cartella Properties, che include un file di risorse e l’AssemblyInfo.cs, che serve per definire informazioni riguardante l’assembly generato dall’applicazione.

A questo punto non ci resta che aggiungere qualche controllo al nostro form e scrivere anche qualche riga di codice nella parte di code-behind relativa ai controlli che abbiamo aggiunto e premere F5 per testarla.

Testing e debugging dell’applicazione

Testare la propria applicazione per dispositivi mobile è come testare una semplice applicazione Web: basta premere F5 e attendere che Visual Studio setti l’ambiente di esecuzione. Unica differenza è però la scelta della piattaforma di destinazione. Uno sviluppatore può scegliere la tipologia di dispositivo in cui l’applicazione verrà deployata e verificare la corretta esecuzione della stessa. In questo ambito uno sviluppatore può scegliere se usare gli emulatori installati sulla macchina di sviluppo o se testare l’applicazione direttamente sul dispositivo fisico. In quest’ultimo caso, Visual Studio effettuerà una copia dell’applicazione nel dispositivo fisico e dopo eseguirà l’applicazione stessa.

Anche per il debugging la situazione resta la stessa. Si hanno a disposizione i ben noti breakpoint, che gli sviluppatori possono sistemare nei punti critici dell’applicazione per verificarne il corretto funzionamento.

Packaging e deploying dell’applicazione

Una volta terminato lo sviluppo della propria applicazione, si può procedere con la creazione di un pacchetto di installazione della stessa. I pacchetti di installazione di software per dispositivi Windows Mobile vengono chiamati CAB (il nome deriva da cabinet e portano l’estensione .cab). I file CAB non sono altri degli archivi eseguibili, che possono contenere al loro interno tutti i file correlati alla nostra applicazione (es.: dll, file di risorse, dipendenze…).

Creare un CAB è semplice. Basta aggiungere alla propria soluzione un nuovo progetto, e selezionare nella finestra che si apre, la sezione ‘Installazione e distribuzione’ sotto la voce ‘Altri tipi di progetto’. Nel riquadro sulla destra compaiono diverse tipologie di progetto disponibili, e tra quelle presenti occorre selezionare ‘Progetto Cab per Smart Device’.

Una volta aggiunto il progetto, vi comparirà la seguente schermata, in cui è necessario aggiungere i file relativi alla vostra applicazione.

In questa schermata occorre selezionare la Cartella Applicazione e dopo aver cliccato con il pulsante destro, vi si aprirà un menù contestuale in cui dovrete selezionare le voci: Aggiungi –> Output Progetto.

Vi si aprirà la seguente schermata:

dove occorrerà selezionare Output Primario per aggiungere l’output della nostra applicazione al pacchetto di installazione. Oltre all’output primario, possono essere aggiunti diversi file al CAB, come file di dipendenze, chiavi di registro, file di risorse, collegamenti ai menù di avvio. La modalità resta sempre la stessa (ovvero Aggiungi –> …).

Fatto questo, occorrerà compilare la soluzione e nella cartella relativa alla stessa, sarà presente una nuova cartella relativa al file CAB e, in base alla configurazione di compilazione utizzata (debug/release), sarà presente una sottocartella che conterrà 3 files:

1)Un file CAB (la nostra applicazione : ) );

2)Un file INF (che contiene informazioni riguardanti la cartella di destinazione e i requisiti di sistema per eseguire l’applicazione);

3)Un file di log (che contiene informazioni relative alla procedura di packaging).

Per incrementare la fiducia degli utenti nei confronti della nostra applicazione, è anche possibile firmare il proprio CAB con un certificato rilasciato da un ente appropriato.

A questo punto non resta che trasferire la nostra applicazione al dispositivo! Enjoy it!

it's all about development...

Sviluppo di una semplice applicazione

Liccardi Antonio — Tue, 05 Jan 2010 23:53:05 GMT
Revision 3 posted to Articoli by Liccardi Antonio on 06/01/2010 00:53:05

Sviluppo di una semplice applicazione

Inserito sotto: windows mobile first app

Qualche mese fa ho postato un webcast in cui illustravo come realizzare una semplice applicazione per Windows Mobile.

L’intento di questo articolo è quello di approfondire ciò che si è detto nel webcast.

Gli strumenti

Ciò che ci occorre è una copia di Visual Studio 2005 standard o maggiore (le versioni express non sono supportate!), a cui si dovranno aggiungere le installazioni dei relativi SDK per Windows Mobile. Oltre a questo deve essere poi installato sulla macchina l’Active Sync o maggiore.

L’installazione di Visual Studio consente di installare anche una serie di tools (come i .net Remote Tools) che aiutano gli sviluppatori nel testare le proprie applicazioni.

Non si può fare a meno di citare anche gli emulatori che non solo aiutano il testing delle applicazioni su diverse tipologie di device (ma anche di OS), ma consentono gli sviluppatori di avere un valido strumento di supporto nello sviluppo (es. gli emulatori consentono di ricreare determinate situazioni tipo una chiamata, la ricezione di un sms…).

Mi pare giusto a questo punto lasciare un pò di link:

- Visual Studio;

- Windows Mobile 6.0 SDK / Windows Mobile 6.5 DTK;

- ActiveSync 4.5 / Centro gestione dispositivi Windows Mobile 6.1 per Vista;

La prima applicazione

Creare una nuova applicazione per dispositivi Windows Mobile con Visual Studio è davvero semplice. Una volta aperto l’IDE basta fare click su Nuovo –> Progetto, e scegliere tra le varie tipologie Smart Device e poi selezionare la tipologia di progetto che si vuole creare, nel nostro caso Applicazione Dispositivo:

Dopo che Visual Studio ha creato tutta la struttura del progetto ci troviamo davanti (a seconda della disposizione degli elementi dell’IDE) la seguente schermata:

Vediamo in particolare la struttura del progetto creato dal Visual Studio:

Abbiamo una serie di file/cartelle create in automatico. Da notare in primis c’è il Program.cs che rappresenta il l’entry-point principale dell’applicazione. Aprendo il file notiamo del codice che consente di far partire l’applicazione:

Naturalmente se decidiamo di cambiare il nome del form principale dobbiamo agire nell’unica riga di codice presente nel Main().

Oltre al file Program.cs abbiamo un form predefinito, Form1.cs, che rappresenta la nostra prima schermata dell’applicazione. In tale form abbiamo la possibilità di trascinare controlli, ed abbiamo anche un MainMenu da impostare per la nostra applicazione.

Altri elementi predefiniti del progetto sono la cartella Riferimenti, che come in altre tipologie di progetto, rappresenta la cartella di “reference” alle librerie del .Net Framework, e la cartella Properties, che include un file di risorse e l’AssemblyInfo.cs, che serve per definire informazioni riguardante l’assembly generato dall’applicazione.

A questo punto non ci resta che aggiungere qualche controllo al nostro form e scrivere anche qualche riga di codice nella parte di code-behind relativa ai controlli che abbiamo aggiunto e premere F5 per testarla.

Testing e debugging dell’applicazione

Testare la propria applicazione per dispositivi mobile è come testare una semplice applicazione Web: basta premere F5 e attendere che Visual Studio setti l’ambiente di esecuzione. Unica differenza è però la scelta della piattaforma di destinazione. Uno sviluppatore può scegliere la tipologia di dispositivo in cui l’applicazione verrà deployata e verificare la corretta esecuzione della stessa. In questo ambito uno sviluppatore può scegliere se usare gli emulatori installati sulla macchina di sviluppo o se testare l’applicazione direttamente sul dispositivo fisico. In quest’ultimo caso, Visual Studio effettuerà una copia dell’applicazione nel dispositivo fisico e dopo eseguirà l’applicazione stessa.

Anche per il debugging la situazione resta la stessa. Si hanno a disposizione i ben noti breakpoint, che gli sviluppatori possono sistemare nei punti critici dell’applicazione per verificarne il corretto funzionamento.

Packaging e deploying dell’applicazione

Una volta terminato lo sviluppo della propria applicazione, si può procedere con la creazione di un pacchetto di installazione della stessa. I pacchetti di installazione di software per dispositivi Windows Mobile vengono chiamati CAB (il nome deriva da cabinet e porta portano l’estensione .cab). I file CAB non sono altri degli archivi eseguibili, che possono contenere al loro interno tutti i file correlati alla nostra applicazione (es.: dll, file di risorse, dipendenze…).

Creare un CAB è semplice. Basta aggiungere alla propria soluzione un nuovo progetto, e selezionare nella finestra che si apre, la sezione ‘Installazione e distribuzione’ sotto la voce ‘Altri tipi di progetto’. Nel riquadro sulla destra compaiono diverse tipologie di progetto disponibili, e tra quelle presenti occorre selezionare ‘Progetto Cab per Smart Device’.

Una volta aggiunto il progetto, vi comparirà la seguente schermata, in cui è necessario aggiungere i file relativi alla vostra applicazione.

In questa schermata occorre selezionare la Cartella Applicazione e dopo aver cliccato con il pulsante destro, vi si aprirà un menù contestuale in cui dovrete selezionare le voci: Aggiungi –> Output Progetto.

Vi si aprirà la seguente schermata:

dove occorrerà selezionare Output Primario per aggiungere l’output della nostra applicazione al pacchetto di installazione. Oltre all’output primario, possono essere aggiunti diversi file al CAB, come file di dipendenze, chiavi di registro, file di risorse, collegamenti ai menù di avvio. La modalità resta sempre la stessa (ovvero Aggiungi –> …).

Fatto questo, occorrerà compilare la soluzione e nella cartella relativa alla stessa, sarà presente una nuova cartella relativa al file CAB e, in base alla configurazione di compilazione utizzata (debug/release), sarà presente una sottocartella che conterrà 3 files:

1)Un file CAB (la nostra applicazione : ) );

2)Un file INF (che contiene informazioni riguardanti la cartella di destinazione e i requisiti di sistema per eseguire l’applicazione);

3)Un file di log (che contiene informazioni relative alla procedura di packaging).

Per incrementare la fiducia degli utenti nei confronti della nostra applicazione, è anche possibile firmare il proprio CAB con un certificato rilasciato da un ente appropriato.

A questo punto non resta che trasferire la nostra applicazione al dispositivo! Enjoy it!

Sviluppo di una semplice applicazione

Liccardi Antonio — Tue, 05 Jan 2010 23:46:55 GMT
Revision 2 posted to Articoli by Liccardi Antonio on 06/01/2010 00:46:55

Sviluppo di una semplice applicazione

Inserito sotto: windows mobile first app

Qualche mese fa ho postato un webcast in cui illustravo come realizzare una semplice applicazione per Windows Mobile.

[WEBCAST]

L’intento

L’intento di questo articolo è è quello di approfondire ciò ciò che si è è detto nel webcast.

Gli strumenti

Ciò
Ciò che ci occorre è è una copia di Visual Studio 2005 standard o maggiore (le versioni express non sono supportate!), a cui si dovranno aggiungere le installazioni dei relativi SDK per Windows Mobile. Oltre a questo deve essere poi installato sulla macchina l’Active l’Active Sync o maggiore.

L’installazione

L’installazione di Visual Studio consente di installare anche una serie di tools (come i .net Remote Tools) che aiutano gli sviluppatori nel testare le proprie applicazioni.

Non si può può fare a meno di citare anche gli emulatori che non solo aiutano il testing delle applicazioni su diverse tipologie di device (ma anche di OS), ma consentono gli sviluppatori di avere un valido strumento di supporto nello sviluppo (es. gli emulatori consentono di ricreare determinate situazioni tipo una chiamata, la ricezione di un sms…).sms…).

Mi pare giusto a questo punto lasciare un pò pò di link:

- Visual Studio;

- Windows Mobile 6.0 SDK / Windows Mobile 6.5 DTK;

- ActiveSync 4.5 / Centro gestione dispositivi Windows Mobile 6.1 per Vista;

La prima applicazione

Creare una nuova applicazione per dispositivi Windows Mobile con Visual Studio è è davvero semplice. Una volta aperto l’IDE l’IDE basta fare click su Nuovo –> –> Progetto, e scegliere tra le varie tipologie Smart Device e poi selezionare la tipologia di progetto che si vuole creare, nel nostro caso Applicazione Dispositivo:

Dopo che Visual Studio ha creato tutta la struttura del progetto ci troviamo davanti (a seconda della disposizione degli elementi dell’IDE) dell’IDE) la seguente schermata:

Vediamo in particolare la struttura del progetto creato dal Visual Studio:

Abbiamo una serie di file/cartelle create in automatico. Da notare in primis c’è c’è il Program.cs che rappresenta il l’entry-point l’entry-point principale dell’applicazione. dell’applicazione. Aprendo il file notiamo del codice che consente di far partire l’applicazione:

l’applicazione:

Naturalmente se decidiamo di cambiare il nome del form principale dobbiamo agire nell’unica nell’unica riga di codice presente nel Main().

Oltre al file Program.cs abbiamo un form predefinito, Form1.cs, che rappresenta la nostra prima schermata dell’applicazione. dell’applicazione. In tale form abbiamo la possibilità possibilità di trascinare controlli, ed abbiamo anche un MainMenu da impostare per la nostra applicazione.

Altri elementi predefiniti del progetto sono la cartella Riferimenti, che come in altre tipologie di progetto, rappresenta la cartella di “reference” “reference” alle librerie del .Net Framework, e la cartella Properties, che include un file di risorse e l’AssemblyInfo.cs, l’AssemblyInfo.cs, che serve per definire informazioni riguardante l’assembly l’assembly generato dall’applicazione.dall’applicazione.

A questo punto non ci resta che aggiungere qualche controllo al nostro form e scrivere anche qualche riga di codice nella parte di code-behind relativa ai controlli che abbiamo aggiunto e premere F5 per testarla.

Testing e debugging dell’applicazionedell’applicazione

Testare la propria applicazione per dispositivi mobile è è come testare una semplice applicazione Web: basta premere F5 e attendere che Visual Studio setti l’ambiente l’ambiente di esecuzione. Unica differenza è però è però la scelta della piattaforma di destinazione. Uno sviluppatore può può scegliere la tipologia di dispositivo in cui l’applicazione verrà l’applicazione verrà deployata e verificare la corretta esecuzione della stessa. In questo ambito uno sviluppatore può può scegliere se usare gli emulatori installati sulla macchina di sviluppo o se testare l’applicazione l’applicazione direttamente sul dispositivo fisico. In quest’ultimo quest’ultimo caso, Visual Studio effettuerà effettuerà una copia dell’applicazione dell’applicazione nel dispositivo fisico e dopo eseguirà l’applicazione eseguirà l’applicazione stessa.

Anche per il debugging la situazione resta la stessa. Si hanno a disposizione i ben noti breakpoint, che gli sviluppatori possono sistemare nei punti critici dell’applicazione dell’applicazione per verificarne il corretto funzionamento.

Packaging e deploying dell’applicazionedell’applicazione

Una volta terminato lo sviluppo della propria applicazione, si può può procedere con la creazione di un pacchetto di installazione della stessa. I pacchetti di installazione di software per dispositivi Windows Mobile vengono chiamati CAB (il nome deriva da cabinet e porta l’estensione l’estensione .cab). I file CAB non sono altri degli archivi eseguibili, che possono contenere al loro interno tutti i file correlati alla nostra applicazione (es.: dll, file di risorse, dipendenze…).dipendenze…).

Creare un CAB è è semplice. Basta aggiungere alla propria soluzione un nuovo progetto, e selezionare nella finestra che si apre, la sezione ‘Installazione ‘Installazione e distribuzione’ ’ sotto la voce ‘Altri ‘Altri tipi di progetto’. progetto’. Nel riquadro sulla destra compaiono diverse tipologie di progetto disponibili, e tra quelle presenti occorre selezionare ‘Progetto ‘Progetto Cab per Smart Device’.Device’.

Una volta aggiunto il progetto, vi comparirà comparirà la seguente schermata, in cui è è necessario aggiungere i file relativi alla vostra applicazione.

In questa schermata occorre selezionare la Cartella Applicazione e dopo aver cliccato con il pulsante destro, vi si aprirà aprirà un menù menù contestuale in cui dovrete selezionare le voci: Aggiungi –> –> Output Progetto.

Vi si aprirà aprirà la seguente schermata:

dove occorrerà occorrerà selezionare Output Primario per aggiungere l’output l’output della nostra applicazione al pacchetto di installazione. Oltre all’output all’output primario, possono essere aggiunti diversi file al CAB, come file di dipendenze, chiavi di registro, file di risorse, collegamenti ai menù menù di avvio. La modalità modalità resta sempre la stessa (ovvero Aggiungi –> …). –> …).

Fatto questo, occorrerà occorrerà compilare la soluzione e nella cartella relativa alla stessa, sarà sarà presente una nuova cartella relativa al file CAB e, in base alla configurazione di compilazione utizzata (debug/release), sarà sarà presente una sottocartella che conterrà conterrà 3 files:

1)Un file CAB (la nostra applicazione : ) );

2)Un file INF (che contiene informazioni riguardanti la cartella di destinazione e i requisiti di sistema per eseguire l’applicazione);l’applicazione);

3)Un file di log (che contiene informazioni relative alla procedura di packaging).

Per incrementare la fiducia degli utenti nei confronti della nostra applicazione, è è anche possibile firmare il proprio CAB con un certificato rilasciato da un ente appropriato.

A questo punto non resta che trasferire la nostra applicazione al dispositivo! Enjoy it!

Sviluppo di una semplice applicazione

Liccardi Antonio — Tue, 05 Jan 2010 23:29:50 GMT
Revision 1 posted to Articoli by Liccardi Antonio on 06/01/2010 00:29:50

Qualche mese fa ho postato un webcast in cui illustravo come realizzare una semplice applicazione per Windows Mobile.

[WEBCAST]

L’intento di questo articolo è quello di approfondire ciò che si è detto nel webcast.

Gli strumenti

Ciò che ci occorre è una copia di Visual Studio 2005 standard o maggiore (le versioni express non sono supportate!), a cui si dovranno aggiungere le installazioni dei relativi SDK per Windows Mobile. Oltre a questo deve essere poi installato sulla macchina l’Active Sync o maggiore.

L’installazione di Visual Studio consente di installare anche una serie di tools (come i .net Remote Tools) che aiutano gli sviluppatori nel testare le proprie applicazioni.

Non si può fare a meno di citare anche gli emulatori che non solo aiutano il testing delle applicazioni su diverse tipologie di device (ma anche di OS), ma consentono gli sviluppatori di avere un valido strumento di supporto nello sviluppo (es. gli emulatori consentono di ricreare determinate situazioni tipo una chiamata, la ricezione di un sms…).

Mi pare giusto a questo punto lasciare un pò di link:

- Visual Studio;

- Windows Mobile 6.0 SDK / Windows Mobile 6.5 DTK;

- ActiveSync 4.5 / Centro gestione dispositivi Windows Mobile 6.1 per Vista;

La prima applicazione

Creare una nuova applicazione per dispositivi Windows Mobile con Visual Studio è davvero semplice. Una volta aperto l’IDE basta fare click su Nuovo –> Progetto, e scegliere tra le varie tipologie Smart Device e poi selezionare la tipologia di progetto che si vuole creare, nel nostro caso Applicazione Dispositivo:

Dopo che Visual Studio ha creato tutta la struttura del progetto ci troviamo davanti (a seconda della disposizione degli elementi dell’IDE) la seguente schermata:

Vediamo in particolare la struttura del progetto creato dal Visual Studio:

Abbiamo una serie di file/cartelle create in automatico. Da notare in primis c’è il Program.cs che rappresenta il l’entry-point principale dell’applicazione. Aprendo il file notiamo del codice che consente di far partire l’applicazione:

Naturalmente se decidiamo di cambiare il nome del form principale dobbiamo agire nell’unica riga di codice presente nel Main().

Oltre al file Program.cs abbiamo un form predefinito, Form1.cs, che rappresenta la nostra prima schermata dell’applicazione. In tale form abbiamo la possibilità di trascinare controlli, ed abbiamo anche un MainMenu da impostare per la nostra applicazione.

Altri elementi predefiniti del progetto sono la cartella Riferimenti, che come in altre tipologie di progetto, rappresenta la cartella di “reference” alle librerie del .Net Framework, e la cartella Properties, che include un file di risorse e l’AssemblyInfo.cs, che serve per definire informazioni riguardante l’assembly generato dall’applicazione.

A questo punto non ci resta che aggiungere qualche controllo al nostro form e scrivere anche qualche riga di codice nella parte di code-behind relativa ai controlli che abbiamo aggiunto e premere F5 per testarla.

Testing e debugging dell’applicazione

Testare la propria applicazione per dispositivi mobile è come testare una semplice applicazione Web: basta premere F5 e attendere che Visual Studio setti l’ambiente di esecuzione. Unica differenza è però la scelta della piattaforma di destinazione. Uno sviluppatore può scegliere la tipologia di dispositivo in cui l’applicazione verrà deployata e verificare la corretta esecuzione della stessa. In questo ambito uno sviluppatore può scegliere se usare gli emulatori installati sulla macchina di sviluppo o se testare l’applicazione direttamente sul dispositivo fisico. In quest’ultimo caso, Visual Studio effettuerà una copia dell’applicazione nel dispositivo fisico e dopo eseguirà l’applicazione stessa.

Anche per il debugging la situazione resta la stessa. Si hanno a disposizione i ben noti breakpoint, che gli sviluppatori possono sistemare nei punti critici dell’applicazione per verificarne il corretto funzionamento.

Packaging e deploying dell’applicazione

Una volta terminato lo sviluppo della propria applicazione, si può procedere con la creazione di un pacchetto di installazione della stessa. I pacchetti di installazione di software per dispositivi Windows Mobile vengono chiamati CAB (il nome deriva da cabinet e porta l’estensione .cab). I file CAB non sono altri degli archivi eseguibili, che possono contenere al loro interno tutti i file correlati alla nostra applicazione (es.: dll, file di risorse, dipendenze…).

Creare un CAB è semplice. Basta aggiungere alla propria soluzione un nuovo progetto, e selezionare nella finestra che si apre, la sezione ‘Installazione e distribuzione’ sotto la voce ‘Altri tipi di progetto’. Nel riquadro sulla destra compaiono diverse tipologie di progetto disponibili, e tra quelle presenti occorre selezionare ‘Progetto Cab per Smart Device’.

Una volta aggiunto il progetto, vi comparirà la seguente schermata, in cui è necessario aggiungere i file relativi alla vostra applicazione.

In questa schermata occorre selezionare la Cartella Applicazione e dopo aver cliccato con il pulsante destro, vi si aprirà un menù contestuale in cui dovrete selezionare le voci: Aggiungi –> Output Progetto.

Vi si aprirà la seguente schermata:

dove occorrerà selezionare Output Primario per aggiungere l’output della nostra applicazione al pacchetto di installazione. Oltre all’output primario, possono essere aggiunti diversi file al CAB, come file di dipendenze, chiavi di registro, file di risorse, collegamenti ai menù di avvio. La modalità resta sempre la stessa (ovvero Aggiungi –> …).

Fatto questo, occorrerà compilare la soluzione e nella cartella relativa alla stessa, sarà presente una nuova cartella relativa al file CAB e, in base alla configurazione di compilazione utizzata (debug/release), sarà presente una sottocartella che conterrà 3 files:

1)Un file CAB (la nostra applicazione : ) );

2)Un file INF (che contiene informazioni riguardanti la cartella di destinazione e i requisiti di sistema per eseguire l’applicazione);

3)Un file di log (che contiene informazioni relative alla procedura di packaging).

Per incrementare la fiducia degli utenti nei confronti della nostra applicazione, è anche possibile firmare il proprio CAB con un certificato rilasciato da un ente appropriato.

A questo punto non resta che trasferire la nostra applicazione al dispositivo! Enjoy it!

Progetto GeRi - Parte 2

Alessandro Forte — Sun, 13 Dec 2009 22:16:10 GMT
Current revision posted to Articoli by Alessandro Forte on 13/12/2009 23:16:10

Progetto GeRi - Parte 2

Inserito sotto: Architettura, Progetto GeRi

Il secondo articolo di questa miniserie sullo sviluppo di un applicativo “enterprise” verterà sulla descrizione del problema da risolvere.

The Problem – Il Problema
GeRi è una piattaforma software che nasce con lo scopo di gestire tutte le attività, dirette e indirette, connesse ad una centro assistenza.
In generale possiamo dire che il punto focale e primario di un centro assistenza (e di molte altre attività, come in seguito approfondiremo), verte sul concetto di Riparazione.
Possiamo sicuramente definire una riparazione come un processo.
In quanto tale essa è caratterizzata da più fasi, e da diversi attori che prendono parte al processo. Addentriamoci quindi nel merito della descrizione delle fasi e degli attori che costituiscono il processo di riparazione.

La prima fase del nostro processo di riparazione è denominata : Ingresso.
In questa fase un Utente, possessore dell’oggetto da riparare, consegna il suddetto presso il centro di riparazione.
Nell’operazione di ingresso, l’Operatore deputato all’ingresso degli oggetti da riparare, prende in consegna l’oggetto da riparare compilando un’apposita Scheda di Ingresso.
Tale Scheda prevede l’inserimento di diverse informazioni, di seguito elencate :

Anagrafica cliente (Inserimento o recupero di un’anagrafica già esistente)

Data di ingresso dell’oggetto

Dati di acquisto dell’oggetto nel caso in cui l’oggetto fosse in garanzia
(incluse Tipo Documento Acquisto, Numero, Data)

Descrizione caratteristiche dell’oggetto
(incluse Tipologia, Marca, Modello, Numero Serie Primario e Secondario)

Descrizione degli eventuali accessori consegnati con l’oggetto

Descrizione dello stato generale dell’oggetto

Descrizione preliminare del malfunzionamento

Descrizione di eventuali non conformità

Locazione dell’oggetto

Eventuale acquisizione di un immagine dell’oggetto

Definizione dell’eventuale “muletto” e/o apparecchio di cortesia consegnato al cliente

mentre contempla la generazione da parte del sistema delle seguenti informazioni :

Codice riparazione (nella duplice modalità Testo/BarCode)

Operatore assegnato alla riparazione
(L’assegnazione avviene per associazione diretta o tramite un apposito algoritmo)

Cambiamento dello stato della riparazione

Clausole contrattuali/legali legate alla riparazione

La fase di ingresso si conclude con la stampa della Scheda di Ingresso da consegnare al cliente come ricevuta.
Tale ricevuta dovrà successivamente essere presentata dall'utente per il ritiro dell'oggetto.

La seconda fase del nostro processo di riparazione è denominata : Riparazione.
In questa fase un Tecnico, figura deputata alla riparazione dell’oggetto da riparare, prende in consegna l’oggetto (con la relativa scheda di ingresso) e comincia l’analisi della riparazione da effettuare.
Nell’operazione di riparazione, il Tecnico deputato alla riparazione dell’oggetto da riparare, esegue le necessarie operazioni di analisi e riparazioni sull’oggetto e al termine dell’intervento compila un’apposita Scheda di Intervento.
Tale Scheda prevede l’inserimento di diverse informazioni, di seguito elencate :

Descrizione della riparazione

Definizione dei costi della riparazione
(inclusi Costo Sostenuto [ricami + manodopera], Costo Riparazione)

Descrizione di eventuali committenti e/o centri esterni di riparazione

mentre contempla la generazione da parte del sistema delle seguenti informazioni :

Cambiamento dello stato della riparazione

Data di riparazione dell’oggetto

Notifica a mezzo SMS dell'avvenuta riparazione

La fase di riparazione può “momentaneamente” interrompersi in virtù delle seguenti situazioni :

Attesa di ricambi

Presentazione di un Preventivo, previa riparazione dell’oggetto

La fase di riparazione si conclude con la redazione, da parte del Tecnico, della Scheda di Intervento che descrive l’elenco delle operazioni effettuate.
Idealmente tale documento dovrebbe essere storato all'interno di un DMS - Document Management System, o "allegato" alla riparazione stessa. Tale funzionalità sarà oggetto di discussione nelle future implementazioni.

La terza ed ultima fase del nostro processo di riparazione è denominata : Riconsegna.
In questa fase l'Utente, proprietario dell’oggetto da riparare, passa a ritirare il suddetto presso il centro di riparazione.
Nell’operazione di riconsegna, l’Operatore deputato alla riconsegna degli oggetti da riparare, restituisce l’oggetto riparato stampando e consegnando al cliente l’apposita Scheda di Ingresso.
Tale Scheda non prevede l’inserimento di alcuna informazione ma contempla la generazione da parte del sistema delle seguenti informazioni :

Cambiamento dello stato della riparazione

Data di riconsegna dell’oggetto

La fase di riconsegna si conclude con la stampa della Scheda di Riconsegna da consegnare al cliente come ricevuta.

Queste operazioni concludono quello che abbiamo definito come processo di riparazione.
Risulta chiaro dall'analisi, che connesse direttamente al processo di riparazione, ci sono tutta una serie di informazioni secondarie non di minore importanza.
In particolare il nostro sistema dovrà contemplare la presenza di :

Anagrafica Clienti, Fornitori, Centri Esterni di Assistenza, Committenti

Tabelle, per l'inserimento rapido delle informazioni

Aggancio a sistemi terzi per la notifica a mezzo SMS dello stato delle riparazioni

Ritengo concluso il secondo articolo della serie, che è servito esclusivamente come descrizione del problema.
Scopo del prossimo articolo sarà quello di "avanzare un proposta di architettura".
Non mi resta quindi che finire con il classico :

See u in the next episode

(Fonte :

Alessandro Forte - http://www.alessandroforte.it/)

Progetto GeRi - Parte 2

Alessandro Forte — Sun, 13 Dec 2009 19:55:50 GMT
Revision 2 posted to Articoli by Alessandro Forte on 13/12/2009 20:55:50

Progetto GeRi - Parte 2

Inserito sotto: Architettura, Progetto GeRi

Il secondo articolo di questa miniserie sullo sviluppo di un applicativo “enterprise” verterà sulla descrizione del problema da risolvere.

The Problem – Il Problema
GeRi è una piattaforma software che nasce con lo scopo di gestire tutte le attività, dirette e indirette, connesse ad una centro assistenza.
In generale possiamo dire che il punto focale e primario di un centro assistenza (e di molte altre attività, come in seguito approfondiremo), verte sul concetto di Riparazione.
Possiamo sicuramente definire una riparazione come un processo.
In quanto tale essa è caratterizzata da più fasi, e da diversi attori che prendono parte al processo. Addentriamoci quindi nel merito della descrizione delle fasi e degli attori che costituiscono il processo di riparazione.

La prima fase del nostro processo di riparazione è denominata : Ingresso.
In questa fase un Utente, possessore dell’oggetto da riparare, consegna il suddetto presso il centro di riparazione.
Nell’operazione di ingresso, l’Operatore deputato all’ingresso degli oggetti da riparare, prende in consegna l’oggetto da riparare compilando un’apposita Scheda di Ingresso.
Tale Scheda prevede l’inserimento di diverse informazioni, di seguito elencate :

Anagrafica cliente (Inserimento o recupero di un’anagrafica già esistente)

Data di ingresso dell’oggetto

Dati di acquisto dell’oggetto nel caso in cui l’oggetto fosse in garanzia
(incluse Tipo Documento Acquisto, Numero, Data)

Descrizione caratteristiche dell’oggetto
(incluse Tipologia, Marca, Modello, Numero Serie Primario e Secondario)

Descrizione degli eventuali accessori consegnati con l’oggetto

Descrizione dello stato generale dell’oggetto

Descrizione preliminare del malfunzionamento

Descrizione di eventuali non conformità

Locazione dell’oggetto

Eventuale acquisizione di un immagine dell’oggetto

Definizione dell’eventuale “muletto” e/o apparecchio di cortesia consegnato al cliente

mentre contempla la generazione da parte del sistema delle seguenti informazioni :

Codice riparazione (nella duplice modalità Testo/BarCode)

Operatore assegnato alla riparazione
(L’assegnazione avviene per associazione diretta o tramite un apposito algoritmo)

Cambiamento dello stato della riparazione

Clausole contrattuali/legali legate alla riparazione

La fase di ingresso si conclude con la stampa della Scheda di Ingresso da consegnare al cliente come ricevuta.
Tale ricevuta dovrà successivamente essere presentata dall'utente per il ritiro dell'oggetto.

La seconda fase del nostro processo di riparazione è denominata : Riparazione.
In questa fase un Tecnico, figura deputata alla riparazione dell’oggetto da riparare, prende in consegna l’oggetto (con la relativa scheda di ingresso) e comincia l’analisi della riparazione da effettuare.
Nell’operazione di riparazione, il Tecnico deputato alla riparazione dell’oggetto da riparare, esegue le necessarie operazioni di analisi e riparazioni sull’oggetto e al termine dell’intervento compila un’apposita Scheda di Intervento.
Tale Scheda prevede l’inserimento di diverse informazioni, di seguito elencate :

Descrizione della riparazione

Definizione dei costi della riparazione
(inclusi Costo Sostenuto [ricami + manodopera], Costo Riparazione)

Descrizione di eventuali committenti e/o centri esterni di riparazione

mentre contempla la generazione da parte del sistema delle seguenti informazioni :

Cambiamento dello stato della riparazione

Data di riparazione dell’oggetto

Notifica a mezzo SMS dell'avvenuta riparazione

La fase di riparazione può “momentaneamente” interrompersi in virtù delle seguenti situazioni :

Attesa di ricambi

Presentazione di un Preventivo, previa riparazione dell’oggetto

La fase di riparazione si conclude con la redazione, da parte del Tecnico, della Scheda di Intervento che descrive l’elenco delle operazioni effettuate.
Idealmente tale documento dovrebbe essere storato all'interno di un DMS - Document Management System, o "allegato" alla riparazione stessa. Tale funzionalità sarà oggetto di discussione nelle future implementazioni.

La terza ed ultima fase del nostro processo di riparazione è denominata : Riconsegna.
In questa fase l'Utente, proprietario dell’oggetto da riparare, passa a ritirare il suddetto presso il centro di riparazione.
Nell’operazione di riconsegna, l’Operatore deputato alla riconsegna degli oggetti da riparare, restituisce l’oggetto riparato stampando e consegnando al cliente l’apposita Scheda di Ingresso.
Tale Scheda non prevede l’inserimento di alcuna informazione ma contempla la generazione da parte del sistema delle seguenti informazioni :

Cambiamento dello stato della riparazione

Data di riconsegna dell’oggetto

La fase di riconsegna si conclude con la stampa della Scheda di Riconsegna da consegnare al cliente come ricevuta.

Queste operazioni concludono quello che abbiamo definito come processo di riparazione.
Risulta chiaro dall'analisi, che connesse direttamente al processo di riparazione, ci sono tutta una serie di informazioni secondarie non di minore importanza.
In particolare il nostro sistema dovrà contemplare la presenza di :

Anagrafica Clienti, Fornitori, Centri Esterni di Assistenza, Committenti

Tabelle, per l'inserimento rapido delle informazioni

Aggancio a sistemi terzi per la notifica a mezzo SMS dello stato delle riparazioni

Ritengo concluso il secondo articolo della serie, che è servito esclusivamente come descrizione del problema.
Scopo del prossimo articolo sarà quello di "avanzare un proposta di architettura".
Non mi resta quindi che finire con il classico :
See u in the next episode

(Fonte : Alessandro Forte - http://www.alessandroforte.it/)

Progetto GeRi - Parte 2

Alessandro Forte — Sun, 13 Dec 2009 19:55:50 GMT
Revision 1 posted to Articoli by Alessandro Forte on 13/12/2009 20:55:50

Il secondo articolo di questa miniserie sullo sviluppo di un applicativo “enterprise” verterà sulla descrizione del problema da risolvere.

The Problem – Il Problema
GeRi è una piattaforma software che nasce con lo scopo di gestire tutte le attività, dirette e indirette, connesse ad una centro assistenza.
In generale possiamo dire che il punto focale e primario di un centro assistenza (e di molte altre attività, come in seguito approfondiremo), verte sul concetto di Riparazione.
Possiamo sicuramente definire una riparazione come un processo.
In quanto tale essa è caratterizzata da più fasi, e da diversi attori che prendono parte al processo. Addentriamoci quindi nel merito della descrizione delle fasi e degli attori che costituiscono il processo di riparazione.

La prima fase del nostro processo di riparazione è denominata : Ingresso.
In questa fase un Utente, possessore dell’oggetto da riparare, consegna il suddetto presso il centro di riparazione.
Nell’operazione di ingresso, l’Operatore deputato all’ingresso degli oggetti da riparare, prende in consegna l’oggetto da riparare compilando un’apposita Scheda di Ingresso.
Tale Scheda prevede l’inserimento di diverse informazioni, di seguito elencate :

Anagrafica cliente (Inserimento o recupero di un’anagrafica già esistente)

Data di ingresso dell’oggetto

Dati di acquisto dell’oggetto nel caso in cui l’oggetto fosse in garanzia
(incluse Tipo Documento Acquisto, Numero, Data)

Descrizione caratteristiche dell’oggetto
(incluse Tipologia, Marca, Modello, Numero Serie Primario e Secondario)

Descrizione degli eventuali accessori consegnati con l’oggetto

Descrizione dello stato generale dell’oggetto

Descrizione preliminare del malfunzionamento

Descrizione di eventuali non conformità

Locazione dell’oggetto

Eventuale acquisizione di un immagine dell’oggetto

Definizione dell’eventuale “muletto” e/o apparecchio di cortesia consegnato al cliente

mentre contempla la generazione da parte del sistema delle seguenti informazioni :

Codice riparazione (nella duplice modalità Testo/BarCode)

Operatore assegnato alla riparazione
(L’assegnazione avviene per associazione diretta o tramite un apposito algoritmo)

Cambiamento dello stato della riparazione

Clausole contrattuali/legali legate alla riparazione

La fase di ingresso si conclude con la stampa della Scheda di Ingresso da consegnare al cliente come ricevuta.
Tale ricevuta dovrà successivamente essere presentata dall'utente per il ritiro dell'oggetto.

La seconda fase del nostro processo di riparazione è denominata : Riparazione.
In questa fase un Tecnico, figura deputata alla riparazione dell’oggetto da riparare, prende in consegna l’oggetto (con la relativa scheda di ingresso) e comincia l’analisi della riparazione da effettuare.
Nell’operazione di riparazione, il Tecnico deputato alla riparazione dell’oggetto da riparare, esegue le necessarie operazioni di analisi e riparazioni sull’oggetto e al termine dell’intervento compila un’apposita Scheda di Intervento.
Tale Scheda prevede l’inserimento di diverse informazioni, di seguito elencate :

Descrizione della riparazione

Definizione dei costi della riparazione
(inclusi Costo Sostenuto [ricami + manodopera], Costo Riparazione)

Descrizione di eventuali committenti e/o centri esterni di riparazione

mentre contempla la generazione da parte del sistema delle seguenti informazioni :

Cambiamento dello stato della riparazione

Data di riparazione dell’oggetto

Notifica a mezzo SMS dell'avvenuta riparazione

La fase di riparazione può “momentaneamente” interrompersi in virtù delle seguenti situazioni :

Attesa di ricambi

Presentazione di un Preventivo, previa riparazione dell’oggetto

La fase di riparazione si conclude con la redazione, da parte del Tecnico, della Scheda di Intervento che descrive l’elenco delle operazioni effettuate.
Idealmente tale documento dovrebbe essere storato all'interno di un DMS - Document Management System, o "allegato" alla riparazione stessa. Tale funzionalità sarà oggetto di discussione nelle future implementazioni.

La terza ed ultima fase del nostro processo di riparazione è denominata : Riconsegna.
In questa fase l'Utente, proprietario dell’oggetto da riparare, passa a ritirare il suddetto presso il centro di riparazione.
Nell’operazione di riconsegna, l’Operatore deputato alla riconsegna degli oggetti da riparare, restituisce l’oggetto riparato stampando e consegnando al cliente l’apposita Scheda di Ingresso.
Tale Scheda non prevede l’inserimento di alcuna informazione ma contempla la generazione da parte del sistema delle seguenti informazioni :

Cambiamento dello stato della riparazione

Data di riconsegna dell’oggetto

La fase di riconsegna si conclude con la stampa della Scheda di Riconsegna da consegnare al cliente come ricevuta.

Queste operazioni concludono quello che abbiamo definito come processo di riparazione.
Risulta chiaro dall'analisi, che connesse direttamente al processo di riparazione, ci sono tutta una serie di informazioni secondarie non di minore importanza.
In particolare il nostro sistema dovrà contemplare la presenza di :

Anagrafica Clienti, Fornitori, Centri Esterni di Assistenza, Committenti

Tabelle, per l'inserimento rapido delle informazioni

Aggancio a sistemi terzi per la notifica a mezzo SMS dello stato delle riparazioni

Ritengo concluso il secondo articolo della serie, che è servito esclusivamente come descrizione del problema.
Scopo del prossimo articolo sarà quello di "avanzare un proposta di architettura".
Non mi resta quindi che finire con il classico :
See u in the next episode

(Fonte : Alessandro Forte - http://www.alessandroforte.it/)

Progetto GeRi - Parte 1

Alessandro Forte — Sun, 13 Dec 2009 22:15:59 GMT
Current revision posted to Articoli by Alessandro Forte on 13/12/2009 23:15:59

Progetto GeRi - Parte 1

Inserito sotto: Architettura, Progetto GeRi

Dopo tantissimo tempo torno a scrivere un articolo e lo faccio animato dalle migliori intenzioni.

In questa serie di articoli, mi pongo un duplice obiettivo. Il primo è quello di portare a termine un lavoro che mi hanno commissionato. Il secondo è quello, ben più sperimentale e interessante, di portare a compimento il lavoro che mi hanno commissionato tramite il vostro aiuto, rendendo poi libero il codice sorgente dell'applicativo. Ho pensato di sviluppare il primo open source software in Co-Produzione con i miei utenti.
E ho deciso di sfruttare sia il mio blog personale che quello dello UG a cui appartengo per diffondere e rendere noto il mio progetto. Per Co-Produzione (o per meglio dire Co-Design/Co-Production/Co-Brand) intendo la capacità, partendo da miei suggerimenti, di raffinare i concetti basandomi totalmente sui vostri suggerimenti e vagliandoli uno ad uno. Ma passiamo subito alla fase operativa e cerchiamo di capire :

Cosa dobbiamo realizzare?

Come lo dobbiamo realizzare?

Chi lo deve realizzare?

Perchè lo dobbiamo realizzare insieme?

Rispondiamo per punti alle varie domande, partendo in ordine inverso.

Perchè lo dobbiamo realizzare insieme Il concetto di Co-Design, Co-Produzione, ecc... mi è venuto leggendo una nota rivista. Viene attualmente utilizzato in moltissimi settori e anche in informatica. Ovviamente nel settore informatico l'Open Source ne rappresenta un degno esempio .

Chi lo deve realizzare Io sarò il primo sviluppatore "ufficiale" (diciamo che quasi non ve l'aspettavate giusto?). A me si aggiungeranno tutti colori i quali saranno ritenuti validi al corretto svolgimento delle attività. Per validità non intendo solo il punto di vista strettamente tecnico, ma anche e sopratutto coloro i quali mostreranno serietà e dedizione. Spero di avervi convinto almeno un pò

Come lo dobbiamo realizzare Ecco qui viene il bello della faccenda. Poichè io questo sistema lo devo realizzare e commercializzare, proporrò step by step la mia visione del lavoro. Abbraccerò tutti i punti di vista. Spazierò dall'architettura, all'organizzazione del codice, alla schedulazione delle milestones, ecc... Ma il punto di forza del progetto, come già ripetuto diverse volte, sarà la vostra visione e il vostro modo di interagire con il sottoscritto apponendo critiche e suggerimenti alle soluzioni che di volta in volta proporrò

Cosa dobbiamo realizzare Il progetto da realizzare è il GeRi acronimo di Gestione Riparazioni. Il software in questione dovrà risolvere tutti i problemi (e vi assicuro che ve ne sono tanti) legati alla gestione delle riparazioni. Inoltre il termine Riparazione deve assolvere a qualunque significato gli sia dato all'interno di contesti diversi quali possa essere un centro di assistenza telefonica piuttuosto che un negozio di computer.

Ritengo concluso il mio primo articolo della serie, che è servito esclusivamente come manifesto. Scopo del prossimo articolo sarà quello di stilere un programma cominciando a definire i vari ToDo. Tutto questo in preparazione dei primi articoli veri e proprii che verteranno sull'acquisizione dei requisiti, sull'architettura sul sistema, e su come realizzare il sistema in esame. Non mi resta quindi che finire con il classico :

See u in the next episode

(Fonte :

Alessandro Forte - http://www.alessandroforte.it/)

Progetto GeRi - Parte 1

Alessandro Forte — Sun, 13 Dec 2009 19:56:23 GMT
Revision 2 posted to Articoli by Alessandro Forte on 13/12/2009 20:56:23

Progetto GeRi - Parte 1

Inserito sotto: Architettura, asp.net tutorials certificazioniProgetto GeRi

Dopo tantissimo tempo torno a scrivere un articolo e lo faccio animato dalle migliori intenzioni.

In questa serie di articoli, mi pongo un duplice obiettivo. Il primo è quello di portare a termine un lavoro che mi hanno commissionato. Il secondo è quello, ben più sperimentale e interessante, di portare a compimento il lavoro che mi hanno commissionato tramite il vostro aiuto, rendendo poi libero il codice sorgente dell'applicativo. Ho pensato di sviluppare il primo open source software in Co-Produzione con i miei utenti.
E ho deciso di sfruttare sia il mio blog personale che quello dello UG a cui appartengo per diffondere e rendere noto il mio progetto. Per Co-Produzione (o per meglio dire Co-Design/Co-Production/Co-Brand) intendo la capacità, partendo da miei suggerimenti, di raffinare i concetti basandomi totalmente sui vostri suggerimenti e vagliandoli uno ad uno. Ma passiamo subito alla fase operativa e cerchiamo di capire :

Cosa dobbiamo realizzare?

Come lo dobbiamo realizzare?

Chi lo deve realizzare?

Perchè lo dobbiamo realizzare insieme?

Rispondiamo per punti alle varie domande, partendo in ordine inverso.

Perchè lo dobbiamo realizzare insieme Il concetto di Co-Design, Co-Produzione, ecc... mi è venuto leggendo una nota rivista. Viene attualmente utilizzato in moltissimi settori e anche in informatica. Ovviamente nel settore informatico l'Open Source ne rappresenta un degno esempio .

Chi lo deve realizzare Io sarò il primo sviluppatore "ufficiale" (diciamo che quasi non ve l'aspettavate giusto?). A me si aggiungeranno tutti colori i quali saranno ritenuti validi al corretto svolgimento delle attività. Per validità non intendo solo il punto di vista strettamente tecnico, ma anche e sopratutto coloro i quali mostreranno serietà e dedizione. Spero di avervi convinto almeno un pò

Come lo dobbiamo realizzare Ecco qui viene il bello della faccenda. Poichè io questo sistema lo devo realizzare e commercializzare, proporrò step by step la mia visione del lavoro. Abbraccerò tutti i punti di vista. Spazierò dall'architettura, all'organizzazione del codice, alla schedulazione delle milestones, ecc... Ma il punto di forza del progetto, come già ripetuto diverse volte, sarà la vostra visione e il vostro modo di interagire con il sottoscritto apponendo critiche e suggerimenti alle soluzioni che di volta in volta proporrò

Cosa dobbiamo realizzare Il progetto da realizzare è il GeRi acronimo di Gestione Riparazioni. Il software in questione dovrà risolvere tutti i problemi (e vi assicuro che ve ne sono tanti) legati alla gestione delle riparazioni. Inoltre il termine Riparazione deve assolvere a qualunque significato gli sia dato all'interno di contesti diversi quali possa essere un centro di assistenza telefonica piuttuosto che un negozio di computer.

Ritengo concluso il mio primo articolo della serie, che è servito esclusivamente come manifesto. Scopo del prossimo articolo sarà quello di stilere un programma cominciando a definire i vari ToDo. Tutto questo in preparazione dei primi articoli veri e proprii che verteranno sull'acquisizione dei requisiti, sull'architettura sul sistema, e su come realizzare il sistema in esame. Non mi resta quindi che finire con il classico :

See u in the next episode

(Fonte : Alessandro Forte - http://www.alessandroforte.it/)

Progetto GeRi - Parte 1

Alessandro Forte — Tue, 29 Sep 2009 09:27:58 GMT
Revision 1 posted to Articoli by Alessandro Forte on 29/09/2009 11:27:58

Dopo tantissimo tempo torno a scrivere un articolo e lo faccio animato dalle migliori intenzioni.

In questa serie di articoli, mi pongo un duplice obiettivo. Il primo è quello di portare a termine un lavoro che mi hanno commissionato. Il secondo è quello, ben più sperimentale e interessante, di portare a compimento il lavoro che mi hanno commissionato tramite il vostro aiuto, rendendo poi libero il codice sorgente dell'applicativo. Ho pensato di sviluppare il primo open source software in Co-Produzione con i miei utenti.
E ho deciso di sfruttare sia il mio blog personale che quello dello UG a cui appartengo per diffondere e rendere noto il mio progetto. Per Co-Produzione (o per meglio dire Co-Design/Co-Production/Co-Brand) intendo la capacità, partendo da miei suggerimenti, di raffinare i concetti basandomi totalmente sui vostri suggerimenti e vagliandoli uno ad uno. Ma passiamo subito alla fase operativa e cerchiamo di capire :

Cosa dobbiamo realizzare?

Come lo dobbiamo realizzare?

Chi lo deve realizzare?

Perchè lo dobbiamo realizzare insieme?

Rispondiamo per punti alle varie domande, partendo in ordine inverso.

Perchè lo dobbiamo realizzare insieme Il concetto di Co-Design, Co-Produzione, ecc... mi è venuto leggendo una nota rivista. Viene attualmente utilizzato in moltissimi settori e anche in informatica. Ovviamente nel settore informatico l'Open Source ne rappresenta un degno esempio .

Chi lo deve realizzare Io sarò il primo sviluppatore "ufficiale" (diciamo che quasi non ve l'aspettavate giusto?). A me si aggiungeranno tutti colori i quali saranno ritenuti validi al corretto svolgimento delle attività. Per validità non intendo solo il punto di vista strettamente tecnico, ma anche e sopratutto coloro i quali mostreranno serietà e dedizione. Spero di avervi convinto almeno un pò

Come lo dobbiamo realizzare Ecco qui viene il bello della faccenda. Poichè io questo sistema lo devo realizzare e commercializzare, proporrò step by step la mia visione del lavoro. Abbraccerò tutti i punti di vista. Spazierò dall'architettura, all'organizzazione del codice, alla schedulazione delle milestones, ecc... Ma il punto di forza del progetto, come già ripetuto diverse volte, sarà la vostra visione e il vostro modo di interagire con il sottoscritto apponendo critiche e suggerimenti alle soluzioni che di volta in volta proporrò

Cosa dobbiamo realizzare Il progetto da realizzare è il GeRi acronimo di Gestione Riparazioni. Il software in questione dovrà risolvere tutti i problemi (e vi assicuro che ve ne sono tanti) legati alla gestione delle riparazioni. Inoltre il termine Riparazione deve assolvere a qualunque significato gli sia dato all'interno di contesti diversi quali possa essere un centro di assistenza telefonica piuttuosto che un negozio di computer.

Ritengo concluso il mio primo articolo della serie, che è servito esclusivamente come manifesto. Scopo del prossimo articolo sarà quello di stilere un programma cominciando a definire i vari ToDo. Tutto questo in preparazione dei primi articoli veri e proprii che verteranno sull'acquisizione dei requisiti, sull'architettura sul sistema, e su come realizzare il sistema in esame. Non mi resta quindi che finire con il classico :

See u in the next episode

Espression Studio: uno sguardo d'insieme

Carmine Alfano — Tue, 22 Sep 2009 12:25:40 GMT
Current revision posted to Articoli by Carmine Alfano on 22/09/2009 14:25:40

Espression Studio: uno sguardo d'insieme

Inserito sotto: Expression Studio, Blend, Silverlight

la
La prima incursione da parte di Microsoft nel campo della progettazione grafica professionale giunge ormai alla terza edizione, il pacchetto comprende: applicazioni web, progettazione, gestione di contenuti multimediali e animazione su linea cronologica.

I programmi più interessanti della suite sono: Expression Design, Expression Web, Expression Blend. Tralasciamo quindi per questa volta Expression Encoder.

EXPRESSION DESIGN

Expression Design è un software per la grafica vettoriale orientato esclusivamente al web, lavorare in dtp (desktop publishing) risulterebbe impossibile a causa della mancanza del supporto CMYK per le stampe con separazioni di colore.

L’interfaccia è stata studiata andando incontro alle esigenze di progettisti e webdesigner che per anni hanno utilizzato soltanto Freehand e Illustrator: un esempio eclatante è quello delle scorciatoie da tastiera del tutto simili ai software sopracitati. Qualcuno potrebbe obiettare che Design sia la copia sfacciata di Illustrator, a questo punto vorrei aprire una piccola parentesi: dobbiamo considerare il software di casa Adobe dal 1986 sul mercato, come uno standard, infatti anche Macromedia Freehand traeva spunto dal suo (ex) rivale.

L’interfaccia nera e grigia è molto elegante ma lavorando per ore su un progetto potrebbe stancare la vista, possiamo risolvere in parte il problema selezionando expression chiaro dal pannello delle opzioni.

Personalmente ritengo Design un software dalle grandi potenzialità ma ancora troppo giovane per un confronto diretto con i suoi concorrenti.

EXPRESSION WEB

In casa Microsoft si sentiva da troppo tempo la mancanza di un software WYSIWYG professionale per la realizzazione di pagine web, ecco il motivo per il quale Frontpage dal 2006 ha ceduto il passo ad Expression Web.

Il programma permette di lavorare agevolmente con javascript, CSS e tutte le tecnologie del web 2.0, offre inoltre il supporto per la codifica ASP.NET, elemento non di poca importanza, perché, come vedremo più avanti, la tecnologia Microsoft per le applicazioni web, rappresenta il nucleo essenziale di Expression Studio.

Anche in questo caso l’interfaccia è stata studiata per ottimizzare il flusso di lavoro del webdesigner, molto semplice ed intuitiva permette anche di disegnare i DIV direttamente sul piano di lavoro, inoltre, dalla versione 2.0, ha aggiunto il supporto per PHP, file Silverlight e Flash. Includendo un filmato flash, Expression web oltre a creare il codice html corrispondente, consente di modificare i parametri di visualizzazione e alcuni attributi necessari al controllo del filmato. Per silverlight è possibile sia modificare le pagine html generate da Expression encoder o Expression Blend sia includere un’applicazione silverlight direttamente all’interno della pagina.

Le immagini create con Photoshop e salvate in formato .PSD hanno un loro, seppur minimale, pannello di controllo, inserendo un’immagine di questo tipo è possibile scegliere dal pannello solo i livelli che si desidera importare e il tipo di compressione da usare sulla foto, la foto può

essere convertita in formato gif png o jpg e la sua qualità viene mostrata immediatamente dalla finestra d’anteprima.

Expression web è un software maturo molto pratico ed essenziale nell’interfaccia.

EXPRESSION BLEND

Che cos’è Blend, o sarebbe meglio dire: cos’è Silverlight? Procediamo con ordine.

Blend è il programma che ci permette di realizzare filmati multimediali e applicazioni sfruttando la tecnologia Silverlight. Silverlight si potrebbe considerare come la risposta di Microsoft a Flash ma in realtà si tratta di una tecnologia molto più complessa.

I vantaggi essenziali di Silverlight sono una gestione più fluida dei materiali video ad alta definizione e una maggiore facilità di creazione di applicazioni per l’utente. Silverlight utilizza inoltre un linguaggio di programmazione a base testuale denominato XAML, che a differenza di Flash può essere facilmente rilevato dai motori di ricerca. Inoltre con Blend abbiamo la possibilità di realizzare delle applicazioni desktop, realizzando i layout da zero.

Chi è abituato ad utilizzare Flash si troverà in difficoltà al primo approccio con Blend: l’interfaccia è totalmente diversa, un pò confusionaria, a parte questo piccolo tallone d’Achille, stiamo parlando di un software dalle grandi capacità in grado di snellire i flussi di lavoro tra designer e programmatori.

CONCLUSIONI

Expression Studio rappresenta, nonostante le pecche, tra cui anche la mancanza di una versione per Apple Mac, un prodotto valido anche in ambito professionale, e merita senza dubbio di essere preso in considerazione.

Espression Studio: uno sguardo d'insieme

Carmine Alfano — Tue, 22 Sep 2009 11:53:04 GMT
Revision 2 posted to Articoli by Carmine Alfano on 22/09/2009 13:53:04

Espression Studio: uno sguardo d'insieme

Inserito sotto: Expression Studio, Blend, Silverlight

la prima incursione da parte di Microsoft nel campo della progettazione grafica professionale giunge ormai alla terza edizione, il pacchetto comprende: applicazioni web, progettazione, gestione di contenuti multimediali e animazione su linea cronologica.

I programmi più interessanti della suite sono: Expression Design, Expression Web, Expression Blend. Tralasciamo quindi per questa volta Expression Encoder.

EXPRESSION DESIGN

Expression Design è un software per la grafica vettoriale orientato esclusivamente al web, lavorare in dtp (desktop publishing) risulterebbe impossibile a causa della mancanza del supporto CMYK per le stampe con separazioni di colore.

L’interfaccia è stata studiata andando incontro alle esigenze di progettisti e webdesigner che per anni hanno utilizzato soltanto Freehand e Illustrator: un esempio eclatante è quello delle scorciatoie da tastiera del tutto simili ai software sopracitati. Qualcuno potrebbe obiettare che Design sia la copia sfacciata di Illustrator, a questo punto vorrei aprire una piccola parentesi: dobbiamo considerare il software di casa Adobe dal 1986 sul mercato, come uno standard, infatti anche Macromedia Freehand traeva spunto dal suo (ex) rivale.

L’interfaccia nera e grigia è molto elegante ma lavorando per ore su un progetto potrebbe stancare la vista, possiamo risolvere in parte il problema selezionando expression chiaro dal pannello delle opzioni.

Personalmente ritengo Design un software dalle grandi potenzialità ma ancora troppo giovane per un confronto diretto con i suoi concorrenti.

EXPRESSION WEB

In casa Microsoft si sentiva da troppo tempo la mancanza di un software WYSIWYG professionale per la realizzazione di pagine web, ecco il motivo per il quale Frontpage dal 2006 ha ceduto il passo ad Expression Web.

Il programma permette di lavorare agevolmente con javascript, CSS e tutte le tecnologie del web 2.0, offre inoltre il supporto per la codifica ASP.NET, elemento non di poca importanza, perché, come vedremo più avanti, la tecnologia Microsoft per le applicazioni web, rappresenta il nucleo essenziale di Expression Studio.

Anche in questo caso l’interfaccia è stata studiata per ottimizzare il flusso di lavoro del webdesigner, molto semplice ed intuitiva permette anche di disegnare i DIV direttamente sul piano di lavoro, inoltre, dalla versione 2.0, ha aggiunto il supporto per PHP, file Silverlight e Flash. Includendo un filmato flash, Expression web oltre a creare il codice html corrispondente, consente di modificare i parametri di visualizzazione e alcuni attributi necessari al controllo del filmato. Per silverlight è possibile sia modificare le pagine html generate da Expression encoder o Expression Blend sia includere un’applicazione silverlight direttamente all’interno della pagina.

Le immagini create con Photoshop e salvate in formato .PSD hanno un loro, seppur minimale, pannello di controllo, inserendo un’immagine di questo tipo è possibile scegliere dal pannello solo i livelli che si desidera importare e il tipo di compressione da usare sulla foto, la foto può

essere convertita in formato gif png o jpg e la sua qualità viene mostrata immediatamente dalla finestra d’anteprima.

Expression web è un software maturo molto pratico ed essenziale nell’interfaccia.

EXPRESSION BLEND

Che cos’è Blend, o sarebbe meglio dire: cos’è Silverlight? Procediamo con ordine.

Blend è il programma che ci permette di realizzare filmati multimediali e applicazioni sfruttando la tecnologia Silverlight. Silverlight si potrebbe considerare come la risposta di Microsoft a Flash ma in realtà si tratta di una tecnologia molto più complessa.

I vantaggi essenziali di Silverlight sono una gestione più fluida dei materiali video ad alta definizione e una maggiore facilità di creazione di applicazioni per l’utente. Silverlight utilizza inoltre un linguaggio di programmazione a base testuale denominato XAML, che a differenza di Flash può essere facilmente rilevato dai motori di ricerca. Inoltre con Blend abbiamo la possibilità di realizzare delle applicazioni desktop, realizzando i layout da zero.

Chi è abituato ad utilizzare Flash si troverà in difficoltà al primo approccio con Blend: l’interfaccia è totalmente diversa, un pò confusionaria, a parte questo piccolo tallone d’Achille, stiamo parlando di un software dalle grandi capacità in grado di snellire i flussi di lavoro tra designer e programmatori.

CONCLUSIONI

Expression Studio rappresenta, nonostante le pecche, tra cui anche la mancanza di una versione per Apple Mac, un prodotto valido anche in ambito professionale, e merita senza dubbio di essere preso in considerazione.