Sfida alla Serie

Questa volta il protagonista non è il codice... o no? Certo che lo è ma si tratta di una sfida molto più analitica. Chi lo trova i sedici numeri in base 4 mancanti vince...

Esempio  blocco va da 0000 a 3333 secondo la regola 0001,0002,0003,0010... etc

0200130310333023 =  99
2002212313311333 = 109
3002232111231221 = 205
0030122113013132 = 323

???????????????? = 340

La sfida è semplice vince chi trova per primo la serie corretta per 340 è necessario trovare l'algoritmo corretto per trovare la scrittura di un corrispondentet 340 !

Chiaramente ho la soluzione.

Sotto a chi tocca...

Potete fare domande, potete pubblicare del codice di prova, le regole sono sempre le stesse il primo che trova 340 corretto vince.

------------------------------------------------------------------------------------------

Mi è stato detto che la richiesta non è del tutto chiara. Cerco di riformularla.

I primi 4 blocchi da 16 cifre corrispondono rispettivamente al numero 99/109/205/323, come sarà rappresentato il numero 340?

Ossia tramite quale algoritmo ( dedotto o desumibile dai primi 4 di esempio ) riesco a ricavare le 14 cifre che mi daranno 340 ?

Spero in questo modo di essere stato un filo più chiaro.

------------------------------------------------------------------------------------------

ITIL V3 foundation

L'argomento è sicuramente esteso ed è decisamente molto complesso, sia per i termini sia per concetti, tuttavia la complessità assume un peso minore se si riesce a creare un paragone con la quotidianità.

ITIL Information Technology Infrastructure Library è in realtà l'insieme di casi di sucesso di differenti realtà catalogate e raccolte per dar vita ad un insieme di "consigli" o "best practices" nella creazione, gestione, evoluzione vita di un Servizio.

Questa libreria o queste librerie ( dato che sono parecchi libri ogniuno con un focus differente ) hanno lo scopo di indicare la best way, non sono centralizzate su uno specifico linguaggio di programmazione, non sono specifiche per una soluzione, e questo è il principale punto di forza.


Questo articolo non ha pretese come al solito, ma presenta una breve overview.

ITIL V3 ( Ciclo ) 

Questa immagine (che nel corso del tempo è stata oggetto di varie revisioni nei colori e nella grafica) rappresenta il ciclo di vita di un ipotetico servizio.

Service Strategy che sottende i processi:

• Strategy Management for IT Services
• Financial Management
• Service Portfolio Management
• Demand Management
• Business Relationship Management

Si occupa principalmente dello studio, della strategia, dell'analisi di mercato, della richiesta e dell'offerta. E' il cuore di ciò che sarà da considerare come offerta verso i clienti.


Service Design che sottende i processi:

• Design Coordination
• Service Catalogue Management
• Service Level Management
• Capacity Management
• Availability Management
• IT Service Continuity Management
• Information Security Management
• Supplier Management

Si occupa della progettazione, della creazione di un servizio offrendo inoltre i limiti d'uso, gli sla i KPI, si occupa di verficare e organizzare forniture esterne nel caso fossero necessarie.
L'importanza di questo processo è inoltre la manutenzione e la gestione del CATALOGO, una raccolta completa dei servizi vecchi, nuovi e in dismissione e/o obsoleti e dismessi.


Service Transition che sottende i processi:

• Transition Planning and Support
• Change Management
• Service Asset and Configuration Management
• Release and Deployment Management
• Service Validation and Testing
• Change Evaluation
• Knowledge Management

Si occupa della gestione del servizio durante la sua erogazione, sono previsti tutti processi sia di confugurazione, sia di Change ( evolute o bug fixing ) sia di Rilascio.


Service Operation che sottende i processi:

• Event Management
• Incident Management
• Request Fulfillment Management
• Access Management
• Problem Management

 Processi tipici della gestione di eccezioni, errori, problemi ( non intesi in senso stretto ). Un processo la cui correlazione è molto forte con il Service Transition.

Continual service improvement
L'anello più esterno che ha il preciso scopo di gestire l'evoluzione, l'anello che consente di comprendere dove siamo e dove ci piacerebbe arrivare.


Molti di questi processi sono noti, quasi sicuramente il più noto di tutti è il Change Management, credo che in ogni realtà ci sia un processo simile. Ammetto che la prima volta in cui mi sono imbattutto in questo elenco la mia prima reazione è stato quasti di terrore ( ma devo imparare tutto questo ?? ) per poi scoprire che molti di questi termini erano già nel mio bagaglio senza tuttavia esserne a piena conoscenza.

Attori 
I due attori principali di ITIL sono sicuramente il Client e il Vendor, il primo rappresente chi gode e chi paga il servizo che il Vendor offre.

Il Client di contro è colui che a sua volta produce ( tramite il servizio ) il Valore, potrebbe anche essere che non sia il Client a utilizzare il servizio, ma un terzo attore comunemente chiamato User.

Il Service Strategy studia, il Service Design realizza, cio che il Client chiede. Nello specifico il Service Strategy non studia nel dettaglio quel particolare Client ma la generica richiesta di mercato, e il Service Design che si focalizza maggiormente sull'esigenza del cliente specifico.

Processo
Il processo per ITIL è un insieme di funzioni composti di differenti attività. 
Ma come sempre un esempio "chiaro" vale più di mille parole.

Il Service Operation è composto da differenti processi, ma anche da 4 funzioni specifiche quali:

• Service Desk
• Technical Management
• IT Operation Management
• Application Management

Service Desk o come molti lo chiamano Help Desk anche se in realtà non si tratta della stessa cosa.
Technical Management tipicamente riferito ad un supporto di natura tecnologico
IT Operation Management gestione del servizio direzione della operazione monitoraggio SLA
Application Management gestione dell'evolutive e correttive prevenute dal Change.

How To:SQLite create DB.

Sulla falsa riga del precedente post, ecco che vi allego una breve brano di codice per la creazione di db SQLite.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Data.SQLite;

namespace SqlLiteTest.CreateDB
{
    class Program
    {
        static void Main(string[] args)
        {
            SQLiteDBHelpers sdH = new SQLiteDBHelpers("DBTest", @"\Data");
            sdH.CreateDBFile();

        }
    }


    public class SQLiteDBHelpers
    {
        private string _fName;
        private string _fPath;

        public SQLiteDBHelpers(string fName, string fPath)
        {
            _fName = fName;
            _fPath = fPath;
        }

        public void CreateDBFile()
        {
            VerifyPath(_fPath);

            if (!CheckName(Path.Combine( _fPath,_fName)))
            {
                SQLiteConnection.CreateFile(Path.Combine(_fPath, _fName) + ".sqlite");

                System.Data.SQLite.SQLiteConnection sc = 
                            new SQLiteConnection("DATA SOURCE ="+
                            Path.Combine(_fName, _fPath)+ ".sqlite;Version=3");

                sc.Open();

                string sqlMaster = "create table master "+ 
                        "(id int, tName varchar(40),tCreation datetime)";


                SQLiteCommand command = new SQLiteCommand(sqlMaster, sc);
                command.ExecuteNonQuery();

                sc.Close();
            }            
        }


        private void VerifyPath(string Path)
        {
            if (!Directory.Exists(Path))
            {
                Directory.CreateDirectory(Path);
            }
        }

        private bool CheckName(string Name)
        {
            return File.Exists(Name);
        }

    }
}

Poca roba, ma comunque utile.

How To :Read FireFox Cookies

E' dura da ammettere ma nell un ottica "del grande tutto" siamo tracciatati e guradati fin nell'intimo..

Mi Nonno l'ha detto fin da quando ha capito che cosa era interent ( e non ha mai fatto in tempo ad usarlo ) "chell'internet lì a l'è un meste undue tutch san quel che te fè"
trad ( dal milanese ) internet è un qualcosa dove tutti sanno quello che fai

Morale da buon curioso mi sono domandato come verificare ( ad esempio su FireFox ) quanti e quali Cookies ho.

Per prima cosa scopro che utilizza sqlLite, per cui il primo step se non lo avete e quello di scaricavi le librerie per la gestione di sqlLite che trovate a questo link:

http://system.data.sqlite.org/index.html/doc/trunk/www/downloads.wiki

Dopo il setup si può partire con: New Windows Application ( X86 se avete scaricato slq lite 32 bit )

Aggiungente un bottone o un menu,
Aggiungete una DataGrid...

E poi "Copia e Incolla... "

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SQLite;
using System.IO;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Web;
using System.Net;

namespace CookiesReader
{
    public partial class frmMain : Form
    {

       
        private DataTable dt = null;
        

        public frmMain()
        {
            InitializeComponent();
        }

        private void mnuRead_Click(object sender, EventArgs e)
        {

            GetFireFoxCookie(getFireFoxDBLite());

            if (dt != null)
            {
                dvgDetails.DataSource = dt;
            }

        }

        private void GetFireFoxCookie(string source)
        {
            if (source == "") { return; }

            using (var conn = new SQLiteConnection("Data Source=" + source))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "select * from moz_cookies order by baseDomain";

                    dt = new DataTable();
                    SQLiteDataAdapter sda = new SQLiteDataAdapter(cmd);

                    conn.Open();
                    sda.Fill(dt);
                }
            }
        }


        private string getFireFoxDBLite()
        {
            string x = Environment.GetFolderPath(
                 Environment.SpecialFolder.ApplicationData);

            x += @"\Mozilla\Firefox\Profiles\";

            DirectoryInfo di = new DirectoryInfo(x);
            DirectoryInfo[] dir = di.GetDirectories("*.default");

            if (dir.Length != 1) { return ""; }

            x += dir[0].Name + @"\" + "cookies.sqlite";

            if (!File.Exists(x)) { return ""; }

            return x;
        }
    }
}

Quindi unbel run .. e mani nei capelli !!

How To: Implement Chain of Responsibility

Questo pattern.. è bellissimo, peccato che nonostante la sua alta usabilità sia considerato e amato poco.

Concettualmente ad una classe è associato il suo successore o in breve chi gestirà il dato o i dati dopo di lui, in questo modo se la classe A non sa ( e non che non può ) gestire e di contro lo demanda a B..
e via così.

Verosimilmente è raro che venga implementato... anche perchè in molti casi risolve parecchie beghe.

Una mia supposizione è che volendo si possa implementare un buon ragionamento su come gestire i Successori.

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

namespace TestChain
{
    class Program
    {
        static void Main(string[] args)
        {
            // Setup Chain of Responsibility

            idealWorker w1 = new Worker();

            idealWorker w2 = new CheafofWorker();

            idealWorker w3 = new SomeONE();

            w1.SetNext(w2);

            w2.SetNext(w3);


            for (int i = 0; i < 40; i++)
            {
                w1.IDoMyWork(i);
            }

            Console.ReadLine();

        }
    }

    public abstract class idealWorker
    {
        protected idealWorker successor;

        public void SetNext(idealWorker bw)
        {
            successor = bw;
        }

        public abstract void IDoMyWork(int Range);
    }

    public class Worker : idealWorker
    {

        public override void IDoMyWork(int Range)
        {
            if ((Range > 0) &&  (Range < 10))
            {
                Console.WriteLine("I'M a Worker and I'll work for :" +
                        Range.ToString());
            }
            else
            {
                if (successor != null)
                successor.IDoMyWork(Range);
            }
        }
    }

    public class CheafofWorker : idealWorker
    {

        public override void IDoMyWork(int Range)
        {
            if ((Range >= 10) && (Range < 20))
            {
                Console.WriteLine("I'M a Cheaf and I'll work for :" + 
                         Range.ToString());
            }
            else
            {
                if (successor != null)
                successor.IDoMyWork(Range);
            }
        }
    }

    public class SomeONE : idealWorker
    {

        public override void IDoMyWork(int Range)
        {
            if ((Range >= 20))
            {
                Console.WriteLine("I'M NoOne... ");
            }
            else
            {
                if (successor != null)
                successor.IDoMyWork(Range);
            }
        }
    }
}

Ed ecco il codice.. facile facile, con un filo di ironia.

tutto nasce da idealWorker ( che di contro non fa nulla demanda ) ai suoi successori... magari domani tiro fuori un esempio più edificante.

How To: Lamba on String

E' bello fare certe scoperte... ( SOLO DOPO ) !

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

namespace LambdaString
{
    class Program
    {
        static void Main(string[] args)
        {
            string Test1 = "questo è uno splendido testo";
            var cTest1 = Test1.ToCharArray().Where(c => c == 'n');
            Console.WriteLine(cTest1.Count());

           
        }
    }
}

E ammetto che ci ho pure provato gusto !
Quello che mi fa sorridere e il non averci mai pensato eppure è li bello ovvio come il sole !

Le stringhe sono array e come tali sono riconducibili ad un Querable Object.. e via .. 

How To: JSon To XML C#

Ho notato che nella maggio parte dei casi per trasformare JSon in un qualcosa di fruibile si ricorre a librerie esterne.
Ammetto la cosa è comoda, ma si ha poca elasticità, sono all'antica, se qualcosa mi serve, la studio e la implemento ( il tutto dipende sempre dai costi e dai tempi ) e aggiungerei anche che programmando sempre meno, ho sempre meno bisogno di inventarmi qualcosa.

MA LA MENTE VA ALLENATA SEMPRE... quindi avendo tempo e avendo la possibilità ritengo sempre un buon esercizio sprecare un po' del prezioso tempo in un implementazione.

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

namespace Json.Test
{

    class Program
    {
        static void Main(string[] args)
        {
            string json = "{\"name\":\"Fabio\";\"surname\":\"Arosio\";" +
                            "\"age\":\"39\";\"friends\":{\"name\":\"Lorenzo\";" +
                            "\"name\":\"Federico\"};\"date\":\"19740226\"}";

            jHelper jH = new jHelper(json);


            Console.WriteLine(jH.XData);

            Console.ReadLine();
        }
    }

    public class jHelper
    {
        private string _data;
        private string _xdata;

        public string Data
        {
            get {return _data;}
            set
            {
                _data = value.Trim();
                _data = _data.TrimStart('{');
                _data = _data.TrimEnd('}');
                _data = _data.Replace("\"", "");
            }
        }

        public string XData
        {
            get { return _xdata; }
        }

        public jHelper (string data)
        {
           
            Data = data;
   
            
            _xdata+="<?xml version=\"1.0\">"; 

            Parse();


            
           
        }


        private void Parse()
        {
            bool allDone = false;

            string iData = _data;

            while (! allDone )
            {
                string cData ="";
                if (iData.IndexOf(";") > 0)
                {
                    cData = iData.Substring(0, iData.IndexOf(";"));
                }
                else
                {
                    cData = iData;
                }
                string pName ="";
                string pValue = "";

                if (!cData.Contains("{"))
                {
                    pName = cData.Split(':')[0];
                    pValue = cData.Split(':')[1];
                    AddData(pName, pValue);
                }
                else
                {
                    cData = iData.Substring(0, iData.LastIndexOf("}")+1);
                    pName = cData.Split(':')[0];

                    jHelper jx = new jHelper(cData.Substring(pName.Length+1));

                    pValue = jx.XData.Replace("<?xml version=\"1.0\">", "");

                    jx = null;
                    AddData(pName, pValue);
                }

                iData = iData.Substring(iData.IndexOf(";") + 1);              
                if (iData.IndexOf(";") == -1) { allDone = true; };
            }

            if (iData.Length > 0)
            {
                AddData(iData.Split(':')[0], iData.Split(':')[1]);            
            }

        }

        private void AddData(string name, string value)
        {
            _xdata += "<" + name + ">" + value + "</" + name + ">\r\n";
        }
    }
}

Posto che quanto realizzato si tratti di un esempio e del tutto causale, ho provato a giocare con un json non proprio base base.
Mi sono concesso di nidificargli un figlio complesso anche se non eccessivamente.

Morale ottengo il mio XML, che di contro è più semplice da manipolare e quanto meno è più vicino a C# ( e al framework ) di quanto non lo sia Json.

How To: Linq IN clause syntax

Ed eccomi qui con la scoperta della settimana.
Mi sono arrovellato, senza troppa congizione di causa su come si potesse implementare una IN con Linq, ammetto di aver avuto l'aiuto dal pubblico, ma la soluzione era "facile, Facile" del resto Microsoft ci ha ben abituato a lavorare al contrario no ?

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

namespace Linq.InWorkaround
{
    class Program
    {
        static void Main(string[] args)
        {
            // Esempio di IN
            List<string> ents = new List<string>();
            ents.Add("Fabio Arosio");
            ents.Add("Lorenzo Arosio");
            ents.Add("Federico Arosio");
            ents.Add("Claudio Eridani");

            // creo quanto ricercare .. 
            List<string> pattern = new List<string>();
            pattern.Add("Fabio Arosio");
            pattern.Add("Claudio Eridani");


            Console.WriteLine("Esempio di IN");
            // basta utilizzare la contains al contrario
            var r = ents.Where(e => pattern.Contains(e));

            foreach (string s in r)
            {
                Console.WriteLine(s);
            }
            Console.ReadKey();

            Console.WriteLine("\n\rEsempio di Like");
            // Questa è la Like
            var r1 = ents.Where(e => e.Contains("Arosio"));

            foreach (string s in r1)
            {
                Console.WriteLine(s);
            }

            Console.ReadKey();
        }
    }
}

Bene non è difficile il tutto si basa sul "chi contiene cosa" generalmente quando in SQL utilizziamo la IN è per identificare una serie di valori per il cui il nostro campo può variare, con LINQ la situazione è inversa dato che la sintassi vera e propria non esiste. Quindi creiamo un set, e chiediamo se il campo è contenuto in quel range.

Easter Eggs:WIN7 ( PSR )

Questo è decisamente "amarcord".... e vediamo se capite perchè...


Posizionatevi su start... e cercate psr


otterrete:

Bene, ora un doppio click su psr.exe...

Ma che bello ... ma cosa fa ?

Tecnicamente non rigistra le macro anche se l'interfaccia lo ricorda molto, ma crea in realtà un archivio Zip contenente un file Mht con tutto quello che avete eseguito.

Tecnicamente serve per riportare gli errori.

Ma con un briciolo di fantasia consente davvero molto di più !

Easter Eggs:WIN7 ( GOD MODE )

Ciao a tutti apro questa nuova sezione dedicata agli Easter Eggs di Windows 7

Questo è particolarmente carino e ricodra molto un Cheat di Quake ...

1) posizionatevi sul vostro Desktop
2) tasto destro "Create New folder"
3) rinomina : GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

Otterrete una cartella con parecchie shortcut...
Provare per credere.

How To: Sum of nullable int

Ma come si comporta linq quando somma un campo che può contenere null ?

Già mi sono posto questa domanda perchè non mi è mai capitato di beccare un errore simile, posto che il compilatore blocchi int i = null mi rimane solo qualche piccola pillola per ovviare a eventuali problemi provenienti da codice scritto male.

Ma linq mi ha data prova di essere abbastanza solido... quanto meno in questo semplice esempio.

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

namespace TestSumLinq
{
    class Program
    {
        public class entity
        {
            public int fstValue { get; set; }
            public int? sndValue { get; set; } 
        }

        static void Main(string[] args)
        {
            List<entity> l = new List<entity>();

            l.Add(new entity() { fstValue = 0, sndValue= null});
            l.Add(new entity() { fstValue = 1, sndValue = 2 });
            l.Add(new entity() { fstValue = 2, sndValue = 3 });
            l.Add(new entity() { fstValue = 3, sndValue = 4 });

            // facendo le somme ottengo ?? 

            var r1 = l.Sum(s => s.fstValue);

            var r2 = l.Sum(s => s.sndValue);

            Console.WriteLine("somma campo int : " + r1.ToString());

            Console.WriteLine("somma campo int?: " + r2.ToString());

            Console.ReadKey();
        }
    }
} 

E in bona sostanza rimango piacevolmente colpito .. perchè funziona senza rompersi.

How To: Export report in 2 Excel Sheet.

Diciamo che ci sono vari modi per assolvere a questo how to.. ma questo è davvero il più semplice,
e il più veloce ( probabilmente il meno elegante ).

Partiamo da una Window Application con Visual Studio 9.

Se avete già un db comodo ( come nel mio caso ) utilizzatelo giusto per fare una prova.
Sempre nel mio caso ho un db di test che contiene il mio prototipo di entità.

Createvi quindi un nuovo report di microsoft, potete gasarvi un po' anche se non lascia molto spazio alla fantasia.

Vi ricordo che i campi si selezionano da dataset e si drag'n droppano dalla tool box del data source.

Nello specifico la proprietà da settare PageBreakAtStart.

Che cosa succederà ?

La cosa è molto semplice non appena la Tabella sarà piena alla riga zero ( header ) si verificherà un salto pagina. In questo modo otterremo:

Ed ecco che abbiamo il nostro report !

How To: Create a multy Layer Method

Giusto per mettere qualche puntino sulle I anche se i per questa volta non è il prefisso di interfaccia.

In molti casi, a volte in troppi, non è difficile imbattersi in codice scritto davvero male. Le cause, sono sempre le stesse ma riassumibili in un unica parola "premura".

Vi posto un esempio banale banale di come scrivere due righette di codice fatte bene, e di contro leggibili .

Come sempre si tratta di un esempio ben poco edificante, ma quanto meno chiaro.

Si tratta di un metodo spalmato su più livelli, e con questo che cosa si intende? che fra il chiamante e il reale esecutore del metodo c'e' almeno un secondo attore.

Questa situazione consente molteplici considerazione e attività ma non è questo il post in cui parlarne.

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

namespace TestLayer
{
    class Program
    {
        static void Main(string[] args)
        {
            EntryPoint ep = new EntryPoint();

            Console.WriteLine(ep.GetData("demo"));

            Console.ReadLine();
        }
    }

    class EntryPoint
    {
        EntryPointLogger epl = new EntryPointLogger();
        EntryPointRealMethod eprm = new EntryPointRealMethod();

        public string GetData(string inputValue)
        {
            string outputValue = "";
            try
            {
                epl.DoWriteLog("Open", 1);
                epl.DoWriteLog("Execute start", 2);
                eprm.GetData(inputValue);
                epl.DoWriteLog("Execute end", 2);
            }
            catch (Exception ex)
            {
                epl.DoWriteLog("Error", 2);
                epl.DoWriteLog("ex:" + ex.Message.ToString(), 2);
            }
            finally
            {
                epl.DoWriteLog("Close", 1);
                eprm = null;
            }
            return outputValue;
        }
    }

    class EntryPointRealMethod
    {
        public string GetData(string value)
        {
            if (value == "HelloWord")
            {
                return "nice try";
            }
            return "*" + value + "*";
        }
    }

    class EntryPointLogger
    {
        public void DoWriteLog(string message, int level)
        {
            if (level == 1)
            {
                Console.WriteLine("Trace:" + message);
                return;
            }
            if (level == 2)
            {
                Console.WriteLine("External:" + message);
                return;
            }
            Console.WriteLine("Error:" + message);
        }
    }

Non è difficile notare che tutta la tracciatura dell'errore e in un unico punto e tutto quello che avverà nel sottostante sarà gestito esclusivamente in quell'unico punto.

In più sfruttando un salto posso cambiare la logica di RealMethod senza cambiare il resto, in più se ho fatto le cose "per bene" posso loggare sempre in un solo punto ...

Tanti vantaggi come un codice leggibile, un codice manutenibile...

How to: DataGridView to Excel

Sfatiamo subito un mito da DataGridView a Excel 2007 non si può fare utilizzando un metodo semplice facile e veloce. L'unica è agire tramite la creazione di un oggetto.

Questo perchè ? Excel.xslx non è in realtà un file ma un insieme di file il che comporta una serie di difficoltà.

Tuttavia è possibile effettuare una conversione diretta o quasi da DataGridView a Excel 97-2003.

Di metodi ce ne sono davvero tanti e tutti più o meno equivalenti.

Quello che vi propongo è più o meno semplice.

Vi serve specificare lo schema :
<
html xmlns:v="urn:schemas-microsoft-com:vml"
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:x="urn:schemas-microsoft-com:office:excel"
xmlns="http://www.w3.org/TR/REC-html40"
>

Vi serve specifica nel tag head
<%
    Response.ContentType = "application/vnd.ms-excel";
    Response.Cache.SetCacheability(HttpCacheability.NoCache);
    Response.AddHeader("Content-Disposition", "inline;filename=File.xls");
%>


Dove file.xls è il nome del vostro file... 

Fatto questo potete pure sbizzarrirvi con i fogli di stile stando però attenti a speficare ad esempio :

     .tableEx
        {
            border: 1px solid #c0504d;
        }       
        .thEx
        {           
            background:#1f497d;          
            color: white;
            font-family: Tahoma,verdana,arial;
            font-size: 11px;
            line-height: 30px;
            border: 1px solid #1f497d !important;
        }
        .tdEx
        {         
            color: black;
            font-family: Tahoma,verdana,arial;
            font-size: 11px;
            border: 1px solid #c0504d;
        }       

HeaderStyle-CssClass="thEx" ItemStyle-CssClass="tdEx"

Come questi debbano lavorare con la tabella. Basta un nulla che il tutto si compromette.

How To: Gridview multiline Cell

Leggendo su internet ho trovato davvero di tutto e di più...

I migliori ...
a) "mettere una item column template con una textarea e un div che la wrappa...usando css3"
b) "come il punto a ma con jquery al posto css3"
c) Creare un controllo custom che si auto "alza" in base al numero di righe presenti...

MAMMA MIA.
Una volta che avete progettato la vostra gridview, una volta che avete stabilito il DataSource, rimane davvero poco da fare.

Esiste un evento semplice semplice RowDataBound che si scatena quando il controllo renderizza se stesso... da dato a HTML.

Perchè non provare ...

protected void gwMain_RowDataBound(object sender, GridViewRowEventArgs e)
{
      e.Row.Cells[3].Text = e.Row.Cells[3].Text.Replace("\n", "
");
}

Fatto così ... e funziona, senza troppi ( in questo caso inutili ) fronzoli.

How To: Implement Dynamic Data Provider

Dopo aver scopert dynamic.. non mi sono più fermato ( ammetto di essermi complicato la vita ) ma il risultato è molto piacevole.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DynamicDataProvider;


namespace DynamicDataProvider.Test
{
    class Program
    {
        static void Main(string[] args)
        {
          
            Entities.contactType ct = new Entities.contactType();
            ct.id = 1;
            ct.Name = "Default";
            ct.Description = "";


            DynamicDataProvider.DataProvider dp = new DataProvider("contactType");

            dp.Insert(ct);

            Entities.contact c = new Entities.contact();
            c.id = 1;
            c.Name = "Fabio";
            c.Surname = "Arosio";
            c.Since = new DateTime(1974, 2, 26);
            c.Contact_Type = ct;

            dp = new DataProvider("contact");

            dp.Insert(c);
           
        }
    }
}

Che cosa si nasconde dietro questo breve listato?
Tanto codice ma riutilizzabile all 100%
il tutto parte da questa semplice ma potente interfaccia

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

namespace DynamicDataProvider.Commons
{
    public interface IDataProvider
    {
        void Insert(dynamic item);
        void Edit(dynamic item);
        void Delete(dynamic item);
        dynamic Select();
    }
}

il cui ruolo è ... non posso svelarvi tutto subito, è necessario leggere tutto il post.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DynamicDataProvider.Commons;
using DynamicDataProvider.XMLcontext;

namespace DynamicDataProvider
{
    public class DataProvider:IDataProvider
    {

        IDataProvider current = null;

        public DataProvider(string t)
        {
            current = new contextDataProvider(t);
        }
       
        public void Insert(dynamic item)
        {
            current.Insert(item);
        }

        public void Edit(dynamic item)
        {
            current.Edit(item);
        }

        public void Delete(dynamic item)
        {
            current.Delete(item);
        }

        public dynamic Select()
        {
            return current.Select();
        }

        
    }
}

Questo è il mio dataProvider, che implementa l'interfaccia, diciamo che in tutto il progetto l'interfaccia è molto molto diffusa, sia per implementare il pattern del proxy, sia per implementare in modo omogeneo tutta la struttura.


Queste le mie entià con relative collezioni

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

namespace DynamicDataProvider.Entities
{
    public class contact
    {
        public int id { get; set; }
        public string Name { get; set; }
        public string Surname { get; set; }
        public DateTime Since { get; set; }
        public contactType Contact_Type { get; set; }
    }

    public class contacts : List<contact>
    { 
    
    }
}

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

namespace DynamicDataProvider.Entities
{
    public class contactType
    {
        public int id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
    }

    public class contactTypes :List<contactType>
    {
    }

}

Ed ora la parte più complessa... il dataContext...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DynamicDataProvider;
using DynamicDataProvider.Commons;
using DynamicDataProvider.Entities;
using DynamicDataProvider.XMLcontext.Utils;

namespace DynamicDataProvider.XMLcontext
{
    public class contextDataProvider : IDataProvider
    {
        #region Contacts
        class contactsDP :IDataProvider
        {
            private string fName = @"\Contacts.xml";
            public contacts Contacts { get; set; }

            public contactsDP()
            {
                if (Contacts == null) { Contacts = new contacts(); }                        
            }


            public void Insert(dynamic item)
            {
                Contacts.Add(item);

                XmlHelpers.Serialize<contacts>(fName, Contacts);
            }

            public void Edit(dynamic item)
            {
                for (int i = 0; i < Contacts.Count; i++)
                {
                    if (Contacts[i].id == item.id)
                    {
                        Contacts[i] = item;
                        break;
                    }
                }

                XmlHelpers.Serialize<contacts>(fName, Contacts);
            }

            public void Delete(dynamic item)
            {
                for (int i = 0; i < Contacts.Count; i++)
                {
                    if (Contacts[i].id == item.id)
                    {
                        Contacts.RemoveAt(i);
                        break;
                    }
                }

                XmlHelpers.Serialize<contacts>(fName, Contacts);
            }

            public dynamic Select()
            {
                return XmlHelpers.Deserialize<contacts>(fName);
            }
        }
        #endregion 

        #region ContactsType
        class contactTypesDP : IDataProvider
        {
            private string fName = @"\ContactsType.xml";
            public contactTypes ContactTypes { get; set; }

            public contactTypesDP()
            {
                if (ContactTypes == null) { ContactTypes = new contactTypes(); }            
            }


            public void Insert(dynamic item)
            {
                ContactTypes.Add(item);

                XmlHelpers.Serialize<contactTypes>(fName, ContactTypes);
            }

            public void Edit(dynamic item)
            {
                for (int i = 0; i < ContactTypes.Count; i++)
                {
                    if (ContactTypes[i].id == item.id)
                    {
                        ContactTypes[i] = item;
                        break;
                    }
                }

                XmlHelpers.Serialize<contactTypes>(fName, ContactTypes);
            }

            public void Delete(dynamic item)
            {
                for (int i = 0; i < ContactTypes.Count; i++)
                {
                    if (ContactTypes[i].id == item.id)
                    {
                        ContactTypes.RemoveAt(i);
                        break;
                    }
                }

                XmlHelpers.Serialize<contactTypes>(fName, ContactTypes);
            }

            public dynamic Select()
            {
                return XmlHelpers.Deserialize<contactTypes>(fName);
            }
        }
        #endregion 


        IDataProvider cur = null;

        public contextDataProvider(string t)
        {
            if (t == "contact")
            { 
                cur = new contactsDP();
            }
            if (t =="contactType")
            {
                cur = new contactTypesDP();
            }

        }



        #region IDataProvider Members

        public void Insert(dynamic item)
        {
            cur.Insert(item);
        }

        public void Edit(dynamic item)
        {
            cur.Edit(item);
        }

        public void Delete(dynamic item)
        {
            cur.Delete(item);
        }

        public dynamic Select()
        {
            return cur.Select();
        }

        #endregion
    }
}

In breve la soluzione ha il seguente aspetto.

Devo essere onesto il codice scritto non è tanto, ma il fatto di essere riuscito a disaccoppiare i dati da chi li gestisce, dal tipo e da chi li chiama... è davvero forte
Mi ha dato una certa soddisfazione arrivare a questo piccolo risultato, e ammetto che probabilmente si più limare ancora qualcosa.
Una nota, nella cartella utils trovate la mia solita utility di serializzazione e deserializzazione. Come sempre buon divertimento