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