Il jackpot del Superenalotto ha superato i 130 milioni di euro,lorda o netta che sia è una cifra assurda che chiunque vorrebbemettersi in tasca. Ebbene, ho un metodo infallibile per vincere: io cimetto il codice, voi ci mettete il culo, perchè è solo edesclusivamente una questione di culo.

Ecco qui il codice:

using System;
using System.Collections.Generic;
using System.Text;

namespace questionediculo
{
    class Program
    {
        private const int MIN_VALUE = 1;
        private const int MAX_VALUE = 90;

        static void Main(string[] args)
        {
            List<int> numbers = GenerateSeries(7);
            int jolly = ExtractFromSeries(numbers);
            numbers.Remove(jolly);

            Console.Write("Sestina fortunata: ");
            foreach (int number in numbers)
            {
                Console.Write(number + " ");
            }
            Console.WriteLine();
            Console.WriteLine("Numero jolly: " + jolly);
        }       

        private static List<int> GenerateSeries(int length)
        {
            List<int> retCol = new List<int>();
            object rand = new object();
            lock (rand)
            {
                Random random = new Random();
                while (retCol.Count < length)
                {
                    int number = random.Next(MIN_VALUE, MAX_VALUE);
                    if (!retCol.Contains(number)) retCol.Add(number);

                }
            }
            retCol.Sort();
            return retCol;
        }

        private static int ExtractFromSeries(List<int> series)
        {
            object rand = new object();
            lock (rand)
            {
                Random random = new Random();
                int index = random.Next(1, series.Count);
                return series[index];
            }
        }
    }
}

Per i più pigri, ecco l'eseguibile questionediculo.zip (9,72 kb)

In caso di vincita, ricordatevi di me ;)

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 framwork 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:

• JSMIN
• the Dojo compressor
• Dean Edwards' Packer
• YUI Compressor

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 Gianluca.Esposito.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.Remove(filePath.LastIndexOf(".axd"));
                    filePath = HttpContext.Current.Server.MapPath(filePath);
                    return filePath;
                }

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

                private void CompressJavaScript(string filePath)
                {
					HttpContext current = HttpContext.Current;
					string requestHash = current.Request.Url.AbsolutePath.GetHashCode().ToString();
                    if (this.useCache & current.Cache[requestHash] != null)
                    {
                        current.Response.Write((string)current.Cache[requestHash]);
                        return;
                    }
                    object fileLock = new object();
                    lock (fileLock)
                    {
                        StreamReader sr = new StreamReader(filePath, true);
                        string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
                        current.Response.Write(compressed);
                        if (this.useCache)
                            current.Cache.Add(requestHash,
								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, mentre mi godo il fresco di questo temporalone estivo :)

Aggiornamento 07/06/2010: Qui una versione modificata delle DLL per farle girare in Medium Trust (Aruba)

Dopo anni e anni di programmazione, tra C, C++, Visual Basic, Php, Java, C# ed altro, la mia attenzione si è focalizzata su quest'ultimo linguaggio. Da diverso tempo infatti utilizzo questo linguaggio per la totalità dei miei progetti, salvo diverse disposizioni dall'alto. Studiando anche codice altrui sono spesso comparse paroline che suscitavano curiosità, che nel tempo ho studiato, ho compreso ed utilizzato. Negli ultimi giorni ho fatto un pò di confusione, così ho deciso di scrivere questo post, anche per creare un documento utile a me in qualunque momento.

internal

La parola chiave internal è un modificatore d'accesso per i tipi ed i loro membri. I membri definiti con questa parola chiave sono accessibili solo da file che si trovano nello stesso assembly. Non si può fare riferimento a un membro con accesso internal dall'esterno dell'assembly in cui è stato definito.

private

La parola chiave private è un modificatore di accesso di un membro. I membri private sono accessibili solo dall'interno del corpo della classe o della struttura in cui sono dichiarati. I tipi annidati nello stesso corpo possono anch'essi accedere ai membri privati.

protected

Un membro protected è accessibile dall'interno della classe in cui è dichiarato e dall'interno di qualsiasi classi derivata da quella in cui è stato dichiarato. Un membro protected di una classe base è accessibile in una classe derivata solo se l'accesso avviene attraverso il tipo di classe derivato. Non è possibile fare riferimento a un membro protected dall'interno di una classe che non sia derivata dalla classe del membro protetto.

public

Non c'è alcuna restrizione per l'accesso a membri pubblici.

abstract

Il modificatore abstract può essere utilizzato con classi, metodi e proprietà. Va utilizzato in una dichiarazione di classe per indicare che una classe deve funzionare esclusivamente da base per un'altra classe. Le classi astratte hanno le seguenti caratteristiche:

• non possono essere istanziate
• possono contenere metodi astratti
• non è possibile modificarle con il modificatore sealed
• una classe astratta derivata da una astratta deve includere le implementazioni reali di tutti i metodi astratti

Il modificatore abstract in una dichiarazione di metodo o di proprietà indica che il metodo o la proprietà non contengono una implementazione. I metodi astratti hanno le seguenti caratteristiche:

• sono implicitamente metodi virtuali
• le loro dichiarazioni sono consentite solo nelle classi astratte
• poichè la loro dichiarazione non fornisce una implementazione effettiva, non hanno un corpo; la dichiarazione del metodo termine semplicemente con un punto e virgola e non ci sono parentesi graffe dopo la firma
• l'implementazione è fornita da un metodo prevalente, membro di una classe non astratta

Le proprietà abstract funzionano come i metodi abstrac, a parte alcune differenze nella sinstassi della dichiarazione e dell'invocazione.

Una classe abstract che implementa una interfaccia deve fornire l'implementazione di tutti i membri dell'interfaccia oppure può mappare i metodi dell'interfaccia stessa su metodi astratti.

const

La parola chiave const viene utilizzata per modificare la dichiarazione di un campo o di una variabile locale. Specifica che il valore del campo o della variabile locale non possono essere modificati.
Un'espressione costante restituisce un valore del tipo di destinazione o di un tipo che possa essere implicitamente convertito in quello di destinazione.
Un'espressione costante è una espressione che può essere completamente elaborata durante la compilazione, quindi gli unici valori possibile per le costati di tipo di riferimento sono string e null.
Il modificatore static non è consentito in una dichiarazione di costante. Una costante può far parte di un'altra espressione costante.

event

La parola chiave event consente di specificare un delegato che verrà chiamato quando si verifica un evento nel codice. Il delegato può avere un o più metodi che vengono chiamati quando il codice indica che l'evento si è verificato.

extern

Il modificatore extern va utilizzato in una dichiarazione di metodo per indicare che il metodo stesso è implementato esternamente. L'uso più comune di questo modificatore è con l'attributo DllImport. Poichè la dichiarazione esterna di un metodo non fornisce una implementazione reale, non esiste neanche il corpo del metodo; la dichiarazione termina semplicemente con un punto e virgola ed è priva di parentesi graffe.

override

Il modificatore override serve a modificare un metodo o una proprietà. Un metodo di questo tipo fornisce una nuova implementazione di un membro ereditato da una classe base. Il metodo ignorato da una dichiarazione di questo tipo iene detto metodo base. Il metodo base ignorato deve avere la medesima firma del metodo che lo ignora.
Non è possibile ignorare un metodo non virtuale o statico; il metodo base deve essere virtuale, astratto o di tipo override.
Una dichiarazione di override non può modificare l'accessibilità del metodo virtuale: entrambi i metodi in gioco devono avere lo stesso modificatore di accesso. Non è possibile utilizzare i seguenti modificatori per modificare un metodo override:

• new
• static
• virtual
• abstract

Una dichiarazione di proprietà che ne ignori un'altra deve specificare il medesimo modificatore d'accesso, tipo e nome della proprietà ereditata e la proprietà ignorata deve essere virtuale, astratta o override.

readonly

La parola chiave readonly è un modificatore che si può utilizzare con i campi. Quando una dichiarazione di campo è marcata con il modificatore readonly le assegnazioni ai campi introdotte dalla dichiarazione possono essere eseguite solo come parte della dichiarazione o in un costruttore della medesima classe.

sealed

La parola chiave sealed è un modificatore che si pul utilizzare in una dichiarazione di classe per evitare di ereditare accidentalmente la classe. Non è possibile utilizzare il modificatore abstract con una classe sealed. Le struct sono implicitamente sealed, quindi non possono essere ereditate.

static

Il modificatore static serve a dichiarare un membro statico che appartiene al tipo stesso e non ad un oggetto specifico. Il modificatore static può essere utilizzato con campi, metodi, proprietà, operatori e costruttori, ma non con indicizzatori, distruttori o tipi.
Nota: anche se una istanza di una classe contiene una copia di tutti i campi dell'istanza della classe, c'è una sola copia per ciascun campo statico.

unsafe

La parola chiave unsafe indica un contesto unsafe, richiesto per le operazione che coinvolgono i puntatori. Questa parola chiave viene utilizzata come modificate nella dichiarazione di membri invocabili come metodi, proprietà, costruttori ed estensori, ma non per i costruttori static.

static unsafe void Metodo(byte[] first, byte[] second, int count)
{
// Contesto unsafe, si possono utilizzare i puntatori
}

L'ambito di un contesto unsafe va dall'elenco dei parametri fino al termine della funzione, quindi è possibile utilizzare i puntatori anche nell'elenco dei parametri.

static unsafe void Metodo(byte* first, byte* second, int count)
{...}

Per compilare il codice non gestito è necessario specificare l'opzione /unsafe del compilatore.

virtual

La parola chiave virtual serve a modificare una dichiarazione di un metodo o di una proprietà (in questi casi il metodo o la proprietà diventano membri virtuali). L'implementazione di un metodo virtual può essere cambiata da un metodo in una classe derivata. Di default i metodi non sono virtuali. Non è possibile prevalere su un metodo non virtuale nè utilizzare il modificatore virtual con i modificatori static, abstract e override.
Le proprietà virtuali si comportano come i metodi abstract, con alcune differenze nella sintassi della dichiarazione e della chiamata. Non è possibile utilizzare il modificatore virtual con una proprietà static. Una proprietà virtuale ereditata può essere ignorata in una classe derivata includendo una dichiarazione di proprietà che utilizza il modificatore override.

volatile

La parola chiave volatile indica che un campo può essere modificato nel programma dal sistema operativo, dall'hardware o da un thread concorrente.
Questo modificatore viene in genere utilizzato per i campi a cui si accede da parte di più thread senza utilizzare l'istruzione lock per serializzare l'accesso. L'uso di questo modificatore assicura che un thread legga il valore più aggiornato scritto da un altro thread.
Solo i seguenti tipi possono essere contrassegnati come volatili:

• tipi di riferimento
• tipi puntatore (in contesto unsafe)
• sbyte, byte, short, ushort, int,uint, char, float, bool
• tipi enumeratore con una base byte, sbyte, short, ushort, int o uint