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

E poi venne DYNAMIC

Lo so lo so sono un pazzo furioso, ammetto tutte le mie colpe ma credo davvero che mi sia spalancata la porta del sapere.
Questa mattina mi stavo arrovellando il cervello su come gestire una connettività fra classi in modo che si attivino come un Cromatoforo di un polpo.
Per chi non conoscesse l'argomento il cromatoforo, è un cellula della pelle di un polpo o di una seppia, che consente se stimolata di modificare il suo stato. La "vera fissa" di questa entità e che lavora in gruppo.
Di contro se questo fosse ralizzabile in ambito "software" sarebbe davvero qualcosa di unico.. immaginate classi di calcolo che lavorano all'unisono solo se sono sollecitate o classi di calcolo che sanno che sollecitare per lavorare... Mi vengono in mente mille soluzioni, e mille ipotesi. Ma per il momento mi godo questo momento e non penso ad altro.
(non è vero sto renderizzando ... )

Dynamic è qualcosa di "astratto" ma concreto non saprei dare una definizione, non è generic, benchè sia generico ha il vantaggio di non dover ( farti ) implementare invocatori di metodi con reflection.

Ma non attendo altro .. questo è il mio esempio.. VS2010 framework 4

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

namespace Dynamic
{
    class Program
    {
        static void Main(string[] args)
        {

            DynamicDataProvider d0 = new DynamicDataProvider(0);
            entities et0 = d0.GetEntities();

            Console.WriteLine("Real Data provider");
            for (int i = 0; i < et0.Count(); i++)
            {
                Console.WriteLine(et0[i].id + "\t" + et0[i].name);
            }

            DynamicDataProvider d1 = new DynamicDataProvider(1);
            entities et1 = d1.GetEntities();

            Console.WriteLine("Mock Data provider");
            for (int i = 0; i < et1.Count(); i++)
            {
                Console.WriteLine(et1[i].id + "\t" + et1[i].name);
            }


            Console.WriteLine("Dynamc Real Data provider");
            dynamic dd = new DynamicDataProvider(0);
            var etn = dd.GetEntities();
            
            foreach (dynamic e in etn)
            {
                Console.WriteLine(e.id + "\t" + e.name);
            }


            Console.WriteLine("Dynamc fake Data provider");
            dynamic dd1 = new DynamicDataProvider(3);
            var etn1 = dd1.GetEntities();

            foreach (dynamic e in etn1)
            {
                Console.WriteLine(e.id + "\t" + e.name);
            }


            Console.ReadLine();

        }
    }

    public class entity
    {
        public int id { get; set; }
        public string name { get; set; }
        public string description { get; set; }
    }


    public class entityBis
    {
        public int id { get; set; }
        public string name { get; set; }
        public string value { get; set; }
    }

    public class entities : List<entity>
    {     
    }


    public class entitiesBis : List<entityBis>
    {
    }


    public class DynamicDataProvider
    {
        int retType = 0;

        public DynamicDataProvider(int cType)
        {
            retType = cType;
        }

        public dynamic GetEntities()
        {
            if (retType == 0)
            {
                return new realDataProvider().fillEntites();
            }
            if ( retType == 1)
            {
                return new mockDataProvider().fillEntites();
            }

            return new fakeDataProvider().fillEntites();
        }

    }

    public class realDataProvider
    {
        public entities fillEntites()
        {
            entities entx = new entities();
            entx.Add(new entity() { id = 1, 
                                    name = "default", 
                                    description = "" });
            entx.Add(new entity() { id = 2, 
                                    name = "one", 
                                    description = "" });
            entx.Add(new entity() { id = 3, 
                                    name = "many", 
                                    description = "" });
            entx.Add(new entity() { id = 4, 
                                    name = "nome", 
                                    description = "" });


            return entx;
        }
    }

    public class fakeDataProvider
    {
        public entitiesBis fillEntites()
        {
            entitiesBis entx = new entitiesBis();
            entx.Add(new entityBis() { id = 1, 
                                       name = "default Bis", 
                                       value = "1" });
            entx.Add(new entityBis() { id = 2, 
                                       name = "one Bis", 
                                       value = "2" });
            entx.Add(new entityBis() { id = 3, 
                                       name = "many Bis", 
                                       value = "3" });
            entx.Add(new entityBis() { id = 4, 
                                       name = "nome Bis", 
                                       value = "4" });


            return entx;
        }
    }


    public class mockDataProvider
    {
        public entities fillEntites()
        {
            entities entx = new entities();
            entx.Add(new entity() { id = 1, 
                                    name = "mock", 
                                    description = "" });

            return entx;
        }
    }
}

L'unica è prendere questo codice e provarlo in una console application.. realDataProvider e fakeDataProvider propongono lo stesso metodo ma non lo stesso tipo e questo mi gasa particolarmente.
Non basta... le ultime due porzioni di codice del Main sono davvero "potentissime" stesso codice differente risultato su due tipi diversi.
Riesco a immaginare librerie che caricano dinamicamente i plugin certo bisogna stare attenti a come si scrive il codice ma le potenzialità sono davvero tante.

How To: Linq Sort / OrderBy

Facendo qualche esperimento mi sono reso conto che l'order by di Linq è meno scomodo di quanto si possa pensare.

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

namespace TestSort
{
    class Program
    {
        static void Main(string[] args)
        {
            entities es = new entities();
            es.Add(new entity() { id = 1, 
                                    name = "fabio", 
                                    description = "nice" });

            es.Add(new entity() { id = 2, 
                                    name = "lorenzo", 
                                    description = "very nice" });

            es.Add(new entity() { id = 2, 
                                    name = "federico", 
                                    description = "it will be" });


            var esx = es.OrderBy(c=> c.name);
            
        }
    }


    public class entity
    {
        public int id { get; set; }
        public string name { get; set; }
        public string description { get; set; }
    }

    public class entities : List<entity>
    { 
    
    }
}

Facile.. no ?