Articoli

Creazione di un sito web con Orchard - Terza Parte

Michele Aponte — Wed, 29 Jun 2011 15:28:23 GMT

Current revision posted to Articoli by Michele Aponte on 29/06/2011 17:28:23

Content Types

Creazione di un nuovo Content Type

Nella colonna sinistra della home page del sito web in esame, vengono visualizzate una serie di news che possono essere facilmente gestite da orchard creando un nuovo Content Type, cioè un nuovo tipo, che chiameremo News, che farà parte delle entità gestite dalla nostra dashboard. E possibile creare un nuovo content type accedendo alla dashboard, selezionando la voce Content, il tab Contet Type e clicccando sul pulsante Create new type.

Ci viene chiesto il nome che vogliamo dare alla nuova entità, che sarà utilizzato anche come suggerimento per l'identificativo dello stesso. Digitiamo News e confermiamo cliccando sul pulsante Create.

Ogni Content Type può essere definito da un insieme di Content Part e da un insieme di Field, dato che desideriamo creare successivamente una lista di news, indichiamo come content part da aggiungere al nostro type quella denominata Conteinable, che abilita il nostro nuovo tipo ad essere inserito all'interno di un contenitore (come le liste che vedremo tra poco) e che richiede necessariamente anche l'aggiunta della Part Common.

Cliccando sul tasto Save ci viene presentata la finestra per la gestione del nuovo Content Type, da cui possiamo aggiungere i Field necessari alla sua definizione. Cliccando sul pulsante Add Field, possiamo raggiungere la pagina per la creazione del nuovo campo, digitiamone il nome, Titolo, e indichaimo il tipo da utilizzate, attualmente l'unico installato, Text Field. Confermiamo cliccando sul tasto Save.

Per i restanti campi abbiamo bisogno di installare dei nuovi Field Type dalla Gallery, clicchiamo quindi sulla voce Modules, selezioniamo il Tab Gallery, nella casella di testo per la ricerca digitiamo la parola "field" e clicchiamo sul pulsante Search. Verrano visualizzati i vari field a disposizione nella gallery di Orchard, installiamo DateTimeField e Html Field.

Tornando al nostro Content Type, possiamo adesso utilizzare i field installati per la crezione dei campi mancanti.

Aggiungendo quindi i field Contentuto (HtmlField) e Data (DateTimeField) abbiamo ultimato il nostro Content Type News.

Creazione di una lista

Possiamo adesso creare la lista di news che utilizzeremo per la nostra home page, cliccando sulla voce New List, settiamo il Title a News e specifichiamo che questa lista conterrà elementi di tipo News.

Creando una nuova News, selezionando la voce New News, potremo a questo punto associare la nuova entità alla lista appena creata grazie a un'apposita dropdownlist etichettata Add to. Digitiamo il contenuto della news, selezioniamo la data, indichiamo il titolo e salviamo cliccando sul pulsante Save.

Creazione di una Widget

La creazione della lista non ne determina l'automatica pubblicazione sul sito, anche perchè dobbiamo indicare dove vogliamo che venga visualizzata. Per fare questo dobbiamo creare una nuova Widget selezionando la voce Widgets dal menu principale della Dashboard, selezionare il layer su cui vogliamo lavorare, Default nel nostro caso perchè vogliamo che la lista delle news compaia in ogni pagina, e cliccare sul pulsante Add in corrispondenza della zona in cui vogliamo aggiungere la Widget, AsideFirst nel nostro caso visto che vogliamo che compaia nella colonna a sinistra rispetto al contenuto principale.

Selezioniamo il tipo di widget che vogliamo realizzare, un Container Widget in questo caso, definiamo un titolo, in questo caso Ultime News, e selezioniamo il contenitore da utilizzare, la lista News.

Cliccando sul tasto Salva otteniamo il risultato cercato:

Customizzazione del template per la Widget

Non ci resta che dare alla widget l'aspetto dettato dal template scelto dal cliente, utilizzando di nuovo i tool per designer messo a disposizione da Orchard. Lo scopo in questo caso è creare un alternate, un file cshtml alternativo da utilizzare per il rendering della widget selezionata, che ci permetta di customizzare il modo in cui viene renderizzato il contenuto della widget stessa.

Torniamo quindi in WebMatrix e andiamo ad editare il file appena creato, sostituendo Display(items) con un foreach. Questo ci permette di non lasciare al comportamento di base della widget, che aggiungerebbe dei tag di contorno che creano rumore per il nostro template, il rendering degli elementi della lista.

Generiamo infine il template per il contenuto della lista, Content-News.cshtml...

... e editiamolo in modo da generare l'html del template scelto dal cliente:

Ed ecco il risultato finale:

Nel prossimo e ultimo articolo vedremo come ultimare il sito completando il template e aggiungendo un po' di moduli dalla gallery.

Creazione di un sito web con Orchard - Seconda Parte

Michele Aponte — Fri, 17 Jun 2011 07:13:39 GMT

Current revision posted to Articoli by Michele Aponte on 17/06/2011 09:13:39

Creazione di un sito web con Orchard - Seconda Parte

Customizzazione del tema

Asp.Net MVC e Razor

Orchard basa il suo presentation layer sul Asp.Net MVC3, utilizzando di default Razor come view engine e C# come linguaggio di programmazione. Per poter personalizzare una tema è necessario quindi avere una minima conoscenza di questi elementi, in particolare della realizzazione delle view con questa tecnologia. A differenza di Asp.Net WebForms, in Asp.Net MVC una view è un elemento completamente passivo, non ha code-behind ed ha la sola responsabilità di visualizzare la UI per l'utente. Sarà infatti il Controller a preoccuparsi di rispondere alle richieste dell'utente, chiedendo al Model di aggiornare il proprio stato in risposta della richiesta, ed è proprio in base alla risposta del model che il controller selezionerà la view successiva da visualizzare.

Una view di Asp.Net MVC che utilizza Razor e C# è un file con estensione .cshtml (c sharp + html) in cui il codice C# è immerso nel markup html attraverso l'utilizzo del simbolo @, a differenza del view engine aspx che invece utilizza i simboli <% %>. Ad esempio possiamo condizionare il rendering di un pezzo di markup html in questo semplice modo:

@if(condizione){
<p>Questo paragrafo sarà stampato solo se la condizione è 
vera</p>
}

Oppure renderizzare un numero arbitrario di volte un pezzo di markup html con un classico ciclo for:

<ul>
@foreach(var elemento in lista) 
{
<li><a href="@elemento.Link">@elemento.Descrizione</a></li>
}
</ul>

Come potete vedere, una delle caratteristiche di Razor è quella di essere molto poco intrusivo, permettendo con una semplice @ di inserire la dinamicità necessaria alla generazione delle nostre view.

La view Layout di Orchard

Tornando al nostro sito creato in Web Matrix, possiamo analizzare i file del nostro progetto cliccando sul voce del menu laterale Files. Per visualizzare i file del nostro tema invece espandiamo la radice Comap Impiantistica e l'elemento Themes, in cui troveremo il nostro tema comapimpiantistica:

Espandendo l'elemento comapimpiantistica possiamo osservare la struttura delle cartelle di un tema:

La cartella Content conterrà le nostre immagini, mentre Scripts e Styles rispettivamente i file javascript e i css. In Views invece metteremo i nostri file .cshtml, mentre lasceremo vuota la cartella Zones. Come avremo modo di esaminare più avanti il file Placement.info ci permetterà di indicare informazioni sul posizionamento dei vari elementi del nostro tema, mentre Theme.png e Theme.txt rappresentano rispettivamente l'immagine di anteprima del tema e il manifest con le informazioni sul tema che stiamo realizzando.

Per aggiungere una nuova view al nostro tema ci basta fare tasto destro sulla cartella Views e scegliere New File dal menu a tendina che compare. A questo punto possiamo selezionare, dalla finestra che ci viene mostrata da Web Matrix, la categoria Common, il formato CSHTML, indicare il nome che vogliamo dare alla view, nel nostro caso Layout, e cliccare sul pulsante Ok.

Il file Layout.cshtml permette di definire il layout del nostro tema, un po' come viene fatto con le master page quando viene utilizzato aspx come view engine. E' proprio in questo file che andiamo a incollare l'html della home page del template grafico scelto dal cliente

Copiamo quindi le immagini del template nella cartella Content, il css nella cartella Styles e l'html della home page nel contenuto del Layout.cshtml:

Chiaramente è necessario modificare i percorsi delle immagini utilizzati nel css andando a sostituire le stringhe "../images/" in "../Content/images", sfruttando il tool di sostituzione testo di Web Matrix.

Eliminiamo l'elemento radice html, head e i tag di apertura e chiusura di body, sostituendoli con un blocco di codice che permette di includere le shape di base di Orchard e il nostro foglio di stile. Per le immagini non linkate dal css, ma direttamente dal nostro html, dobbiamo specificare come generare il path in modo che sia indipendente dal path della pagina che utilizzerà il layout cshtml e il percorso fisico del tema. Per fare questo utiliziamo alcuni helper forniti da Asp.Net MVC per la generazine dinamica del markup html, in particolare l'url helper Content e l'html helper fornito da Orchard per recuperare il path del tema corrente, ThemePath.

Lanciando il sito si cominciano a vedere già i primi risultati:

Non ci resta che delimitare le sezioni del layout, che in Orchard sono dette Zone, che saranno renderizzate dinamicamente dalle view che utilizzano il nostro layout.cshtml. Cominciamo dal menu principale, identificando la sezione di markup che visualizza le voci di menu:

Tagliamo questo markup e sostituiamolo con l'istruzione necessario al rendering della Zone standard di Orchard per il menu principale, denominata Navigation:

Andiamo adesso ad aggiungere un'altra View al nostro tema, che chiameremo Menu e in cui andremo ad incollare proprio il pezzo di markup tagliato precedentemente: questo ci permetterà di rendere in un secondo momento dinamico il menu in modo che risponda agli elementi creati nella dashboard.

La domanda che dobbiamo farci a questo punto è: dobbiamo conoscere a memoria il nome delle zone che vogliamo personalizzare, il nome delle proprietà che esprimono dinamicamente i contenuti modificati nella dashboard e tutte le altre informazioni definite dal team di Orchard? Ricordando che sostanzialmente possiamo modificare qualsiasi aspetto di Orchard, anche perchè ne abbiamo i sorgenti, potremmo in prima analisi pensare di andare a modificare un po' di cose ma in realtà esiste un modulo che ci permette di visualizzare direttamente sul sito le informazioni di cui abbiamo bisogno.

I Designer Tools

Il modulo in questione di chiama Designer Tools e può essere installato dalla gallery raggiungibile dalla voce Modules della dashboard.

Dopo aver attivato il modulo il nostro sito presenterà nella parte in basso un barra speciale che permette di aprire i designer tools per l'utilizzo:

Con i designer tools aperti il sito non risponderà più ai click del mouse, questo perchè saranno interpretati come selezione di una sezione di interesse, oppurtanamente evidenziata, le cui informazioni saranno visualizzate nei tools:

Cliccando sulle informazioni del Model per questo template possiamo esaminare le informazioni fornite alla view che ci interessa, in questo caso il Model di menu, che contiene una collezione di Item da cui possiamo recuperare il testo del menu dalla proprietà Text e l'Href a cui si riferisce.

Possiamo quindi modificare la view Menu in modo che cicli sull'insieme degli item utilizzando queste proprietà per generare le voci di menu:

Per vedere l'effetto ottenuto aggiungiamo la pagina Chi Siamo, creando una nuova Page dalla dashboard, inserendo del testo descrittivo e indicando di inserire una voce nel menu principale, chiamata Chi Siamo, che punti al link della pagina:

Come avevamo notato però la pagina principale e le altre pagine, tra cui anche la nostra Chi Siamo, hanno nel template un'impaginazione diversa, abbiamo quindi bisogno di strutturare diversamente il layout per i due casi. Nel caso della home page ci basta modificare il nome del file layout in layout-url-homepage, in questo modo Orchard utilizzerà questa view come layout solo per la homepage:

AsideFirst, Content, AsideSecond e AfterMain sono alcune delle zone del template standard di Orchard. TheThemeMachine, come mostra lo schema proprio di questo template:

Duplichiamo a questo punto la view, la rinominiamo in Layout.cshtml e utilizziamo l'html della pagina Chi Siamo per definire le zone AsideFirst, Content e Footer:

Ottenendo così il risultato voluto per le pagine diverse dalla Home Page:

Nel prossimo articolo ultimeremo il nostro tema aggiungendo gli elementi mancanti ad una corrispondenza perfetta al template scelto dal cliente.

Creazione di un sito web con Orchard - Prima Parte

Michele Aponte — Thu, 09 Jun 2011 12:47:26 GMT

Current revision posted to Articoli by Michele Aponte on 09/06/2011 14:47:26

Introduzione

Che cos'è Orchard

Orchard è un Content Management System gratuito e open source realizzato da Microsoft. Completamente modulare, ha un'architettura basata su tutta una serie di framework e pattern che ne rendono l'estendibilità uno dei suoi punti di forza, abilitando di fatto gli sviluppatori .net a realizzare praticamente qualsiasi tipo di modulo. Ed è questo il segreto di Orchard: ogni suo componente è un modulo e come tale può essere installato, disinstallato, abilitato o disabilitato. Il progetto dispone già di un'ampia gallery di moduli già pronti, realizzati dal team di Orchard ma anche da sviluppatori indipendenti; noi stessi possiamo condividerne con la community del CMS. E' inoltre completamente personalizzabile dal punto di vista grafico, partendo da un tema già pronto, scaricato sempre dalla gallery, o partendo completamente da zero.

Sono quattro le figure che ruotano attorno all'ecosistema Orchard: l'amministratore che installa e configura l'ambiente; lo sviluppatore che può realizzare moduli aggiuntivi; il designer che realizza o modifica l'html e i css del tema da utilizzare; l'utente che usufruisce dei contenuti presentati.

Cosa vogliamo realizzare?

Con la versione 1.1 Orchard ha già raggiunto un grado di maturità tale da poterlo usare in produzione per progetti medio-piccoli. Lo scopo di questa serie di articoli è proprio quello di mostrare come sia possibile, da zero, realizzare un sito web reale. Nel caso specifico si tratta del sito di presentazione di una piccola azienda di impianti elettrici, utilizzando un template scelto dall'azienda stessa, quindi nessun template della gallery di Orchard. Inoltre, nonostante sia possibile partire dai sorgenti rilasciati pubblicamente e utilizzare Visual Studio 2010 per editare alcuni componenti, useremo Web Matrix.

Creazione e configurazione del progetto

Creazione del progetto in Web Matrix

Il primo passo consiste nel creare il nostro progetto con Web Matrix. Cliccando su Site From Web Gallery vi verranno visualizzati i template disponibili tra cui, nella categoria CMS, troveremo Orchard. Indichiamo a questo punto il nome che vogliamo dare al sito nella casella di testo etichettata Site Name, nel nostro caso Comap Impiantistica, e clicchiamo sul tasto Next.

Ci verrà chiesto di accettare le condizioni di utilizzo, clicchiamo su I Accept e attendiamo qualche secondo per la creazione del progetto. A conferma avvenuta clicchiamo sul pulsante Ok.

Web Matrix configura per noi tutto l'ambiente di lavoro, fornendoci fin da subito la possibilità di avviare il sito, che sarà hostato sulla nostra macchina locale grazie ad IIS Express. Cliccando sul link etichettato URL verrà aperto il browser predefinito che visualizzerà il sito web.

Configurazione iniziale del sito web

Al primo avvio il framework di Orchard verifica l'esistenza di una configurazione per il sito; se non trovata, come nel nostro caso, verranno richieste le informazioni necessarie alla sua creazione. Dobbiamo semplicemente specificare il nome del sito, l'account dell'amministratore, il tipo di storage che vogliamo utilizzare e la preconfigurazione preferita.

Nome del sito e credenziali sono successivamente modificabili dal pannello di amministrazione, mentre non è così indolore modificare il tipo di storage, a scelta tra il nuovo SQL Server Compact, uno storage locale basato su file che non necessita di nessuna installazione aggiuntiva sul server che ospiterà il sito, o un'istanza di Sql Server, anche Express, che invece richiede una precedente installazione e configurazione. Il fatto che non sia indolore il passaggio non significa che non si possa fare, intanto per il nostro esempio utilizzeremo Sql Server Compact.

La scelta della preconfigurazione inziale, denominata Recipe nell'ecosistema Orchard, permette di preinstallazione e attivare tutta una serie di moduli utili ad una determinata tipologia di sito. La Default installa e attiva i moduli più comuni per un sito di presentazione contenuti, Blog invece installa e configura l'ambiente per essere usato come blog personale; Core invece è un'installazione base molto utile per lo sviluppo di moduli aggiuntivi. Scegliamo Default per il nostro esempio e clicchiamo sul pulsante Finish Setup.

Con la configurazione Default viene creata una Home Page all'interno della quale vengono inseriti, a titolo di esempio, dei contenuti in varie zone. Essendo autenticati automaticamente con il ruolo di amministratore, abbiamo i permessi necessari a editare tali contenuti, cliccando sulle piccole etichette Edit nell'angolo in alto a destra di ogni sezione.Andiamo ad esempio ad eliminare le tre colonne First, Second e Thrid Leader Aside, cliccando sulle rispettive etichette Edit.

Il click sull'etichetta Edit ci porta al pannello di amministrazione di Orchard, chiamato Dashboard, direttamente nella pagina che permette di gestire il contenuto sul quale si è cliccato. Scorrendo in fondo alla pagina troviamo il pulsante Delete per l'eliminazione del contenuto.

Creazione del tema

Il template utilizzato

Il template che utilizzeremo è stato selezionato dal cliente stesso da una collezione di temi scaricabili da internet.

Ovviamente il grafico ha apportato alcune modifiche per inserire il logo dell'azienda, e localizzare in italiano i testi di alcune immagini.

Creazione del nuovo tema

Per creare il nostro tema abbiamo diverse possibilità, una di queste è l'utilizzo della console di Orchard, che potete avviare dalla cartella bin del progetto cliccando sul file Orchard.exe. Verrà aperta la console che, dopo qualche secondo, ci offrirà, attraverso il prompt, la possibiità di digitare dei comandi. Per la generazione di un tema il comando è codegen theme <nometema>, nel nostro caso codegen theme comapimpiantistica.

Come potete notare dalla figura il comando non è riconosciuto. Questo perchè anche la Code Generation è un modulo in Orchard e come tale va installato e attivato. Questa operazione si può fare da console, ma è più pratico utilizzare il pannello Modules della Dashboard, cliccare sul tab Gallery, cercare i moduli che rispondono al nome code generation e cliccare sul link Install.

Attiviamo il modulo e rilanciamo il comando, in modo da creare il nostro nuovo tema

Una volta creato il tema possiamo impostarlo come tema corrente dalla dashboard, selezionando la voce di menu Themes, e cliccando sul pulsante Set Current in corrispondenza del nuovo tema.

Ed ecco il risultato provvisorio:

Nel prossimo articolo vedremo come modificare il tema per ottenere l'aspetto scelto dal cliente.

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.

Espression Studio: uno sguardo d'insieme

Carmine Alfano — Tue, 22 Sep 2009 11:51:05 GMT
Revision 1 posted to Articoli by Carmine Alfano on 22/09/2009 13:51:05

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.

I Fondamenti del .Net Compact Framework

Liccardi Antonio — Mon, 14 Sep 2009 20:47:35 GMT
Current revision posted to Articoli by Liccardi Antonio on 14/09/2009 22:47:35

I Fondamenti del .Net Compact Framework

Inserito sotto: .net compact framework

Il .Net Compact Framework è l’ambiente integrato in Windows Mobile che consente l’esecuzione di applicazioni gestite, sviluppate in linguaggi di programmazione quali il VB.net e il C#. Il .Net Compact Framework (da ora in poi netCF), può essere considerato come una versione “snellita” del .Net Framework, ma al tempo stesso include namespace che non sono presenti nel fratello maggiore. Appare quindi evidente che il netCF è stato privato di classi che non avrebbero senso in applicazioni per sistemi come Windows Mobile, ma d’altro canto, è stato munito di classi per la gestione di eventi collegati alla telefonia, oppure di eventi connessi all’ottimizzazione di applicazioni a causa dell’hardware [limitato] di cui un dispositivo mobile è munito.

Una cosa importante da capire è che il netCF non è nato a partire dal .Net Framework, ma, anche se ne condivide l’architettura di base, è stato riscritto da zero al fine di includere solo il necessario per ottimizzare la gestione dei dispositivi mobili.

Architettura del .Net Compact Framework

L’architettura del netCF può essere riepilogata tramite la seguente figura:

Framework Class Library

E’ l’insieme delle classi, interfacce e tipi organizzati in namespace. Ha meno classi del fratello maggiore, ma a differenza di quest’ultimo include determinate classi per la gestione di determinate operazioni su i dispositivi mobili. La cosa interessante è che una discreta conoscenza del .Net Framework, facilita la comprensione del netCF. Nell’immagine seguente sono illustrate le classi presenti nel netCF in relazione a quelle presenti nel .Net Framework:

[Fonte: http://download.microsoft.com/download/9/B/6/9B64192D-7381-451E-8692-B6B450643412/poster_updated.pdf]

Common Language Runtime

Il CLR del netCF è stato ri-creato in base alle funzionalità del CLR per il .Net Framework. E’ possibile sviluppare le proprie applicazioni in VB.Net o C#, e il risultato è come sempre in MSIL, il linguaggio intermedio che verrà poi compilato runtime tramite il JIT (e quindi convertito in linguaggio macchina). Il CLR pone particolare attenzione alla memoria: infatti, poiché quasi sempre gira su dispositivi che hanno una limitata quantità di memoria, si occupa di gestire in modo efficiente, la quantità di memoria messa a disposizione.

Windows CE

Oltre al codice gestito, il netCF consente di sviluppare applicazioni in codice nativo. In realtà il netCF non sviluppa direttamente codice nativo, ma usa le dll native di Windows CE per raggiungere l’obiettivo. Tale modalità viene anche definita con il nome di Platform Invoke. Una caratteristica delle P/Invoke è che consentono di accedere ad oggetti COM tramite un’applicazione managed. In pratica il netCF non consente l’interazione diretta con gli oggetti COM, ma il workaround consiste nel richiamare tramite le P/Invoke una DLL wrapper dell’oggetto COM a cui bisogna accedere. Inoltre viene effettuato un marshalling dei tipi di dati tra il CLR e l’ambiente nativo. Le P/Invoke sono fornite tramite il namespace System.Runtime.InteropServices.

La Gestione della memoria nel .Net Compact Framework

Come già detto, il netCF ha una ottimale gestione della memoria, consentendo di far girare applicazioni in modo accettabile anche su dispositivi con limitata quantità di memoria (naturalmente sempre se l’applicazione richiede una quantità di memoria minore di quella disponibile!). Infatti, quando non è disponibile memoria sufficiente, in .NET Compact Framework vengono automaticamente rilasciate le strutture di dati interne non richieste dal codice attualmente in esecuzione. Inoltre, durante l’esecuzione di una applicazione non viene effettuato alcun accesso alle memoria ram. Dal punto di vista della protezione, invece, in caso di accesso alla memoria senza proprietario vengono sempre generate eccezioni.

In aggiunta a questo, come l’MSDN riporta:

“Mediante l'host del dominio applicazione vengono avviati le applicazioni .NET Compact Framework e Common Language Runtime. Le applicazioni .NET Compact Framework utilizzano lo spazio del codice e lo spazio dei dati statici e dinamici come le applicazioni native. Quando non sono in esecuzione applicazioni .NET Compact Framework, la RAM viene utilizzata solo per l'host del dominio applicazione, mentre una quantità ridotta di dati statici viene utilizzata da Common Language Runtime. In Windows CE .NET viene creato un host del dominio applicazione all'avvio di un'applicazione .NET Compact Framework.

Le applicazioni .NET Compact Framework vengono assemblate in file EXE e DLL, che possono essere memorizzati in un file system in sola lettura o in lettura/scrittura nella memoria flash oppure in sola lettura nella ROM. Questi file possono essere letti dal caricatore di classe di Common Language Runtime in blocchi indirizzabili direttamente, senza la creazione di una copia in memoria e senza che sia richiesta un'unità di gestione della memoria per creare una visualizzazione mappata in memoria del file.”

La memoria RAM e la memoria ROM vengono usate in questo modo:

RAM: viene in genere usata per la memorizzazione di strutture dati dinamiche e codice compilato tramite JIT. Il netCF usa una quantità prestabilita di RAM, che è pronto a liberare nel momento opportuno. Il CLR inoltre usa tecniche di code-pitching, liberando così spazi di memoria.

ROM: viene in genere usata per la memorizzazione del codice nativo di cui è costituito il CLR, ed in alcuni casi anche i file contenenti metadati e istruzioni MSIL (Microsoft Intermediate Language) per librerie di classi.

Tipi di dati

Come nel .Net Framework, anche nel netCF esistono 2 tipi di dati: per valore e per riferimento. Il primo serve per memorizzare solo valori, il secondo invece consente la memorizzazione di oggetti. La principale differenza tra i due è dove vengono memorizzati. I tipi di valore vengono allocati nello stack, i tipi di riferimento invece usano l’heap e per tale motivo necessitano di un garbage collector, al fine di liberare la memoria occupata e non più utile ai fini della corretta esecuzione di un’applicazione.

Bisogna aggiungere che il netCF supporta l’ereditarietà singola, la Reflection, e le Generics. Inoltre anche nel netCF il programmatore può far uso dei blocchi di codice try/catch/finally al fine di gestire eccezioni runtime.

Installazione del .Net Compact Framework

In genere il .Net Compact Framework viene installato insieme al Visual Studio. C’è da notare che non tutte le versioni di Visual Studio supportano la creazione di applicazioni per smart device: solo le versioni Standard e superiori di Visual Studio, hanno la possibilità di creare questo tipo di progetto. E’ necessario installare anche il Windows Mobile SDK, che include molti esempi di codice e gli indispensabili emulatori (nel prossimo articolo ne parleremo in dettaglio) per testare a fondo le nostre applicazioni.

Stato dell’arte

Attualmente il netCF si trova alla versione 3.5. Ecco alcune novità rispetto alle versioni precedenti sono le seguenti:

netCF 3.5 supporta Windows Communication Foundation;

netCF 3.5 consente di effettuare query su database, xml e oggetti in memoria tramite LINQ;

miglioramento delle windows form;

introduzione di SoundPlayer, che consente la riproduzione di più suoni;

supporto per la compressione tramite il namespace System.IO.Compression;

è stato aggiunto il profiler CLR, che consente di visualizzare l'heap gestito di un processo ed esaminare il comportamento del Garbage Collector;

Epilogo

Oggi giorno l’uso dei dispositivi mobili risulta sempre più diffuso. Basti pensare che sistemi operativi come Windows Mobile consentono di portarsi un vero e proprio ufficio in tasca, che di gran lunga facilitano il lavoro delle persone. Ma non solo. Il target non si limita ai soli lavoratori! Anche un adolescente,può farne uso per ascoltarne musica, consultare pagine web, controllare la posta. Insomma, appare evidente che i dispositivi mobili si prestano ad una marea di usi, indipendentemente da chi li usa.

In questa primo articolo, abbiamo dato un’occhiata al cuore che consente di far “pulsare” le nostre applicazioni su Windows Mobile. La conoscenza del netCF risulta necessaria per capire innanzitutto come dover sviluppare le nostre applicazioni, ma anche come ottenerne il meglio sfruttando appieno ciò che il netCF ci mette a disposizione.

Per il momento non mi resta che salutarvi e darvi appuntamento al prossimo articolo.

Stay tuned :)

[Bibliografia]
- Sezione relativa al .Net Compact Framework su MSDN;
- Professional Microsoft Smartphone Programming (Yang, Zheng, Ni) - Wiley 2007

I Fondamenti del .Net Compact Framework

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

I Fondamenti del .Net Compact Framework

Inserito sotto: .net compact framework

Il .Net Compact Framework è l’ambiente integrato in Windows Mobile che consente l’esecuzione di applicazioni gestite, sviluppate in linguaggi di programmazione quali il VB.net e il C#. Il .Net Compact Framework (da ora in poi netCF), può essere considerato come una versione “snellita” del .Net Framework, ma al tempo stesso include namespace che non sono presenti nel fratello maggiore. Appare quindi evidente che il netCF è stato privato di classi che non avrebbero senso in applicazioni per sistemi come Windows Mobile, ma d’altro canto, è stato munito di classi per la gestione di eventi collegati alla telefonia, oppure di eventi connessi all’ottimizzazione di applicazioni a causa dell’hardware [limitato] di cui un dispositivo mobile è munito.

Una cosa importante da capire è che il netCF non è nato a partire dal .Net Framework, ma, anche se ne condivide l’architettura di base, è stato riscritto da zero al fine di includere solo il necessario per ottimizzare la gestione dei dispositivi mobili.

Architettura del .Net Compact Framework

L’architettura del netCF può essere riepilogata tramite la seguente figura:

Framework Class Library

E’ l’insieme delle classi, interfacce e tipi organizzati in namespace. Ha meno classi del fratello maggiore, ma a differenza di quest’ultimo include determinate classi per la gestione di determinate operazioni su i dispositivi mobili. La cosa interessante è che una discreta conoscenza del .Net Framework, facilita la comprensione del netCF. Nell’immagine seguente sono illustrate le classi presenti nel netCF in relazione a quelle presenti nel .Net Framework:

[Fonte: http://download.microsoft.com/download/9/B/6/9B64192D-7381-451E-8692-B6B450643412/poster_updated.pdf]

Common Language Runtime

Il CLR del netCF è stato ri-creato in base alle funzionalità del CLR per il .Net Framework. E’ possibile sviluppare le proprie applicazioni in VB.Net o C#, e il risultato è come sempre in MSIL, il linguaggio intermedio che verrà poi compilato runtime tramite il JIT (e quindi convertito in linguaggio macchina). Il CLR pone particolare attenzione alla memoria: infatti, poiché quasi sempre gira su dispositivi che hanno una limitata quantità di memoria, si occupa di gestire in modo efficiente, la quantità di memoria messa a disposizione.

Windows CE

Oltre al codice gestito, il netCF consente di sviluppare applicazioni in codice nativo. In realtà il netCF non sviluppa direttamente codice nativo, ma usa le dll native di Windows CE per raggiungere l’obiettivo. Tale modalità viene anche definita con il nome di Platform Invoke. Una caratteristica delle P/Invoke è che consentono di accedere ad oggetti COM tramite un’applicazione managed. In pratica il netCF non consente l’interazione diretta con gli oggetti COM, ma il workaround consiste nel richiamare tramite le P/Invoke una DLL wrapper dell’oggetto COM a cui bisogna accedere. Inoltre viene effettuato un marshalling dei tipi di dati tra il CLR e l’ambiente nativo. Le P/Invoke sono fornite tramite il namespace System.Runtime.InteropServices.

La Gestione della memoria nel .Net Compact Framework

Come già detto, il netCF ha una ottimale gestione della memoria, consentendo di far girare applicazioni in modo accettabile anche su dispositivi con limitata quantità di memoria (naturalmente sempre se l’applicazione richiede una quantità di memoria minore di quella disponibile!). Infatti, quando non è disponibile memoria sufficiente, in .NET Compact Framework vengono automaticamente rilasciate le strutture di dati interne non richieste dal codice attualmente in esecuzione. Inoltre, durante l’esecuzione di una applicazione non viene effettuato alcun accesso alle memoria ram. Dal punto di vista della protezione, invece, in caso di accesso alla memoria senza proprietario vengono sempre generate eccezioni.

In aggiunta a questo, come l’MSDN riporta:

“Mediante l'host del dominio applicazione vengono avviati le applicazioni .NET Compact Framework e Common Language Runtime. Le applicazioni .NET Compact Framework utilizzano lo spazio del codice e lo spazio dei dati statici e dinamici come le applicazioni native. Quando non sono in esecuzione applicazioni .NET Compact Framework, la RAM viene utilizzata solo per l'host del dominio applicazione, mentre una quantità ridotta di dati statici viene utilizzata da Common Language Runtime. In Windows CE .NET viene creato un host del dominio applicazione all'avvio di un'applicazione .NET Compact Framework.

Le applicazioni .NET Compact Framework vengono assemblate in file EXE e DLL, che possono essere memorizzati in un file system in sola lettura o in lettura/scrittura nella memoria flash oppure in sola lettura nella ROM. Questi file possono essere letti dal caricatore di classe di Common Language Runtime in blocchi indirizzabili direttamente, senza la creazione di una copia in memoria e senza che sia richiesta un'unità di gestione della memoria per creare una visualizzazione mappata in memoria del file.”

La memoria RAM e la memoria ROM vengono usate in questo modo:

RAM: viene in genere usata per la memorizzazione di strutture dati dinamiche e codice compilato tramite JIT. Il netCF usa una quantità prestabilita di RAM, che è pronto a liberare nel momento opportuno. Il CLR inoltre usa tecniche di code-pitching, liberando così spazi di memoria.

ROM: viene in genere usata per la memorizzazione del codice nativo di cui è costituito il CLR, ed in alcuni casi anche i file contenenti metadati e istruzioni MSIL (Microsoft Intermediate Language) per librerie di classi.

Tipi di dati

Come nel .Net Framework, anche nel netCF esistono 2 tipi di dati: per valore e per riferimento. Il primo serve per memorizzare solo valori, il secondo invece consente la memorizzazione di oggetti. La principale differenza tra i due è dove vengono memorizzati. I tipi di valore vengono allocati nello stack, i tipi di riferimento invece usano l’heap e per tale motivo necessitano di un garbage collector, al fine di liberare la memoria occupata e non più utile ai fini della corretta esecuzione di un’applicazione.

Bisogna aggiungere che il netCF supporta l’ereditarietà singola, la Reflection, e le Generics. Inoltre anche nel netCF il programmatore può far uso dei blocchi di codice try/catch/finally al fine di gestire eccezioni runtime.

Installazione del .Net Compact Framework

In genere il .Net Compact Framework viene installato insieme al Visual Studio. C’è da notare che non tutte le versioni di Visual Studio supportano la creazione di applicazioni per smart device: solo le versioni Standard e superiori di Visual Studio, hanno la possibilità di creare questo tipo di progetto. E’ necessario installare anche il Windows Mobile SDK, che include molti esempi di codice e gli indispensabili emulatori (nel prossimo articolo ne parleremo in dettaglio) per testare a fondo le nostre applicazioni.

Stato dell’arte

Attualmente il netCF si trova alla versione 3.5. Ecco alcune novità rispetto alle versioni precedenti sono le seguenti:

netCF 3.5 supporta Windows Communication Foundation;

netCF 3.5 consente di effettuare query su database, xml e oggetti in memoria tramite LINQ;

miglioramento delle windows form;

introduzione di SoundPlayer, che consente la riproduzione di più suoni;

supporto per la compressione tramite il namespace System.IO.Compression;

è stato aggiunto il profiler CLR, che consente di visualizzare l'heap gestito di un processo ed esaminare il comportamento del Garbage Collector;

Epilogo

Oggi giorno l’uso dei dispositivi mobili risulta sempre più diffuso. Basti pensare che sistemi operativi come Windows Mobile consentono di portarsi un vero e proprio ufficio in tasca, che di gran lunga facilitano il lavoro delle persone. Ma non solo. Il target non si limita ai soli lavoratori! Anche un adolescente,può farne uso per ascoltarne musica, consultare pagine web, controllare la posta. Insomma, appare evidente che i dispositivi mobili si prestano ad una marea di usi, indipendentemente da chi li usa.

In questa primo articolo, abbiamo dato un’occhiata al cuore che consente di far “pulsare” le nostre applicazioni su Windows Mobile. La conoscenza del netCF risulta necessaria per capire innanzitutto come dover sviluppare le nostre applicazioni, ma anche come ottenerne il meglio sfruttando appieno ciò che il netCF ci mette a disposizione.

Per il momento non mi resta che salutarvi e darvi appuntamento al prossimo articolo.

Stay tuned :)

[Bibliografia]
- Sezione relativa al .Net Compact Framework su MSDN;
- Professional Microsoft Smartphone Programming (Yang, Zheng, Ni) - Wiley 2007

I Fondamenti del .Net Compact Framework

Liccardi Antonio — Mon, 14 Sep 2009 20:39:40 GMT
Revision 1 posted to Articoli by Liccardi Antonio on 14/09/2009 22:39:40

Il .Net Compact Framework è l’ambiente integrato in Windows Mobile che consente l’esecuzione di applicazioni gestite, sviluppate in linguaggi di programmazione quali il VB.net e il C#. Il .Net Compact Framework (da ora in poi netCF), può essere considerato come una versione “snellita” del .Net Framework, ma al tempo stesso include namespace che non sono presenti nel fratello maggiore. Appare quindi evidente che il netCF è stato privato di classi che non avrebbero senso in applicazioni per sistemi come Windows Mobile, ma d’altro canto, è stato munito di classi per la gestione di eventi collegati alla telefonia, oppure di eventi connessi all’ottimizzazione di applicazioni a causa dell’hardware [limitato] di cui un dispositivo mobile è munito.

Una cosa importante da capire è che il netCF non è nato a partire dal .Net Framework, ma, anche se ne condivide l’architettura di base, è stato riscritto da zero al fine di includere solo il necessario per ottimizzare la gestione dei dispositivi mobili.

Architettura del .Net Compact Framework

L’architettura del netCF può essere riepilogata tramite la seguente figura:

Framework Class Library

E’ l’insieme delle classi, interfacce e tipi organizzati in namespace. Ha meno classi del fratello maggiore, ma a differenza di quest’ultimo include determinate classi per la gestione di determinate operazioni su i dispositivi mobili. La cosa interessante è che una discreta conoscenza del .Net Framework, facilita la comprensione del netCF. Nell’immagine seguente sono illustrate le classi presenti nel netCF in relazione a quelle presenti nel .Net Framework:

[Fonte: http://download.microsoft.com/download/9/B/6/9B64192D-7381-451E-8692-B6B450643412/poster_updated.pdf]

Common Language Runtime

Il CLR del netCF è stato ri-creato in base alle funzionalità del CLR per il .Net Framework. E’ possibile sviluppare le proprie applicazioni in VB.Net o C#, e il risultato è come sempre in MSIL, il linguaggio intermedio che verrà poi compilato runtime tramite il JIT (e quindi convertito in linguaggio macchina). Il CLR pone particolare attenzione alla memoria: infatti, poiché quasi sempre gira su dispositivi che hanno una limitata quantità di memoria, si occupa di gestire in modo efficiente, la quantità di memoria messa a disposizione.

Windows CE

Oltre al codice gestito, il netCF consente di sviluppare applicazioni in codice nativo. In realtà il netCF non sviluppa direttamente codice nativo, ma usa le dll native di Windows CE per raggiungere l’obiettivo. Tale modalità viene anche definita con il nome di Platform Invoke. Una caratteristica delle P/Invoke è che consentono di accedere ad oggetti COM tramite un’applicazione managed. In pratica il netCF non consente l’interazione diretta con gli oggetti COM, ma il workaround consiste nel richiamare tramite le P/Invoke una DLL wrapper dell’oggetto COM a cui bisogna accedere. Inoltre viene effettuato un marshalling dei tipi di dati tra il CLR e l’ambiente nativo. Le P/Invoke sono fornite tramite il namespace System.Runtime.InteropServices.

La Gestione della memoria nel .Net Compact Framework

Come già detto, il netCF ha una ottimale gestione della memoria, consentendo di far girare applicazioni in modo accettabile anche su dispositivi con limitata quantità di memoria (naturalmente sempre se l’applicazione richiede una quantità di memoria minore di quella disponibile!). Infatti, quando non è disponibile memoria sufficiente, in .NET Compact Framework vengono automaticamente rilasciate le strutture di dati interne non richieste dal codice attualmente in esecuzione. Inoltre, durante l’esecuzione di una applicazione non viene effettuato alcun accesso alle memoria ram. Dal punto di vista della protezione, invece, in caso di accesso alla memoria senza proprietario vengono sempre generate eccezioni.

In aggiunta a questo, come l’MSDN riporta:

“Mediante l'host del dominio applicazione vengono avviati le applicazioni .NET Compact Framework e Common Language Runtime. Le applicazioni .NET Compact Framework utilizzano lo spazio del codice e lo spazio dei dati statici e dinamici come le applicazioni native. Quando non sono in esecuzione applicazioni .NET Compact Framework, la RAM viene utilizzata solo per l'host del dominio applicazione, mentre una quantità ridotta di dati statici viene utilizzata da Common Language Runtime. In Windows CE .NET viene creato un host del dominio applicazione all'avvio di un'applicazione .NET Compact Framework.

Le applicazioni .NET Compact Framework vengono assemblate in file EXE e DLL, che possono essere memorizzati in un file system in sola lettura o in lettura/scrittura nella memoria flash oppure in sola lettura nella ROM. Questi file possono essere letti dal caricatore di classe di Common Language Runtime in blocchi indirizzabili direttamente, senza la creazione di una copia in memoria e senza che sia richiesta un'unità di gestione della memoria per creare una visualizzazione mappata in memoria del file.”

La memoria RAM e la memoria ROM vengono usate in questo modo:

RAM: viene in genere usata per la memorizzazione di strutture dati dinamiche e codice compilato tramite JIT. Il netCF usa una quantità prestabilita di RAM, che è pronto a liberare nel momento opportuno. Il CLR inoltre usa tecniche di code-pitching, liberando così spazi di memoria.

ROM: viene in genere usata per la memorizzazione del codice nativo di cui è costituito il CLR, ed in alcuni casi anche i file contenenti metadati e istruzioni MSIL (Microsoft Intermediate Language) per librerie di classi.

Tipi di dati

Come nel .Net Framework, anche nel netCF esistono 2 tipi di dati: per valore e per riferimento. Il primo serve per memorizzare solo valori, il secondo invece consente la memorizzazione di oggetti. La principale differenza tra i due è dove vengono memorizzati. I tipi di valore vengono allocati nello stack, i tipi di riferimento invece usano l’heap e per tale motivo necessitano di un garbage collector, al fine di liberare la memoria occupata e non più utile ai fini della corretta esecuzione di un’applicazione.

Bisogna aggiungere che il netCF supporta l’ereditarietà singola, la Reflection, e le Generics. Inoltre anche nel netCF il programmatore può far uso dei blocchi di codice try/catch/finally al fine di gestire eccezioni runtime.

Installazione del .Net Compact Framework

In genere il .Net Compact Framework viene installato insieme al Visual Studio. C’è da notare che non tutte le versioni di Visual Studio supportano la creazione di applicazioni per smart device: solo le versioni Standard e superiori di Visual Studio, hanno la possibilità di creare questo tipo di progetto. E’ necessario installare anche il Windows Mobile SDK, che include molti esempi di codice e gli indispensabili emulatori (nel prossimo articolo ne parleremo in dettaglio) per testare a fondo le nostre applicazioni.

Stato dell’arte

Attualmente il netCF si trova alla versione 3.5. Ecco alcune novità rispetto alle versioni precedenti sono le seguenti:

netCF 3.5 supporta Windows Communication Foundation;

netCF 3.5 consente di effettuare query su database, xml e oggetti in memoria tramite LINQ;

miglioramento delle windows form;

introduzione di SoundPlayer, che consente la riproduzione di più suoni;

supporto per la compressione tramite il namespace System.IO.Compression;

è stato aggiunto il profiler CLR, che consente di visualizzare l'heap gestito di un processo ed esaminare il comportamento del Garbage Collector;

Epilogo

Oggi giorno l’uso dei dispositivi mobili risulta sempre più diffuso. Basti pensare che sistemi operativi come Windows Mobile consentono di portarsi un vero e proprio ufficio in tasca, che di gran lunga facilitano il lavoro delle persone. Ma non solo. Il target non si limita ai soli lavoratori! Anche un adolescente,può farne uso per ascoltarne musica, consultare pagine web, controllare la posta. Insomma, appare evidente che i dispositivi mobili si prestano ad una marea di usi, indipendentemente da chi li usa.

In questa primo articolo, abbiamo dato un’occhiata al cuore che consente di far “pulsare” le nostre applicazioni su Windows Mobile. La conoscenza del netCF risulta necessaria per capire innanzitutto come dover sviluppare le nostre applicazioni, ma anche come ottenerne il meglio sfruttando appieno ciò che il netCF ci mette a disposizione.

Per il momento non mi resta che salutarvi e darvi appuntamento al prossimo articolo.

Stay tuned :)

[Bibliografia]
- Sezione relativa al .Net Compact Framework su MSDN;
- Professional Microsoft Smartphone Programming (Yang, Zheng, Ni)

Architettura: tutto comincia dai requisiti!

Michele Aponte — Sun, 13 Sep 2009 20:45:26 GMT
Current revision posted to Articoli by Michele Aponte on 13/09/2009 22:45:26

ArchietturaArchitettura: tutto comincia dai requisiti!

Inserito sotto: Architettura

Rieccoci a parlare di architettura e come promesso in questo appuntamento parleremo di requisiti, i famosi requisiti software da cui un architetto comincia il suo lavoro e l’analista termina il suo con la loro definizione.

Che cos’è un requisito?

In accordo con la standardizzazione IEEE un requisito può essere definito come:

1. Una condizione o capacità necessaria ad un utente per risolvere un problema o raggiungere un obiettivo

2. Una condizione o capacità che deve essere posseduta dal sistema o da un componente del sistema per soddisfare un contratto, uno standard, una specifica o altre formalizzazioni.

3. Una rappresentazione documentata di una condizione o capacità che soddisfi i primi due punti

Alla luce di questa definizione, che ci aiuta a formalizzare meglio il concetto abbastanza intuitivo di requisito software, possiamo dunque dire che un requisito è un una capacità che il sistema deve possedere per risolvere un problema dell’utente, formalizzata opportunamente e opportunamente documentata.

Il fatto che un requisito per essere tale debba essere scritto da qualche parte è una fattore fondamentale: è l’unico modo di renderlo comunicabile efficacemente a chi ha bisogno di conoscerlo!

Tipologie di requisiti

Secondo la norma ISO 9126 è possibile raggruppare i requisiti in 6 categorie e 21 sottocategorie, alcune orientate all’utente, altre orientate allo sviluppo e manutenzione. Ognuna di queste categorie rappresenta una caratteristica del sistema:

Funzionalità

Esprime la capacità del sistema di soddisfare esigenze implicite o esplicite.

Idoneità:esprime l’appropriatezza delle funzionalità a specifici compiti.

Accuratezza: esprime la precisione con cui vengono forniti i risultati.

Interoperabilità: esprime la capacità di interagire con altre applicazioni

Sicurezza: esprime la protezione da utilizzi non autorizzati

Concordanza: esprime l’aderenza a standard o regolamentazioni legislative

Disponibilità

Esprime la capacità di fornire continuità nel servizio.

Maturità: esprime la mancanza di interruzioni per malfunzionamenti

Tolleranza: esprime il degrado delle prestazioni in presenza di malfunzionamenti

Recupero: esprime la capacità e la velocità di rispristino a seguito di malfunzionamenti

Usabilità

Esprime la facilità di utilizzo da parte degli utenti.

Comprensione: esprime la capacità di acquisire un adeguato livello di conoscenza del sistema

Apprendimento: esprime la facilità di familiarizzazione del sistema

Utilizzabilità: esprime la facilità di uso e controllo del sistema

Attrattiva: esprime il livello di gradimento nell’utilizzo del sistema

Efficienza

Esprime la capacità di fornire prestazioni adeguate

Tempo risposta: esprime la reattività agli stimoli dell’utente

Utilizzo di risorse: esprime l’adeguatezza dell’utilizzo delle risorse del sistema

Manutenibilità

Esprime la facilità di manutenzione correttiva ed evolutiva.

Analizzabilità: esprime la facilità di diagnosi e individuazione dei componenti

Modificabilità: esprime la facilità di applicazione delle modifiche al sistema

Stabilità: esprime il grado di introduzione effetti indesiderati a seguito di modifiche al sistema

Collaudabilità: esprime la capacità di testare le modifiche effettuate

Portabilità

Esprime la capacità di trasferibilità da un ambiente ad un altro

Adattabilità: esprime la facilità di adeguamento ad un nuovo ambiente

Installabilità: esprime la velocità e completezza di installazione

Coesistenza: esprime la capacità di risiedere con altre applicazioni nello stesso ambiente

Sostituibilità: esprime la capacità di rimpiazzare un’altra applicazione con simili funzionalità

Come si esprimono i requisiti?

Una volta capito cos’è un requisito chiediamoci adesso come esprimerli, una volta raccolti, in modo che sia possibile fornire la sopracitata rappresentazione documentata.

Il primo passo in assoluto da compiere è essere sicuri che abbiamo circoscritto per bene il sistema e gli unici a darci conferma della nostra corretta interpretazione delle interviste effettuate sono proprio gli intervistati: gli stakeholder! Dobbiamo quindi compilare per loro un documento che non utilizzi formalismi tecnici e che sia capace di descrivere, anche brevemente, quello che secondo noi è il sistema di cui il cliente ha bisogno. Questo documento ha un nome…

Documento di Vision e Scopo

Il documento di Vision e Scopo serve fondamentalmente ad allineare l’opinione di tutti gli stakeholder su quello che sarà fatto e a risolvere i conflitti nati da pareri discordati degli stessi.

Volendo fornire un template di tale documento, possiamo schematizzarlo nella seguente struttura:

Requisiti di Business

In questa sezione vengono descritti i principali benefici del nuovo sistema, con un’enfasi diversa a seconda del tipo di prodotto da realizzare.

Premessa:

in questo paragrafo descriveremo la storia delle valutazioni effettuate che hanno portato alla decisione di realizzare il prodotto.

Opportunità:

per un prodotto da immettere sul mercato in questo paragrafo descriveremo i principali fattori che potrebbero causare il successo delle vendite, nel caso di prodotto commissionato per una specifica azienda descriveremo i vantaggi dell’uso del sistema.

Obiettivi e criteri si successo:

in questo paragrafo descriveremo i vantaggi, in termini statistici e/o numerici, dell’adozione del prodotto; per un nuovo portale ad esempio descriveremo l’incremento di visite derivante dall’adozione del nuovo sistema.

Necessità del cliente o del mercato:

senza entrare nel dettaglio tecnico, descriveremo in questo paragrafo le necessità di un tipico cliente o del segmento del mercato in cui si colloca il prodotto, descrivendo ad esempio come il cliente dovrebbe usare il sistema.

Rischi:

qui descriveremo i potenziali rischi a cui si potrebbe andare incontro durante e dopo lo sviluppo del sistema; ad esempio un radicale cambio di interfaccia potrebbe portare l’utente a smettere di utilizzare il nuovo prodotto.

Vision della soluzione

In questa sezione sarà descritto il sistema che si andrà a realizzare per soddisfare gli obiettivi proposti. Non saranno descritti né i requisiti funzionali né informazioni sulla pianificazione del progetto.

Descrizione della soluzione:

in questo paragrafo sarà riassunto il sistema che sarà realizzato e come quest’ultimo permette di raggiungere gli obiettivi proposti. Si tratta di una descrizione che deve indicare le seguenti informazioni:

Per: clienti target

che: necessità e opportunità

il: nome del prodotto

è: la categoria del prodotto

che: benefici e/o ragioni che portano all’acquisto e/o all’utilizzo

a differenza: del sistema esistente o del non utilizzo del nuovo sistema

il nostro prodotto: principali differenze e vantaggi del nuovo prodotto

Un esempio potrebbe essere:

Per gli utenti che necessitano di emettere fatture e altri documenti in modalità differita, il nuovo MDVIN è un software gestionale che permette una gestione automatizzata di tutti i documenti necessari alla gestione di impresa. A differenza del suo predecessore il nostro prodotto permette di lavorare in modalità disconnessa da tutte le postazioni, sincronizzando solo quando necessario o indicato i dati con il server centrale.

Chiaramente sono indicazioni, che permettono di restare sintetici e incisivi sulle informazioni fornite.

Principali caratteristiche:

In questo paragrafo descriveremo le principali caratteristiche del nuovo prodotto, indicando cosa il nuovo sistema farà. Le nuove features vanno elencate con un identificativo univoco, in modo da potercisi riferire facilmente. E’ inoltre possibile fare confronti con prodotti direttamente concorrenti o precedenti versioni del sistema.

Assunzioni e dipendenze:

Qui è possibile elencare tutte le assunzioni venute fuori dalle interviste con gli stakeholder, probabilmente diverse o addirittura in contrasto tra di loro. Questo è il momento per mettere ordine e allineare tutti. E’ qui inoltre che vengono descritte eventuali dipendenze da altri sistemi o standard.

Scopo e limitazioni

In questa sezione saranno illustrati scopi e limitazioni del nuovo prodotto definendo delle priorità per i vari rilasci. Qui indicheremo sostanzialmente cosa il sistema farà e non farà.

Scopo del primo rilascio

Qui verranno descritte le priorità che saranno perseguite per il primo rilascio del software.

Scopo dei rilasci successivi

In questo paragrafo verranno descritte le schedulazioni dei vari rilasci fino al raggiungimento di tutti gli obiettivi mediante l’implementazione di tutte le caratteristiche.

Limitazioni ed esclusioni

Questo è il momento migliore per indicare cosa il sistema non farà e i limiti del suo utilizzo, indicando eventualmente eventuali predisposizioni a sviluppi futuri.

Contesto di analisi

In questa sezione viene descritto il contesto in cui ci muoviamo, indicando le categorie di stakeholder intervistati, le priorità del progetto e l’ambiente in cui il sistema sarà utilizzato.

Profili degli stakeholder

In questo paragrafo descriveremo schematicamente le categorie di stakeholder intervistati. Non necessariamente tutti vanno inclusi, solamente i più indicativi per gli obiettivi del progetto.

Priorità del progetto

Qui descriveremo le priorità funzionali e non funzionali del progetto, bilanciando tempi di sviluppo e obiettivi delle varie release, costi e benefici, considerando le cinque dimensioni di un progetto software: features, qualità, schedulazione, costo e staff.

Ambiente operativo

In questo paragrafo sarà descritto l’ambiente operativo in cui il sistema sarà utilizzato definendo la disponibilità, le performance e l’integrità richiesta. Queste informazioni influenzeranno sensibilmente l’architettura del sistema.

Naturalmente non tutte le voci potrebbero applicarsi a tutti i progetti ma soprattutto ricordiamoci che tale documento dovrà essere letto e approvato dagli stakeholder ed essendo un documento preliminare non mettiamoci a scrivere la bibbia del progetto: il documento deve essere sintetico altrimenti nessuno lo leggerà (o diranno di averlo letto ma in verità non lo hanno fatto!)

Conclusioni

Una volta avuta l’approvazione dagli stakeholder, dopo le n revisioni del documento, si passa alla realizzazione dei documenti che arriveranno all’architetto e da cui comincerà il suo lavoro! Alla prossima puntata!

Archiettura: tutto comincia dai requisiti!

Michele Aponte — Sun, 13 Sep 2009 20:43:26 GMT
Revision 1 posted to Articoli by Michele Aponte on 13/09/2009 22:43:26

Rieccoci a parlare di architettura e come promesso in questo appuntamento parleremo di requisiti, i famosi requisiti software da cui un architetto comincia il suo lavoro e l’analista termina il suo con la loro definizione.

Che cos’è un requisito?

In accordo con la standardizzazione IEEE un requisito può essere definito come:

1. Una condizione o capacità necessaria ad un utente per risolvere un problema o raggiungere un obiettivo

2. Una condizione o capacità che deve essere posseduta dal sistema o da un componente del sistema per soddisfare un contratto, uno standard, una specifica o altre formalizzazioni.

3. Una rappresentazione documentata di una condizione o capacità che soddisfi i primi due punti

Alla luce di questa definizione, che ci aiuta a formalizzare meglio il concetto abbastanza intuitivo di requisito software, possiamo dunque dire che un requisito è un una capacità che il sistema deve possedere per risolvere un problema dell’utente, formalizzata opportunamente e opportunamente documentata.

Il fatto che un requisito per essere tale debba essere scritto da qualche parte è una fattore fondamentale: è l’unico modo di renderlo comunicabile efficacemente a chi ha bisogno di conoscerlo!

Tipologie di requisiti

Secondo la norma ISO 9126 è possibile raggruppare i requisiti in 6 categorie e 21 sottocategorie, alcune orientate all’utente, altre orientate allo sviluppo e manutenzione. Ognuna di queste categorie rappresenta una caratteristica del sistema:

Funzionalità

Esprime la capacità del sistema di soddisfare esigenze implicite o esplicite.

Idoneità:esprime l’appropriatezza delle funzionalità a specifici compiti.

Accuratezza: esprime la precisione con cui vengono forniti i risultati.

Interoperabilità: esprime la capacità di interagire con altre applicazioni

Sicurezza: esprime la protezione da utilizzi non autorizzati

Concordanza: esprime l’aderenza a standard o regolamentazioni legislative

Disponibilità

Esprime la capacità di fornire continuità nel servizio.

Maturità: esprime la mancanza di interruzioni per malfunzionamenti

Tolleranza: esprime il degrado delle prestazioni in presenza di malfunzionamenti

Recupero: esprime la capacità e la velocità di rispristino a seguito di malfunzionamenti

Usabilità

Esprime la facilità di utilizzo da parte degli utenti.

Comprensione: esprime la capacità di acquisire un adeguato livello di conoscenza del sistema

Apprendimento: esprime la facilità di familiarizzazione del sistema

Utilizzabilità: esprime la facilità di uso e controllo del sistema

Attrattiva: esprime il livello di gradimento nell’utilizzo del sistema

Efficienza

Esprime la capacità di fornire prestazioni adeguate

Tempo risposta: esprime la reattività agli stimoli dell’utente

Utilizzo di risorse: esprime l’adeguatezza dell’utilizzo delle risorse del sistema

Manutenibilità

Esprime la facilità di manutenzione correttiva ed evolutiva.

Analizzabilità: esprime la facilità di diagnosi e individuazione dei componenti

Modificabilità: esprime la facilità di applicazione delle modifiche al sistema

Stabilità: esprime il grado di introduzione effetti indesiderati a seguito di modifiche al sistema

Collaudabilità: esprime la capacità di testare le modifiche effettuate

Portabilità

Esprime la capacità di trasferibilità da un ambiente ad un altro

Adattabilità: esprime la facilità di adeguamento ad un nuovo ambiente

Installabilità: esprime la velocità e completezza di installazione

Coesistenza: esprime la capacità di risiedere con altre applicazioni nello stesso ambiente

Sostituibilità: esprime la capacità di rimpiazzare un’altra applicazione con simili funzionalità

Come si esprimono i requisiti?

Una volta capito cos’è un requisito chiediamoci adesso come esprimerli, una volta raccolti, in modo che sia possibile fornire la sopracitata rappresentazione documentata.

Il primo passo in assoluto da compiere è essere sicuri che abbiamo circoscritto per bene il sistema e gli unici a darci conferma della nostra corretta interpretazione delle interviste effettuate sono proprio gli intervistati: gli stakeholder! Dobbiamo quindi compilare per loro un documento che non utilizzi formalismi tecnici e che sia capace di descrivere, anche brevemente, quello che secondo noi è il sistema di cui il cliente ha bisogno. Questo documento ha un nome…

Documento di Vision e Scopo

Il documento di Vision e Scopo serve fondamentalmente ad allineare l’opinione di tutti gli stakeholder su quello che sarà fatto e a risolvere i conflitti nati da pareri discordati degli stessi.

Volendo fornire un template di tale documento, possiamo schematizzarlo nella seguente struttura:

Requisiti di Business

In questa sezione vengono descritti i principali benefici del nuovo sistema, con un’enfasi diversa a seconda del tipo di prodotto da realizzare.

Premessa:

in questo paragrafo descriveremo la storia delle valutazioni effettuate che hanno portato alla decisione di realizzare il prodotto.

Opportunità:

per un prodotto da immettere sul mercato in questo paragrafo descriveremo i principali fattori che potrebbero causare il successo delle vendite, nel caso di prodotto commissionato per una specifica azienda descriveremo i vantaggi dell’uso del sistema.

Obiettivi e criteri si successo:

in questo paragrafo descriveremo i vantaggi, in termini statistici e/o numerici, dell’adozione del prodotto; per un nuovo portale ad esempio descriveremo l’incremento di visite derivante dall’adozione del nuovo sistema.

Necessità del cliente o del mercato:

senza entrare nel dettaglio tecnico, descriveremo in questo paragrafo le necessità di un tipico cliente o del segmento del mercato in cui si colloca il prodotto, descrivendo ad esempio come il cliente dovrebbe usare il sistema.

Rischi:

qui descriveremo i potenziali rischi a cui si potrebbe andare incontro durante e dopo lo sviluppo del sistema; ad esempio un radicale cambio di interfaccia potrebbe portare l’utente a smettere di utilizzare il nuovo prodotto.

Vision della soluzione

In questa sezione sarà descritto il sistema che si andrà a realizzare per soddisfare gli obiettivi proposti. Non saranno descritti né i requisiti funzionali né informazioni sulla pianificazione del progetto.

Descrizione della soluzione:

in questo paragrafo sarà riassunto il sistema che sarà realizzato e come quest’ultimo permette di raggiungere gli obiettivi proposti. Si tratta di una descrizione che deve indicare le seguenti informazioni:

Per: clienti target

che: necessità e opportunità

il: nome del prodotto

è: la categoria del prodotto

che: benefici e/o ragioni che portano all’acquisto e/o all’utilizzo

a differenza: del sistema esistente o del non utilizzo del nuovo sistema

il nostro prodotto: principali differenze e vantaggi del nuovo prodotto

Un esempio potrebbe essere:

Per gli utenti che necessitano di emettere fatture e altri documenti in modalità differita, il nuovo MDVIN è un software gestionale che permette una gestione automatizzata di tutti i documenti necessari alla gestione di impresa. A differenza del suo predecessore il nostro prodotto permette di lavorare in modalità disconnessa da tutte le postazioni, sincronizzando solo quando necessario o indicato i dati con il server centrale.

Chiaramente sono indicazioni, che permettono di restare sintetici e incisivi sulle informazioni fornite.

Principali caratteristiche:

In questo paragrafo descriveremo le principali caratteristiche del nuovo prodotto, indicando cosa il nuovo sistema farà. Le nuove features vanno elencate con un identificativo univoco, in modo da potercisi riferire facilmente. E’ inoltre possibile fare confronti con prodotti direttamente concorrenti o precedenti versioni del sistema.

Assunzioni e dipendenze:

Qui è possibile elencare tutte le assunzioni venute fuori dalle interviste con gli stakeholder, probabilmente diverse o addirittura in contrasto tra di loro. Questo è il momento per mettere ordine e allineare tutti. E’ qui inoltre che vengono descritte eventuali dipendenze da altri sistemi o standard.

Scopo e limitazioni

In questa sezione saranno illustrati scopi e limitazioni del nuovo prodotto definendo delle priorità per i vari rilasci. Qui indicheremo sostanzialmente cosa il sistema farà e non farà.

Scopo del primo rilascio

Qui verranno descritte le priorità che saranno perseguite per il primo rilascio del software.

Scopo dei rilasci successivi

In questo paragrafo verranno descritte le schedulazioni dei vari rilasci fino al raggiungimento di tutti gli obiettivi mediante l’implementazione di tutte le caratteristiche.

Limitazioni ed esclusioni

Questo è il momento migliore per indicare cosa il sistema non farà e i limiti del suo utilizzo, indicando eventualmente eventuali predisposizioni a sviluppi futuri.

Contesto di analisi

In questa sezione viene descritto il contesto in cui ci muoviamo, indicando le categorie di stakeholder intervistati, le priorità del progetto e l’ambiente in cui il sistema sarà utilizzato.

Profili degli stakeholder

In questo paragrafo descriveremo schematicamente le categorie di stakeholder intervistati. Non necessariamente tutti vanno inclusi, solamente i più indicativi per gli obiettivi del progetto.

Priorità del progetto

Qui descriveremo le priorità funzionali e non funzionali del progetto, bilanciando tempi di sviluppo e obiettivi delle varie release, costi e benefici, considerando le cinque dimensioni di un progetto software: features, qualità, schedulazione, costo e staff.

Ambiente operativo

In questo paragrafo sarà descritto l’ambiente operativo in cui il sistema sarà utilizzato definendo la disponibilità, le performance e l’integrità richiesta. Queste informazioni influenzeranno sensibilmente l’architettura del sistema.

Naturalmente non tutte le voci potrebbero applicarsi a tutti i progetti ma soprattutto ricordiamoci che tale documento dovrà essere letto e approvato dagli stakeholder ed essendo un documento preliminare non mettiamoci a scrivere la bibbia del progetto: il documento deve essere sintetico altrimenti nessuno lo leggerà (o diranno di averlo letto ma in verità non lo hanno fatto!)

Conclusioni

Una volta avuta l’approvazione dagli stakeholder, dopo le n revisioni del documento, si passa alla realizzazione dei documenti che arriveranno all’architetto e da cui comincerà il suo lavoro! Alla prossima puntata!

Uno schedulatore in .Net

Alessandro Forte — Tue, 21 Jul 2009 07:56:18 GMT
Current revision posted to Articoli by Alessandro Forte on 21/07/2009 09:56:18

Spesso mi sono trovato ad affrontare problemi "banali e comuni" ma che richiedevano l'utilizzo di funzioni temporali.
Un classico sono i famosi Backup di archivi Access o di comuni files, la possibilità di mandare avvisi a cadenza temporale, o l'organizzazione di attività (task) in determinate ore della giornata...
Bene come avrete capito avevo bisogno quindi di uno Scheduler, italianizzato in Schedulatore.
Per definizione uno lo scheduler è un componente fondamentale dei sistemi operativi multitasking, cioè quelli in grado di eseguire più processi (task) concorrentemente.
Nel nostro caso possiamo semplicemente affermare che uno scheduler è un componente in grado di eseguire più processi (task) concorrentemente e in tempi prefissati.
La prima domanda che sorge spontanea è : "Esistono schedulators gratuiti o rilasciati in open source, tali da poter essere inclusi nei nostri progetti .Net?"

La risposta è : QUARTZ (che sottende il SI ed il nome del componente che ci risolve il problema [:D] )

Come cita direttamente il sito :
Quartz.NET is a port of very propular open source Java job scheduling framework, Quartz . This project owes very much to original Java project, it's father James House and the project contributors.
E' quindi un sistema "portato" da java (come il fantastico Log4Net) che offre una piattaforma di job scheduling.
Sempre il sito si promette di utilizzare il sistema in : Quartz.NET is a full-featured, open source job scheduling system that can be used from smallest apps to large scale enterprise systems.
L'ho utilizzato (e conosciuto grazie ad un collega [Maurizio ndr]) e mi sento di affermare che quanto dice è sicuramente vero.

Il sistema in sè è molto facile da utilizzare grazie all'apposita sezione di tutorials messi a disposizione dalla comunità di Quartz.

Nel prossimo articolo entrerò nel dettaglio di come implementare una soluzione completa utilizzando Quartz come framework di base per il job scheduling.

See u in the next episode

Hello Windows Mobile

Liccardi Antonio — Sun, 19 Jul 2009 15:33:27 GMT
Current revision posted to Articoli by Liccardi Antonio on 19/07/2009 17:33:27

Hello Windows Mobile

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.

Enjoy it!

Chiedo venia ma ci sono alcuni problemi tecnici e ho dovuto togliere momentaneamente

Sotto trovate le slides, il webcast. Quanto prima ripristinerò codice sorgente e il tutto filmato in alta qualità.

Slides: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/HelloWindowsMobile.ppsx]

Code: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/MyHelloWorld.zip]

Video HQ (promesso...)circa 170mb): [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/1_5F00_HelloWindowsMobile.rar]

Hello Windows Mobile

Liccardi Antonio — Thu, 16 Jul 2009 16:25:19 GMT
Revision 7 posted to Articoli by Liccardi Antonio on 16/07/2009 18:25:19

Hello Windows Mobile

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.

Enjoy it!


Chiedo venia ma ci sono alcuni problemi tecnici e ho dovuto togliere momentaneamente il webcast. Quanto prima ripristinerò il tutto (promesso...)

Hello Windows Mobile

Liccardi Antonio — Thu, 16 Jul 2009 16:24:27 GMT
Revision 6 posted to Articoli by Liccardi Antonio on 16/07/2009 18:24:27

Hello Windows Mobile

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.

Enjoy it!

Chiedo venia ma ci sono alcuni problemi tecnici e ho dovuto togliere momentaneamente il webcast. Quanto prima ripristinerò il tutto (promesso...)

Hello Windows Mobile

Liccardi Antonio — Mon, 13 Jul 2009 21:09:17 GMT
Revision 5 posted to Articoli by Liccardi Antonio on 13/07/2009 23:09:17

Hello Windows Mobile2Mobile

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.

Enjoy it!

Sotto trovate le slides, il codice sorgente e il filmato in alta qualità.

Slides: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/HelloWindowsMobile.ppsx]

Code: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/MyHelloWorld.zip]

Video HQ (circa 170mb): [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/1_5F00_HelloWindowsMobile.rar]

Hello Windows Mobile2

Liccardi Antonio — Mon, 13 Jul 2009 21:01:18 GMT
Revision 4 posted to Articoli by Liccardi Antonio on 13/07/2009 23:01:18

Hello Windows Mobile2

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.

Enjoy it!

Sotto trovate le slides, il codice sorgente e il filmato in alta qualità.

Slides: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/HelloWindowsMobile.ppsx]

Code: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/MyHelloWorld.zip]

Video HQ (circa 170mb): [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/1_5F00_HelloWindowsMobile.rar]

Hello Windows Mobile2

Liccardi Antonio — Mon, 13 Jul 2009 20:59:50 GMT
Revision 3 posted to Articoli by Liccardi Antonio on 13/07/2009 22:59:50

Hello Windows Mobile2

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.

Enjoy it!

Sotto trovate le slides, il codice sorgente e il filmato in alta qualità.

Slides: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/HelloWindowsMobile.ppsx]

Code: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/MyHelloWorld.zip]

Video HQ (circa 170mb): [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/1_5F00_HelloWindowsMobile.rar]

Hello Windows Mobile2

Liccardi Antonio — Mon, 13 Jul 2009 20:59:10 GMT
Revision 2 posted to Articoli by Liccardi Antonio on 13/07/2009 22:59:10

Hello Windows Mobile2

Inserito sotto: windows mobile first app

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare.
Enjoy it!

Sotto trovate le slides, il codice sorgente e il filmato in alta qualità.

Slides: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/HelloWindowsMobile.ppsx]

Code: [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/MyHelloWorld.zip]

Video HQ (circa 170mb): [View:http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Components.UserFiles/00.00.00.21.04/1_5F00_HelloWindowsMobile.rar]

Hello Windows Mobile2

Liccardi Antonio — Mon, 13 Jul 2009 20:58:41 GMT
Revision 1 posted to Articoli by Liccardi Antonio on 13/07/2009 22:58:41

Dopo circa 2 settimane di problemi tecnici incontrati (pc da formattare, problemi con camstudio, problemi con movie maker, problemi con community server...) sono riuscito finalmente a postare il primo webcast sulla programmazione in Windows Mobile. In questo webcast illustrerò come preparare la propria macchina per lo sviluppo di applicazioni per WM, e farò un semplice esempio di prima applicazione. Mi auguro che sia di vostro gradimento, per qualsiasi informazione o dubbio non esitate a postare. Enjoy it!

Sotto trovate le slides, il codice sorgente e il filmato in alta qualità.

Slides: (Please visit the site to view this media)

Code: (Please visit the site to view this media)

Video HQ (circa 170mb): (Please visit the site to view this media)

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Michele Aponte — Wed, 15 Jul 2009 20:42:17 GMT
Current revision posted to Articoli by Michele Aponte on 15/07/2009 22:42:17

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Inserito sotto: Certificazioni Esame 70-536

OOP: Object Oriented Programming

Oggi parliamo di programmazione ad oggetti, introducendone le caratteristiche principali e come queste sono implementate nel .NET Framework.

Come molti di voi sapranno la programmazione ad oggetti è un paradigma di programmazione adottato dalla stragrande maggioranza dei programmatori a partire dagli anni '90, anni in cui si è cominciato ad abbandonare il paradigma procedurale in cui la definizione dei tipi di dato vedeva separate la struttura del dato dalle procedure che operavano su di esse. A un certo punto si è giustamente pensato: ma se un'entità è caratterizzata da un insieme di informazioni e dalle operazioni che posso realizzare su di esse perchè la loro definizione deve essere separata? Ed ecco a voi nascere il concetto di classe che insieme alle 3 caratteristiche principali della OOP definisce questo nuovo modo di concepire l'organizzazione della soluzione algoritmica ad un problema dato.

INCAPSULAMENTO

Come detto tutto ruota intorno al concetto di classe, che possiamo vedere come il costrutto offerto dal linguaggio per realizzare l'astrazione del concetto di oggetto. In pratica il trucco sta nell'affrontare il problema da risolvere modellandolo come un sistema in cui esistono e vivono un insieme di oggeti che comunicano tra di loro attraverso un'interfaccia bene definita: i METODI della classe! La struttura del dato incapsulato nell'oggetto è invece definita da quelli che vengono chiamati ATTRIBUTI. Una classe è quindi costituita da attributi e metodi, che insieme definiscono un nuovo tipo di dato per l'ambiente in cui vengono definiti. Un oggetto è un'istanza di una data classe.

Due oggetti, istanza di una certa classe, possono differire in un certo istante di tempo per il valore che in quell'istante hanno i suoi attributi, che nel loro insieme definiscono lo STATO dell'oggetto. Il concetto di stato di un oggetto è di fondamentale importanza perchè su di esso di basa uno dei tre principi fondamentali dalla OOP: l'INFORMATION HIDING o INCAPSULAMENTO secondo il quale l'unico modo attraverso cui debba essere possibile modificare tale stato dovrebbe essere l'utilizzo dei metodi della classe. Tecnicamente questo è possibile grazie all'utilizzo di indicatori di visibilità per gli attributi che dovrebbero negarne l'accesso all'utilizzatore della classe. Quindi gli oggetti del sistema comunicano tra di loro attraverso messaggi scambiati grazie all'invocazione dei metodi alterandone lo stato.

In .NET è possibile realizzare una classe utilizzando il costrutto Class in Visual Basic e class in C#, è possibile definire gli attributi dichiarando all'interno delle classi delle variabili del tipo voluto, è possible definire i metodi definendo delle Sub o delle Function in Visual Basic, definendo delle funzioni in C#. Sia per gli attributi che per i metodi e possibile indicare la visibilità che essi devono avere rispetto agli utilizzatori delle classi, gli indicatori possibili sono tre: privato, publico o protetto. Nel primo classe la visibilità è consentita solo all'interno della classe, nel secondo caso e consentita anche agli utilizzatori, nel terzo caso solo alla classe e alle classi che la estendono, concetto quest'ultimo che affronteremo tra poco. In Visual Basic si utilizzano le parole riservate Private, Public e Protected, in C# private, public e protected:

Come potete notare esiste un metodo speciale nella definizione di una classe, chiamato costruttore, che viene automaticamente invocato all'atto dell'istanziazione di una classe: in questo metodo, che in Visual Basic viene identificato dalla Sub New, mentre in C# è un metodo che ha lo stesso nome della classe e non ha valore di ritorno, possiamo eseguire l'inizializzazione dello stato dell'oggetto.

EREDITARIETA'

La seconda caratteristica principale della OOP è l'ereditarietà, caratteristica che permette di estendere una classe esistente aggiungogli funzionalità che non prevedeva, quindi sono non diversamente indicato dal programmatore della classe (con appositi costrutti) è possibile prendere una classe esistente ed estenderla fornendo funzionalità che la classe base non aveva. Consideriamo ad esempio il classico esempio degli utenti di un sistema: un cliente o un fornitore potrebbe essere un utente del sistema quindi anzichè replicare nelle classi fornitore e cliente le funzionalità specifiche e comuni degli utenti possiamo definire le classi cliente e fornitore come specializzazioni della classe utente:

Come potete osservare nei due costruttori abbiamo valorizzato l'attributo protetto _denominazione, la cui visibilità ci è consentita dalla dichiarazione come protected dell'attributo. Questa caratteristica permette il riuso del codice esistente in utente il chè è un bel vantaggio già di per se, ma l'ereditarietà mostra le sue vere potenzialità quando viene usata come forma di polimorfismo...

POLIMORFISMO

E veniamo all'ultima, non per importanza, delle tre caratteristiche fondamentali della OOP, il polimorfismo, ovvero, come ci sugegrisce il nome stesso, la capacità di un oggetto di assumere più forme. Penso che il modo migliore di spiegare questo concetto sia attraverso un esempio. Riprendiamo le classi Utente, Cliente e Fornitore e supponiamo che in Utente esista un metodo che ritorni la propria denominazione:

Consideriamo il seguente listato:

quale sarà l'output prodotto? Lanciamo...ed ecco il risultato:

Sorpresi? Spero di no: Nonostante siano tutti definiti come utenti, la classe concreta di ogni istanza è diversa.

Facciamo un passo in più...ridefiniamo il metodo ChiSono() nella classe Cliente e Fornitore:

Rilanciano il listato precedente, il risultato questa volta è:

Questa volta il meccanismo del polimorfismo invoca il metodo della classe concreta anzichè quella del tipo della variabile fornendo il risultato illustrato. Come potete notare è necessario marcare i metodi come sovrascrivibili (Overridable in Visual Basic, virtual in C#) per poter ottenere questo effetto. Questo tipo di polimorfimo ha un nome è si chiama OVERRIDE, da non confondere con una seconda forma di polimorfismo molto interessante che si chiama OVERLOAD che permette di avere all'interno della stessa classe o in classi della stessa catena di ereditarietà metodi con lo stesso nome ma con numero e/o tipo di parametri diversi:

Il listato:

comporta il seguente risultato:

Molto probabilmente non riuscirete subito a cogliere le potenzialità di questo meccanismo e non mi illudo di riuscire a farlo: vedremo nel corso di questi articoli come questa caratteristica della OOP abbia reso possibile la realizzazione di molti meccanismi dei moderni framework di sviluppo.

Il contributo di Microsoft alla OOP

A questi meccanismi ormai consolidati e supportati da tutti i linguaggi ad oggetti, Microsoft ha aggiunto due nuovi concetti: le PROPERTIES e le CLASSI PARTIAL.

Volendo mantenere l'incapsulamento ma permettere ad una classe di esporre i proprio attributi in maniere "sicura" potendone controllare l'accesso, basta creare due metodi, spesso chiamati getter e setter, pubblici all'interno dei quali gli attributi possono essere restituiti o impostati:

Dato che questa esigenza è molto comune nello sviluppo software la Microsoft ha pensato di introdurre il concetto di property: un ibrido tra attributo e metodo che rendesse palese ed elegante l'implementazione dei getter e dei setter:

L'accesso a questi metodi avviene come se fossero degli attributi pubblici:

Le classi partial invece sono un sistema che permette di definire una classe in più file. Grazie a questo meccanismo, che si implementa semplicemente anteponendo la parola chiave Partial in Visual Basic, partial in C#, al nome della classe nella sua definizione, viene risolto un problema molto sentito dai programmatori che si avvalgono di strumenti di sviluppo RAD come Visual Studio in cui alcune parti delcodice vengono generate dal tool: le eventuali aggiunte al codice generato possono essere fatte in un file separato, in questo modo eventuali aggirnamenti del codice da parte del tool a seguito di modifiche non sovrascriveranno le aggiunte fatte dal programmatore che si trovano in un file separato.

Conclusioni

Penso che per oggi possa bastare, abbiamo messo molta carne a cuocere, appuntamento al prossimo articolo in cui parleremo di interfacce, classi astratte e classi generiche.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Michele Aponte — Wed, 15 Jul 2009 20:38:44 GMT
Revision 5 posted to Articoli by Michele Aponte on 15/07/2009 22:38:44

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Inserito sotto: Certificazioni Esame 70-536

OOP: Object Oriented Programming

Oggi parliamo di programmazione ad oggetti, introducendone le caratteristiche principali e come queste sono implementate nel .NET Framework.

Come molti di voi sapranno la programmazione ad oggetti è un paradigma di programmazione adottato dalla stragrande maggioranza dei programmatori a partire dagli anni '90, anni in cui si è cominciato ad abbandonare il paradigma procedurale in cui la definizione dei tipi di dato vedeva separate la struttura del dato dalle procedure che operavano su di esse. A un certo punto si è giustamente pensato: ma se un'entità è caratterizzata da un insieme di informazioni e dalle operazioni che posso realizzare su di esse perchè la loro definizione deve essere separata? Ed ecco a voi nascere il concetto di classe che insieme alle 3 caratteristiche principali della OOP definisce questo nuovo modo di concepire l'organizzazione della soluzione algoritmica ad un problema dato.

INCAPSULAMENTO

Come detto tutto ruota intorno al concetto di classe, che possiamo vedere come il costrutto offerto dal linguaggio per realizzare l'astrazione del concetto di oggetto. In pratica il trucco sta nell'affrontare il problema da risolvere modellandolo come un sistema in cui esistono e vivono un insieme di oggeti che comunicano tra di loro attraverso un'interfaccia bene definita: i METODI della classe! La struttura del dato incapsulato nell'oggetto è invece definita da quelli che vengono chiamati ATTRIBUTI. Una classe è quindi costituita da attributi e metodi, che insieme definiscono un nuovo tipo di dato per l'ambiente in cui vengono definiti. Un oggetto è un'istanza di una data classe.

Due oggetti, istanza di una certa classe, possono differire in un certo istante di tempo per il valore che in quell'istante hanno i suoi attributi, che nel loro insieme definiscono lo STATO dell'oggetto. Il concetto di stato di un oggetto è di fondamentale importanza perchè su di esso di basa uno dei tre principi fondamentali dalla OOP: l'INFORMATION HIDING o INCAPSULAMENTO secondo il quale l'unico modo attraverso cui debba essere possibile modificare tale stato dovrebbe essere l'utilizzo dei metodi della classe. Tecnicamente questo è possibile grazie all'utilizzo di indicatori di visibilità per gli attributi che dovrebbero negarne l'accesso all'utilizzatore della classe. Quindi gli oggetti del sistema comunicano tra di loro attraverso messaggi scambiati grazie all'invocazione dei metodi alterandone lo stato.

In .NET è possibile realizzare una classe utilizzando il costrutto Class in Visual Basic e class in C#, è possibile definire gli attributi dichiarando all'interno delle classi delle variabili del tipo voluto, è possible definire i metodi definendo delle Sub o delle Function in Visual Basic, definendo delle funzioni in C#. Sia per gli attributi che per i metodi e possibile indicare la visibilità che essi devono avere rispetto agli utilizzatori delle classi, gli indicatori possibili sono tre: privato, publico o protetto. Nel primo classe la visibilità è consentita solo all'interno della classe, nel secondo caso e consentita anche agli utilizzatori, nel terzo caso solo alla classe e alle classi che la estendono, concetto quest'ultimo che affronteremo tra poco. In Visual Basic si utilizzano le parole riservate Private, Public e Protected, in C# private, public e protected:

Come potete notare esiste un metodo speciale nella definizione di una classe, chiamato costruttore, che viene automaticamente invocato all'atto dell'istanziazione di una classe: in questo metodo, che in Visual Basic viene identificato dalla Sub New, mentre in C# è un metodo che ha lo stesso nome della classe e non ha valore di ritorno, possiamo eseguire l'inizializzazione dello stato dell'oggetto.

EREDITARIETA'

La seconda caratteristica principale della OOP è l'ereditarietà, caratteristica che permette di estendere una classe esistente aggiungogli funzionalità che non prevedeva, quindi sono non diversamente indicato dal programmatore della classe (con appositi costrutti) è possibile prendere una classe esistente ed estenderla fornendo funzionalità che la classe base non aveva. Consideriamo ad esempio il classico esempio degli utenti di un sistema: un cliente o un fornitore potrebbe essere un utente del sistema quindi anzichè replicare nelle classi fornitore e cliente le funzionalità specifiche e comuni degli utenti possiamo definire le classi cliente e fornitore come specializzazioni della classe utente:

Come potete osservare nei due costruttori abbiamo valorizzato l'attributo protetto _denominazione, la cui visibilità ci è consentita dalla dichiarazione come protected dell'attributo. Questa caratteristica permette il riuso del codice esistente in utente il chè è un bel vantaggio già di per se, ma l'ereditarietà mostra le sue vere potenzialità quando viene usata come forma di polimorfismo...

POLIMORFISMO

E veniamo all'ultima, non per importanza, delle tre caratteristiche fondamentali della OOP, il polimorfismo, ovvero, come ci sugegrisce il nome stesso, la capacità di un oggetto di assumere più forme. Penso che il modo migliore di spiegare questo concetto sia attraverso un esempio. Riprendiamo le classi Utente, Cliente e Fornitore e supponiamo che in utente Utente esista un metodo che ritorni la propria denominazione:

Consideriamo il seguente listato:

quale sarà l'output prodotto? Lanciamo...ed ecco il risultato:

Sorpresi? Spero di no: Nonostante siano tutti definiti come utenti, la classe concreta di ogni istanza è diversa.

Facciamo un passo in più...ridefiniamo il metodo ChiSono() nella classe Cliente e Fornitore:

Rilanciano il listato precedente, il risultato questa volta è:

Questa volta il meccanismo del polimorfismo invoca il metodo della classe concreta anzichè quella del tipo della variabile fornendo il risultato illustrato. Come potete notare è necessario marcare i metodi come sovrascrivibili (Overridable in Visual Basic, virtual in C#) per poter ottenere questo effetto. Questo tipo di polimorfimo ha un nome è si chiama OVERRIDE, da non confondere con una seconda forma di polimorfismo molto interessante che si chiama OVERLOAD che permette di avere all'interno della stessa classe o in classi della stessa catena di ereditarietà metodi con lo stesso nome ma con numero e/o tipo di parametri diversi:

Il listato:

comporta il seguente risultato:

Molto probabilmente non riuscirete subito a cogliere le potenzialità di questo meccanismo e non mi illudo di riuscire a farlo: vedremo nel corso di questi articoli come questa caratteristica della OOP abbia reso possibile la realizzazione di molti meccanismi dei moderni framework di sviluppo.

Il contributo di Microsoft alla OOP

A questi meccanismi ormai consolidati e supportati da tutti i linguaggi ad oggetti, Microsoft ha aggiunto due nuovi concetti: le PROPERTIES e le CLASSI PARTIAL.

Volendo mantenere l'incapsulamento ma permettere ad una classe di esporre i proprio attributi in maniere "sicura" potendone controllare l'accesso, basta creare due metodi, spesso chiamati getter e setter, pubblici all'interno dei quali gli attributi possono essere restituiti o impostati:

Dato che questa esigenza è molto comune nello sviluppo software la Microsoft ha pensato di introdurre il concetto di property: un ibrido tra attributo e metodo che rendesse palese ed elegante l'implementazione dei getter e dei setter:

L'accesso a questi metodi avviene come se fossero degli attributi pubblici:

Le classi partial invece sono un sistema che permette di definire una classe in più file. Grazie a questo meccanismo, che si implementa semplicemente anteponendo la parola chiave Partial in Visual Basic, partial in C#, al nome della classe nella sua definizione, viene risolto un problema molto sentito dai programmatori che si avvalgono di strumenti di sviluppo RAD come Visual Studio in cui alcune parti delcodice vengono generate dal tool: le eventuali aggiunte al codice generato possono essere fatte in un file separato, in questo modo eventuali aggirnamenti del codice da parte del tool a seguito di modifiche non sovrascriveranno le aggiunte fatte dal programmatore che si trovano in un file separato.

Conclusioni

Penso che per oggi possa bastare, abbiamo messo molta carne a cuocere, appuntamento al prossimo articolo in cui parleremo di interfacce, classi astratte e classi generiche.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Michele Aponte — Wed, 15 Jul 2009 19:54:02 GMT
Revision 4 posted to Articoli by Michele Aponte on 15/07/2009 21:54:02

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Inserito sotto: Certificazioni Esame 70-536

OOP: Object Oriented Programming

Oggi parliamo di programmazione ad oggetti, introducendone le caratteristiche principali e come queste sono implementate nel .NET Framework.

Come molti di voi sapranno la programmazione ad oggetti è un paradigma di programmazione adottato dalla stragrande maggioranza dei programmatori a partire dagli anni '90, anni in cui si è cominciato ad abbandonare il paradigma procedurale in cui la definizione dei tipi di dato vedeva separate la struttura del dato dalle procedure che operavano su di esse. A un certo punto si è giustamente pensato: ma se un'entità è caratterizzata da un insieme di informazioni e dalle operazioni che posso realizzare su di esse perchè la loro definizione deve essere separata? Ed ecco a voi nascere il concetto di classe che insieme alle 3 caratteristiche principali della OOP definisce questo nuovo modo di concepire l'organizzazione della soluzione algoritmica ad un problema dato.

INCAPSULAMENTO

Come detto tutto ruota intorno al concetto di classe, che possiamo vedere come il costrutto offerto dal linguaggio per realizzare l'astrazione del concetto di oggetto. In pratica il trucco sta nell'affrontare il problema da risolvere modellandolo come un sistema in cui esistono e vivono un insieme di oggeti che comunicano tra di loro attraverso un'interfaccia bene definita: i METODI della classe! La struttura del dato incapsulato nell'oggetto è invece definita da quelli che vengono chiamati ATTRIBUTI. Una classe è quindi costituita da attributi e metodi, che insieme definiscono un nuovo tipo di dato per l'ambiente in cui vengono definiti. Un oggetto è un'istanza di una data classe.

Due oggetti, istanza di una certa classe, possono differire in un certo istante di tempo per il valore che in quell'istante hanno i suoi attributi, che nel loro insieme definiscono lo STATO dell'oggetto. Il concetto di stato di un oggetto è di fondamentale importanza perchè su di esso di basa uno dei tre principi fondamentali dalla OOP: l'INFORMATION HIDING o INCAPSULAMENTO secondo il quale l'unico modo attraverso cui debba essere possibile modificare tale stato dovrebbe essere l'utilizzo dei metodi della classe. Tecnicamente questo è possibile grazie all'utilizzo di indicatori di visibilità per gli attributi che dovrebbero negarne l'accesso all'utilizzatore della classe. Quindi gli oggetti del sistema comunicano tra di loro attraverso messaggi scambiati grazie all'invocazione dei metodi alterandone lo stato.

In .NET è possibile realizzare una classe utilizzando il costrutto Class in Visual Basic e class in C#, è possibile definire gli attributi dichiarando all'interno delle classi delle variabili del tipo voluto, è possible definire i metodi definendo delle Sub o delle Function in Visual Basic, definendo delle funzioni in C#. Sia per gli attributi che per i metodi e possibile indicare la visibilità che essi devono avere rispetto agli utilizzatori delle classi, gli indicatori possibili sono tre: privato, publico o protetto. Nel primo classe la visibilità è consentita solo all'interno della classe, nel secondo caso e consentita anche agli utilizzatori, nel terzo caso solo alla classe e alle classi che la estendono, concetto quest'ultimo che affronteremo tra poco. In Visual Basic si utilizzano le parole riservate Private, Public e Protected, in C# private, public e protected:

Come potete notare esiste un metodo speciale nella definizione di una classe, chiamato costruttore, che viene automaticamente invocato all'atto dell'istanziazione di una classe: in questo metodo, che in Visual Basic viene identificato dalla Sub New, mentre in C# è un metodo che ha lo stesso nome della classe e non ha valore di ritorno, possiamo eseguire l'inizializzazione dello stato dell'oggetto.

EREDITARIETA'

La seconda caratteristica principale della OOP è l'ereditarietà, caratteristica che permette di estendere una classe esistente aggiungogli funzionalità che non prevedeva, quindi sono non diversamente indicato dal programmatore della classe (con appositi costrutti) è possibile prendere una classe esistente ed estenderla fornendo funzionalità che la classe base non aveva. Consideriamo ad esempio il classico esempio degli utenti di un sistema: un cliente o un fornitore potrebbe essere un utente del sistema quindi anzichè replicare nelle classi fornitore e cliente le funzionalità specifiche e comuni degli utenti possiamo definire le classi cliente e fornitore come specializzazioni della classe utente:

Come potete osservare nei due costruttori abbiamo valorizzato l'attributo protetto _denominazione, la cui visibilità ci è consentita dalla dichiarazione come protected dell'attributo. Questa caratteristica permette il riuso del codice esistente in utente il chè è un bel vantaggio già di per se, ma l'ereditarietà mostra le sue vere potenzialità quando viene usata come forma di polimorfismo...

POLIMORFISMO

E veniamo all'ultima, non per importanza, delle tre caratteristiche fondamentali della OOP, il polimorfismo, ovvero, come ci sugegrisce il nome stesso, la capacità di un oggetto di assumere più forme. Penso che il modo migliore di spiegare questo concetto sia attraverso un esempio. Riprendiamo le classi Utente, Cliente e Fornitore e supponiamo che in utente esista un metodo che ritorni la propria denominazione:

Consideriamo il seguente listato:

quale sarà l'output prodotto? Lanciamo...ed ecco il risultato:

Sorpresi? Spero di no: Nonostante siano tutti definiti come utenti, la classe concreta di ogni istanza è diversa.

Facciamo un passo in più...ridefiniamo il metodo ChiSono() nella classe Cliente e Fornitore:

Rilanciano il listato precedente, il risultato questa volta è:

Questa volta il meccanismo del polimorfismo invoca il metodo della classe concreta anzichè quella del tipo della variabile fornendo il risultato illustrato. Come potete notare è necessario marcare i metodi come sovrascrivibili (Overridable in Visual Basic, virtual in C#) per poter ottenere questo effetto. Questo tipo di polimorfimo ha un nome è si chiama OVERRIDE, da non confondere con una seconda forma di polimorfismo molto interessante che si chiama OVERLOAD che permette di avere all'interno della stessa classe o in classi della stessa catena di ereditarietà metodi con lo stesso nome ma con numero e/o tipo di parametri diversi:

Il listato:

Molto probabilmente non riuscirete subito a cogliere le potenzialità di questo meccanismo e non mi illudo di riuscire a farlo: vedremo nel corso di questi articoli come questa caratteristica della OOP abbia reso possibile la realizzazione di molti meccanismi dei moderni framework di sviluppo.

Il contributo di Microsoft alla OOP

A questi meccanismi ormai consolidati e supportati da tutti i linguaggi ad oggetti, Microsoft ha aggiunto due nuovi concetti: le PROPERTIES e le CLASSI PARTIAL.

Volendo mantenere l'incapsulamento ma permettere ad una classe di esporre i proprio attributi in maniere "sicura" potendone controllare l'accesso, basta creare due metodi, spesso chiamati getter e setter, pubblici all'interno dei quali gli attributi possono essere restituiti o impostati:

Dato che questa esigenza è molto comune nello sviluppo software la Microsoft ha pensato di introdurre il concetto di property: un ibrido tra attributo e metodo che rendesse palese ed elegante l'implementazione dei getter e dei setter:

L'accesso a questi metodi avviene come se fossero degli attributi pubblici:

Le classi partial invece sono un sistema che permette di definire una classe in più file. Grazie a questo meccanismo, che si implementa semplicemente anteponendo la parola chiave Partial in Visual Basic, partial in C#, al nome della classe nella sua definizione, viene risolto un problema molto sentito dai programmatori che si avvalgono di strumenti di sviluppo RAD come Visual Studio in cui alcune parti delcodice vengono generate dal tool: le eventuali aggiunte al codice generato possono essere fatte in un file separato, in questo modo eventuali aggirnamenti del codice da parte del tool a seguito di modifiche non sovrascriveranno le aggiunte fatte dal programmatore che si trovano in un file separato.

Conclusioni

Penso che per oggi possa bastare, abbiamo messo molta carne a cuocere, appuntamento al prossimo articolo in cui parleremo di interfacce, classi astratte e classi generiche.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Michele Aponte — Tue, 14 Jul 2009 23:01:55 GMT
Revision 3 posted to Articoli by Michele Aponte on 15/07/2009 01:01:55

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Inserito sotto: Certificazioni Esame 70-536

OOP: Object Oriented Programming

Oggi parliamo di programmazione ad oggetti, introducendone le caratteristiche principali e come queste sono implementate nel .NET Framework.

Come molti di voi sapranno la programmazione ad oggetti è un paradigma di programmazione adottato dalla stragrande maggioranza dei programmatori a partire dagli anni '90, anni in cui si è cominciato ad abbandonare il paradigma procedurale in cui la definizione dei tipi di dato vedeva separate la struttura del dato dalle procedure che operavano su di esse. A un certo punto si è giustamente pensato: ma se un'entità è caratterizzata da un insieme di informazioni e dalle operazioni che posso realizzare su di esse perchè la loro definizione deve essere separata? Ed ecco a voi nascere il concetto di classe che insieme alle 3 caratteristiche principali della OOP definisce questo nuovo modo di concepire l'organizzazione della soluzione algoritmica ad un problema dato.

INCAPSULAMENTO

Come detto tutto ruota intorno al concetto di classe, che possiamo vedere come il costrutto offerto dal linguaggio per realizzare l'astrazione del concetto di oggetto. In pratica il trucco sta nell'affrontare il problema da risolvere modellandolo come un sistema in cui esistono e vivono un insieme di oggeti che comunicano tra di loro attraverso un'interfaccia bene definita: i METODI della classe! La struttura del dato incapsulato nell'oggetto è invece definita da quelli che vengono chiamati ATTRIBUTI. Una classe è quindi costituita da attributi e metodi, che insieme definiscono un nuovo tipo di dato per l'ambiente in cui vengono definiti. Un oggetto è un'istanza di una data classe.

Due oggetti, istanza di una certa classe, possono differire in un certo istante di tempo per il valore che in quell'istante hanno i suoi attributi, che nel loro insieme definiscono lo STATO dell'oggetto. Il concetto di stato di un oggetto è di fondamentale importanza perchè su di esso di basa uno dei tre principi fondamentali dalla OOP: l'INFORMATION HIDING o INCAPSULAMENTO secondo il quale l'unico modo attraverso cui debba essere possibile modificare tale stato dovrebbe essere l'utilizzo dei metodi della classe. Tecnicamente questo è possibile grazie all'utilizzo di indicatori di visibilità per gli attributi che dovrebbero negarne l'accesso all'utilizzatore della classe. Quindi gli oggetti del sistema comunicano tra di loro attraverso messaggi scambiati grazie all'invocazione dei metodi alterandone lo stato.

In .NET è possibile realizzare una classe utilizzando il costrutto Class in Visual Basic e class in C#, è possibile definire gli attributi dichiarando all'interno delle classi delle variabili del tipo voluto, è possible definire i metodi definendo delle Sub o delle Function in Visual Basic, definendo delle funzioni in C#. Sia per gli attributi che per i metodi e possibile indicare la visibilità che essi devono avere rispetto agli utilizzatori delle classi, gli indicatori possibili sono tre: privato, publico o protetto. Nel primo classe la visibilità è consentita solo all'interno della classe, nel secondo caso e consentita anche agli utilizzatori, nel terzo caso solo alla classe e alle classi che la estendono, concetto quest'ultimo che affronteremo tra poco. In Visual Basic si utilizzano le parole riservate Private, Public e Protected, in C# private, public e protected:

public class Utente     private string _userID;     private string _password;     protected string _denominazione;     public Utente() "guest"; String.Empty; "Guest";     public bool Autenticato()         return !_userID.Equals("guest");

{

    {

        _userID =

        _password =

        _denominazione =

    }

    {

     }

}

' VB

Public Class Utente     Private _userID As String     Private _password As String     Protected _denominazione As String     Public Sub New() "guest"

        _userID =

         _password = String.Empty "Guest"

         _denominazione =

     End Sub     Public Function Autenticato() As Boolean         Return Not _userID.Equals("guest")     End Function Class

End

Come potete notare esiste un metodo speciale nella definizione di una classe, chiamato costruttore, che viene automaticamente invocato all'atto dell'istanziazione di una classe: in questo metodo, che in Visual Basic viene identificato dalla Sub New, mentre in C# è un metodo che ha lo stesso nome della classe e non ha valore di ritorno, possiamo eseguire l'inizializzazione dello stato dell'oggetto.

EREDITARIETA'

La seconda caratteristica principale della OOP è l'ereditarietà, caratteristica che permette di estendere una classe esistente aggiungogli funzionalità che non prevedeva, quindi sono non diversamente indicato dal programmatore della classe (con appositi costrutti) è possibile prendere una classe esistente ed estenderla fornendo funzionalità che la classe base non aveva. Consideriamo ad esempio il classico esempio degli utenti di un sistema: un cliente o un fornitore potrebbe essere un utente del sistema quindi anzichè replicare nelle classi fornitore e cliente le funzionalità specifiche e comuni degli utenti possiamo definire le classi cliente e fornitore come specializzazioni della classe utente:

// C#
public class Fornitore : Utente     public Fornitore() "Un Fornitore";

{

    {

        _denominazione =

   }

}

// C#
public class Cliente : Utente

{    public Cliente() "Un cliente";

    {

        _denominazione =

    }

}

Come potete osservare nei due costruttori abbiamo valorizzato l'attributo protetto _denominazione, la cui visibilità ci è consentita dalla dichiarazione come protected dell'attributo. Questa caratteristica permette il riuso del codice esistente in utente il chè è un bel vantaggio già di per se, ma l'ereditarietà mostra le sue vere potenzialità quando viene usata come forma di polimorfismo...

POLIMORFISMO

E veniamo all'ultima, non per importanza, delle tre caratteristiche fondamentali della OOP, il polimorfismo, ovvero, come ci sugegrisce il nome stesso, la capacità di un oggetto di assumere più forme. Penso che il modo migliore di spiegare questo concetto sia attraverso un esempio. Riprendiamo le classi Utente, Cliente e Fornitore e supponiamo che in utente esista un metodo che ritorni la propria denominazione:

// C# string ChiSono()     return _denominazione;

public

{

}

'VB

Public Function ChiSono() As String     Return _denominazione End Function

Consideriamo il seguente listato:

// C#
static void Main(string[] args)     Utente utente1 = new Utente();     Utente utente2 = new Cliente();     Utente utente3 = new Fornitore();     Console.WriteLine(utente1.ChiSono()); Console.WriteLine(utente2.ChiSono()); Console.WriteLine(utente3.ChiSono());

{

}

' VB
Sub Main()    Dim utente1 As Utente = New Utente    Dim utente2 As Utente = New Cliente    Dim utente3 As Utente = New Fornitore End Sub

    Console.WriteLine(utente1.ChiSono())

    Console.WriteLine(utente2.ChiSono())

    Console.WriteLine(utente3.ChiSono())

quale sarà l'output prodotto? Lanciamo...ed ecco il risultato:

Sorpresi? Spero di no: Nonostante siano tutti definiti come utenti, la classe concreta di ogni istanza è diversa.

Facciamo un passo in più...ridefiniamo il metodo ChiSono() nella classe Cliente e Fornitore:

// C#

public class Utente    public virtual string ChiSono()        return _denominazione;

{

    ...

    {

     }

}

// C#

public class Fornitore : Utente

   public override string ChiSono()        return "Chi Sono del fornitore";

{

    ...

    {

     }

}

// C#

public class Cliente : Utente     ...

{

    public override string ChiSono()        return "Chi sono del cliente";

    {

    }

}

Public

Class Utente

   ...

   Public Overridable Function ChiSono() As String

       Return _denominazione

   End Function
End

Class

Public

Class Fornitore

    Inherits Utente

    ...

    Public Overrides Function ChiSono() As String

        Return "Chi sono del fornitore"

    End Function
End

Class

Public

Class Cliente

    Inherits Utente

   ...

   Public Overrides Function ChiSono() As String

       Return "Chi sono del cliente"

   End Function
End

Class

Questa volta il meccanismo del polimorfismo invoca il metodo della classe concreta anzichè quella del tipo della variabile fornendo il risultato illustrato. Come potete notare è necessario marcare i metodi come sovrascrivibili (Overridable in Visual Basic, virtual in C#) per poter ottenere questo effetto. Questo tipo di polimorfimo ha un nome è si chiama OVERRIDE, da non confondere con una seconda forma di polimorfismo molto interessante che si chiama OVERLOAD che permette di avere all'interno della stessa classe o in classi della stessa catena di ereditarietà metodi con lo stesso nome ma con numero e/o tipo di parametri diversi:

// C#

public class Cliente : Utente

{

     ...

    public override string ChiSono()
    {

          return "Chi sono del cliente";
    }

    public string ChiSono(string denominazione)
    {

         _denominazione = denominazione;

        return base.ChiSono();

    }

}

' VB

Public

Class Cliente

    Inherits Utente

    Public Sub New ()
        _denominazione =

"Un Cliente"

    End Sub

    Public Overrides Function ChiSono() As String

         Return "Chi sono del cliente"

    End Function

    Public Overloads Function ChiSono(ByVal denominazione As String) As String

         _denominazione = denominazione

        Return MyBase.ChiSono()

    End Function
End

Class

Il listato:

// C#

static void Main(string[] args)
{

    Cliente cliente = new Cliente();

    Console.WriteLine(cliente.ChiSono());

    Console.WriteLine(cliente.ChiSono("overload"));

}

' VB

Sub Main()

    Dim cliente As New Cliente
    Console.WriteLine(cliente.ChiSono())

    Console.WriteLine(cliente.ChiSono(

"overload"))

End Sub

Molto probabilmente non riuscirete subito a cogliere le potenzialità di questo meccanismo e non mi illudo di riuscire a farlo: vedremo nel corso di questi articoli come questa caratteristica della OOP abbia reso possibile la realizzazione di molti meccanismi dei moderni framework di sviluppo.

Il contributo di Microsoft alla OOP

A questi meccanismi ormai consolidati e supportati da tutti i linguaggi ad oggetti, Microsoft ha aggiunto due nuovi concetti: le PROPERTIES e le CLASSI PARTIAL.

Volendo mantenere l'incapsulamento ma permettere ad una classe di esporre i proprio attributi in maniere "sicura" potendone controllare l'accesso, basta creare due metodi, spesso chiamati getter e setter, pubblici all'interno dei quali gli attributi possono essere restituiti o impostati:

// C#

public string GetUserID()
{

    return _userID;
}

public void SerUserID (string valore)
{

    _userID = valore;

}

'VB

Public Function GetUserID() As String

    Return _userID

End Function

Public Sub SetUserID(ByVal valore)
    _userID = valore

End Sub

Dato che questa esigenza è molto comune nello sviluppo software la Microsoft ha pensato di introdurre il concetto di property: un ibrido tra attributo e metodo che rendesse palese ed elegante l'implementazione dei getter e dei setter:

// C#

public

string UserID

{

    get { return _userID; }

    set { _userID = value; }

}

' VB
Public Property UserId() As String

Get

    Return _userID

End Get

Set(ByVal value As String)

    _userID = value

End Set

End Property

L'accesso a questi metodi avviene come se fossero degli attributi pubblici:

// C#

Utente utente = new Utente();
utente.UserID =

"Michele";

string uid = utente.UserID;

' VB
Dim utente As New Utente

utente.UserId =

"Michele"

Dim uid As String = utente.UserId

Le classi partial invece sono un sistema che permette di definire una classe in più file. Grazie a questo meccanismo, che si implementa semplicemente anteponendo la parola chiave Partial in Visual Basic, partial in C#, al nome della classe nella sua definizione, viene risolto un problema molto sentito dai programmatori che si avvalgono di strumenti di sviluppo RAD come Visual Studio in cui alcune parti delcodice vengono generate dal tool: le eventuali aggiunte al codice generato possono essere fatte in un file separato, in questo modo eventuali aggirnamenti del codice da parte del tool a seguito di modifiche non sovrascriveranno le aggiunte fatte dal programmatore che si trovano in un file separato.

Conclusioni

Penso che per oggi possa bastare, abbiamo messo molta carne a cuocere, appuntamento al prossimo articolo in cui parleremo di interfacce, classi astratte e classi generiche.

Happy Coding.

' VB

' VB
Rilanciano il listato precedente, il risultato questa volta è:

' VB

// C#

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Michele Aponte — Tue, 14 Jul 2009 22:37:26 GMT
Revision 2 posted to Articoli by Michele Aponte on 15/07/2009 00:37:26

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Inserito sotto: Certificazioni Esame 70-536

OOP: Object Oriented Programming

Oggi parliamo di programmazione ad oggetti, introducendone le caratteristiche principali e come queste sono implementate nel .NET Framework.

Come molti di voi sapranno la programmazione ad oggetti è un paradigma di programmazione adottato dalla stragrande maggioranza dei programmatori a partire dagli anni '90, anni in cui si è cominciato ad abbandonare il paradigma procedurale in cui la definizione dei tipi di dato vedeva separate la struttura del dato dalle procedure che operavano su di esse. A un certo punto si è giustamente pensato: ma se un'entità è caratterizzata da un insieme di informazioni e dalle operazioni che posso realizzare su di esse perchè la loro definizione deve essere separata? Ed ecco a voi nascere il concetto di classe che insieme alle 3 caratteristiche principali della OOP definisce questo nuovo modo di concepire l'organizzazione della soluzione algoritmica ad un problema dato.

INCAPSULAMENTO

Come detto tutto ruota intorno al concetto di classe, che possiamo vedere come il costrutto offerto dal linguaggio per realizzare l'astrazione del concetto di oggetto. In pratica il trucco sta nell'affrontare il problema da risolvere modellandolo come un sistema in cui esistono e vivono un insieme di oggeti che comunicano tra di loro attraverso un'interfaccia bene definita: i METODI della classe! La struttura del dato incapsulato nell'oggetto è invece definita da quelli che vengono chiamati ATTRIBUTI. Una classe è quindi costituita da attributi e metodi, che insieme definiscono un nuovo tipo di dato per l'ambiente in cui vengono definiti. Un oggetto è un'istanza di una data classe.

Due oggetti, istanza di una certa classe, possono differire in un certo istante di tempo per il valore che in quell'istante hanno i suoi attributi, che nel loro insieme definiscono lo STATO dell'oggetto. Il concetto di stato di un oggetto è di fondamentale importanza perchè su di esso di basa uno dei tre principi fondamentali dalla OOP: l'INFORMATION HIDING o INCAPSULAMENTO secondo il quale l'unico modo attraverso cui debba essere possibile modificare tale stato dovrebbe essere l'utilizzo dei metodi della classe. Tecnicamente questo è possibile grazie all'utilizzo di indicatori di visibilità per gli attributi che dovrebbero negarne l'accesso all'utilizzatore della classe. Quindi gli oggetti del sistema comunicano tra di loro attraverso messaggi scambiati grazie all'invocazione dei metodi alterandone lo stato.

In .NET è possibile realizzare una classe utilizzando il costrutto Class in Visual Basic e class in C#, è possibile definire gli attributi dichiarando all'interno delle classi delle variabili del tipo voluto, è possible definire i metodi definendo delle Sub o delle Function in Visual Basic, definendo delle funzioni in C#:. Sia per gli attributi che per i metodi e possibile indicare la visibilità che essi devono avere rispetto agli utilizzatori delle classi, gli indicatori possibili sono tre: privato, publico o protetto. Nel primo classe la visibilità è consentita solo all'interno della classe, nel secondo caso e consentita anche agli utilizzatori, nel terzo caso solo alla classe e alle classi che la estendono, concetto quest'ultimo che affronteremo tra poco. In Visual Basic si utilizzano le parole riservate Private, Public e Protected, in C# private, public e protected:

public class Utente     private string _userID;     private string _password;     protected string _denominazione;     public Utente() "guest"; String.Empty; "Guest";     public bool Autenticato()         return !_userID.Equals("guest");

{

    {

        _userID =

        _password =

        _denominazione =

    }

    {

     }

}

' VB

Public Class Utente     Private _userID As String     Private _password As String     Protected _denominazione As String     Public Sub New() "guest"

        _userID =

         _password = String.Empty "Guest"

         _denominazione =

     End Sub     Public Function Autenticato() As Boolean         Return Not _userID.Equals("guest")     End Function Class

End

Come potete notare esiste un metodo speciale nella definizione di una classe, chiamato costruttore, che viene automaticamente invocato all'atto dell'istanziazione di una classe: in questo metodo, che in Visual Basic viene identificato dalla Sub New, mentre in C# è un metodo che ha lo stesso nome della classe e non ha valore di ritorno, possiamo eseguire l'inizializzazione dello stato dell'oggetto.

EREDITARIETA'

La seconda caratteristica principale della OOP è l'ereditarietà, caratteristica che permette di estendere una classe esistente aggiungogli funzionalità che non prevedeva, quindi sono non diversamente indicato dal programmatore della classe (con appositi costrutti) è possibile prendere una classe esistente ed estenderla fornendo funzionalità che la classe base non aveva. Consideriamo ad esempio il classico esempio degli utenti di un sistema: un cliente o un fornitore potrebbe essere un utente del sistema quindi anzichè replicare nelle classi fornitore e cliente le funzionalità specifiche e comuni degli utenti possiamo definire le classi cliente e fornitore come specializzazioni della classe utente:

// C#
public class Fornitore : Utente     public Fornitore() "Un Fornitore";

{

    {

        _denominazione =

   }

}

// C#
public class Cliente : Utente

{    public Cliente() "Un cliente";

    {

        _denominazione =

    }

}

Come potete osservare nei due costruttori abbiamo valorizzato l'attributo protetto _denominazione, la cui visibilità ci è consentita dalla dichiarazione come protected dell'attributo. Questa caratteristica permette il riuso del codice esistente in utente il chè è un bel vantaggio già di per se, ma l'ereditarietà mostra le sue vere potenzialità quando viene usata come forma di polimorfismo...

POLIMORFISMO

E veniamo all'ultima, non per importanza, delle tre caratteristiche fondamentali della OOP, il polimorfismo, ovvero, come ci sugegrisce il nome stesso, la capacità di un oggetto di assumere più forme. Penso che il modo migliore di spiegare questo concetto sia attraverso un esempio. Riprendiamo le classi Utente, Cliente e Fornitore e supponiamo che in utente esista un metodo che ritorni la propria denominazione:

// C# string ChiSono()     return _denominazione;

public

{

}

'VB

Public Function ChiSono() As String     Return _denominazione End Function

Consideriamo il seguente listato:

// C#
static void Main(string[] args)     Utente utente1 = new Utente();     Utente utente2 = new Cliente();     Utente utente3 = new Fornitore();     Console.WriteLine(utente1.ChiSono()); Console.WriteLine(utente2.ChiSono()); Console.WriteLine(utente3.ChiSono());

{

}

' VB
Sub Main()    Dim utente1 As Utente = New Utente    Dim utente2 As Utente = New Cliente    Dim utente3 As Utente = New Fornitore End Sub

    Console.WriteLine(utente1.ChiSono())

    Console.WriteLine(utente2.ChiSono())

    Console.WriteLine(utente3.ChiSono())

quale sarà l'output prodotto? Lanciamo...ed ecco il risultato:

Sorpresi? Spero di no: Nonostante siano tutti definiti come utenti, la classe concreta di ogni istanza è diversa.

Facciamo un passo in più...ridefiniamo il metodo ChiSono() nella classe Cliente e Fornitore:

// C#

public class Utente    public virtual string ChiSono()        return _denominazione;

{

    ...

    {

     }

}

// C#

public class Fornitore : Utente

   public override string ChiSono()        return "Chi Sono del fornitore";

{

    ...

    {

     }

}

// C#

public class Cliente : Utente     ...

{

    public override string ChiSono()        return "Chi sono del cliente";

    {

    }

}

Public

Class Utente

   ...

   Public Overridable Function ChiSono() As String

       Return _denominazione

   End Function
End

Class

Public

Class Fornitore

    Inherits Utente

    ...

    Public Overrides Function ChiSono() As String

        Return "Chi sono del fornitore"

    End Function
End

Class

Public

Class Cliente

    Inherits Utente

   ...

   Public Overrides Function ChiSono() As String

       Return "Chi sono del cliente"

   End Function
End

Class

Questa volta il meccanismo del polimorfismo invoca il metodo della classe concreta anzichè quella del tipo della variabile fornendo il risultato illustrato. Come potete notare è necessario marcare i metodi come sovrascrivibili (Overridable in Visual Basic, virtual in C#) per poter ottenere questo effetto. Questo tipo di polimorfimo ha un nome è si chiama OVERRIDE, da non confondere con una seconda forma di polimorfismo molto interessante che si chiama OVERLOAD che permette di avere all'interno della stessa classe o in classi della stessa catena di ereditarietà metodi con lo stesso nome ma con numero e/o tipo di parametri diversi:

// C#

public class Cliente : Utente

{

     ...

    public override string ChiSono()
    {

          return "Chi sono del cliente";
    }

    public string ChiSono(string denominazione)
    {

         _denominazione = denominazione;

        return base.ChiSono();

    }

}

' VB

Public

Class Cliente

    Inherits Utente

    Public Sub New ()
        _denominazione =

"Un Cliente"

    End Sub

    Public Overrides Function ChiSono() As String

         Return "Chi sono del cliente"

    End Function

    Public Overloads Function ChiSono(ByVal denominazione As String) As String

         _denominazione = denominazione

        Return MyBase.ChiSono()

    End Function
End

Class

Il listato:

// C#

static void Main(string[] args)
{

    Cliente cliente = new Cliente();

    Console.WriteLine(cliente.ChiSono());

    Console.WriteLine(cliente.ChiSono("overload"));

}

' VB

Sub Main()

    Dim cliente As New Cliente
    Console.WriteLine(cliente.ChiSono())

    Console.WriteLine(cliente.ChiSono(

"overload"))

End Sub

Molto probabilmente non riuscirete subito a cogliere le potenzialità di questo meccanismo e non mi illudo di riuscire a farlo: vedremo nel corso di questi articoli come questa caratteristica della OOP abbia reso possibile la realizzazione di molti meccanismi dei moderni framework di sviluppo.

Il contributo di Microsoft alla OOP

A questi meccanismi ormai consolidati e supportati da tutti i linguaggi ad oggetti, Microsoft ha aggiunto due nuovi concetti: le PROPERTIES e le CLASSI PARTIAL.

Volendo mantenere l'incapsulamento ma permettere ad una classe di esporre i proprio attributi in maniere "sicura" potendone controllare l'accesso, basta creare due metodi, spesso chiamati getter e setter, pubblici all'interno dei quali gli attributi possono essere restituiti o impostati:

// C#

public string GetUserID()
{

    return _userID;
}

public void SerUserID (string valore)
{

    _userID = valore;

}

'VB

Public Function GetUserID() As String

    Return _userID

End Function

Public Sub SetUserID(ByVal valore)
    _userID = valore

End Sub

Dato che questa esigenza è molto comune nello sviluppo software la Microsoft ha pensato di introdurre il concetto di property: un ibrido tra attributo e metodo che rendesse palese ed elegante l'implementazione dei getter e dei setter:

// C#

public

string UserID

{

    get { return _userID; }

    set { _userID = value; }

}

' VB
Public Property UserId() As String

Get

    Return _userID

End Get

Set(ByVal value As String)

    _userID = value

End Set

End Property

L'accesso a questi metodi avviene come se fossero degli attributi pubblici:

// C#

Utente utente = new Utente();
utente.UserID =

"Michele";

string uid = utente.UserID;

' VB
Dim utente As New Utente

utente.UserId =

"Michele"

Dim uid As String = utente.UserId

Le classi partial invece sono un sistema che permette di definire una classe in più file. Grazie a questo meccanismo, che si implementa semplicemente anteponendo la parola chiave Partial in Visual Basic, partial in C#, al nome della classe nella sua definizione, viene risolto un problema molto sentito dai programmatori che si avvalgono di strumenti di sviluppo RAD come Visual Studio in cui alcune parti delcodice vengono generate dal tool: le eventuali aggiunte al codice generato possono essere fatte in un file separato, in questo modo eventuali aggirnamenti del codice da parte del tool a seguito di modifiche non sovrascriveranno le aggiunte fatte dal programmatore che si trovano in un file separato.

Conclusioni

Penso che per oggi possa bastare, abbiamo messo molta carne a cuocere, appuntamento al prossimo articolo in cui parleremo di interfacce, classi astratte e classi generiche.

Happy Coding.

' VB

' VB
Rilanciano il listato precedente, il risultato questa volta è:

' VB

// C#

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 03

Michele Aponte — Tue, 14 Jul 2009 20:04:03 GMT
Revision 1 posted to Articoli by Michele Aponte on 14/07/2009 22:04:03

OOP: Object Oriented Programming

Oggi parliamo di programmazione ad oggetti, introducendone le caratteristiche principali e come queste sono implementate nel .NET Framework.

Come molti di voi sapranno la programmazione ad oggetti è un paradigma di programmazione adottato dalla stragrande maggioranza dei programmatori a partire dagli anni '90, anni in cui si è cominciato ad abbandonare il paradigma procedurale in cui la definizione dei tipi di dato vedeva separate la struttura del dato dalle procedure che operavano su di esse. A un certo punto si è giustamente pensato: ma se un'entità è caratterizzata da un insieme di informazioni e dalle operazioni che posso realizzare su di esse perchè la loro definizione deve essere separata? Ed ecco a voi nascere il concetto di classe che insieme alle 3 caratteristiche principali della OOP definisce questo nuovo modo di concepire l'organizzazione della soluzione algoritmica ad un problema dato.

INCAPSULAMENTO

Come detto tutto ruota intorno al concetto di classe, che possiamo vedere come il costrutto offerto dal linguaggio per realizzare l'astrazione del concetto di oggetto. In pratica il trucco sta nell'affrontare il problema da risolvere modellandolo come un sistema in cui esistono e vivono un insieme di oggeti che comunicano tra di loro attraverso un'interfaccia bene definita: i METODI della classe! La struttura del dato incapsulato nell'oggetto è invece definita da quelli che vengono chiamati ATTRIBUTI. Una classe è quindi costituita da attributi e metodi, che insieme definiscono un nuovo tipo di dato per l'ambiente in cui vengono definiti. Un oggetto è un'istanza di una data classe.

Due oggetti, istanza di una certa classe, possono differire in un certo istante di tempo per il valore che in quell'istante hanno i suoi attributi, che nel loro insieme definiscono lo STATO dell'oggetto. Il concetto di stato di un oggetto è di fondamentale importanza perchè su di esso di basa uno dei tre principi fondamentali dalla OOP: l'INFORMATION HIDING o INCAPSULAMENTO secondo il quale l'unico modo attraverso cui debba essere possibile modificare tale stato dovrebbe essere l'utilizzo dei metodi della classe. Tecnicamente questo è possibile grazie all'utilizzo di indicatori di visibilità per gli attributi che dovrebbero negarne l'accesso all'utilizzatore della classe. Quindi gli oggetti del sistema comunicano tra di loro attraverso messaggi scambiati grazie all'invocazione dei metodi alterandone lo stato.

In .NET è possibile realizzare una classe utilizzando il costrutto Class in Visual Basic e class in C#, è possibile definire gli attributi dichiarando all'interno delle classi delle variabili del tipo voluto, è possible definire i metodi definendo delle Sub o delle Function in Visual Basic, definendo delle funzioni in C#:

Sia per gli attributi che per i metodi e possibile indicare la visibilità che essi devono avere rispetto agli utilizzatori delle classi, gli indicatori possibili sono tre: privato, publico o protetto. Nel primo classe la visibilità è consentita solo all'interno della classe, nel secondo caso e consentita anche agli utilizzatori, nel terzo caso solo alla classe e alle classi che la estendono, concetto quest'ultimo che affronteremo tra poco. In Visual Basic si utilizzano le parole riservate Private, Public e Protected, in C# private, public e protected:

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Michele Aponte — Tue, 23 Jun 2009 14:09:58 GMT
Current revision posted to Articoli by Michele Aponte on 23/06/2009 16:09:58

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Inserito sotto: Certificazioni Esame 70-536

I Reference Type

Come già detto nella precedente lezione un tipo reference memorizza il valore della sua variabile nell’area di memoria chiamata heap, mentre mantiene il rifermento a tale area di memoria nell’area di memoria chiamata stack.

Mentre lo stack viene pulito man mano che le variabili in esso memorizzate perdono visibilità (out-of-scope), l’heap viene gestito da un sistema chiamato garbage collector, attraverso un procedimento chiamato garbage collection che consiste nel verificare periodicamente i riferimenti esistenti ad una certa area di memoria heap e pulirla quando non esistono più riferimenti di questo tipo.

Il modo più semplice di capire il funzionamento pratico di un tipo reference è quello di confrontarlo con un value type. Consideriamo ad esempio il value type personalizzato creato l’ultima volta con un esempio di utilizzo:

// C#

struct MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void Main(string[] args)

    {

        MioTipo primo;

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Structure MioTipo

    Dim i As Integer

    Dim b As Boolean

End Structure

Sub Main()

    Dim primo As MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in output è il seguente:

Per costrruire un reference type basta sotituire il costrutto struct (Structure in Visual Basic) con il costrutto Class:

// C#

public class MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void <st1:place w:st="on">Main</st1:place>(Main(string[] args)

    {

        MioTipo primo = new MioTipo();

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Public Class MioTipo

    Public i As Integer

    Public b As Boolean

End Class

Sub <st1:place w:st="on">Main</st1:place>() Main()

    Dim primo As New MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in questo caso invece è il seguente:

Come mai questa differenza? Molto semplicemente perché in entrambi i casi l’assegnazione alla variabile secondo del valore di primo consiste in una copia del valore delle variabili, che nel primo caso (value type) è proprio il valore della variabile, mentre nel secondo caso (reference type) si tratta del riferimento al valore della variabile, di conseguenza dopo l’assegnazione nel secondo caso secondo punta alla stessa locazione di memoria heap di primo.

Un’altra grande differenza è sicuramente l’utilizzo dell’operatore new (New in Visual Basic) che permette di istanziare la classe MioTipo, creando così lo spazio nello heap destinato alla variabile, cosa non necessaria per i value type dato che l’allocazione avviene sullo stack.

I più comuni reference type sono i seguenti:

-          System.Object, la classe base di tutti i tipi del .net framework

-          System.String, la classe per il contenimento delle stringhe di testo

-          System.Text.StringBuilder, la classe per il contenimento di stringhe di testo dinamiche

-          System.Array, la classe base di tutti gli array del framework,

-          System.IO.Stream, la classe base per la gestione degli stream di dati

-          System.Exception, la classe base di tutte le eccezioni del farmework

Del significato della parola classe base parleremo nei prossimi articoli, adesso focalizziamo la nostra attenzione sulla differenza non necessariamente ovvia tra String e StringBuilder.

String vs StringBuilder

Come potrete immaginare sul tipo String sono definite le più comuni operazioni tra stringhe quale ad esempio la somma, perché dunque avere una classe che permetta la gestione di stringhe dinamiche?

Il tipo System.String è un tipo cosiddetto immutabile, il che significa molto semplicemente che ogni volta che la stringa viene modificata, il runtime di .NET crea una nuova stringa, abbandonando la vecchia. Molti programmatori non ci fanno caso perché la cosa avviene in maniera trasparente ma sapendolo vi renderete sicuramente conto di quanto possa essere uno spreco un simile comportamento. Al fine di evitare questo spiacevole inconveniente è stata creata la classe StringBuilder:

// C#

StringBuilder sb = new StringBuilder();

sb.Append("DotNetCampania - ");

sb.Append("Il primo User Group su .NET ");

sb.Append("tutto campano!");

Console.WriteLine(sb);

' VB

Dim sb As New System.Text.StringBuilder

sb.Append("DotNetCampania - ")

sb.Append("Il primo User Group su .NET ")

sb.Append("tutto campano!")

Console.WriteLine(sb)

Il risultato è del tutto immaginabile:

Di default il costruttore (il metodo della classe che inizializza lo stato di un oggetto, ne parleremo nei prossimi articoli) di StringBuilder crea un buffer di 16 byte che ingrandisce in base alle necessità, ma è possibile specificare la dimensione iniziale e anche la dimensione massima.

Creare e ordinare Arrays

Uno dei contenitori più importanti di dati, dopo la variabile, è l’array, per capirci lo possiamo vedere come un insieme contiguo di variabili dello stesso tipo indicizzate in base alla posizione nell’insieme. La creazione in .NET è molto semplice: le parentesi tonde in Visual Basic e le parentesi quadre in C#.

// C#

int[] ar = {20, 30, 10};

' VB

Dim ar() As Integer = {20, 30, 10}

Grazie alla classe stratta Array e al suo metodo statico Sort, l’ordinamento di un array è veramente un’operazione banale:

// C#

Array.Sort(ar);

Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);

' VB

Array.Sort(ar)

Console.WriteLine("{0}, {1}, {2}", ar(0), ar(1), ar(2))

L’ovvio risultato:

Gli stream di dati

Nel framework .NET l’accesso al disco o la scambio dati nelle comunicazioni di rete sono uniformati dal concetto di Stream, un tipo base grazie al quale è possibile unificare l’accesso ai dati tra varie fonti. Tecnicamente stiamo parlando di una classe stratta da cui vengono create delle classi specifiche della fonte dei dati:

System.IO Type

Usato per

FileStream

Scrivere e leggere da un file

MemoryStream

Scrivere e leggere dalla memoria

StreamReader

Leggere dati da un file di testo

StreamWriter

Scrivere dati in un file di testo

Grazie a queste classi operazioni come la scrittura in un file di testo diventano veramente elementari:

// C#

StreamWriter sw = new StreamWriter("text.txt");

sw.WriteLine("DotNetCampania");

sw.Close();

StreamReader sr = new StreamReader("text.txt");

Console.WriteLine(sr.ReadToEnd());

sr.Close();

' VB

Dim sw As New StreamWriter("text.txt")

sw.WriteLine("DotNetCampania")

sw.Close()

Dim sr As New StreamReader("text.txt")

Console.WriteLine(sr.ReadToEnd)

sr.Close()

Il risultato è abbastanza intuitivo:

Data la loro importanza approfondiremo gli stream nei prossimi articoli.

Gestione delle eccezioni

Che succede se il nostro programma sta leggendo un file da una penna usb e la nostra sorellina, con quell’aria furtiva ma con quello sguardo angelico che ci impedisce di terminarla, ci tira fuori la penna dalla porta USB? Nella speranza che la penna non si sia rotta l’unico problema e che il programma verrebbe interrotto da un’eccezione, cioè un evento inaspettato che interrompe la normale esecuzione dell’algoritmo.

Se una tale eventualità non è stata gestita molto probabilmente il programma termina miseramente con un messaggio di errore generato dal framework, ci va bene? Direi di no! Ecco che quindi ci vengono messi a disposizione i costrutti necessari a gestire una tale eventualità: il blocco Try…Catch…Finally in Visual Basic, try…catch…finally in C#.

Niente è più illuminante di un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

In pratica si divide il codice in due o tre blocchi (il finally è facoltativo): nel primo, il try, si inserisce il codice da sottoporre a gestione delle eccezioni; nel secondo, il catch, si gestisce l’eccezione, nel nostro esempio abbiamo stampato un messaggio di errore; nell’eventuale terzo, il finally, si inseriscono le operazioni da eseguire in qualsiasi caso, sia di normale flusso dell’applicazione che di eccezione. Notate la dichiarazione dello StreamReader fuori dal try: è l’unico modo di renderlo visibile anche al blocco finally.

L’esempio ci da inoltre modo di notare un oggetto molto interessante, Exception, che contiene tutte le informazioni che ci posso essere utili sull’eccezione che è stata generata. La sua struttura è molto generica e viene usata come classe base per creare eccezioni più specifiche, quali ad esempio FileNotFoundException.

La cosa interessante è che mentre il blocco try e il blocco finally sono unici, possiamo creare tutti i blocchi catch che vogliamo a patto di gestire tipi di eccezioni diverse e ricordando che solamente uno sarà utilizzato in caso di eccezione. Facciamo un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (System.IO.FileNotFoundException ex)

{

    Console.WriteLine("File non trovato!");

}

catch (System.UnauthorizedAccessException ex)

{

    Console.WriteLine("Non di dispone dei permessi necessari!");

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As System.IO.FileNotFoundException

    Console.WriteLine("File non trovato!")

Catch ex As System.UnauthorizedAccessException

    Console.WriteLine("Non di dispone dei permessi necessari!")

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

Il bello di questo meccanismo è che possiamo decidere cosa fare in base alla tipologia di eccezione che è stata generata. Tieniamo presente che l’ordine in cui sono messi i catch non è assolutamente casuale, anzi, essendo Exception più generica sia di FileNotFoundException che di UnauthorizedAccessException, metterla in cima ai blocchi catch avrebbe provocato la completa inutilità dei blocchi sottostanti: qualsiasi eccezione sarebbe stata sempre gestita dal blocco catch Exception. Fortuna che il nostro ambiente di sviluppo sa essere molto esplicativo:

Conclusioni

Se non lo avete già fatto penso sia arrivato il momento di aprire visual studio e cominciare a smanettare un po’ altrimenti farete fatica a continuare a seguire questa serie di articoli. Vi do appuntamento al prossimo articolo in cui parleremo di OOP e del contributo di Microsoft a questo paradigma di programmazione che ha rivoluzionato il modo di programmare.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Michele Aponte — Tue, 23 Jun 2009 14:07:32 GMT
Revision 5 posted to Articoli by Michele Aponte on 23/06/2009 16:07:32

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Inserito sotto: Certificazioni Esame 70-536

I Reference Type

Come già detto nella precedente lezione un tipo reference memorizza il valore della sua variabile nell’area di memoria chiamata heap, mentre mantiene il rifermento a tale area di memoria nell’area di memoria chiamata stack.

Mentre lo stack viene pulito man mano che le variabili in esso memorizzate perdono visibilità (out-of-scope), l’heap viene gestito da un sistema chiamato garbage collector, attraverso un procedimento chiamato garbage collection che consiste nel verificare periodicamente i riferimenti esistenti ad una certa area di memoria heap e pulirla quando non esistono più riferimenti di questo tipo.

Il modo più semplice di capire il funzionamento pratico di un tipo reference è quello di confrontarlo con un value type. Consideriamo ad esempio il value type personalizzato creato l’ultima volta con un esempio di utilizzo:

// C#

struct MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void Main(string[] args)

    {

        MioTipo primo;

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Structure MioTipo

    Dim i As Integer

    Dim b As Boolean

End Structure

Sub Main()

    Dim primo As MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in output è il seguente:

/v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock>

Per costrruire un reference type basta sotituire il costrutto struct (Structure in Visual Basic) con il costrutto Class:

// C#

public class MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void <st1:place w:st="on">Main</st1:place>(string[] args)

    {

        MioTipo primo = new MioTipo();

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Public Class MioTipo

    Public i As Integer

    Public b As Boolean

End Class

Sub <st1:place w:st="on">Main</st1:place>()

    Dim primo As New MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in questo caso invece è il seguente:

Come mai questa differenza? Molto semplicemente perché in entrambi i casi l’assegnazione alla variabile secondo del valore di primo consiste in una copia del valore delle variabili, che nel primo caso (value type) è proprio il valore della variabile, mentre nel secondo caso (reference type) si tratta del riferimento al valore della variabile, di conseguenza dopo l’assegnazione nel secondo caso secondo punta alla stessa locazione di memoria heap di primo.

Un’altra grande differenza è sicuramente l’utilizzo dell’operatore new (New in Visual Basic) che permette di istanziare la classe MioTipo, creando così lo spazio nello heap destinato alla variabile, cosa non necessaria per i value type dato che l’allocazione avviene sullo stack.

I più comuni reference type sono i seguenti:

-          System.Object, la classe base di tutti i tipi del .net framework

-          System.String, la classe per il contenimento delle stringhe di testo

-          System.Text.StringBuilder, la classe per il contenimento di stringhe di testo dinamiche

-          System.Array, la classe base di tutti gli array del framework,

-          System.IO.Stream, la classe base per la gestione degli stream di dati

-          System.Exception, la classe base di tutte le eccezioni del farmework

Del significato della parola classe base parleremo nei prossimi articoli, adesso focalizziamo la nostra attenzione sulla differenza non necessariamente ovvia tra String e StringBuilder.

String vs StringBuilder

Come potrete immaginare sul tipo String sono definite le più comuni operazioni tra stringhe quale ad esempio la somma, perché dunque avere una classe che permetta la gestione di stringhe dinamiche?

Il tipo System.String è un tipo cosiddetto immutabile, il che significa molto semplicemente che ogni volta che la stringa viene modificata, il runtime di .NET crea una nuova stringa, abbandonando la vecchia. Molti programmatori non ci fanno caso perché la cosa avviene in maniera trasparente ma sapendolo vi renderete sicuramente conto di quanto possa essere uno spreco un simile comportamento. Al fine di evitare questo spiacevole inconveniente è stata creata la classe StringBuilder:

// C#

StringBuilder sb = new StringBuilder();

sb.Append("DotNetCampania - ");

sb.Append("Il primo User Group su .NET ");

sb.Append("tutto campano!");

Console.WriteLine(sb);

' VB

Dim sb As New System.Text.StringBuilder

sb.Append("DotNetCampania - ")

sb.Append("Il primo User Group su .NET ")

sb.Append("tutto campano!")

Console.WriteLine(sb)

Il risultato è del tutto immaginabile:

Di default il costruttore (il metodo della classe che inizializza lo stato di un oggetto, ne parleremo nei prossimi articoli) di StringBuilder crea un buffer di 16 byte che ingrandisce in base alle necessità, ma è possibile specificare la dimensione iniziale e anche la dimensione massima.

Creare e ordinare Arrays

Uno dei contenitori più importanti di dati, dopo la variabile, è l’array, per capirci lo possiamo vedere come un insieme contiguo di variabili dello stesso tipo indicizzate in base alla posizione nell’insieme. La creazione in .NET è molto semplice: le parentesi tonde in Visual Basic e le parentesi quadre in C#.

// C#

int[] ar = {20, 30, 10};

' VB

Dim ar() As Integer = {20, 30, 10}

Grazie alla classe stratta Array e al suo metodo statico Sort, l’ordinamento di un array è veramente un’operazione banale:

// C#

Array.Sort(ar);

Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);

' VB

Array.Sort(ar)

Console.WriteLine("{0}, {1}, {2}", ar(0), ar(1), ar(2))

L’ovvio risultato:

Gli stream di dati

Nel framework .NET l’accesso al disco o la scambio dati nelle comunicazioni di rete sono uniformati dal concetto di Stream, un tipo base grazie al quale è possibile unificare l’accesso ai dati tra varie fonti. Tecnicamente stiamo parlando di una classe stratta da cui vengono create delle classi specifiche della fonte dei dati:

System.IO Type

Usato per

FileStream

Scrivere e leggere da un file

MemoryStream

Scrivere e leggere dalla memoria

StreamReader

Leggere dati da un file di testo

StreamWriter

Scrivere dati in un file di testo

Grazie a queste classi operazioni come la scrittura in un file di testo diventano veramente elementari:

// C#

StreamWriter sw = new StreamWriter("text.txt");

sw.WriteLine("DotNetCampania");

sw.Close();

StreamReader sr = new StreamReader("text.txt");

Console.WriteLine(sr.ReadToEnd());

sr.Close();

' VB

Dim sw As New StreamWriter("text.txt")

sw.WriteLine("DotNetCampania")

sw.Close()

Dim sr As New StreamReader("text.txt")

Console.WriteLine(sr.ReadToEnd)

sr.Close()

Il risultato è abbastanza intuitivo:

Data la loro importanza approfondiremo gli stream nei prossimi articoli.

Gestione delle eccezioni

Che succede se il nostro programma sta leggendo un file da una penna usb e la nostra sorellina, con quell’aria furtiva ma con quello sguardo angelico che ci impedisce di terminarla, ci tira fuori la penna dalla porta USB? Nella speranza che la penna non si sia rotta l’unico problema e che il programma verrebbe interrotto da un’eccezione, cioè un evento inaspettato che interrompe la normale esecuzione dell’algoritmo.

Se una tale eventualità non è stata gestita molto probabilmente il programma termina miseramente con un messaggio di errore generato dal framework, ci va bene? Direi di no! Ecco che quindi ci vengono messi a disposizione i costrutti necessari a gestire una tale eventualità: il blocco Try…Catch…Finally in Visual Basic, try…catch…finally in C#.

Niente è più illuminante di un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

In pratica si divide il codice in due o tre blocchi (il finally è facoltativo): nel primo, il try, si inserisce il codice da sottoporre a gestione delle eccezioni; nel secondo, il catch, si gestisce l’eccezione, nel nostro esempio abbiamo stampato un messaggio di errore; nell’eventuale terzo, il finally, si inseriscono le operazioni da eseguire in qualsiasi caso, sia di normale flusso dell’applicazione che di eccezione. Notate la dichiarazione dello StreamReader fuori dal try: è l’unico modo di renderlo visibile anche al blocco finally.

L’esempio ci da inoltre modo di notare un oggetto molto interessante, Exception, che contiene tutte le informazioni che ci posso essere utili sull’eccezione che è stata generata. La sua struttura è molto generica e viene usata come classe base per creare eccezioni più specifiche, quali ad esempio FileNotFoundException.

La cosa interessante è che mentre il blocco try e il blocco finally sono unici, possiamo creare tutti i blocchi catch che vogliamo a patto di gestire tipi di eccezioni diverse e ricordando che solamente uno sarà utilizzato in caso di eccezione. Facciamo un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (System.IO.FileNotFoundException ex)

{

    Console.WriteLine("File non trovato!");

}

catch (System.UnauthorizedAccessException ex)

{

    Console.WriteLine("Non di dispone dei permessi necessari!");

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As System.IO.FileNotFoundException

    Console.WriteLine("File non trovato!")

Catch ex As System.UnauthorizedAccessException

    Console.WriteLine("Non di dispone dei permessi necessari!")

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

Il bello di questo meccanismo è che possiamo decidere cosa fare in base alla tipologia di eccezione che è stata generata. Tieniamo presente che l’ordine in cui sono messi i catch non è assolutamente casuale, anzi, essendo Exception più generica sia di FileNotFoundException che di UnauthorizedAccessException, metterla in cima ai blocchi catch avrebbe provocato la completa inutilità dei blocchi sottostanti: qualsiasi eccezione sarebbe stata sempre gestita dal blocco catch Exception. Fortuna che il nostro ambiente di sviluppo sa essere molto esplicativo:

Conclusioni

Se non lo avete già fatto penso sia arrivato il momento di aprire visual studio e cominciare a smanettare un po’ altrimenti farete fatica a continuare a seguire questa serie di articoli. Vi do appuntamento al prossimo articolo in cui parleremo di OOP e del contributo di Microsoft a questo paradigma di programmazione che ha rivoluzionato il modo di programmare.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Michele Aponte — Tue, 23 Jun 2009 14:03:00 GMT
Revision 4 posted to Articoli by Michele Aponte on 23/06/2009 16:03:00

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Inserito sotto: Certificazioni Esame 70-536

I Reference Type

Come già detto nella precedente lezione un tipo reference memorizza il valore della sua variabile nell’area di memoria chiamata heap, mentre mantiene il rifermento a tale area di memoria nell’area di memoria chiamata stack.

Mentre lo stack viene pulito man mano che le variabili in esso memorizzate perdono visibilità (out-of-scope), l’heap viene gestito da un sistema chiamato garbage collector, attraverso un procedimento chiamato garbage collection che consiste nel verificare periodicamente i riferimenti esistenti ad una certa area di memoria heap e pulirla quando non esistono più riferimenti di questo tipo.

Il modo più semplice di capire il funzionamento pratico di un tipo reference è quello di confrontarlo con un value type. Consideriamo ad esempio il value type personalizzato creato l’ultima volta con un esempio di utilizzo:

// C#

struct MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void <st1:place w:st="on">Main</st1:place>(Main(string[] args)

    {

        MioTipo primo;

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Structure MioTipo

    Dim i As Integer

    Dim b As Boolean

End Structure

Sub <st1:place w:st="on">Main</st1:place>() Main()

    Dim primo As MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in output è il seguente:

/v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock>

Per costrruire un reference type basta sotituire il costrutto struct (Structure in Visual Basic) con il costrutto Class:

// C#

public class MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void <st1:place w:st="on">Main</st1:place>(string[] args)

    {

        MioTipo primo = new MioTipo();

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Public Class MioTipo

    Public i As Integer

    Public b As Boolean

End Class

Sub <st1:place w:st="on">Main</st1:place>()

    Dim primo As New MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in questo caso invece è il seguente:

Come mai questa differenza? Molto semplicemente perché in entrambi i casi l’assegnazione alla variabile secondo del valore di primo consiste in una copia del valore delle variabili, che nel primo caso (value type) è proprio il valore della variabile, mentre nel secondo caso (reference type) si tratta del riferimento al valore della variabile, di conseguenza dopo l’assegnazione nel secondo caso secondo punta alla stessa locazione di memoria heap di primo.

Un’altra grande differenza è sicuramente l’utilizzo dell’operatore new (New in Visual Basic) che permette di istanziare la classe MioTipo, creando così lo spazio nello heap destinato alla variabile, cosa non necessaria per i value type dato che l’allocazione avviene sullo stack.

I più comuni reference type sono i seguenti:

-          System.Object, la classe base di tutti i tipi del .net framework

-          System.String, la classe per il contenimento delle stringhe di testo

-          System.Text.StringBuilder, la classe per il contenimento di stringhe di testo dinamiche

-          System.Array, la classe base di tutti gli array del framework,

-          System.IO.Stream, la classe base per la gestione degli stream di dati

-          System.Exception, la classe base di tutte le eccezioni del farmework

Del significato della parola classe base parleremo nei prossimi articoli, adesso focalizziamo la nostra attenzione sulla differenza non necessariamente ovvia tra String e StringBuilder.

String vs StringBuilder

Come potrete immaginare sul tipo String sono definite le più comuni operazioni tra stringhe quale ad esempio la somma, perché dunque avere una classe che permetta la gestione di stringhe dinamiche?

Il tipo System.String è un tipo cosiddetto immutabile, il che significa molto semplicemente che ogni volta che la stringa viene modificata, il runtime di .NET crea una nuova stringa, abbandonando la vecchia. Molti programmatori non ci fanno caso perché la cosa avviene in maniera trasparente ma sapendolo vi renderete sicuramente conto di quanto possa essere uno spreco un simile comportamento. Al fine di evitare questo spiacevole inconveniente è stata creata la classe StringBuilder:

// C#

StringBuilder sb = new StringBuilder();

sb.Append("DotNetCampania - ");

sb.Append("Il primo User Group su .NET ");

sb.Append("tutto campano!");

Console.WriteLine(sb);

' VB

Dim sb As New System.Text.StringBuilder

sb.Append("DotNetCampania - ")

sb.Append("Il primo User Group su .NET ")

sb.Append("tutto campano!")

Console.WriteLine(sb)

Il risultato è del tutto immaginabile:

Di default il costruttore (il metodo della classe che inizializza lo stato di un oggetto, ne parleremo nei prossimi articoli) di StringBuilder crea un buffer di 16 byte che ingrandisce in base alle necessità, ma è possibile specificare la dimensione iniziale e anche la dimensione massima.

Creare e ordinare Arrays

Uno dei contenitori più importanti di dati, dopo la variabile, è l’array, per capirci lo possiamo vedere come un insieme contiguo di variabili dello stesso tipo indicizzate in base alla posizione nell’insieme. La creazione in .NET è molto semplice: le parentesi tonde in Visual Basic e le parentesi quadre in C#.

// C#

int[] ar = {20, 30, 10};

' VB

Dim ar() As Integer = {20, 30, 10}

Grazie alla classe stratta Array e al suo metodo statico Sort, l’ordinamento di un array è veramente un’operazione banale:

// C#

Array.Sort(ar);

Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);

' VB

Array.Sort(ar)

Console.WriteLine("{0}, {1}, {2}", ar(0), ar(1), ar(2))

L’ovvio risultato:

Gli stream di dati

Nel framework .NET l’accesso al disco o la scambio dati nelle comunicazioni di rete sono uniformati dal concetto di Stream, un tipo base grazie al quale è possibile unificare l’accesso ai dati tra varie fonti. Tecnicamente stiamo parlando di una classe stratta da cui vengono create delle classi specifiche della fonte dei dati:

System.IO Type

Usato per

FileStream

Scrivere e leggere da un file

MemoryStream

Scrivere e leggere dalla memoria

StreamReader

Leggere dati da un file di testo

StreamWriter

Scrivere dati in un file di testo

Grazie a queste classi operazioni come la scrittura in un file di testo diventano veramente elementari:

// C#

StreamWriter sw = new StreamWriter("text.txt");

sw.WriteLine("DotNetCampania");

sw.Close();

StreamReader sr = new StreamReader("text.txt");

Console.WriteLine(sr.ReadToEnd());

sr.Close();

' VB

Dim sw As New StreamWriter("text.txt")

sw.WriteLine("DotNetCampania")

sw.Close()

Dim sr As New StreamReader("text.txt")

Console.WriteLine(sr.ReadToEnd)

sr.Close()

Il risultato è abbastanza intuitivo:

Data la loro importanza approfondiremo gli stream nei prossimi articoli.

Gestione delle eccezioni

Che succede se il nostro programma sta leggendo un file da una penna usb e la nostra sorellina, con quell’aria furtiva ma con quello sguardo angelico che ci impedisce di terminarla, ci tira fuori la penna dalla porta USB? Nella speranza che la penna non si sia rotta l’unico problema e che il programma verrebbe interrotto da un’eccezione, cioè un evento inaspettato che interrompe la normale esecuzione dell’algoritmo.

Se una tale eventualità non è stata gestita molto probabilmente il programma termina miseramente con un messaggio di errore generato dal framework, ci va bene? Direi di no! Ecco che quindi ci vengono messi a disposizione i costrutti necessari a gestire una tale eventualità: il blocco Try…Catch…Finally in Visual Basic, try…catch…finally in C#.

Niente è più illuminante di un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

In pratica si divide il codice in due o tre blocchi (il finally è facoltativo): nel primo, il try, si inserisce il codice da sottoporre a gestione delle eccezioni; nel secondo, il catch, si gestisce l’eccezione, nel nostro esempio abbiamo stampato un messaggio di errore; nell’eventuale terzo, il finally, si inseriscono le operazioni da eseguire in qualsiasi caso, sia di normale flusso dell’applicazione che di eccezione. Notate la dichiarazione dello StreamReader fuori dal try: è l’unico modo di renderlo visibile anche al blocco finally.

L’esempio ci da inoltre modo di notare un oggetto molto interessante, Exception, che contiene tutte le informazioni che ci posso essere utili sull’eccezione che è stata generata. La sua struttura è molto generica e viene usata come classe base per creare eccezioni più specifiche, quali ad esempio FileNotFoundException.

La cosa interessante è che mentre il blocco try e il blocco finally sono unici, possiamo creare tutti i blocchi catch che vogliamo a patto di gestire tipi di eccezioni diverse e ricordando che solamente uno sarà utilizzato in caso di eccezione. Facciamo un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (System.IO.FileNotFoundException ex)

{

    Console.WriteLine("File non trovato!");

}

catch (System.UnauthorizedAccessException ex)

{

    Console.WriteLine("Non di dispone dei permessi necessari!");

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As System.IO.FileNotFoundException

    Console.WriteLine("File non trovato!")

Catch ex As System.UnauthorizedAccessException

    Console.WriteLine("Non di dispone dei permessi necessari!")

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

Il bello di questo meccanismo è che possiamo decidere cosa fare in base alla tipologia di eccezione che è stata generata. Tieniamo presente che l’ordine in cui sono messi i catch non è assolutamente casuale, anzi, essendo Exception più generica sia di FileNotFoundException che di UnauthorizedAccessException, metterla in cima ai blocchi catch avrebbe provocato la completa inutilità dei blocchi sottostanti: qualsiasi eccezione sarebbe stata sempre gestita dal blocco catch Exception. Fortuna che il nostro ambiente di sviluppo sa essere molto esplicativo:

Conclusioni

Se non lo avete già fatto penso sia arrivato il momento di aprire visual studio e cominciare a smanettare un po’ altrimenti farete fatica a continuare a seguire questa serie di articoli. Vi do appuntamento al prossimo articolo in cui parleremo di OOP e del contributo di Microsoft a questo paradigma di programmazione che ha rivoluzionato il modo di programmare.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Michele Aponte — Tue, 23 Jun 2009 14:00:04 GMT
Revision 3 posted to Articoli by Michele Aponte on 23/06/2009 16:00:04

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Inserito sotto: Certificazioni Esame 70-536

I Reference Type

Come già detto nella precedente lezione un tipo reference memorizza il valore della sua variabile nell’area di memoria chiamata heap, mentre mantiene il rifermento a tale area di memoria nell’area di memoria chiamata stack.

Mentre lo stack viene pulito man mano che le variabili in esso memorizzate perdono visibilità (out-of-scope), l’heap viene gestito da un sistema chiamato garbage collector, attraverso un procedimento chiamato garbage collection che consiste nel verificare periodicamente i riferimenti esistenti ad una certa area di memoria heap e pulirla quando non esistono più riferimenti di questo tipo.

Il modo più semplice di capire il funzionamento pratico di un tipo reference è quello di confrontarlo con un value type. Consideriamo ad esempio il value type personalizzato creato l’ultima volta con un esempio di utilizzo:

// C#

struct MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void <st1:place w:st="on">Main</st1:place>(string[] args)

    {

        MioTipo primo;

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Structure MioTipo

    Dim i As Integer

    Dim b As Boolean

End Structure

Sub <st1:place w:st="on">Main</st1:place>()

    Dim primo As MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in output è il seguente:

<v:shapetype coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f" id="_x0000_t75"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype>

Per costrruire un reference type basta sotituire il costrutto struct (Structure in Visual Basic) con il costrutto Class:

// C#

public class MioTipo

{

    public int i;

    public bool b;

}

class Program

{

    static void <st1:place w:st="on">Main</st1:place>(string[] args)

    {

        MioTipo primo = new MioTipo();

        primo.i = 1;

        primo.b = true;

        MioTipo secondo = primo;

        secondo.i = 2;

        secondo.b = false;

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);

    }

}

' VB

Public Class MioTipo

    Public i As Integer

    Public b As Boolean

End Class

Sub <st1:place w:st="on">Main</st1:place>()

    Dim primo As New MioTipo

    primo.i = 1

    primo.b = True

    Dim secondo As MioTipo = primo

    secondo.i = 2

    secondo.b = False

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)

End Sub

Il risultato in questo caso invece è il seguente:

Come mai questa differenza? Molto semplicemente perché in entrambi i casi l’assegnazione alla variabile secondo del valore di primo consiste in una copia del valore delle variabili, che nel primo caso (value type) è proprio il valore della variabile, mentre nel secondo caso (reference type) si tratta del riferimento al valore della variabile, di conseguenza dopo l’assegnazione nel secondo caso secondo punta alla stessa locazione di memoria heap di primo.

Un’altra grande differenza è sicuramente l’utilizzo dell’operatore new (New in Visual Basic) che permette di istanziare la classe MioTipo, creando così lo spazio nello heap destinato alla variabile, cosa non necessaria per i value type dato che l’allocazione avviene sullo stack.

I più comuni reference type sono i seguenti:

-          System.Object, la classe base di tutti i tipi del .net framework

-          System.String, la classe per il contenimento delle stringhe di testo

-          System.Text.StringBuilder, la classe per il contenimento di stringhe di testo dinamiche

-          System.Array, la classe base di tutti gli array del framework,

-          System.IO.Stream, la classe base per la gestione degli stream di dati

-          System.Exception, la classe base di tutte le eccezioni del farmework

Del significato della parola classe base parleremo nei prossimi articoli, adesso focalizziamo la nostra attenzione sulla differenza non necessariamente ovvia tra String e StringBuilder.

String vs StringBuilder

Come potrete immaginare sul tipo String sono definite le più comuni operazioni tra stringhe quale ad esempio la somma, perché dunque avere una classe che permetta la gestione di stringhe dinamiche?

Il tipo System.String è un tipo cosiddetto immutabile, il che significa molto semplicemente che ogni volta che la stringa viene modificata, il runtime di .NET crea una nuova stringa, abbandonando la vecchia. Molti programmatori non ci fanno caso perché la cosa avviene in maniera trasparente ma sapendolo vi renderete sicuramente conto di quanto possa essere uno spreco un simile comportamento. Al fine di evitare questo spiacevole inconveniente è stata creata la classe StringBuilder:

// C#

StringBuilder sb = new StringBuilder();

sb.Append("DotNetCampania - ");

sb.Append("Il primo User Group su .NET ");

sb.Append("tutto campano!");

Console.WriteLine(sb);

' VB

Dim sb As New System.Text.StringBuilder

sb.Append("DotNetCampania - ")

sb.Append("Il primo User Group su .NET ")

sb.Append("tutto campano!")

Console.WriteLine(sb)

Il risultato è del tutto immaginabile:

Di default il costruttore (il metodo della classe che inizializza lo stato di un oggetto, ne parleremo nei prossimi articoli) di StringBuilder crea un buffer di 16 byte che ingrandisce in base alle necessità, ma è possibile specificare la dimensione iniziale e anche la dimensione massima.

Creare e ordinare Arrays

Uno dei contenitori più importanti di dati, dopo la variabile, è l’array, per capirci lo possiamo vedere come un insieme contiguo di variabili dello stesso tipo indicizzate in base alla posizione nell’insieme. La creazione in .NET è molto semplice: le parentesi tonde in Visual Basic e le parentesi quadre in C#.

// C#

int[] ar = {20, 30, 10};

' VB

Dim ar() As Integer = {20, 30, 10}

Grazie alla classe stratta Array e al suo metodo statico Sort, l’ordinamento di un array è veramente un’operazione banale:

// C#

Array.Sort(ar);

Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);

' VB

Array.Sort(ar)

Console.WriteLine("{0}, {1}, {2}", ar(0), ar(1), ar(2))

L’ovvio risultato:

Gli stream di dati

Nel framework .NET l’accesso al disco o la scambio dati nelle comunicazioni di rete sono uniformati dal concetto di Stream, un tipo base grazie al quale è possibile unificare l’accesso ai dati tra varie fonti. Tecnicamente stiamo parlando di una classe stratta da cui vengono create delle classi specifiche della fonte dei dati:

System.IO Type

Usato per

FileStream

Scrivere e leggere da un file

MemoryStream

Scrivere e leggere dalla memoria

StreamReader

Leggere dati da un file di testo

StreamWriter

Scrivere dati in un file di testo

Grazie a queste classi operazioni come la scrittura in un file di testo diventano veramente elementari:

// C#

StreamWriter sw = new StreamWriter("text.txt");

sw.WriteLine("DotNetCampania");

sw.Close();

StreamReader sr = new StreamReader("text.txt");

Console.WriteLine(sr.ReadToEnd());

sr.Close();

' VB

Dim sw As New StreamWriter("text.txt")

sw.WriteLine("DotNetCampania")

sw.Close()

Dim sr As New StreamReader("text.txt")

Console.WriteLine(sr.ReadToEnd)

sr.Close()

Il risultato è abbastanza intuitivo:

Data la loro importanza approfondiremo gli stream nei prossimi articoli.

Gestione delle eccezioni

Che succede se il nostro programma sta leggendo un file da una penna usb e la nostra sorellina, con quell’aria furtiva ma con quello sguardo angelico che ci impedisce di terminarla, ci tira fuori la penna dalla porta USB? Nella speranza che la penna non si sia rotta l’unico problema e che il programma verrebbe interrotto da un’eccezione, cioè un evento inaspettato che interrompe la normale esecuzione dell’algoritmo.

Se una tale eventualità non è stata gestita molto probabilmente il programma termina miseramente con un messaggio di errore generato dal framework, ci va bene? Direi di no! Ecco che quindi ci vengono messi a disposizione i costrutti necessari a gestire una tale eventualità: il blocco Try…Catch…Finally in Visual Basic, try…catch…finally in C#.

Niente è più illuminante di un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

In pratica si divide il codice in due o tre blocchi (il finally è facoltativo): nel primo, il try, si inserisce il codice da sottoporre a gestione delle eccezioni; nel secondo, il catch, si gestisce l’eccezione, nel nostro esempio abbiamo stampato un messaggio di errore; nell’eventuale terzo, il finally, si inseriscono le operazioni da eseguire in qualsiasi caso, sia di normale flusso dell’applicazione che di eccezione. Notate la dichiarazione dello StreamReader fuori dal try: è l’unico modo di renderlo visibile anche al blocco finally.

L’esempio ci da inoltre modo di notare un oggetto molto interessante, Exception, che contiene tutte le informazioni che ci posso essere utili sull’eccezione che è stata generata. La sua struttura è molto generica e viene usata come classe base per creare eccezioni più specifiche, quali ad esempio FileNotFoundException.

La cosa interessante è che mentre il blocco try e il blocco finally sono unici, possiamo creare tutti i blocchi catch che vogliamo a patto di gestire tipi di eccezioni diverse e ricordando che solamente uno sarà utilizzato in caso di eccezione. Facciamo un esempio:

// C#

StreamReader sr = null;

try

{

    sr = new StreamReader("text.txt");

    Console.WriteLine(sr.ReadToEnd());

}

catch (System.IO.FileNotFoundException ex)

{

    Console.WriteLine("File non trovato!");

}

catch (System.UnauthorizedAccessException ex)

{

    Console.WriteLine("Non di dispone dei permessi necessari!");

}

catch (Exception ex)

{

    Console.WriteLine("Errore: " + ex.Message);

}

finally

{

    sr.Close();

}

' VB

Dim sr As StreamReader = Nothing

Try

    sr = New StreamReader("text.txt")

    Console.WriteLine(sr.ReadToEnd())

Catch ex As System.IO.FileNotFoundException

    Console.WriteLine("File non trovato!")

Catch ex As System.UnauthorizedAccessException

    Console.WriteLine("Non di dispone dei permessi necessari!")

Catch ex As Exception

    Console.WriteLine("Errore: " + ex.Message)

Finally

    sr.Close()

End Try

Il bello di questo meccanismo è che possiamo decidere cosa fare in base alla tipologia di eccezione che è stata generata. Tieniamo presente che l’ordine in cui sono messi i catch non è assolutamente casuale, anzi, essendo Exception più generica sia di FileNotFoundException che di UnauthorizedAccessException, metterla in cima ai blocchi catch avrebbe provocato la completa inutilità dei blocchi sottostanti: qualsiasi eccezione sarebbe stata sempre gestita dal blocco catch Exception. Fortuna che il nostro ambiente di sviluppo sa essere molto esplicativo:

Conclusioni

Se non lo avete già fatto penso sia arrivato il momento di aprire visual studio e cominciare a smanettare un po’ altrimenti farete fatica a continuare a seguire questa serie di articoli. Vi do appuntamento al prossimo articolo in cui parleremo di OOP e del contributo di Microsoft a questo paradigma di programmazione che ha rivoluzionato il modo di programmare.

Happy Coding.

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Michele Aponte — Tue, 23 Jun 2009 13:57:51 GMT
Revision 2 posted to Articoli by Michele Aponte on 23/06/2009 15:57:51

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Inserito sotto: Certificazioni Esame 70-536

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02
I Reference Type

Come già detto nella precedente lezione un tipo reference memorizza il valore della sua variabile nell’area di memoria chiamata heap, mentre mantiene il rifermento a tale area di memoria nell’area di memoria chiamata stack.

Mentre lo stack viene pulito man mano che le variabili in esso memorizzate perdono visibilità (out-of-scope), l’heap viene gestito da un sistema chiamato garbage collector, attraverso un procedimento chiamato garbage collection che consiste nel verificare periodicamente i riferimenti esistenti ad una certa area di memoria heap e pulirla quando non esistono più riferimenti di questo tipo.

Il modo più semplice di capire il funzionamento pratico di un tipo reference è quello di confrontarlo con un value type. Consideriamo ad esempio il value type personalizzato creato l’ultima volta con un esempio di utilizzo:

<o:p> </o:p>

// C#<o:p></o:p>

struct MioTipo<o:p></o:p>

{<o:p></o:p>

    public int i;<o:p></o:p>

    public bool b;<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

class Program<o:p></o:p>

{<o:p></o:p>

    static void <st1:place w:st="on">Main</st1:place>(string[] args)<o:p></o:p>

    {<o:p></o:p>

        MioTipo primo;<o:p></o:p>

        primo.i = 1;<o:p></o:p>

        primo.b = true;<o:p></o:p>

<o:p> </o:p>

        MioTipo secondo = primo;<o:p></o:p>

        secondo.i = 2;<o:p></o:p>

        secondo.b = false;<o:p></o:p>

<o:p> </o:p>

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);<o:p></o:p>

    }<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Structure MioTipo<o:p></o:p>

    Dim i As Integer<o:p></o:p>

    Dim b As Boolean<o:p></o:p>

End Structure<o:p></o:p>

<o:p> </o:p>

Sub <st1:place w:st="on">Main</st1:place>()<o:p></o:p>"on">Main</st1:place>()

    Dim primo As MioTipo<o:p></o:p>

    primo.i = 1<o:p></o:p>

    primo.b = True<o:p></o:p>

<o:p> </o:p>

    Dim secondo As MioTipo = primo<o:p></o:p>

    secondo.i = 2<o:p></o:p>

    secondo.b = False<o:p></o:p>

<o:p> </o:p>

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)<o:p></o:p>

End Sub<o:p></o:p>

<o:p> </o:p>

Il risultato in output è il seguente:<o:p></o:p>

<o:p></o:p>

<v:shapetype coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f" id="_x0000_t75"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><o:p></o:p>

<o:p></o:p>

<o:p>"t"></o:lock></v:shapetype>

</o:p>

<o:p> </o:p>

Per costrruire un reference type basta sotituire il costrutto struct (Structure in Visual Basic) con il costrutto Class:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

public class MioTipo<o:p></o:p>

{<o:p></o:p>

    public int i;<o:p></o:p>

    public bool b;<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

class Program<o:p></o:p>

{<o:p></o:p>

    static void <st1:place w:st="on">Main</st1:place>(string[] args)<o:p></o:p>

    {<o:p></o:p>

        MioTipo primo = new MioTipo();<o:p></o:p>

        primo.i = 1;<o:p></o:p>

        primo.b = true;<o:p></o:p>

<o:p> </o:p>

        MioTipo secondo = primo;<o:p></o:p>

        secondo.i = 2;<o:p></o:p>

        secondo.b = false;<o:p></o:p>

<o:p> </o:p>

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);<o:p></o:p>

    }<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Public Class MioTipo<o:p></o:p>

    Public i As Integer<o:p></o:p>

    Public b As Boolean<o:p></o:p>

End Class<o:p></o:p>

<o:p> </o:p>

Sub <st1:place w:st="on">Main</st1:place>()<o:p></o:p>"on">Main</st1:place>()

    Dim primo As New MioTipo<o:p></o:p>

    primo.i = 1<o:p></o:p>

    primo.b = True<o:p></o:p>

<o:p> </o:p>

    Dim secondo As MioTipo = primo<o:p></o:p>

    secondo.i = 2<o:p></o:p>

    secondo.b = False<o:p></o:p>

<o:p> </o:p>

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)<o:p></o:p>

End Sub<o:p></o:p>

<o:p> </o:p>

Il risultato in questo caso invece è il seguente:

Come mai questa differenza? Molto semplicemente perché in entrambi i casi l’assegnazione alla variabile secondo del valore di primo consiste in una copia del valore delle variabili, che nel primo caso (value type) è proprio il valore della variabile, mentre nel secondo caso (reference type) si tratta del riferimento al valore della variabile, di conseguenza dopo l’assegnazione nel secondo caso secondo punta alla stessa locazione di memoria heap di primo.

Un’altra grande differenza è sicuramente l’utilizzo dell’operatore new (New in Visual Basic) che permette di istanziare la classe MioTipo, creando così lo spazio nello heap destinato alla variabile, cosa non necessaria per i value type dato che l’allocazione avviene sullo stack.

I più comuni reference type sono i seguenti:

-          System.Object, la classe base di tutti i tipi del .net framework<o:p></o:p>

-          System.String, la classe per il contenimento delle stringhe di testo<o:p></o:p>

-          System.Text.StringBuilder, la classe per il contenimento di stringhe di testo dinamiche<o:p></o:p>

-          System.Array, la classe base di tutti gli array del framework,<o:p></o:p>

-          System.IO.Stream, la classe base per la gestione degli stream di dati<o:p></o:p>

-          System.Exception, la classe base di tutte le eccezioni del farmework<o:p></o:p>

Del significato della parola classe base parleremo nei prossimi articoli, adesso focalizziamo la nostra attenzione sulla differenza non necessariamente ovvia tra String e StringBuilder.

String vs StringBuilder

Come potrete immaginare sul tipo String sono definite le più comuni operazioni tra stringhe quale ad esempio la somma, perché dunque avere una classe che permetta la gestione di stringhe dinamiche?

Il tipo System.String è un tipo cosiddetto immutabile, il che significa molto semplicemente che ogni volta che la stringa viene modificata, il runtime di .NET crea una nuova stringa, abbandonando la vecchia. Molti programmatori non ci fanno caso perché la cosa avviene in maniera trasparente ma sapendolo vi renderete sicuramente conto di quanto possa essere uno spreco un simile comportamento. Al fine di evitare questo spiacevole inconveniente è stata creata la classe StringBuilder:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

StringBuilder sb = new StringBuilder();<o:p></o:p>

sb.Append("DotNetCampania - ");<o:p></o:p>

sb.Append("Il primo User Group su .NET ");<o:p></o:p>

sb.Append("tutto campano!");<o:p></o:p>

Console.WriteLine(sb);<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sb As New System.Text.StringBuilder<o:p></o:p>

sb.Append("DotNetCampania - ")<o:p></o:p>

sb.Append("Il primo User Group su .NET ")<o:p></o:p>

sb.Append("tutto campano!")<o:p></o:p>

Console.WriteLine(sb)<o:p></o:p>

<o:p> </o:p>

Il risultato è del tutto immaginabile:<o:p></o:p>

<o:p></o:p>

<o:p>

</o:p>

Di default il costruttore (il metodo della classe che inizializza lo stato di un oggetto, ne parleremo nei prossimi articoli) di StringBuilder crea un buffer di 16 byte che ingrandisce in base alle necessità, ma è possibile specificare la dimensione iniziale e anche la dimensione massima.

Creare e ordinare Arrays

Uno dei contenitori più importanti di dati, dopo la variabile, è l’array, per capirci lo possiamo vedere come un insieme contiguo di variabili dello stesso tipo indicizzate in base alla posizione nell’insieme. La creazione in .NET è molto semplice: le parentesi tonde in Visual Basic e le parentesi quadre in C#.

<o:p> </o:p>

// C#<o:p></o:p>

int[] ar = {20, 30, 10};<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim ar() As Integer = {20, 30, 10}<o:p></o:p>

<o:p> </o:p>

Grazie alla classe stratta Array e al suo metodo statico Sort, l’ordinamento di un array è veramente un’operazione banale:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

Array.Sort(ar);<o:p></o:p>

Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Array.Sort(ar)<o:p></o:p>

Console.WriteLine("{0}, {1}, {2}", ar(0), ar(1), ar(2))<o:p></o:p>

<o:p> </o:p>

L’ovvio risultato:<o:p></o:p>

<o:p></o:p>

Gli stream di dati

Nel framework .NET l’accesso al disco o la scambio dati nelle comunicazioni di rete sono uniformati dal concetto di Stream, un tipo base grazie al quale è possibile unificare l’accesso ai dati tra varie fonti. Tecnicamente stiamo parlando di una classe stratta da cui vengono create delle classi specifiche della fonte dei dati:

<o:p> </o:p>

System.IO Type <o:p></o:p>

Usato per<o:p></o:p>

FileStream <o:p></o:p>

Scrivere e leggere da un file<o:p></o:p>

MemoryStream <o:p></o:p>

Scrivere e leggere dalla memoria<o:p></o:p>

StreamReader <o:p></o:p>

Leggere dati da un file di testo<o:p></o:p>

StreamWriter <o:p></o:p>

Scrivere dati in un file di testo<o:p></o:p>

<o:p> </o:p>

Grazie a queste classi operazioni come la scrittura in un file di testo diventano veramente elementari:

<o:p> </o:p>

// C#<o:p></o:p>

StreamWriter sw = new StreamWriter("text.txt");<o:p></o:p>

sw.WriteLine("DotNetCampania");<o:p></o:p>

sw.Close();<o:p></o:p>

<o:p> </o:p>

StreamReader sr = new StreamReader("text.txt");<o:p></o:p>

Console.WriteLine(sr.ReadToEnd());<o:p></o:p>

sr.Close();<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sw As New StreamWriter("text.txt")<o:p></o:p>

sw.WriteLine("DotNetCampania")<o:p></o:p>

sw.Close()<o:p></o:p>

<o:p> </o:p>

Dim sr As New StreamReader("text.txt")<o:p></o:p>

Console.WriteLine(sr.ReadToEnd)<o:p></o:p>

sr.Close()<o:p></o:p>

<o:p> </o:p>

Il risultato è abbastanza intuitivo:<o:p></o:p>

<o:p></o:p>

<o:p>

</o:p>

Data la loro importanza approfondiremo gli stream nei prossimi articoli.

Gestione delle eccezioni

Che succede se il nostro programma sta leggendo un file da una penna usb e la nostra sorellina, con quell’aria furtiva ma con quello sguardo angelico che ci impedisce di terminarla, ci tira fuori la penna dalla porta USB? Nella speranza che la penna non si sia rotta l’unico problema e che il programma verrebbe interrotto da un’eccezione, cioè un evento inaspettato che interrompe la normale esecuzione dell’algoritmo.

Se una tale eventualità non è stata gestita molto probabilmente il programma termina miseramente con un messaggio di errore generato dal framework, ci va bene? Direi di no! Ecco che quindi ci vengono messi a disposizione i costrutti necessari a gestire una tale eventualità: il blocco Try…Catch…Finally in Visual Basic, try…catch…finally in C#.

<o:p> </o:p>

Niente è più illuminante di un esempio:

<o:p> </o:p>

// C#<o:p></o:p>

StreamReader sr = null;<o:p></o:p>

try<o:p></o:p>

{<o:p></o:p>

    sr = new StreamReader("text.txt");<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd());<o:p></o:p>

}<o:p></o:p>

catch (Exception ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message);<o:p></o:p>

}<o:p></o:p>

finally<o:p></o:p>

{<o:p></o:p>

    sr.Close();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sr As StreamReader = Nothing<o:p></o:p>

Try<o:p></o:p>

    sr = New StreamReader("text.txt")<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd())<o:p></o:p>

Catch ex As Exception<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message)<o:p></o:p>

Finally<o:p></o:p>

    sr.Close()<o:p></o:p>

End Try<o:p></o:p>

<o:p> </o:p>

In pratica si divide il codice in due o tre blocchi (il finally è facoltativo): nel primo, il try, si inserisce il codice da sottoporre a gestione delle eccezioni; nel secondo, il catch, si gestisce l’eccezione, nel nostro esempio abbiamo stampato un messaggio di errore; nell’eventuale terzo, il finally, si inseriscono le operazioni da eseguire in qualsiasi caso, sia di normale flusso dell’applicazione che di eccezione. Notate la dichiarazione dello StreamReader fuori dal try: è l’unico modo di renderlo visibile anche al blocco finally.<o:p></o:p>

L’esempio ci da inoltre modo di notare un oggetto molto interessante, Exception, che contiene tutte le informazioni che ci posso essere utili sull’eccezione che è stata generata. La sua struttura è molto generica e viene usata come classe base per creare eccezioni più specifiche, quali ad esempio FileNotFoundException.<o:p></o:p>

La cosa interessante è che mentre il blocco try e il blocco finally sono unici, possiamo creare tutti i blocchi catch che vogliamo a patto di gestire tipi di eccezioni diverse e ricordando che solamente uno sarà utilizzato in caso di eccezione. Facciamo un esempio:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

StreamReader sr = null;<o:p></o:p>

try<o:p></o:p>

{<o:p></o:p>

    sr = new StreamReader("text.txt");<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd());<o:p></o:p>

}<o:p></o:p>

catch (System.IO.FileNotFoundException ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("File non trovato!");<o:p></o:p>

}<o:p></o:p>

catch (System.UnauthorizedAccessException ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("Non di dispone dei permessi necessari!");<o:p></o:p>

}<o:p></o:p>

catch (Exception ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message);<o:p></o:p>

}<o:p></o:p>

finally<o:p></o:p>

{<o:p></o:p>

    sr.Close();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sr As StreamReader = Nothing<o:p></o:p>

Try<o:p></o:p>

    sr = New StreamReader("text.txt")<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd())<o:p></o:p>

Catch ex As System.IO.FileNotFoundException<o:p></o:p>

    Console.WriteLine("File non trovato!")<o:p></o:p>

Catch ex As System.UnauthorizedAccessException<o:p></o:p>

    Console.WriteLine("Non di dispone dei permessi necessari!")<o:p></o:p>

Catch ex As Exception<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message)<o:p></o:p>

Finally<o:p></o:p>

    sr.Close()<o:p></o:p>

End Try<o:p></o:p>

<o:p> </o:p>

Il bello di questo meccanismo è che possiamo decidere cosa fare in base alla tipologia di eccezione che è stata generata. Tieniamo presente che l’ordine in cui sono messi i catch non è assolutamente casuale, anzi, essendo Exception più generica sia di FileNotFoundException che di UnauthorizedAccessException, metterla in cima ai blocchi catch avrebbe provocato la completa inutilità dei blocchi sottostanti: qualsiasi eccezione sarebbe stata sempre gestita dal blocco catch Exception. Fortuna che il nostro ambiente di sviluppo sa essere molto esplicativo:<o:p></o:p>

<o:p>

</o:p>

<o:p></o:p>

Conclusioni<o:p></o:p>

Se non lo avete già fatto penso sia arrivato il momento di aprire visual studio e cominciare a smanettare un po’ altrimenti farete fatica a continuare a seguire questa serie di articoli. Vi do appuntamento al prossimo articolo in cui parleremo di OOP e del contributo di Microsoft a questo paradigma di programmazione che ha rivoluzionato il modo di programmare.

<o:p> </o:p>

Happy Coding.

<o:p> </o:p>

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

Michele Aponte — Tue, 23 Jun 2009 13:55:54 GMT
Revision 1 posted to Articoli by Michele Aponte on 23/06/2009 15:55:54

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 02

I Reference Type

Come già detto nella precedente lezione un tipo reference memorizza il valore della sua variabile nell’area di memoria chiamata heap, mentre mantiene il rifermento a tale area di memoria nell’area di memoria chiamata stack.

Mentre lo stack viene pulito man mano che le variabili in esso memorizzate perdono visibilità (out-of-scope), l’heap viene gestito da un sistema chiamato garbage collector, attraverso un procedimento chiamato garbage collection che consiste nel verificare periodicamente i riferimenti esistenti ad una certa area di memoria heap e pulirla quando non esistono più riferimenti di questo tipo.

Il modo più semplice di capire il funzionamento pratico di un tipo reference è quello di confrontarlo con un value type. Consideriamo ad esempio il value type personalizzato creato l’ultima volta con un esempio di utilizzo:

<o:p> </o:p>

// C#<o:p></o:p>

struct MioTipo<o:p></o:p>

{<o:p></o:p>

    public int i;<o:p></o:p>

    public bool b;<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

class Program<o:p></o:p>

{<o:p></o:p>

    static void <st1:place w:st="on">Main</st1:place>(string[] args)<o:p></o:p>

    {<o:p></o:p>

        MioTipo primo;<o:p></o:p>

        primo.i = 1;<o:p></o:p>

        primo.b = true;<o:p></o:p>

<o:p> </o:p>

        MioTipo secondo = primo;<o:p></o:p>

        secondo.i = 2;<o:p></o:p>

        secondo.b = false;<o:p></o:p>

<o:p> </o:p>

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);<o:p></o:p>

    }<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Structure MioTipo<o:p></o:p>

    Dim i As Integer<o:p></o:p>

    Dim b As Boolean<o:p></o:p>

End Structure<o:p></o:p>

<o:p> </o:p>

Sub <st1:place w:st="on">Main</st1:place>()<o:p></o:p>

    Dim primo As MioTipo<o:p></o:p>

    primo.i = 1<o:p></o:p>

    primo.b = True<o:p></o:p>

<o:p> </o:p>

    Dim secondo As MioTipo = primo<o:p></o:p>

    secondo.i = 2<o:p></o:p>

    secondo.b = False<o:p></o:p>

<o:p> </o:p>

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)<o:p></o:p>

End Sub<o:p></o:p>

<o:p> </o:p>

Il risultato in output è il seguente:<o:p></o:p>

<o:p></o:p>

<v:shapetype coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f" id="_x0000_t75"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><o:p></o:p>

<o:p></o:p>

<o:p></o:p>

<o:p> </o:p>

Per costrruire un reference type basta sotituire il costrutto struct (Structure in Visual Basic) con il costrutto Class:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

public class MioTipo<o:p></o:p>

{<o:p></o:p>

    public int i;<o:p></o:p>

    public bool b;<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

class Program<o:p></o:p>

{<o:p></o:p>

    static void <st1:place w:st="on">Main</st1:place>(string[] args)<o:p></o:p>

    {<o:p></o:p>

        MioTipo primo = new MioTipo();<o:p></o:p>

        primo.i = 1;<o:p></o:p>

        primo.b = true;<o:p></o:p>

<o:p> </o:p>

        MioTipo secondo = primo;<o:p></o:p>

        secondo.i = 2;<o:p></o:p>

        secondo.b = false;<o:p></o:p>

<o:p> </o:p>

        Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b);<o:p></o:p>

    }<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Public Class MioTipo<o:p></o:p>

    Public i As Integer<o:p></o:p>

    Public b As Boolean<o:p></o:p>

End Class<o:p></o:p>

<o:p> </o:p>

Sub <st1:place w:st="on">Main</st1:place>()<o:p></o:p>

    Dim primo As New MioTipo<o:p></o:p>

    primo.i = 1<o:p></o:p>

    primo.b = True<o:p></o:p>

<o:p> </o:p>

    Dim secondo As MioTipo = primo<o:p></o:p>

    secondo.i = 2<o:p></o:p>

    secondo.b = False<o:p></o:p>

<o:p> </o:p>

    Console.WriteLine("a: {0}, {1}; b: {2}, {3}", primo.i, primo.b, secondo.i, secondo.b)<o:p></o:p>

End Sub<o:p></o:p>

<o:p> </o:p>

Il risultato in questo caso invece è il seguente:

Come mai questa differenza? Molto semplicemente perché in entrambi i casi l’assegnazione alla variabile secondo del valore di primo consiste in una copia del valore delle variabili, che nel primo caso (value type) è proprio il valore della variabile, mentre nel secondo caso (reference type) si tratta del riferimento al valore della variabile, di conseguenza dopo l’assegnazione nel secondo caso secondo punta alla stessa locazione di memoria heap di primo.

Un’altra grande differenza è sicuramente l’utilizzo dell’operatore new (New in Visual Basic) che permette di istanziare la classe MioTipo, creando così lo spazio nello heap destinato alla variabile, cosa non necessaria per i value type dato che l’allocazione avviene sullo stack.

I più comuni reference type sono i seguenti:

-          System.Object, la classe base di tutti i tipi del .net framework<o:p></o:p>

-          System.String, la classe per il contenimento delle stringhe di testo<o:p></o:p>

-          System.Text.StringBuilder, la classe per il contenimento di stringhe di testo dinamiche<o:p></o:p>

-          System.Array, la classe base di tutti gli array del framework,<o:p></o:p>

-          System.IO.Stream, la classe base per la gestione degli stream di dati<o:p></o:p>

-          System.Exception, la classe base di tutte le eccezioni del farmework<o:p></o:p>

Del significato della parola classe base parleremo nei prossimi articoli, adesso focalizziamo la nostra attenzione sulla differenza non necessariamente ovvia tra String e StringBuilder.

String vs StringBuilder

Come potrete immaginare sul tipo String sono definite le più comuni operazioni tra stringhe quale ad esempio la somma, perché dunque avere una classe che permetta la gestione di stringhe dinamiche?

Il tipo System.String è un tipo cosiddetto immutabile, il che significa molto semplicemente che ogni volta che la stringa viene modificata, il runtime di .NET crea una nuova stringa, abbandonando la vecchia. Molti programmatori non ci fanno caso perché la cosa avviene in maniera trasparente ma sapendolo vi renderete sicuramente conto di quanto possa essere uno spreco un simile comportamento. Al fine di evitare questo spiacevole inconveniente è stata creata la classe StringBuilder:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

StringBuilder sb = new StringBuilder();<o:p></o:p>

sb.Append("DotNetCampania - ");<o:p></o:p>

sb.Append("Il primo User Group su .NET ");<o:p></o:p>

sb.Append("tutto campano!");<o:p></o:p>

Console.WriteLine(sb);<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sb As New System.Text.StringBuilder<o:p></o:p>

sb.Append("DotNetCampania - ")<o:p></o:p>

sb.Append("Il primo User Group su .NET ")<o:p></o:p>

sb.Append("tutto campano!")<o:p></o:p>

Console.WriteLine(sb)<o:p></o:p>

<o:p> </o:p>

Il risultato è del tutto immaginabile:<o:p></o:p>

<o:p></o:p>

<o:p> </o:p>

Di default il costruttore (il metodo della classe che inizializza lo stato di un oggetto, ne parleremo nei prossimi articoli) di StringBuilder crea un buffer di 16 byte che ingrandisce in base alle necessità, ma è possibile specificare la dimensione iniziale e anche la dimensione massima.

Creare e ordinare Arrays

Uno dei contenitori più importanti di dati, dopo la variabile, è l’array, per capirci lo possiamo vedere come un insieme contiguo di variabili dello stesso tipo indicizzate in base alla posizione nell’insieme. La creazione in .NET è molto semplice: le parentesi tonde in Visual Basic e le parentesi quadre in C#.

<o:p> </o:p>

// C#<o:p></o:p>

int[] ar = {20, 30, 10};<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim ar() As Integer = {20, 30, 10}<o:p></o:p>

<o:p> </o:p>

Grazie alla classe stratta Array e al suo metodo statico Sort, l’ordinamento di un array è veramente un’operazione banale:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

Array.Sort(ar);<o:p></o:p>

Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Array.Sort(ar)<o:p></o:p>

Console.WriteLine("{0}, {1}, {2}", ar(0), ar(1), ar(2))<o:p></o:p>

<o:p> </o:p>

L’ovvio risultato:<o:p></o:p>

<o:p></o:p>

Gli stream di dati

Nel framework .NET l’accesso al disco o la scambio dati nelle comunicazioni di rete sono uniformati dal concetto di Stream, un tipo base grazie al quale è possibile unificare l’accesso ai dati tra varie fonti. Tecnicamente stiamo parlando di una classe stratta da cui vengono create delle classi specifiche della fonte dei dati:

<o:p> </o:p>

System.IO Type <o:p></o:p>

Usato per<o:p></o:p>

FileStream <o:p></o:p>

Scrivere e leggere da un file<o:p></o:p>

MemoryStream <o:p></o:p>

Scrivere e leggere dalla memoria<o:p></o:p>

StreamReader <o:p></o:p>

Leggere dati da un file di testo<o:p></o:p>

StreamWriter <o:p></o:p>

Scrivere dati in un file di testo<o:p></o:p>

<o:p> </o:p>

Grazie a queste classi operazioni come la scrittura in un file di testo diventano veramente elementari:

<o:p> </o:p>

// C#<o:p></o:p>

StreamWriter sw = new StreamWriter("text.txt");<o:p></o:p>

sw.WriteLine("DotNetCampania");<o:p></o:p>

sw.Close();<o:p></o:p>

<o:p> </o:p>

StreamReader sr = new StreamReader("text.txt");<o:p></o:p>

Console.WriteLine(sr.ReadToEnd());<o:p></o:p>

sr.Close();<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sw As New StreamWriter("text.txt")<o:p></o:p>

sw.WriteLine("DotNetCampania")<o:p></o:p>

sw.Close()<o:p></o:p>

<o:p> </o:p>

Dim sr As New StreamReader("text.txt")<o:p></o:p>

Console.WriteLine(sr.ReadToEnd)<o:p></o:p>

sr.Close()<o:p></o:p>

<o:p> </o:p>

Il risultato è abbastanza intuitivo:<o:p></o:p>

<o:p></o:p>

<o:p> </o:p>

Data la loro importanza approfondiremo gli stream nei prossimi articoli.

Gestione delle eccezioni

Che succede se il nostro programma sta leggendo un file da una penna usb e la nostra sorellina, con quell’aria furtiva ma con quello sguardo angelico che ci impedisce di terminarla, ci tira fuori la penna dalla porta USB? Nella speranza che la penna non si sia rotta l’unico problema e che il programma verrebbe interrotto da un’eccezione, cioè un evento inaspettato che interrompe la normale esecuzione dell’algoritmo.

Se una tale eventualità non è stata gestita molto probabilmente il programma termina miseramente con un messaggio di errore generato dal framework, ci va bene? Direi di no! Ecco che quindi ci vengono messi a disposizione i costrutti necessari a gestire una tale eventualità: il blocco Try…Catch…Finally in Visual Basic, try…catch…finally in C#.

<o:p> </o:p>

Niente è più illuminante di un esempio:

<o:p> </o:p>

// C#<o:p></o:p>

StreamReader sr = null;<o:p></o:p>

try<o:p></o:p>

{<o:p></o:p>

    sr = new StreamReader("text.txt");<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd());<o:p></o:p>

}<o:p></o:p>

catch (Exception ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message);<o:p></o:p>

}<o:p></o:p>

finally<o:p></o:p>

{<o:p></o:p>

    sr.Close();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sr As StreamReader = Nothing<o:p></o:p>

Try<o:p></o:p>

    sr = New StreamReader("text.txt")<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd())<o:p></o:p>

Catch ex As Exception<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message)<o:p></o:p>

Finally<o:p></o:p>

    sr.Close()<o:p></o:p>

End Try<o:p></o:p>

<o:p> </o:p>

In pratica si divide il codice in due o tre blocchi (il finally è facoltativo): nel primo, il try, si inserisce il codice da sottoporre a gestione delle eccezioni; nel secondo, il catch, si gestisce l’eccezione, nel nostro esempio abbiamo stampato un messaggio di errore; nell’eventuale terzo, il finally, si inseriscono le operazioni da eseguire in qualsiasi caso, sia di normale flusso dell’applicazione che di eccezione. Notate la dichiarazione dello StreamReader fuori dal try: è l’unico modo di renderlo visibile anche al blocco finally.<o:p></o:p>

L’esempio ci da inoltre modo di notare un oggetto molto interessante, Exception, che contiene tutte le informazioni che ci posso essere utili sull’eccezione che è stata generata. La sua struttura è molto generica e viene usata come classe base per creare eccezioni più specifiche, quali ad esempio FileNotFoundException.<o:p></o:p>

La cosa interessante è che mentre il blocco try e il blocco finally sono unici, possiamo creare tutti i blocchi catch che vogliamo a patto di gestire tipi di eccezioni diverse e ricordando che solamente uno sarà utilizzato in caso di eccezione. Facciamo un esempio:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

StreamReader sr = null;<o:p></o:p>

try<o:p></o:p>

{<o:p></o:p>

    sr = new StreamReader("text.txt");<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd());<o:p></o:p>

}<o:p></o:p>

catch (System.IO.FileNotFoundException ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("File non trovato!");<o:p></o:p>

}<o:p></o:p>

catch (System.UnauthorizedAccessException ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("Non di dispone dei permessi necessari!");<o:p></o:p>

}<o:p></o:p>

catch (Exception ex)<o:p></o:p>

{<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message);<o:p></o:p>

}<o:p></o:p>

finally<o:p></o:p>

{<o:p></o:p>

    sr.Close();<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim sr As StreamReader = Nothing<o:p></o:p>

Try<o:p></o:p>

    sr = New StreamReader("text.txt")<o:p></o:p>

    Console.WriteLine(sr.ReadToEnd())<o:p></o:p>

Catch ex As System.IO.FileNotFoundException<o:p></o:p>

    Console.WriteLine("File non trovato!")<o:p></o:p>

Catch ex As System.UnauthorizedAccessException<o:p></o:p>

    Console.WriteLine("Non di dispone dei permessi necessari!")<o:p></o:p>

Catch ex As Exception<o:p></o:p>

    Console.WriteLine("Errore: " + ex.Message)<o:p></o:p>

Finally<o:p></o:p>

    sr.Close()<o:p></o:p>

End Try<o:p></o:p>

<o:p> </o:p>

Il bello di questo meccanismo è che possiamo decidere cosa fare in base alla tipologia di eccezione che è stata generata. Tieniamo presente che l’ordine in cui sono messi i catch non è assolutamente casuale, anzi, essendo Exception più generica sia di FileNotFoundException che di UnauthorizedAccessException, metterla in cima ai blocchi catch avrebbe provocato la completa inutilità dei blocchi sottostanti: qualsiasi eccezione sarebbe stata sempre gestita dal blocco catch Exception. Fortuna che il nostro ambiente di sviluppo sa essere molto esplicativo:<o:p></o:p>

<o:p> </o:p>

<o:p></o:p>

Conclusioni<o:p></o:p>

Se non lo avete già fatto penso sia arrivato il momento di aprire visual studio e cominciare a smanettare un po’ altrimenti farete fatica a continuare a seguire questa serie di articoli. Vi do appuntamento al prossimo articolo in cui parleremo di OOP e del contributo di Microsoft a questo paradigma di programmazione che ha rivoluzionato il modo di programmare.

<o:p> </o:p>

Happy Coding.

<o:p> </o:p>

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 01

Michele Aponte — Sat, 20 Jun 2009 22:55:57 GMT
Current revision posted to Articoli by Michele Aponte on 21/06/2009 00:55:57

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 01

Inserito sotto: Certificazioni Esame 70-536

Introduzione

Diciamoci la verità: possiamo anche essere i migliori programmatori .NET in circolazione, ma se non c’è qualcuno che certifichi la nostra competenza la lettura del nostro curriculum potrebbe anche sembrare un insieme di fandonie. Ma non è solo questo. Sorte vuole che il modo migliore di approfondire le tecnologie .NET, dando uno sguardo attento alle parti del framework che probabilmente non ci capiterà mai di usare (perché non le conosciamo) è proprio studiare per prepararsi agli esami delle certificazioni Microsoft.

Dopo tanti anni passati a programmare con queste tecnologie mi sono reso conto, studiando per il mio primo esame, che tante cose si potevano fare più velocemente di come le ho fatte: semplicemente erano già pronte nel framework (e i tanti insegnanti che mi dicevano di non reinventare la ruota hanno immediatamente acquisito un certa credibilità…).

Da qui scaturisce l’idea di incamminarsi insieme nel percorso delle certificazioni: in questo modo possiamo partire dalle basi del framework e raggiungere insieme una certa maturità professionale rendendo DotNetCampania uno strumento utile per il proprio lavoro, uno degli obiettivi per la quale questa community è nata.

Da dove si comincia?

Il primo livello di certificazione Microsoft va sotto il nome di Microsoft Certified Technical Specialist (MCTS) che si compone di 9 certificazioni:

<o:p> </o:p>

.NET Framework 2.0 Web Applications<o:p></o:p>

.NET Framework 2.0 Windows Applications<o:p></o:p>

.NET Framework 2.0 Distributed Applications <o:p></o:p>

.NET Framework 3.5, Windows Presentation Foundation Applications<o:p></o:p>

.NET Framework 3.5, Windows Communication Foundation Applications<o:p></o:p>

.NET Framework 3.5, Windows Workflow Foundation Applications<o:p></o:p>

.NET Framework 3.5, Windows Forms Applications <o:p></o:p>

.NET Framework 3.5, ADO.NET Applications <o:p></o:p>

.NET Framework 3.5, ASP.NET Applications <o:p></o:p>

<o:p> </o:p>

Per ottenere una di queste certificazioni è necessario sostenere un singolo esame, ma per sostenere uno qualsiasi di questi esami è necessario avere superato un esame comune propedeutico: Microsoft .NET Framework - Application Development Foundation, ovvero l’esame 70-536. Quindi la prima cosa da fare è sostenere questo esame, che da solo non costituisce una certificazione, ma permette di sostenere ognuno degli esami della lista precedente per ottenere invece una singola certificazione.<o:p></o:p>

Il modo migliore per prepararsi a questo esame è l’utilizzo Training-Kit appositamente scritto per questo scopo, lo potete acquistare sia in italiano che in inglese a prezzi molto differenti (quello in italiano circa 100€, quello in inglese circa 40€) ma in qualsiasi caso l’esame che sosterrete è in lingua inglese quindi consiglio vivamente di studiare dal testo in inglese ed esercitarsi con test in inglese.<o:p></o:p>

A proposito di esercitazioni diciamo subito che la prova consiste in un test a risposta singola e multipla (in qualche caso c’è anche da fare drag & drop) da sostenere al PC, in cui vi verrà chiesto quale linguaggio di programmazione (VB.NET o C#) utilizzare: dovrete rispondere a 40 domande in 2 ore e 15 minuti, per un totale di 1000 punti, dovrete fare almeno 700 punti per superare la prova e tenete conto che ogni domanda ha un peso diverso. Spaventati? No, dai… cominciamo subito a studiare!<o:p></o:p>

Prerequisiti

Per affrontare il corso studiando dal training kit dell’esame (e aiutandosi con questo corso) e necessario conoscere la sintassi almeno a livello basilare di visual basic .net o c#. Cercherò di non darlo per scontato ma dovrò almeno assumere che conosciate i fondamenti della programmazione: che cos’è un algoritmo, che cos’è una variabile, che cosa si intende con il termine tipo, cose del genere insomma. Si parte!

Prima lezione: I Value Type

Come potremmo cominciare il nostro studio senza parlare dei tipi che ci vengono messi a disposizione dal framework, facciamo quindi subito una netta distinzione tra value type e reference type: i primi contengono i valore della variabile direttamente al loro interno, i secondi invece contengono un riferimento al vero punto della memoria in cui è memorizzato il valore della variabile. Le istanze di un value type vengono memorizzate nell’area di memoria chiamato stack, mentre i reference type puntano a dati memorizzati nell’area di memoria chiamata heap. Per chi avesse qualche dubbio sulla differenza tra i due ricadiamo purtroppo nei prerequisiti, ma potete comunque dare uno sguardo qui.

I più semplici value type del framework sono i tipi primitivi, usati così spesso dai programmatori da aver indotto i progettisti del vari linguaggi .net a definire degli alias:

<o:p> </o:p>

Tipo<o:p></o:p>

(Visual Basic/ C# alias)<o:p></o:p>

Dimensione<o:p></o:p>

(Bytes)<o:p></o:p>

Range dei valori<o:p></o:p>

System.Char (Char/char)<o:p></o:p>

2<o:p></o:p>

-<o:p></o:p>

System.Boolean (Boolean/bool)<o:p></o:p>

1<o:p></o:p>

-<o:p></o:p>

System.SByte (SByte/sbyte) <o:p></o:p>

1<o:p></o:p>

da <st1:metricconverter productid="-128 a" w:st="on">-<st1:metricconverter productid="128 a" w:st="on">128 a</st1:metricconverter></st1:metricconverter> 127<o:p></o:p>

System.Byte (Byte/byte) <o:p></o:p>

1<o:p></o:p>

Da <st1:metricconverter productid="0 a" w:st="on">0 a</st1:metricconverter> 255<o:p></o:p>

System.Int16 (Short/short) <o:p></o:p>

2<o:p></o:p>

da <st1:metricconverter productid="-32768 a" w:st="on">-32768 a</st1:metricconverter> 32767<o:p></o:p>

System.Int32 (Integer/int) <o:p></o:p>

4<o:p></o:p>

da <st1:metricconverter productid="-2147483648 a" w:st="on">-2147483648 a</st1:metricconverter> 2147483647<o:p></o:p>

System.UInt32 (UInteger/uint) <o:p></o:p>

4<o:p></o:p>

Da <st1:metricconverter productid="0 a" w:st="on">0 a</st1:metricconverter> 4294967295<o:p></o:p>

System.Int64 (Long/long) <o:p></o:p>

8<o:p></o:p>

da -9223372036854775808 a 9223372036854775807<o:p></o:p>

System.Single (Single/float) <o:p></o:p>

4<o:p></o:p>

da -3.402823E+<st1:metricconverter productid="38 a" w:st="on">38 a</st1:metricconverter> 3.402823E+38<o:p></o:p>

System.Double (Double/double) <o:p></o:p>

8<o:p></o:p>

da -1.79769313486232E+<st1:metricconverter productid="308 a" w:st="on">308 a</st1:metricconverter> 1.79769313486232E+308<o:p></o:p>

System.Decimal (Decimal/decimal) <o:p></o:p>

16<o:p></o:p>

Da -79228162514264337593543950335 a 79228162514264337593543950335<o:p></o:p>

System.DateTime (Date/date)<o:p></o:p>

8<o:p></o:p>

Dal 1/1/0001 12:00:00 AM al 12/31/9999 11:59:59 PM<o:p></o:p>

<o:p> </o:p>

La dichiarazione di una variabile è molto semplice:

<o:p> </o:p>

// C#<o:p></o:p>

int i = 0;<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim i As Integer = 0<o:p></o:p>

<o:p> </o:p>

Con questo piccolo esempio abbiamo anche visto il modo di commentare nei due linguaggi di programmazione. Se vogliamo definire noi stessi un value type basta creare una Structure in Visual Basic o una struct in C#:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

struct MioTipo<o:p></o:p>

{<o:p></o:p>

    int i;<o:p></o:p>

    bool b;<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Structure MioTipo<o:p></o:p>

    Dim i As Integer<o:p></o:p>

    Dim b As Boolean<o:p></o:p>

End Structure<o:p></o:p>

<o:p> </o:p>

Un’altra tipologia di value type molto utile è l’enumerazione: un insieme di simboli con un valore fisso che è possibile utilizzare per fornire una lista di scelte obbligate a chi debba utilizzare il nostro tipo:

<o:p> </o:p>

// C#<o:p></o:p>

enum Colori<o:p></o:p>

{<o:p></o:p>

    Rosso,<o:p></o:p>

    Verde,<o:p></o:p>

    Azzurro<o:p></o:p>

}

<o:p> </o:p>

' VB<o:p></o:p>

Enum Colori<o:p></o:p>

    Rosso<o:p></o:p>

    Verde<o:p></o:p>

    Azzurro<o:p></o:p>

End Enum<o:p></o:p>

<o:p> </o:p>

Un limite dei tipi primitivi molto sentito è quello di non poter dare un valore indefinito ad una variabile (Nothing in Visual Basic, null in C#), limite superabile con l’uso dei Generics (che vedremo tra qualche articolo), in particolare il tipo generico Nullable:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

Nullable<int> a = null;<o:p></o:p>

int? a = null;<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim a As Nullable(Of Integer) = Nothing<o:p></o:p>

<o:p> </o:p>

Per C# è possibile usare il punto interrogativo come contrazione del tipo Nullable (una vera comodità!)<o:p></o:p>

<o:p> </o:p>à!)

Fermiamoci qui per questo primo articolo, esercitatevi un po’ perché il modo migliore di memorizzare queste cose è usarle!<o:p></o:p>

<o:p> </o:p>

Appuntamento alla prossima lezione, restati sintonizzati.<o:p></o:p>

Insieme verso il primo esame per la certificazione Microsoft: Esame 70-536 – Lezione 01

Michele Aponte — Sat, 20 Jun 2009 22:54:02 GMT
Revision 1 posted to Articoli by Michele Aponte on 21/06/2009 00:54:02

Introduzione

Diciamoci la verità: possiamo anche essere i migliori programmatori .NET in circolazione, ma se non c’è qualcuno che certifichi la nostra competenza la lettura del nostro curriculum potrebbe anche sembrare un insieme di fandonie. Ma non è solo questo. Sorte vuole che il modo migliore di approfondire le tecnologie .NET, dando uno sguardo attento alle parti del framework che probabilmente non ci capiterà mai di usare (perché non le conosciamo) è proprio studiare per prepararsi agli esami delle certificazioni Microsoft.

Dopo tanti anni passati a programmare con queste tecnologie mi sono reso conto, studiando per il mio primo esame, che tante cose si potevano fare più velocemente di come le ho fatte: semplicemente erano già pronte nel framework (e i tanti insegnanti che mi dicevano di non reinventare la ruota hanno immediatamente acquisito un certa credibilità…).

Da qui scaturisce l’idea di incamminarsi insieme nel percorso delle certificazioni: in questo modo possiamo partire dalle basi del framework e raggiungere insieme una certa maturità professionale rendendo DotNetCampania uno strumento utile per il proprio lavoro, uno degli obiettivi per la quale questa community è nata.

Da dove si comincia?

Il primo livello di certificazione Microsoft va sotto il nome di Microsoft Certified Technical Specialist (MCTS) che si compone di 9 certificazioni:

<o:p> </o:p>

.NET Framework 2.0 Web Applications<o:p></o:p>

.NET Framework 2.0 Windows Applications<o:p></o:p>

.NET Framework 2.0 Distributed Applications <o:p></o:p>

.NET Framework 3.5, Windows Presentation Foundation Applications<o:p></o:p>

.NET Framework 3.5, Windows Communication Foundation Applications<o:p></o:p>

.NET Framework 3.5, Windows Workflow Foundation Applications<o:p></o:p>

.NET Framework 3.5, Windows Forms Applications <o:p></o:p>

.NET Framework 3.5, ADO.NET Applications <o:p></o:p>

.NET Framework 3.5, ASP.NET Applications <o:p></o:p>

<o:p> </o:p>

Per ottenere una di queste certificazioni è necessario sostenere un singolo esame, ma per sostenere uno qualsiasi di questi esami è necessario avere superato un esame comune propedeutico: Microsoft .NET Framework - Application Development Foundation, ovvero l’esame 70-536. Quindi la prima cosa da fare è sostenere questo esame, che da solo non costituisce una certificazione, ma permette di sostenere ognuno degli esami della lista precedente per ottenere invece una singola certificazione.<o:p></o:p>

Il modo migliore per prepararsi a questo esame è l’utilizzo Training-Kit appositamente scritto per questo scopo, lo potete acquistare sia in italiano che in inglese a prezzi molto differenti (quello in italiano circa 100€, quello in inglese circa 40€) ma in qualsiasi caso l’esame che sosterrete è in lingua inglese quindi consiglio vivamente di studiare dal testo in inglese ed esercitarsi con test in inglese.<o:p></o:p>

A proposito di esercitazioni diciamo subito che la prova consiste in un test a risposta singola e multipla (in qualche caso c’è anche da fare drag & drop) da sostenere al PC, in cui vi verrà chiesto quale linguaggio di programmazione (VB.NET o C#) utilizzare: dovrete rispondere a 40 domande in 2 ore e 15 minuti, per un totale di 1000 punti, dovrete fare almeno 700 punti per superare la prova e tenete conto che ogni domanda ha un peso diverso. Spaventati? No, dai… cominciamo subito a studiare!<o:p></o:p>

Prerequisiti

Per affrontare il corso studiando dal training kit dell’esame (e aiutandosi con questo corso) e necessario conoscere la sintassi almeno a livello basilare di visual basic .net o c#. Cercherò di non darlo per scontato ma dovrò almeno assumere che conosciate i fondamenti della programmazione: che cos’è un algoritmo, che cos’è una variabile, che cosa si intende con il termine tipo, cose del genere insomma. Si parte!

Prima lezione: I Value Type

Come potremmo cominciare il nostro studio senza parlare dei tipi che ci vengono messi a disposizione dal framework, facciamo quindi subito una netta distinzione tra value type e reference type: i primi contengono i valore della variabile direttamente al loro interno, i secondi invece contengono un riferimento al vero punto della memoria in cui è memorizzato il valore della variabile. Le istanze di un value type vengono memorizzate nell’area di memoria chiamato stack, mentre i reference type puntano a dati memorizzati nell’area di memoria chiamata heap. Per chi avesse qualche dubbio sulla differenza tra i due ricadiamo purtroppo nei prerequisiti, ma potete comunque dare uno sguardo qui.

I più semplici value type del framework sono i tipi primitivi, usati così spesso dai programmatori da aver indotto i progettisti del vari linguaggi .net a definire degli alias:

<o:p> </o:p>

Tipo<o:p></o:p>

(Visual Basic/ C# alias)<o:p></o:p>

Dimensione<o:p></o:p>

(Bytes)<o:p></o:p>

Range dei valori<o:p></o:p>

System.Char (Char/char)<o:p></o:p>

2<o:p></o:p>

-<o:p></o:p>

System.Boolean (Boolean/bool)<o:p></o:p>

1<o:p></o:p>

-<o:p></o:p>

System.SByte (SByte/sbyte) <o:p></o:p>

1<o:p></o:p>

da <st1:metricconverter productid="-128 a" w:st="on">-<st1:metricconverter productid="128 a" w:st="on">128 a</st1:metricconverter></st1:metricconverter> 127<o:p></o:p>

System.Byte (Byte/byte) <o:p></o:p>

1<o:p></o:p>

Da <st1:metricconverter productid="0 a" w:st="on">0 a</st1:metricconverter> 255<o:p></o:p>

System.Int16 (Short/short) <o:p></o:p>

2<o:p></o:p>

da <st1:metricconverter productid="-32768 a" w:st="on">-32768 a</st1:metricconverter> 32767<o:p></o:p>

System.Int32 (Integer/int) <o:p></o:p>

4<o:p></o:p>

da <st1:metricconverter productid="-2147483648 a" w:st="on">-2147483648 a</st1:metricconverter> 2147483647<o:p></o:p>

System.UInt32 (UInteger/uint) <o:p></o:p>

4<o:p></o:p>

Da <st1:metricconverter productid="0 a" w:st="on">0 a</st1:metricconverter> 4294967295<o:p></o:p>

System.Int64 (Long/long) <o:p></o:p>

8<o:p></o:p>

da -9223372036854775808 a 9223372036854775807<o:p></o:p>

System.Single (Single/float) <o:p></o:p>

4<o:p></o:p>

da -3.402823E+<st1:metricconverter productid="38 a" w:st="on">38 a</st1:metricconverter> 3.402823E+38<o:p></o:p>

System.Double (Double/double) <o:p></o:p>

8<o:p></o:p>

da -1.79769313486232E+<st1:metricconverter productid="308 a" w:st="on">308 a</st1:metricconverter> 1.79769313486232E+308<o:p></o:p>

System.Decimal (Decimal/decimal) <o:p></o:p>

16<o:p></o:p>

Da -79228162514264337593543950335 a 79228162514264337593543950335<o:p></o:p>

System.DateTime (Date/date)<o:p></o:p>

8<o:p></o:p>

Dal 1/1/0001 12:00:00 AM al 12/31/9999 11:59:59 PM<o:p></o:p>

<o:p> </o:p>

La dichiarazione di una variabile è molto semplice:

<o:p> </o:p>

// C#<o:p></o:p>

int i = 0;<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim i As Integer = 0<o:p></o:p>

<o:p> </o:p>

Con questo piccolo esempio abbiamo anche visto il modo di commentare nei due linguaggi di programmazione. Se vogliamo definire noi stessi un value type basta creare una Structure in Visual Basic o una struct in C#:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

struct MioTipo<o:p></o:p>

{<o:p></o:p>

    int i;<o:p></o:p>

    bool b;<o:p></o:p>

}<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Structure MioTipo<o:p></o:p>

    Dim i As Integer<o:p></o:p>

    Dim b As Boolean<o:p></o:p>

End Structure<o:p></o:p>

<o:p> </o:p>

Un’altra tipologia di value type molto utile è l’enumerazione: un insieme di simboli con un valore fisso che è possibile utilizzare per fornire una lista di scelte obbligate a chi debba utilizzare il nostro tipo:

<o:p> </o:p>

// C#<o:p></o:p>

enum Colori<o:p></o:p>

{<o:p></o:p>

    Rosso,<o:p></o:p>

    Verde,<o:p></o:p>

    Azzurro<o:p></o:p>

}

<o:p> </o:p>

' VB<o:p></o:p>

Enum Colori<o:p></o:p>

    Rosso<o:p></o:p>

    Verde<o:p></o:p>

    Azzurro<o:p></o:p>

End Enum<o:p></o:p>

<o:p> </o:p>

Un limite dei tipi primitivi molto sentito è quello di non poter dare un valore indefinito ad una variabile (Nothing in Visual Basic, null in C#), limite superabile con l’uso dei Generics (che vedremo tra qualche articolo), in particolare il tipo generico Nullable:<o:p></o:p>

<o:p> </o:p>

// C#<o:p></o:p>

Nullable<int> a = null;<o:p></o:p>

int? a = null;<o:p></o:p>

<o:p> </o:p>

' VB<o:p></o:p>

Dim a As Nullable(Of Integer) = Nothing<o:p></o:p>

<o:p> </o:p>

Per C# è possibile usare il punto interrogativo come contrazione del tipo Nullable (una vera comodità!)<o:p></o:p>

<o:p> </o:p>

Fermiamoci qui per questo primo articolo, esercitatevi un po’ perché il modo migliore di memorizzare queste cose è usarle!<o:p></o:p>

<o:p> </o:p>

Appuntamento alla prossima lezione, restati sintonizzati.<o:p></o:p>

ASP.Net ed il Viaggio verso...la Certificazione

Alessandro Forte — Tue, 16 Jun 2009 18:33:51 GMT
Current revision posted to Articoli by Alessandro Forte on 16/06/2009 20:33:51

Bene, salve a tutti gli aderenti di questa fantastica community.

Cominciamo oggi la prima di una serie di "tutorial" sulla conoscenza di ASP.Net.
In giro ci sono migliaia di post sulle basi di ASP.Net, su come funziona e su quali sono le sue caratteristiche.
Al fine quindi di rendere maggiormente attrattiva la serie di post che andrò a pubblicare ( e soprattutto per invorgliarmi a farveli leggere), ho deciso di seguire una strada "rischiosa", ma "remunerativa".

In che senso?

Ve lo spiego subito...andrò ad introdurre tutti gli argomenti step by step proprio come viene fatto nel sistema di Certificazione Microsoft.
Ovviamente ciò non significa che voi leggete i miei posts e quindi sarete in grado di affrontare "agevolmente" i quiz per i test di certificazione.
Ma questa serie di tutorial consentirà a voi (quanto a me) di imparare (ripetere) le nozioni che un "certificato" deve conoscere!

Inoltre articolerò i miei posts come una specie di "Work in progress", in cui andremo insieme ad aggiungere eventuali "manchevolezze".

Ho già parlato troppo quindi mettiamoci subito in marcia.

Lezione 1 - Introduzione ad Asp.Net (da notare il titolo davvero originale) .
Capiamo cosa c'è sotto

Microsoft Visual Studio 2005 (seppur soppiantato dall'ormai ben più solido 2008) e ASP.NET 2.0 (che sta lasciando il passo alla versione 3.5) rappresentano due delle maggiori produzioni di Mamma Microsoft.

In questa lezione andremo ad introdurre queste tecnologie per comprendere come funziona e cosa c'è alla base di ASP.NET.

Sicuramente tutti abbiamo sentito parlare di Web server, Web browser e Hypertext Transfer Protocol o in forma contratta e più nota HTTP.
Come tutti questi software, tecnologie e protocolli interagiscono tra di loro?

Individuiamo quindi gli attori e definiamo per ognuno di essi il suo ruolo :

Cominciamo con il Web Server.
Un WebServer o Servizio Web (definizione Wikipedia) è un processo, e per estensione il computer su cui è in esecuzione,  che si occupa di fornire, su richiesta del browser, una pagina web e le risorse da essa referenziate.
Possiamo quindi tranquillamente affermare che un WebServer non è altro che un controller responsabile della ricezione (e quindi della conseguente Risposta) delle Richieste derivanti da un Browser tramite un protocollo noto (come per esempio HTTP).

Il Web Browser.
Un Web Browser o Navigatore (definizione Wikipedia) è un programma che consente agli utenti di visualizzare e interagire con testi, immagini e altre informazioni, tipicamente contenute in una pagina web di un sito.
ll browser è in grado di interpretare il codice HTML (e più recentemente XHTML) e visualizzarlo in forma di ipertesto. L'HTML è il codice col quale la maggioranza delle pagine web nel mondo sono composte.
Possiamo quindi tranquillamente affermare che un Web Browser non è altro che un visualizzatore di pagine HTML (o XHTML) indipendente dalla piattaforma sulla quale viene eseguito.

Finiamo con HTTP.
L'HTTP, acronimo di Hypertext Transfer Protocol, è un protocollo di trasferimento di un ipertesto che viene utilizzato per la richiesta di Pagine Web da un Web Server e per l'invio delle risposte dietro al Web Browser.
L'HTTP difatti funziona su un meccanismo richiesta/risposta (client/server): il client esegue una richiesta ed il server restituisce la risposta. Nell'uso comune il client corrisponde al browser ed il server al sito web.

A questo punto dell'articolo risulterà quindi abbastanza chiaro come avviene lo scambio delle informazioni tra tutti gli attori descritti.
Banalmente una Pagina Web residente su WebServer viene invocata da un client, il WebBrowser per l'appunto, tramite un protocollo di comunicazione come HTTP.
Questo meccanismo viene definito come Richiesta (Request).

Il WebServer elabora la richiesta proveniente dal client, e risponde inviando al Web Browser tutte le informazioni, avvalendosi del medesimo protocollo di comunicazione utilizzato nella richiesta.
Questo meccanismo viene definito come Risposta (Response).

Concetto da approfondire per la prossima puntata

Capita "l'architettura" concentriamoci su come essa influisce su ASP.Net introducendo uno dei concetti che maggiormente utilizzeremo nella nostra vita di sviluppatori Asp.Net, ovvero il concetto di PostBack.
Il Postback è comunemente indicato come la metodologia, utilizzata da una WebForm, di inviare i dati verso un server (DifattiPostBack sta proprio ad indicare il MandaIndietro al server i dati (che esso stesso ci ha fornito in virtù della nostra richiesta)).
Per testare se i dati sono stati precedentemente spediti indietro al Web Server o per determinare se si tratta di una semplice richiesta di pagina, ASP.Net mette a disposizione dell'oggetto Page, la property IsPostBack.

Domande e Risposte

Proviamo quindi a farci delle domande e a darci delle risposte (in tipico stile Marzulloniano) :

1. Quale protocollo è utilizzato per la comunicazione tra il Web browser e il Web server?
2. In ASP.NET, cosa rappresenta l'oggetto Request?
3. In ASP.NET, cosa rappresenta l'oggetto Response?

Risposte :
1. HTTP
2. La Richiesta e/o Request rappresenta la comunicazione che si instaura dal Web Browser verso il Web server.
3. La Risposta e/o Response rappresenta la comunicazione che si instaura dal Web Server verso il Web browser.

Siamo quindi giunti alla fine del nostro primo tutorial su Asp.Net.
Capisco che per molti di voi, quanto scritto in questo post, sfonda porte già aperte...
Ma vi assicuro che argomento dopo argomento matureremo insieme quel know-how sulla materia che ci porterà, per coloro i quali vogliano realmente approfondire, a facilitare il nostro cammino (e quindi studio) verso l'acquisizione della Certificazione.

See u in the next episode

Architettura: sfatiamo i luoghi comuni…

Michele Aponte — Fri, 12 Jun 2009 17:42:12 GMT
Current revision posted to Articoli by Michele Aponte on 12/06/2009 19:42:12

Conscio della grande confusione che si fa sui termini "tecnici" utilizzati nel nostro campo, confusione che io stesso non ho timore ad ammettere, ho pensato che come primo articolo per DotNetCampania potesse essere utile fare un po' di chiarezza sul significato dei termini che utilizzeremo in questa serie di articoli sull'architettura e le applicazioni enterprise.

Cominciamo subito dalla definizione stessa di architettura, che meraviglia delle meraviglie, è standardizzata dalla norma ANSI/IEEE Std 1471-2000, la quale ci dice che l'architettura è

"The fundamental organization of a system embodied in

its components, their relationships to each other,

and to the environment, and the

principles guiding its design and evolution"[1]

Quindi possiamo dire che con il termine architettura intendiamo l'organizzazione di un sistema in componenti relazionati tra di loro, che interagiscono con l'ambiente circostante secondo dei principi, principi progettuali, principi che ne guidano la progettazione e l'evoluzione.

Chi è dunque l'architetto? Secondo IEEE è la persona, il team, l'azienda responsabile dell'architettura del sistema. Semplice? Si, ma quanto spesso confondiamo questo figura con l'analista o il project manager? D'accordo, possono essere la stessa persona, ma non svolgono assolutamente lo stesso ruolo. Quindi:

Architetto != Analista && Architetto != Project Manager

O per gli irriducibili di Visual Basic:

Architetto <> Analista AND Architetto <> Project Manager

L'analista è un esperto del dominio applicativo, delle regole che devono governare il sistema, che in linea di massima può non essere un tecnico, anzi, meglio! In questo modo è libero da pregiudizi implementativi che potrebbero influenzare il suo modo di percepire i requisiti del cliente, potendosi concentrare unicamente sul COSA e non sul COME.

Il Project Manager è tutto altro, e wikipedia è chiarissima sull'argomento:

"Il project manager è un ruolo di gestione operativa. Tale figura è il responsabile unico della valutazione, pianificazione, realizzazione e controllo di un progetto. [...] Il suo obiettivo essenziale è quello di assicurare il rispetto dei costi, dei tempi e della qualità concordati e soprattutto il raggiungimento della soddisfazione del committente.". [2]

Non sarei riuscito a dirlo meglio.

Un altro errore molto comune e confondere l'architettura con il design di un'applicazione, il design al limite è una parte dell'architettura ma non è l'architettura, cosa che si evince chiaramente dalla definizione data sopra:

Design Є Architettura

Cosa fa dunque un architetto? Potremmo riassumere il suo lavoro nei seguenti punti:

Prende i requisiti passatigli dall'analista.

Suddivide il sistema in sottosistemi assegnabili ad un singolo programmatore o a un gruppo di lavoro.

Verifica se è il caso di utilizzare componenti già esistenti per alcuni sottosistemi.

Crea le specifiche da passare ai programmatori per la realizzazione del sistema.

Analizziamo questi punti. Ok, l'analista ha finito il suo lavoro e ci consegna i requisiti da soddisfare, da questo momento in poi questo o questi documenti diventano il nostro vangelo, ma giusto per farci un'idea cerchiamo di capire che cosa ha fatto in assenza dello spirito santo per redigere il nostro testo sacro.

Per prima cosa è andato dal cliente e ha individuato gli stakeholder, cioè quei personaggi a cui deve letteralmente estorcere le informazioni che gli sono necessarie per stabilire quali sono i requisiti del sistema da realizzare.

Vi state domandando perché estorcere? Molto banalmente perché non è assolutamente detto che sappiano cosa vogliono veramente ed è qui che si vede la bravura di un analista: ridimensionare gli stakeholder su quello che un sistema software può fare e concordare insieme quello di cui veramente hanno bisogno per ottenere un vantaggio dall'utilizzo del sistema che ci si appresta a realizzare.

Se alla fine del processo gli stakeholder sono soddisfatti il progetto avrà successo, il che significa che probabilmente saremo pagati per il nostro lavoro, in caso contrario cominciate a chiamare l'avvocato. Finite le interviste e le riunioni con gli stakeholder l'analista definisce i requisiti funzionali e non funzionali (scalabilità, sicurezza, ecc.), di cui parleremo nel dettaglio nel prossimo articolo sull'architettura.

Ricevuti i requisiti e studiatili con attenzione l'architetto comincia a suddividere il sistema in sottosistemi sempre più piccoli in modo da rendere possibile la valutazione tempi e risorse. Lo scopo in questa fase e determinare il "costo del sistema" in modo da permettere a chi di dovere di verificare i margini del budget disponibile o a definire il costo preventivo con il quale fare l'offerta al cliente.

E' questo il momento in cui l'architetto decide se eventualmente è il caso di utilizzare componenti già pronte, commerciali o non, per alcuni sottosistemi cercando di tenere a bada la sua natura di programmatore che lo esorterebbe a mettere alla prova le sue capacità tecniche!

L'ultima fase del suo lavoro consiste nel creare le specifiche da fornire ai programmatori per la realizzazione del sistema, il cui livello di dettaglio varia a seconda della complessità del sistema e delle competenze delle risorse coinvolte: si va da una descrizione passo passo del lavoro da svolgere, con tanto di use-case, class e sequence diagram (in alcuni casi mi è anche capitato di dover scrivere le query SQL o Linq da utilizzare), alla semplice descrizione del caso d'uso lasciando piena autonomia allo sviluppatore.

Nei prossimi articoli analizzeremo questi passi in maniera più approfondita progettando insieme un ipotetico sistema di esempio, dandoci dei requisiti e realizzando la documentazione necessaria. Naturalmente i vostri feedback e le vostre idee saranno fondamentali per simulare un vero e proprio brain storming tra architetti al fine di fare le giuste scelte per il problema che ci porremo. Alla prossima puntata.

[1] http://www.iso-architecture.org/ieee-1471/

[2] http://it.wikipedia.org/wiki/Project_manager

*System.IO* Type	Usato per
FileStream	Scrivere e leggere da un file
MemoryStream	Scrivere e leggere dalla memoria
StreamReader	Leggere dati da un file di testo
StreamWriter	Scrivere dati in un file di testo

*System.IO* Type <o:p></o:p>	Usato per<o:p></o:p>
FileStream <o:p></o:p>	Scrivere e leggere da un file<o:p></o:p>
MemoryStream <o:p></o:p>	Scrivere e leggere dalla memoria<o:p></o:p>
StreamReader <o:p></o:p>	Leggere dati da un file di testo<o:p></o:p>
StreamWriter <o:p></o:p>	Scrivere dati in un file di testo<o:p></o:p>

Tipo<o:p></o:p> (Visual Basic/ C# alias)<o:p></o:p>	Dimensione<o:p></o:p> (Bytes)<o:p></o:p>	Range dei valori<o:p></o:p>
System.Char (Char/char)<o:p></o:p>	2<o:p></o:p>	-<o:p></o:p>
System.Boolean (Boolean/bool)<o:p></o:p>	1<o:p></o:p>	-<o:p></o:p>
System.SByte (SByte/sbyte) <o:p></o:p>	1<o:p></o:p>	da <st1:metricconverter productid="-128 a" w:st="on">-<st1:metricconverter productid="128 a" w:st="on">128 a</st1:metricconverter></st1:metricconverter> 127<o:p></o:p>
System.Byte (Byte/byte) <o:p></o:p>	1<o:p></o:p>	Da <st1:metricconverter productid="0 a" w:st="on">0 a</st1:metricconverter> 255<o:p></o:p>
System.Int16 (Short/short) <o:p></o:p>	2<o:p></o:p>	da <st1:metricconverter productid="-32768 a" w:st="on">-32768 a</st1:metricconverter> 32767<o:p></o:p>
System.Int32 (Integer/int) <o:p></o:p>	4<o:p></o:p>	da <st1:metricconverter productid="-2147483648 a" w:st="on">-2147483648 a</st1:metricconverter> 2147483647<o:p></o:p>
System.UInt32 (UInteger/uint) <o:p></o:p>	4<o:p></o:p>	Da <st1:metricconverter productid="0 a" w:st="on">0 a</st1:metricconverter> 4294967295<o:p></o:p>
System.Int64 (Long/long) <o:p></o:p>	8<o:p></o:p>	da -9223372036854775808 a 9223372036854775807<o:p></o:p>
System.Single (Single/float) <o:p></o:p>	4<o:p></o:p>	da -3.402823E+<st1:metricconverter productid="38 a" w:st="on">38 a</st1:metricconverter> 3.402823E+38<o:p></o:p>
System.Double (Double/double) <o:p></o:p>	8<o:p></o:p>	da -1.79769313486232E+<st1:metricconverter productid="308 a" w:st="on">308 a</st1:metricconverter> 1.79769313486232E+308<o:p></o:p>
System.Decimal (Decimal/decimal) <o:p></o:p>	16<o:p></o:p>	Da -79228162514264337593543950335 a 79228162514264337593543950335<o:p></o:p>
System.DateTime (Date/date)<o:p></o:p>	8<o:p></o:p>	Dal 1/1/0001 12:00:00 AM al 12/31/9999 11:59:59 PM<o:p></o:p>