How to: Count all numeric row with "n" decimals

Sembra facile ma non è difficile...
come si possono contare tutte le righe di una tabella per cui un campo numerico ha un Dato numero di decimali.

Consideriamo di avere una tabella simile a questa:

ID	ContoDiCasa	Causale	Importo_con_decimali	Percentuali
1	Elettrodomestici	Televisione	2300,000	48,191
2	Assicurazioni	Macchina_A	1800,000	37,714
3	Spesa	supermercato	123,950	2,60
4	Benzina	Macchina_A	70,000	1,467
5	Elettrodomestici	Frullatore	120,000	2,55
6	Elettrodomestici	Bilancia	30,000	0,629
7	Benzina	Macchina_B	20,000	0,42
8	Assicurazioni	Casa	186,000	3,897
9	Giochi	Console	75,050	1,572
10	Giochi	Under18	47,720	1,00

Rappresenta in breve un ipotetico conto di casa, supponiamo di voler cercare tutte le occorrenze che hanno solo 2 posizioni decimali.

Select
      Percentuali,
      right(CONVERT(varchar,Percentuali),3) soloDec,
      CHARINDEX('.', right(CONVERT(varchar,Percentuali),3)) PosizionePunto,     
from
      mia_Tabella
where
      Percentuali >0
and
      CHARINDEX('.', right(CONVERT(varchar,Percentuali),3)) =2

Con questa prima query recuperiamo solo i dati di nostro interesse.

Select count (*) from
(
 Select
  Percentuali,
  right(CONVERT(varchar,Percentuali),3) soloDec,
  CHARINDEX('.', right(CONVERT(varchar,Percentuali),3)) PosizionePunto,     
 from
  mia_Tabella
 where
  Percentuali >0
 and
  CHARINDEX('.', right(CONVERT(varchar,Percentuali),3)) =2
)

Con questa seconda otteniamo il conteggio.

How To: Run Edit and Manage DTS on Win 7

Avevo trovato una guida per poter far questa attività, ma a quanto pare i link risultano essere vecchi e non più funzionanti.

Per cui ripropongo qui la nuova versione sperando di aver trovato dei link permanenti.

In molte realtà persistono e sono ancora in uso parecchi DTS (SQL 2000) che tuttavia non sono sempre consultabili tramite i nuovi sistemi operativi.
Non riuscite ad accedervi? Questa è una breve guida di come accedere al  DTS Designer / Runtime lavorando su SQL 2005/2008 Studio / R2 Management.

Diciamo che bisogna risalire a qualche vecchio pacchetto (per cui mi auguro che MS mantenga i link) e alla fine di questo tortuoso giro si dovrebbe essere in grado di operare sui DTS. Io ci sono riuscito ma è piuttosto intricato e verosimilmente bisogna fare qualche prova in più.


Questo è il link alla documentazione ufficiale per SQL 2000 DTS - SQL 2008 R2. Ci sono 2 tipi

1. Run-time support  (Execute DTS packages using dtsrun.exe)
2. Design-time support (Import, open & design DTS packages in SSMS)

Install Support for Data Transformation Services Packages

Potrebbe non essere strettamente utile ma una lettura dovrebbe quanto meno aiutare a comprendere meglio la situazione.

Si parte da qui !

A) Download dei componenti aggiuntivi
Il primo pacchetto da installare è :

Download SQLServer2005_DTS.msi
https://www.microsoft.com/en-us/download/details.aspx?id=24793
(se non dovesse funzionare il link vi consiglio di cercare "SQLServer2005_DTS.msi" su Google).

il secondo dipende dal fatto che il sistema operativo sia a 64bit
Download SQLServer2005_BC.msi >
X86 http://go.microsoft.com/fwlink/?LinkId=123702&clcid=0x409
X64 http://go.microsoft.com/fwlink/?LinkId=123703&clcid=0x409
(se non dovesse funzionare il link vi consiglio di cercare il nome del pacchetto su Google).

B) Installazione dei componenti aggiuntivi
Installare entrambi i pacchetti stesso nell'ordine di presentazione prima ( SQLServer2005_DTS.msi, poi SQLServer2005_BC.msi).
Al termine dovreste trovare nei seguenti percorsi le DLL:
C:\Program Files (x86)\Microsoft SQL Server\80\Tools\Binn\

Oppure potete trovarli qui:
C:\Program Files\Microsoft SQL Server\80\Tools\Binn\

* binn è proprio con "2 N".

C) Impostare il path
Altro punto da non dimenticare, saltando questo verosimilmente il processo non funzionerà, per cui:

E' necessario settare il percorso in cui è stata effettuata l'installazione e in cui avete trovato la cartella Tools\BINN


A questo punto è necessario effettuare una copia a mano

32-bit (x86)
a. Copiare i files:
SEMSFC.DLL,
SQLGUI.DLL,
SQLSVC.DLL,
DA %ProgramFiles%\Microsoft SQL Server\80\Tools\Binn
A %ProgramFiles%\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\ folder

b. Copiare i files:
SEMSFC.RLL,
SQLGUI.RLL,
SQLSVC.RLL,
DA  %ProgramFiles%\Microsoft SQL Server\80\Tools\Binn\Resources\
A %ProgramFiles%\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\Resources\1033\

(1033) rappresenta la lingua del pacchetto di installazione (dovrebbe esserci una sola cartella)



64-bit (x64)
a. Copiare i files:
SEMSFC.DLL,
SQLGUI.DLL,
SQLSVC.DLL,
DA %ProgramFiles(x86)%\Microsoft SQL Server\80\Tools\Binn
A %ProgramFiles%\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\ folder

b. Copiare i files:
SEMSFC.RLL,
SQLGUI.RLL,
SQLSVC.RLL,
DA %ProgramFiles(x86)%\Microsoft SQL Server\80\Tools\Binn\Resources\
A %ProgramFiles(x86)%\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\Resources\1033\
 
(1033) rappresenta la lingua del pacchetto di installazione (dovrebbe esserci una sola cartella)

Generalmente:
%ProgramFiles(x86)% –> C:\Program Files (x86)\
%ProgramFiles% –> C:\Program Files\

Riavviare...

E se non ci sono stati problemi, tutto dovrebbe funzionare.

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...