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.