Code and fun - Il blog di Matteo Casati

L'ordine dei parametri in alcune classi del framework

...è deciso in modo casuale???

Qualcuno mi spiega perché ArgumentException(string, string) vuole prima il messaggio e poi il nome del parametro mentre, ad esempio, ArgumentNullException(string, string) e ArgumentOutOfRangeException(string, string) funzionano al contrario (prima il nome del parametro e poi il messaggio?

Certe cose proprio non le capisco.

The Developer Highway Code

A corollario dei miei due articoli sulla sicurezza delle applicazioni ASP.NET pubblicati in gennaio ("Realizzare applicazioni ASP.NET sicure - Prima parte" e "Realizzare applicazioni ASP.NET sicure - Seconda parte") segnalo la possibilità di scaricare gratuitamente da MSDN UK la versione digitale - e-book - dell'ottimo (seppur datato) "The Developer Highway Code" di Paul Maher and Alex Mackman.

L'ebook è disponibile all'indirizzo http://msdn.microsoft.com/en-gb/security/aa473878.aspx (sia in formato PDF che XPS) ed è un aggiornamento della copia edita da Microsft Press nel 2006.

È possibile scegliere di scaricare la versione completa (circa 7 MB per il PDF) oppure ogni singola sezione:

Part 1 – Security Engineering
Part 2 – Checklists and Question Lists
Part 3 – What’s New for Security in the .NET Framework v2.0
Part 4 – Microsoft Patterns & Practices Security Resources

Buona lettura a tutti.

Tags: ASP.NET

RollingList<T>

Nel post precedente ho parlato di come utilizzare le classi di base del framework per realizzare una collection con le seguenti caratteristiche:

all'inserimento di un nuovo elemento questo viene posizionato all'inizio della lista (i più recenti verranno visualizzati per primi)
la lista deve contenere al massimo n elementi: l'inserimento di un nuovo elemento, raggiunto il limite n, deve prevedere la rimozione dell'elemento più vecchio presente nella lista (ovvero quello inserito da più tempo)
garantire ottime performance

Il commento di rsaccav mi ha fatto convinto ad implementare una collezione generica "from scratch", così da colmare il vuoto lasciato in System.Collection.Generic.

Con estrema fantasia l'ho battezzata RollingList<T>

Il principio è piuttosto semplice: la lista si basa su un array con dimensione fissa pari al limite di elementi da conservare (Capacity; la proprietà deve essere impostata nel costruttore o comunque *prima* dell'inserimento del primo elemento) associato ad un cursore (backward) che definisce la posizione di inserimento/sostituzione e che consente di enumerare gli elementi nell'ordine corretto.

Il codice completo della classe:

using System; using System.Collections; using System.Threading; public class RollingList<T> : ICollection { private int _cursor; private int _size; private int _capacity; private T[] _items; private object _syncRoot; public RollingList(int capacity) { Capacity = capacity; } public int Capacity { get { return _capacity; } set { if (value <= 0) throw new ArgumentOutOfRangeException("value", "Capacity must be greater than zero"); if (_capacity > 0) throw new ArgumentException("Capacity has just been defined", "value"); _capacity = value; _items = new T[_capacity]; _cursor = (_capacity - 1); } } public void Add(T item) { if (_capacity <= 0) throw new NotSupportedException("Capacity is not greater than zero"); _items[_cursor--] = item; if (_size < _capacity) _size++; if (_cursor < 0) _cursor = (_capacity - 1); } public void Clear() { Array.Clear(_items, 0, _size); _size = 0; _cursor = (_capacity - 1); } public T[] ToArray() { T[] destinationArray = new T[_size]; if (_size == 0) return destinationArray; int cursorPosition = (_cursor + 1 == _capacity) ? 0 : _cursor + 1; Array.Copy(_items, cursorPosition, destinationArray, 0, (_capacity - cursorPosition)); if (_size == _capacity && cursorPosition > 0) Array.Copy(_items, 0, destinationArray, (_capacity - cursorPosition), cursorPosition); return destinationArray; } public void CopyTo(Array array, int index) { Array.Copy(ToArray(), 0, array, index, _size); } public int Count { get { return _size; } } public bool IsSynchronized { get { return false; } } public object SyncRoot { get { if (_syncRoot == null) { Interlocked.CompareExchange(ref _syncRoot, new object(), null); } return _syncRoot; } } public IEnumerator GetEnumerator() { return ToArray().GetEnumerator(); } }

Questa implementazione è sicuramente migliorabile (ad esempio, oltre a ICollection potrebbe essere utile implementare l'interfaccia ICollection<T>, supportare la serializzazione, ecc.) ma è decisamente preferibile rispetto all'uso di Stack<T>, Queue<T> o LinkedList<T> in quanto:

semplifica il codice di inserimento di elementi (le operazioni di IN/OUT al raggiungimento della capacità massima definita sono gestite dalla collection stessa, quindi non richiedono codice di controllo aggiuntivo)
semplifica la lettura grazie ad una corretta enumerazione nativa degli elementi
permette di avere performance notevolmente più elevate:

// 
  
// RollingList performance test 

  
// 

  
int capacity = 10000; 

  
int max = 1000000000; 

  
DateTime start = DateTime.Now; 

  
RollingList<int> list = new RollingList<int>(capacity); 

  
for (int i = 1; i <= max; i++) 

  
{ 

  
    list.Add(i); 

  
} 

  
foreach (int item in list) 

  
{ 

  
    // do something with "item" 

  
} 

  
Console.WriteLine("RollingList: max={0} -> {1}", 

  
    max.ToString("#,###"), 

  
    DateTime.Now.Subtract(start));

Produce:

RollingList: max=1.000.000.000 -> 00:00:11.5610000

Ovvero un tempo di esecuzione che è circa un terzo rispetto a Queue<T>!!!

HTH

Una semplice (ma solo in apparenza) collection generica

Nel progetto (Web) a cui sto lavorando è stata richiesta la visualizzazione di una lista di elementi con le seguenti caratteristiche:

i nuovi elementi devono essere inseriti all'inizio dell'elenco (i più recenti verranno visualizzati per primi)
la lista deve contenere al massimo n elementi: l'inserimento di un nuovo elemento, raggiunto il limite n, deve prevedere la rimozione dell'elemento più vecchio presente nella lista (ovvero quello inserito da più tempo)
l'aggiunta di nuovi elementi è corposa (centinaia di insert al secondo per tutto il ciclo di vita dell'applicazione)
il limite del numero massimo di elementi che devono essere mantenuti nella lista (n) è relativamente basso (< 10.000)

In pratica, definito un limite di 3 elementi e immaginando l'accodamento dei primi 5 interi in ordine crescente (1, 2, 3, 4 e 5) il risultato atteso è:

1
2 1
3 2 1
4 3 2
5 4 3

Ho pensato che sia una cosa semplicissima da realizzare in .NET sfruttando le classi in System.Collection.Generic ma... quale usare? Il framework prevede infatti:

List<T>

Lista generica, non utilizzabile allo scopo in quanto non è possibile inserire elementi in posizioni specifiche ma solo "to the end of the List(T)".

In realtà sarebbe possibile effettuare l'inserimento all'inizio della lista effettuando uno shift di tutti gli elementi ma le performance sarebbero improponibili!

Stack<T>

È letteralmente un insieme di elementi "impilati"; possiamo vederlo come una vaschetta portadocumenti sulla scrivania in cui vengono aggiunte delle pratiche (Push) semplicemente appoggiandole sopra e con l'impiegato che le processa che prende (Pop) il primo foglio che trova in cima alla pigna. Non assolve dunque allo scopo in quanto rimuove gli elementi più "nuovi" anziché quelli più "vecchi".

In pratica il seguente codice:

int capacity = 3; 
  
int max = 5; 

  
Stack<int> list = new Stack<int>(capacity); 

  
for (int i = 1; i <= max; i++) 

  
{ 

  
    if (list.Count >= capacity) 

  
        list.Pop(); 

  
    list.Push(i); 

  
    foreach (var item in list) 

  
        Console.Write("{0} ", item); 

  
    Console.WriteLine(); 

  
}

Produce:

1
2 1
3 2 1
4 2 1
5 2 1

Non ci siamo.

Queue<T>

È appunto una "coda" dove il primo elemento inserito (Enqueue) è anche il primo a venire rimosso (Dequeue); l'analogia che mi viene in mente è quella delle macchine ferme al casello dell'autostrada: il primo arrivato sarà anche il primo a superare la barriera. Questa collection assolve per metà allo scopo garantendo il corretto meccanismo di in/out ma ha il contro di presentare l'enumerazione degli elementi in ordine inverso rispetto a quanto richiesto (scorrendo la collection ottengo prima gli elementi più "vecchi" e poi quelli più "nuovi")

In pratica il seguente codice:

int capacity = 3; 
  
int max = 5; 

  
Queue<int> list = new Queue<int>(capacity); 

  
for (int i = 1; i <= max; i++) 

  
{ 

  
    if (list.Count >= capacity) 

  
        list.Dequeue(); 

  
    list.Enqueue(i); 

  
    foreach (var item in list) 

  
        Console.Write("{0} ", item); 

  
    Console.WriteLine(); 

  
}

Produce:

1
1 2
1 2 3
2 3 4
3 4 5

Non ci siamo ancora ma manca poco :-)

LinkedList<T>

Si tratta di un elenco con doppio collegamento; espone metodi per l'inserimento di nuovi elementi sia all'inizio dell'elenco (AddFirst) che alla fine (AddLast) che in posizioni intermedie (AddAfter e AddBefore), sia per la rimozione (RemoveFirst, RemoveLast, Remove), dandoci la massima flessibilità possibile. In pratica possiamo immaginare questa collection come un trenino giocattolo: possiamo aggiungere o togliere vagoni da entrambe le estremità del convoglio in modo del tutto indifferente.

In pratica il seguente codice:

int capacity = 3; 
  
int max = 5; 

  
LinkedList<int> list = new LinkedList<int>(); 

  
for (int i = 1; i <= max; i++) 

  
{ 

  
    if (list.Count >= capacity) 

  
        list.RemoveLast(); 

  
    list.AddFirst(i); 

  
    foreach (var item in list) 

  
        Console.Write("{0} ", item); 

  
    Console.WriteLine(); 

  
}

Produce:

1
2 1
3 2 1
4 3 2
5 4 3

Missione compiuta? Sembrerebbe di sì.

Per scrupolo ho fatto un piccolo test di performance, aspettandomi prestazioni simili per Queue e LinkedList:

// 
  
// Performance test configuration 

  
// 

  
DateTime start; 

  
int[] results; 

  
int capacity = 10000; 

  
int max = 1000000000; 

  


  
// 

  
// LinkedList performance test 

  
// 

  
start = DateTime.Now; 

  
LinkedList<int> list = new LinkedList<int>(); 

  
for (int i = 1; i <= max; i++) 

  
{ 

  
    if (list.Count >= capacity) 

  
        list.RemoveLast(); 

  
    list.AddFirst(i); 

  
} 

  
results = new int[list.Count]; 

  
list.CopyTo(results, 0); 

  
foreach (int item in results) 

  
{ 

  
    // do something with "item" 

  
} 

  
Console.WriteLine("LinkedList: max={0} -> {1}", 

  
    max.ToString("#,###"), 

  
    DateTime.Now.Subtract(start)); 

  


  
// 

  
// Queue performance test 

  
// 

  
start = DateTime.Now; 

  
results = null; 

  
Queue<int> queue = new Queue<int>(capacity); 

  
for (int i = 1; i <= max; i++) 

  
{ 

  
    if (queue.Count >= capacity) 

  
        queue.Dequeue(); 

  
    queue.Enqueue(i); 

  
} 

  
results = queue.ToArray(); 

  
foreach (int item in results) 

  
{ 

  
    // do something with "item" 

  
} 

  
Console.WriteLine("Queue: max={0} -> {1}", 

  
    max.ToString("#,###"), 

  
    DateTime.Now.Subtract(start));

Sebbene questo tipo di misurazione sia piuttosto "spannometrico", il risultato (per un miliardo di inserimenti a fronte di una lista con al più 10.000 items) mi ha lasciato basito:

LinkedList: max=1.000.000.000 -> 00:01:17.6770000
Queue: max=1.000.000.000 -> 00:00:30.4030000

Ovvero LinkedList richiede circa 2.5 volte il tempo necessario a Queue!

Conclusioni

Sebbene LinkedList<T> faccia il suo "sporco lavoro" lo fa... troppo lentamente!

Alla fine ho dunque optato per l'utilizzo di Queue<T> con l'aggiunta di poche righe di codice per leggere in modo inverso il contenuto enumerato della lista:

Queue<int> queue = new Queue<int>(capacity); 
  
// (codice omesso) 

  
List<int> temp = new List<int>(queue.ToArray()); 

  
temp.Reverse(); 

  
results = temp.ToArray(); 

  
foreach (int item in results) 

  
{ 

  
    // do something with "item" 

  
}

Infatti il numero di elementi mantenuti nella coda è decisamente troppo basso - meno di 10.000 - per risultare influenti le operazioni di copia in una List e di reverse della lista, anche se molto probabilmente questa porzione di codice potrebbe essere migliorata :-)

PS 1: qualcuno avrà notato l'assenza di acronimi come FIFO (first-in, first-out), LIFO (last-in, first-out), ecc.
Sono stati volutamente omessi perché il significato di "primo" e "ultimo" mi è risultato, leggendo qua e là sul Web, interpretato in modo non del tutto univoco (si riferisce all'ordine di inserimento? alla posizione che assume l'elemento nella collection? ad altro?)

PS 2: un doveroso grazie a Cristian e a Marco che mi hanno ~~supportato~~ sopportato in questa ricerca

IDictionary e la serializzazione in XML

Chi lavora con i Web Service si sarà accorto che le strutture chiave/valore (Hashtable, Dictionary generici o specializzati, ecc.), non implementando l'interfaccia IXmlSerializable risultano "intrasportabili".

Qualcuno ci ha anche provato a chiedere a Microsoft di modificare questo comportamento ma la risposta è stata "Won't fix"... La motivazione? Semplice: "Unfortunately, we cannot change Dictionary<K,V> to implement IXmlSerializable since it is located in the mscorlib assembly that cannot reference System.Xml.dll."

In realtà creare un Dictionary generico serializzabile in XML è piuttosto semplice: basta creare una classe "SerializableDictionary" che derivi da Dictionary<TKey, TValue> e implementi IXmlSerializable, serializzando - per ogni KeyValuePair contenuto nella collection di base - sia la chiave che il valore.

Ho fatto due implementazioni: la prima serializza le chiavi e i valori in Base64, la seconda in XML.

KeyValuePair in Base64

using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
#region IXmlSerializable Members

    private const string NS = "";
    private const string XML_ITEM_NODE_NAME = "item";
    private const string XML_KEY_ATTRIBUTE_NAME = "key";
    private const string XML_VALUE_ATTRIBUTE_NAME = "value";

    public XmlSchema GetSchema()
    {
        return null;
    }

    public void WriteXml(XmlWriter w)
    {
        foreach (TKey key in Keys)
        {
            TValue value = this[key];
            w.WriteStartElement(XML_ITEM_NODE_NAME, NS);
            w.WriteElementString(XML_KEY_ATTRIBUTE_NAME, NS, ToBase64(key));
            w.WriteElementString(XML_VALUE_ATTRIBUTE_NAME, NS, ToBase64(value));
            w.WriteEndElement();
        }
    }

    public void ReadXml(XmlReader r)
    {
        r.Read();
        r.MoveToContent();
        while (r.NodeType != XmlNodeType.EndElement)
        {
            r.ReadStartElement(XML_ITEM_NODE_NAME, NS);
            TKey key = FromBase64<TKey>(r.ReadElementString(XML_KEY_ATTRIBUTE_NAME, NS));
            TValue value = FromBase64<TValue>(r.ReadElementString(XML_VALUE_ATTRIBUTE_NAME, NS));
            r.ReadEndElement();
            r.MoveToContent();
            Add(key, value);
        }
    }

#endregion

#region Base64 Serialization

    private static string ToBase64(object value)
    {
        using (MemoryStream stream = new MemoryStream())
        {
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.AssemblyFormat = FormatterAssemblyStyle.Simple;
            formatter.Serialize(stream, value);
            byte[] buffer = stream.ToArray();
            return Convert.ToBase64String(buffer, 0, buffer.Length, Base64FormattingOptions.None);
        }
    }

    public static T FromBase64<T>(string base64)
    {
        byte[] buffer = Convert.FromBase64String(base64);
        using (MemoryStream stream = new MemoryStream(buffer))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.AssemblyFormat = FormatterAssemblyStyle.Simple;
            return (T)formatter.Deserialize(stream);
        }
    }

#endregion
}

KeyValuePair in XML

using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Collections.Generic;

[Serializable]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
#region IXmlSerializable Members

    private const string NS = "";
    private const string XML_ITEM_NODE_NAME = "item";
    private const string XML_KEY_NODE_NAME = "key";
    private const string XML_VALUE_NODE_NAME = "value";

    public XmlSchema GetSchema()
    {
        return null;
    }
    public void ReadXml(XmlReader reader)
    {
        XmlSerializer ks = new XmlSerializer(typeof(TKey));
        XmlSerializer vs = new XmlSerializer(typeof(TValue));
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
        if (wasEmpty)
            return;
        while (reader.NodeType != XmlNodeType.EndElement)
        {
            reader.ReadStartElement(XML_ITEM_NODE_NAME, NS);
            reader.ReadStartElement(XML_KEY_NODE_NAME, NS);
            TKey key = (TKey)ks.Deserialize(reader);
            reader.ReadEndElement();
            reader.ReadStartElement(XML_VALUE_NODE_NAME, NS);
            TValue value = (TValue)vs.Deserialize(reader);
            reader.ReadEndElement();
            Add(key, value);
            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }

    public void WriteXml(XmlWriter writer)
    {
        XmlSerializer ks = new XmlSerializer(typeof(TKey));
        XmlSerializer vs = new XmlSerializer(typeof(TValue));
        foreach (TKey key in Keys)
        {
            writer.WriteStartElement(XML_ITEM_NODE_NAME, NS);
            writer.WriteStartElement(XML_KEY_NODE_NAME, NS);
            ks.Serialize(writer, key);
            writer.WriteEndElement();
            writer.WriteStartElement(XML_VALUE_NODE_NAME, NS);
            TValue value = this[key];
            vs.Serialize(writer, value);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }
    }

#endregion
}

A voi la scelta :-)

Tags: .NET Framework, Web Service, XML

Grazie ASPItalia!

Un grazie enorme a Daniele. Lui sa perché!

(chiedo scusa per l'OT e per la cripticità del messaggio ma... quando ci vuole ci vuole)

Tags: 10annidi, ASPItalia.com, Off Topic

3-Tier, 3-Layer e MVC: ma sono la stessa cosa?

Questa riflessione parte dalla domanda di un utente nel forum:

"Domanda: Analogie tra MVC e Three-tier - Sono troppe e a me sembra che l'uno possa sostituire l'altro.. ma quanto sbaglio?"

Ho l'impressione che questa perplessità sia parecchio diffusa e che, più in generale, ci sia parecchia confusione quando si parla di software architecture: spero che questo post possa chiarire un po' meglio alcuni concetti.

Iniziamo definendo, in termini strettamente lessicali, cosa si intende per "3-Tier", dato che la stessa Wikipedia non è affatto chiara nè precisa (sia in italiano che in inglese) contribuendo ad aumentare la confusione.

Architettura 3-Tier (o n-Tier)

Letteralmente si parla di "architetture a 3 o più livelli" per definire un modello che fornisca una separazione fisica dell'applicazione; in pratica si dice che un'applicazione può essere erogata usando un'infrastruttura complessa e diversificata, tipicamente usando più server, ciascuno dedicato ad una funzionalità specifica (fron-end, middleware, back-end, ecc.)
Una spiegazione più dettagliata di questo modello distributivo è disponibile sul sito "Microsoft patterns & practices Developer Center": Three-Tiered Distribution

In pratica ritengo che si dovrebbe parlare di "tier" in riferimento a qualcosa di "sistemistico", e non per architettura software in senso stretto.

Architettura 3-Layer (o n-Layer)

Le architetture a 3 strati (o più: il "3" è entrato nella concezione comune in quanto rappresenta la stratificazione più semplice ed utilizzata) sono un modello di organizzazione del codice applicativo basato sulla separazione delle funzionalità logiche. Tipicamente avremo:

Presentation (PL): la visualizzazione dei dati e, più in generale, la rappresentazione dei controlli (forms, controlli di input, labels, ecc.) necessari per l'interfaccia utente
Business Logic (BLL): rappresenta la parte principale dell'applicazione, definendo il domain model dell'applicazione, ovvero le entità (ad esempio: fattura, cliente, ecc.), le loro relazioni e le logiche applicative. Non deve contenere contenere alcun riferimento a come i dati saranno presentati all'utente o a come verranno salvati
Data Access (DAL): contiene tutto quello che concerne la persistenza dei dati (database, tabelle, record, file system, ecc.)

Questo tipo di architettura ha principalmente il vantaggio di fornire una separazione logica così da aumentarne la manutenibilità, la scalabilità ed il riutilizzo.
Una spiegazione più dettagliata di questo tipo di architettura è disponibile sul sito "Microsoft patterns & practices Developer Center": Three-Layered Services Application

Model-View-Controller (MVC)

Questo pattern, introdotto solo di recente nel mondo .NET ma diffuso da tempo in altri ambienti, fornisce un modello per strutturare in modo organizzato le funzionalità relative alla UI e orchestrare l'accesso agli altri strati applicativi (BLL e DAL):

Model: è l'insieme dei componenti che mantengono lo "stato": i dati e i metodi per accedervi. In pratica costituisce la logica applicativa o - IMHO preferibilmente - l'accesso al layer (separato) di BL
View: deputato alla visualizzazione vera e propria dell'interfaccia utente per la presentazione dei dati
Controller: gestisce le interazioni dell'utente con l'applicazione (tipicamente intercettando e gestendo gli eventi e gli input dell'utente), mediante accesso al Model e definendo la View corrispondente da presentare

MVC non contraddice quindi il modello 3-Layer, semplicemente è una delle possibili implementazioni di questo tipo di architettura; da un certo punto di vista possiamo addirittura vedere MVC come un'estensione dell'architettura a 3 strati, in quanto porta una separazione logica ulteriore nel livello di presentation.

MVC è dunque un'alternativa ai Web Forms di ASP.NET e, come tale, ha vantaggi e svantaggi.

Per quanto mi riguarda (non ne faccio mistero: il modello a forms ASP.NET non mi è mai piaciuto per tanti motivi) MVC ha solo vantaggi :-)

Tags: .NET Framework, Architettura, ASP.NET

Test: che programmatore sei?

Visto che oggi va tanto di moda questo test, ho pensato di proporlo anche ai bloggers di ASPItalia: Programmer Personality Test

Io sono un DHSB:

You're a Doer.
You are very quick at getting tasks done. You believe the outcome is the most important part of a task and the faster you can reach that outcome the better. After all, time is money.

You like coding at a High level.
The world is made up of objects and components, you should create your programs in the same way.

You work best in a Solo situation.
The best way to program is by yourself. There's no communication problems, you know every part of the code allowing you to write the best programs possible.

You are a liBeral programmer.
Programming is a complex task and you should use white space and comments as freely as possible to help simplify the task. We're not writing on paper anymore so we can take up as much room as we need.

E voi che tipi siete?

Tags: Off Topic

Italia.it è online

Dopo una lunga gestazione è online il portale italia.it.

Complimenti, proprio un ottimo lavoro! (ovviamente è ironico)

In particolare:

di un lento spaventoso: o tutta Italia è collegata al portale o sta girando su server collegati via modem 56K
immediatezza nulla: due pagine di intro prima di accedere alla home (la prima solo per sentire un Pavarotti che inneggia al Belpaese, la seconda solo per selezionare la lingua, il tutto corredato da animazioni Flash pesanti, brutte ed inutili)
url agghiaccianti: http:// www.italia.it / wps / portal / ut / p / kcxml / 04_Sj9SPykssy0xPLMnMz0vM0Y_QjzKLN4j3Mg TJgFjGpvqRqCKOcIEgfW99X4 _83FT9AP2C3NCIckdHRQAuuTD4 / delta / base64xml / L3dJdyEvd0ZNQ UFzQ UMvNElV RS82XzBfSjI!? WCM_GLOBAL_CONTEXT= / wps / wcm / connect / Portale+del+Turismo / homepage / Visita+l%27Italia/ (ho messo qualche spazio qua e là giusto per preservare il layout del blog) per accedere ad una pagina di secondo livello???? Prometto che non mi lementerò mai più dei link dei downlaod di Microsoft!!!
front-end HTML basato sulle tabelle (sveglia! siamo nel 2007!!!)... ma forse la colpa è di IBM WebSphere (anche per le URL)... Già: è fatto in Java... LOL! In tutta onestà però devo dire che non è colpa della piattaforma ma di chi l'ha usata in modo così approssimativo (i template di WebSphere sono ovviamente customizzabili, così come le url delle pagine generate)
uso di finestre pop-up
la versione accessibile (non ho indagato se sia realmente accessibile) è a parte... ma nemmeno il governo applica le leggi??!
i contenuti non li capisco (sono tardo io?): se clicco "Cosa Fare" visualizzo informazioni su... "il barocco in Italia"... e che c'azzecca? Bho!
complimenti per il logo: la "T" sembra... un fallo (non calcistico ma anatomico) e il mix di maiuscole e minuscole pensavo fosse una prerogativa dei dodicenni di oggi. UPDATE: pare che solo il logo sia costato qualcosa come 100.000 Euro. Centomila euro che, fatti quattro conti, equivalgono a un intero anno di lavoro di un grafico ben pagato (50 settimane x 5 giorni lavorativi x 8 ore a 50 Euro l'ora)... Mi sa che ho sbagliato mestiere!

Interrompo qui la lista per non infierire.

Beh, c'è da dire che almeno - come già anticipato da Marco - è costato poco "solo" 45.000.000 di Euro (45 milioni dei nostri euro!)

Laciamo perdere... è meglio.

PS: non ho usato nessun "IMHO" prima delle considerazioni perché mi sembrano oggettive e non soggettive; vi sfido a dire il contrario!

IE6 e IE7 su una singola macchina

Con l'uscita di IE7 si è posto nuovamente il problema di testare i siti Web su differenti versioni di Internet Explorer. Esitono fondamentalmente due modi per avere più versioni di IE sulla stessa macchina:

utilizzando versioni "stand-alone" di IE e modificando qualche chiave di registro come spiegato in "Internet Explorer 7 running side by side with IE6. (standalone)" oppure utilizzando un setup che automatizzi l'operazione come ad esempio Multiple_IE (che consente di avere sullo stesso PC praticamente tutte le versioni di IE, come segnalato da Andrea Moro)
utilizzando una virtual machine

La seconda strada è quella "ufficiale" consigliata da Microsoft su IEBlog: senza bisogno di licenze di Windows aggiuntive è possibile scaricare Internet Explorer 6 Application Compatibility VPC Image per avere la nostra virtual machine su Virtual PC 2004 (o Virtual PC 2007)

Anonymous Methods e collection generiche

Tutto quello che ci serve sapere per lavorare con le collection generiche usando anonymous methods; purtroppo è in lingua inglese... ma se insistiamo tutti insieme magari Simone lo traduce e lo posta anche sul suo blog italiano o su GURU4.net ;-)

L'articolo è un po' datato ma - per chi non l'avesse ancora visto - credo valga la pena spendere 10 minuti per risparmiare qualche ora al momento del bisogno :-)

Tags: .NET Framework, .NET Framework 2.0

Mobile 10.7 Beta Refresh

Oggi mi è arrivato l'annuncio:

"After months of waiting the new G2 bits are here for both Smartphone and Pocket PC devices!"

Su Microsoft Connect è disponibile il download della versione 10.7 Beta di Windows Live for Mobile (code name "G2") che include Messenger, Live Mail, Contatti, RSS news feeds e Local Search. Interessante anche la possibilità di aggiungere Live alla schermata "Today".

Enjoy it!

Tags: Windows Mobile

Generare documenti Office via ASP.NET

Quasi tutti noi abbiamo (almeno una volta, confessate!) avuto la necessità di creare nelle nostre applicazioni web funzionalità di esportazione dei dati in formato Exel o di generazione di documenti Word, trovandoci inevitabilmente a fare i conti con le difficoltà del caso (Office sul server? E chi ce l'ha???)

Il vecchio formato binario in uso da 10 anni in Office era infatti decisamente troppo complesso per essere manipolato fuori dalla suite di Microsoft (ok, le versioni 2000 e 2003 hanno introdotto la possibilità di creare documenti in formato XML ma è un po' un "optional" e con diverse limitazioni)

Però...

Se tra gli importanti e sostanziosi cambiamenti introdotti con Office 2007 quello più evidente è la nuova interfaccia grafica, quello più interessante è il cambiamento del formato dei documenti: ora finalmente possiamo dire addio alle difficoltà di manipolazione dei documenti Office da codice e Ted Pattison, su MSDN Magazine di Novembre 2006 ci illustra quanto diventa semplice lavorare con Office usando .NET: Server-Side Generation of Word 2007 Docs

Happy (office documents) programming!

JavaScript SOAP Client Library su CodePlex

Era già da un po' che pensavo di farlo, poi un utente su CodeProject me l'ha chiesto esplicitamente (cito: "Isn't time for a source repository somewhere?")

In effetti, tra il forum di CodeProject e i feedback diretti da GURU4.net mi ritrovo con una tasklist di almeno 20 attività di sviluppo, fix o integrazione che mi sa che non riuscirò mai ad evadere! Non solo: alcuni dei ragazzi che mi hanno proposto dei fix sono *molto* più in gamba di me e non vorrei rischiare di rovinare il loro lavoro ;-)

Ho così provato a richiedere l'ammissione del progetto su CodePlex (sebbene non sia strettamente connesso a .NET) perché lo preferisco decisamente ad altri repository come Google Code o SourceForge.

L'email automatica di risposta mi ha un po' demoralizzato: "Given the large number of incoming requests that we receive, we cannot guarantee that your project will be created until we have added additional servers to our site."

Invece, dopo sole 8 ore, mi arriva un'altra mail per avvisarmi che "Your project has been created"!

Che dire? Spettacoloooo!!!!!!

CodePlex è veramente fantastico: è gratuito, ti mette a disposizione un sacco di strumenti (forum, feeds RSS, wiki, gestione del team, ecc.) oltre al vero plus: il controllo del versioning del codice sorgente ed il tracking dei work item basati su Team Foundation Server!
Come se non bastasse... è tutto semplicissimo da usare e configurare!

Ho avuto solo 5 minuti di panico quando in Visual Studio non potevo aggiungere il progetto al repository del codice sorgente... Ma sono stato demente io a dimenticarmi di cambiare il plug-in del source control da Visual SourceSafe a TFS :-)))

Dimenticavo: per chi fosse interessato l'url della home page del JavaScript SOAP Client su CodePlex è: http://www.codeplex.com/Wiki/View.aspx?ProjectName=JavaScriptSoapClient

Enjoy!

PS: se usate la libreria e avete qualche idea per migliorarla si accettano developers!

Tags: AJAX, Javascript, Visual Studio, Web Service

Internet Explorer 7 - disponibile la RC1

IE7 è finalmente giunto alla prima RC (Release Candidate), come annunciato sul blog del team: Internet Explorer 7 Release Candidate Now Available. Nel post originale sono spiegate le variazioni.

La prima cosa che salta all'occhio sono le Installation Changes in IE7 Release Candidate per cui non sarà più necessario rimuovere manualmente eventuali versioni precedenti (beh, ad ogni modo un paio di reboot non ve li toglie nessuno!)

Unico problema da me riscontrato: al termine dell'installazione non era più visibile la "Quick Start Toolbar" nella barra di Windows; niente di grave insomma :-)

Dimenticavo il link diretto per il download (gratuito, previa autenticazione della copia di Windows) di IE7 RC1.

Enjoy!