C# Light

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

2017-09-13T00:59:00.000-07:00

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

2017-03-01T00:24:00.001-08:00

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

Run-time support (Execute DTS packages using dtsrun.exe)
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

2013-11-07T07:37:00.000-08:00

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

2013-11-05T07:44:00.001-08:00

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.

2013-11-04T09:42:00.001-08:00

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

2013-10-24T08:08:00.000-07:00

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

2013-10-23T09:16:00.000-07:00

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

2013-10-14T08:49:00.002-07:00

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#

2013-10-10T07:34:00.001-07:00

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

2013-10-09T00:56:00.001-07:00

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 )

2013-09-27T01:07:00.002-07:00

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 )

2013-09-26T07:48:00.001-07:00

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

2013-09-25T06:37:00.000-07:00

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.

2013-09-09T01:53:00.001-07:00

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

2013-08-09T03:39:00.001-07:00

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

2013-07-23T05:46:00.001-07:00

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

2013-06-27T07:47:00.001-07:00

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

2013-06-14T04:16:00.000-07:00

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

2013-06-11T03:25:00.000-07:00

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

2013-06-10T03:55:00.001-07:00

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 ?

How to: C# Lazy ( Side effect )

2013-05-31T02:45:00.001-07:00

Recentemente mi sono confrontato con un cordiale discorso di performance.

La maggior parte delle nostre applicazione vive l'ansia di dover caricare dei dati, e a dispetto delle mille possibilità (leggasi "entity framework" ) non sempre possiamo rivolgerci ad estrattori specifici, o di contro questi sono rappresentati da elementi che wrappano i vare ef.

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

namespace LazyTester
{
    public class entity
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string Surname { get; set; }    
    }

    public class entites : List<entity>
    {
        public entites()
        {
            this.Add( new entity(){
                    ID=1,
                    Name = "Fabio",
                    Surname ="Arosio"});

            this.Add( new entity(){
                    ID=2,
                    Name = "Claudio",
                    Surname ="Arosio"});
            
            this.Add( new entity(){
                    ID=3,
                    Name = "Lorenzo",
                    Surname ="Arosio"});
            
            this.Add( new entity(){
                    ID=4,
                    Name = "Federico",
                    Surname ="Arosio"});
            
            Console.WriteLine("done");
        }    
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Lazy...");
            Lazy<entites> ldsE = new Lazy<entites>();
                       

            Console.WriteLine("Normal...");
            entites dsE = new entites();
          
            Console.WriteLine("Normal:"+ dsE.Count.ToString());

            Console.WriteLine("Lazy:" + ldsE.Value.Count.ToString());

            Console.ReadLine();
        }
    }
}

Questo esempietto anche se molto molto scarno presenta il vantaggio di un costruttore Lazy.

già nel nome ben si comprende che cosa farà ma in breve possiamo ipotizzare che quanto costruito come lazy non sarà disponibile fin da subito.
Tanto che la "done" sulla console appare appena prima di della WriteLine Lazy.

Supponiamo giusto per dare visibiltà della situazione che il caricamento differito dei dati avrà luogo solo quando questi saranno necessari e di contro questo "sposta il tempo d'accesso" solo e soltanto a quando questi servono davvero.

var ldsEE = new Lazy<entites>().Value.Where (c=> c.Name.StartsWith("F"));

Ci è lecito pensare e implementare anche in questo modo .. ma perdendone qualche beneficio..

Sicuramente credo che sia sempre cosa buona e giusta sperimentare. !

How TO: C# internal WEB CAM r2

2013-05-30T06:18:00.001-07:00

La prima versione mi è piaciuta ma onestamente non mi ha soddisfatto, perchè il sorgente era strettamente legato al form, oggi con un filo di calma in più ( giocandomi la pausa ) sono riuscito a migliorare il tutto e il gioco sta nel come gestire le cose.

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

namespace CameraCapture.Objects
{
    public class HandledObject
    {
        public int width;
        public int height;
        public Size clientSize;
        public IntPtr handle; 
    }
}

Questo primo oggetto mi serve come tramite per la gestiione dell'Handle... quasi mi sembra di tornare ai fasti delle API a 32bit.

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

namespace CameraCapture.Objects
{
    public enum PlayState
    {
        Stopped,
        Paused,
        Running,
        Init
    }
}

Questo è rimasto invariato.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DirectShowLib;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;

namespace CameraCapture.Objects
{
    public class DirectShowWrapper
    {

        public int D = Convert.ToInt32("0X8000", 16);

        public int WM_GRAPHNOTIFY = 0;

        public IVideoWindow VideoWindow = null;
        public IMediaControl MediaControl = null;
        public IMediaEventEx MediaEventEx = null;
        public IGraphBuilder GraphBuilder = null;
        public ICaptureGraphBuilder2 CaptureGraphBuilder = null;

        public DsROTEntry rot = null;
        private PlayState CurrentState = PlayState.Stopped;

        public DirectShowWrapper()
        {
            WM_GRAPHNOTIFY = D + 1;
        }

        public void GetInterfaces(HandledObject f)
        {
            int hr = 0;
            this.GraphBuilder = (IGraphBuilder)(new FilterGraph());
            this.CaptureGraphBuilder = (ICaptureGraphBuilder2)(new CaptureGraphBuilder2());
            this.MediaControl = (IMediaControl)(this.GraphBuilder);
            this.VideoWindow = (IVideoWindow)(this.GraphBuilder);
            this.MediaEventEx = (IMediaEventEx)(this.GraphBuilder);
            hr = this.MediaEventEx.SetNotifyWindow(f.handle, 
                                    WM_GRAPHNOTIFY, 
                                    IntPtr.Zero);
        }

        public void CaptureVideo(HandledObject f)
        {
            int hr = 0;
            IBaseFilter sourceFilter = null;
            try
            {
                GetInterfaces(f);

                hr = this.CaptureGraphBuilder.SetFiltergraph(this.GraphBuilder);


                sourceFilter = FindCaptureDevice();

                hr = this.GraphBuilder.AddFilter(sourceFilter, "Video Capture");


                hr = this.CaptureGraphBuilder.RenderStream(PinCategory.Preview,
                        MediaType.Video,
                        sourceFilter,
                        null, null);

                Marshal.ReleaseComObject(sourceFilter);

                SetupVideoWindow(f);

                rot = new DsROTEntry(this.GraphBuilder);

                hr = this.MediaControl.Run();

                this.CurrentState = PlayState.Running;

            }
            catch (Exception ex)
            {

            }
        }

        public void SetupVideoWindow(HandledObject f)
        {
            int hr = 0;

            hr = VideoWindow.put_Owner(f.handle);


            hr = VideoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipChildren);

            ResizeVideoWindow(f);

            hr = VideoWindow.put_Visible(OABool.True);
        }

        public void closeinterfaces()
        {

            if (this.MediaControl != null)
            {
                this.MediaControl.StopWhenReady();
            }

            this.CurrentState = PlayState.Stopped;


            if (this.MediaEventEx != null)
            {
                this.MediaEventEx.SetNotifyWindow(IntPtr.Zero, 
                        WM_GRAPHNOTIFY, 
                        IntPtr.Zero);
            }


            if (this.VideoWindow != null)
            {
                this.VideoWindow.put_Visible(OABool.False);
                this.VideoWindow.put_Owner(IntPtr.Zero);
            }


            if (rot != null)
            {
                rot.Dispose();
                rot = null;
            }


            Marshal.ReleaseComObject(this.MediaControl);
            Marshal.ReleaseComObject(this.MediaEventEx);
            Marshal.ReleaseComObject(this.VideoWindow);
            Marshal.ReleaseComObject(this.GraphBuilder);
            Marshal.ReleaseComObject(this.CaptureGraphBuilder);

            this.MediaControl = null;
            this.MediaEventEx = null;
            this.VideoWindow = null;
            this.CaptureGraphBuilder = null;
            this.GraphBuilder = null;
        }



        public void HandleGraphEvent()
        {
            int hr = 0;
            EventCode evCode;
            int evParam1;
            int evParam2;

            if (MediaEventEx == null)
            {
                return;
            }

            while (MediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
            {
                hr = MediaEventEx.FreeEventParams(evCode, evParam1, evParam2);
            }
        }

        public IBaseFilter FindCaptureDevice()
        {

            int hr = 0;
            IEnumMoniker IclassEnum;
            System.Runtime.InteropServices.UCOMIEnumMoniker classEnum;

            IMoniker[] moniker = new IMoniker[1];

            Object source = null;
            ICreateDevEnum devEnum = (ICreateDevEnum)(new CreateDevEnum());

            hr = devEnum.CreateClassEnumerator(FilterCategory.VideoInputDevice,
                out classEnum, 0);


            IclassEnum = (IEnumMoniker)(classEnum);

            Marshal.ReleaseComObject(devEnum);

            if (classEnum == null)
            {
                throw new ApplicationException("No device video on board.");
            }
            if (IclassEnum.Next(moniker.Length, moniker, IntPtr.Zero) == 0)
            {
                Guid iid = typeof(IBaseFilter).GUID;
                moniker[0].BindToObject(null, null, iid, out source);
            }
            else
            {
                throw new ApplicationException("Unable to access video capture device!");
            }
            Marshal.ReleaseComObject(moniker[0]);
            Marshal.ReleaseComObject(classEnum);
            return (IBaseFilter)(source);
        }


        public void ChangePreviewState(bool showVideo)
        {
            int hr = 0;

            if (this.MediaControl == null)
            {
                return;
            }
            if (showVideo == true)
            {
                if (this.CurrentState != PlayState.Running)
                {
                    hr = this.MediaControl.Run();
                    this.CurrentState = PlayState.Running;
                }
            }
            else
            {

                hr = this.MediaControl.StopWhenReady();
                this.CurrentState = PlayState.Stopped;
            }
        }

        public void ResizeVideoWindow(HandledObject ho)
        {
            if (VideoWindow != null)
            {
                VideoWindow.SetWindowPosition(0, 0, ho.width, ho.clientSize.Height);
            }
        }
    }
}

Questo è l'oggetto che sostituisce e wrappa tutte le attività lasciando libero e snello il form.
Il motivo è semplice, in questo modo posso aggiungere una picturebox o qualsiasi altro oggetto per cui sussistano dimensioni e handle, mapparlo nell'oggetto di scambio, e gestire così la camera.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using DirectShowLib;
using System.Windows.Forms;
using CameraCapture.Objects;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
namespace CameraCapture
{
    public partial class frmMain : Form
    {
        DirectShowWrapper dsw = new DirectShowWrapper();
        HandledObject ho = new HandledObject();

      
        public frmMain()
        {            
            InitializeComponent();

            ho.height = this.Height;
            ho.width = this.Width;
            ho.handle = this.Handle;
            ho.clientSize = this.ClientSize;

            dsw.CaptureVideo(ho);
        }


        protected void WndProc(Message m)
        {
            if (m.Msg == dsw.WM_GRAPHNOTIFY)
            {
                dsw.HandleGraphEvent();
            }

            if (dsw.VideoWindow != null)
            {
                dsw.VideoWindow.NotifyOwnerMessage(
                                m.HWnd,
                                m.Msg,
                                (int)m.WParam,
                                (int)m.LParam);
            }
            else
            {
                base.WndProc(ref m);
            }
        }


        private void frmMain_Resize(object sender, EventArgs e)
        {
            if (this.WindowState == FormWindowState.Minimized)
                dsw.ChangePreviewState(false);

            if (this.WindowState == FormWindowState.Normal)
                dsw.ChangePreviewState(true);

            ho.height = this.Height;
            ho.width = this.Width;
            ho.handle = this.Handle;
            ho.clientSize = this.ClientSize;

            dsw.ResizeVideoWindow(ho);
        }

        public void frmMain_FormClosed(object sender, FormClosedEventArgs e)
        {
            dsw.closeinterfaces();
        }

    
    }
}

Orbene questo è quanto rimane del form ...ora la situazione è sicuramente molto più gestibile e pulita.

How TO: C# internal WEB CAM

2013-05-29T06:46:00.000-07:00

Ho cercato in lungo e in largo qualcosa di UTILIZZABILE e facilmente documentabile per creare un applicazione C# che sia in grado di utilizzare la WEBcam interna..

Ammetto che non c'e' molto ( c'è tanto ma nulla come lo cercavo io ) se non qualche esempio con Wia, o librerie create da qualcuno di cui non sempre si sa la provenienza.

Questo listato .. frutto di una traduzione da VB.Net, mi ha dato un buon risultato, e ammetto che paga. E' veloce, decisamente snello non semplicissimo da leggere.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using DirectShowLib;
using System.Windows.Forms;
using CameraCapture.Objects;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
namespace CameraCapture
{
    public partial class frmMain : Form
    {

        public int D = Convert.ToInt32("0X8000", 16);

        public int WM_GRAPHNOTIFY = 0;

        public IVideoWindow VideoWindow = null;
        public IMediaControl MediaControl = null;
        public IMediaEventEx MediaEventEx = null;
        public IGraphBuilder GraphBuilder = null;
        public ICaptureGraphBuilder2 CaptureGraphBuilder = null;

        public DsROTEntry rot = null;

        private PlayState CurrentState = PlayState.Stopped;

       

        public frmMain()
        {
            WM_GRAPHNOTIFY = D + 1;
            InitializeComponent();
            CaptureVideo(this);
        }



        protected void WndProc(Message m)
        {
            if (m.Msg == WM_GRAPHNOTIFY)
            {
                HandleGraphEvent();
            }

            if (VideoWindow != null)
            {
                VideoWindow.NotifyOwnerMessage(m.HWnd, m.Msg, 
                        (int)m.WParam, 
                        (int)m.LParam);
            }
            else
            {
                base.WndProc(ref m);
            }
        }

        public void HandleGraphEvent()
        {
            int hr = 0;
            EventCode evCode;
            int evParam1;
            int evParam2;

            if (MediaEventEx ==null) 
            {
                return;
            }

            while (MediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
            {
                hr = MediaEventEx.FreeEventParams(evCode, evParam1, evParam2);            
            }
        }

        private void frmMain_FormClosed(object sender, FormClosedEventArgs e)
        {
            closeinterfaces();
        }


        public void SetupVideoWindow()
        {
            int hr = 0;

            hr = VideoWindow.put_Owner(this.Handle);


            hr = VideoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipChildren);

            ResizeVideoWindow();

            hr = VideoWindow.put_Visible(OABool.True);
        }


        private void frmMain_Resize(object sender, EventArgs e)
        {
            if (this.WindowState == FormWindowState.Minimized )
                ChangePreviewState(false);
            
            if (this.WindowState == FormWindowState.Normal )
                ChangePreviewState(true);

            ResizeVideoWindow();
        }

        public void ResizeVideoWindow()
        {
            if (VideoWindow != null) 
            {
                VideoWindow.SetWindowPosition(0, 0, this.Width, this.ClientSize.Height);
            }
        }



        public void GetInterfaces(Form f)
        {
            int hr = 0;
            this.GraphBuilder = (IGraphBuilder)(new FilterGraph());
            this.CaptureGraphBuilder = (ICaptureGraphBuilder2)(new CaptureGraphBuilder2());
            this.MediaControl = (IMediaControl)(this.GraphBuilder);
            this.VideoWindow = (IVideoWindow)(this.GraphBuilder);
            this.MediaEventEx = (IMediaEventEx)(this.GraphBuilder);
            hr = this.MediaEventEx.SetNotifyWindow(f.Handle, WM_GRAPHNOTIFY, IntPtr.Zero);
        }


        public IBaseFilter FindCaptureDevice()
        {

            int hr = 0;
            IEnumMoniker IclassEnum;
            System.Runtime.InteropServices.UCOMIEnumMoniker classEnum;

            IMoniker[] moniker = new IMoniker[1];

            Object source = null;
            ICreateDevEnum devEnum = (ICreateDevEnum)(new CreateDevEnum());

            hr = devEnum.CreateClassEnumerator(FilterCategory.VideoInputDevice, 
                out classEnum, 0);


            IclassEnum = (IEnumMoniker)(classEnum);

            Marshal.ReleaseComObject(devEnum);

            if (classEnum == null)
            {
                throw new ApplicationException("No device video on board.");
            }
            if (IclassEnum.Next(moniker.Length, moniker, IntPtr.Zero) == 0)
            {
                Guid iid = typeof(IBaseFilter).GUID;
                moniker[0].BindToObject(null, null, iid, out source);
            }
            else
            {
                throw new ApplicationException("Unable to access video capture device!");
            }
            Marshal.ReleaseComObject(moniker[0]);
            Marshal.ReleaseComObject(classEnum);
            return (IBaseFilter)(source);
        }

        public void CaptureVideo(frmMain f)
        {
            int hr = 0;
            IBaseFilter sourceFilter = null;
            try
            {
                GetInterfaces(f);

                hr = this.CaptureGraphBuilder.SetFiltergraph(this.GraphBuilder);


                sourceFilter = FindCaptureDevice();

                hr = this.GraphBuilder.AddFilter(sourceFilter, "Video Capture");


                hr = this.CaptureGraphBuilder.RenderStream(PinCategory.Preview, 
                        MediaType.Video, 
                        sourceFilter, 
                        null, null);

                Marshal.ReleaseComObject(sourceFilter);

                f.SetupVideoWindow();

                rot = new DsROTEntry(this.GraphBuilder);

                hr = this.MediaControl.Run();

                this.CurrentState = PlayState.Running;

            }
            catch (Exception ex)
            {

            }
        }

        public void closeinterfaces()
        {

            if (this.MediaControl != null)
            {
                this.MediaControl.StopWhenReady();
            }

            this.CurrentState = PlayState.Stopped;


            if (this.MediaEventEx != null)
            {
                this.MediaEventEx.SetNotifyWindow(IntPtr.Zero, WM_GRAPHNOTIFY, IntPtr.Zero);
            }


            if (this.VideoWindow != null)
            {
                this.VideoWindow.put_Visible(OABool.False);
                this.VideoWindow.put_Owner(IntPtr.Zero);
            }


            if (rot != null)
            {
                rot.Dispose();
                rot = null;
            }


            Marshal.ReleaseComObject(this.MediaControl);
            Marshal.ReleaseComObject(this.MediaEventEx);
            Marshal.ReleaseComObject(this.VideoWindow);
            Marshal.ReleaseComObject(this.GraphBuilder);
            Marshal.ReleaseComObject(this.CaptureGraphBuilder);

            this.MediaControl = null;
            this.MediaEventEx = null;
            this.VideoWindow = null;
            this.CaptureGraphBuilder = null;
            this.GraphBuilder = null;
        }

        public void ChangePreviewState(bool showVideo)
        {
            int hr = 0;

            if (this.MediaControl == null)
            {
                return;
            }
            if (showVideo == true)
            {
                if (this.CurrentState != PlayState.Running)
                {
                    hr = this.MediaControl.Run();
                    this.CurrentState = PlayState.Running;
                }
            }
            else
            {

                hr = this.MediaControl.StopWhenReady();
                this.CurrentState = PlayState.Stopped;
            }
        }
    }
}

E questo è l'enumerativo.

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

namespace CameraCapture.Objects
{
    public enum PlayState
    {
        Stopped,
        Paused,
        Running,
        Init
    }
}

L'unica notazione è l'aggiunta della libreria di DirectShow.

Il resto è solo divertimento .. o sperimentazione:

... E buon prò vi faccia come al solito !!

Grand Sla

2013-05-29T01:07:00.001-07:00

Fra i prodotti presenti su WEB per la gestione di SLA e KPI, mi sono imbattuto in questo prodotto, l’ho provato e ammetto di essere rimasto piacevolmente soddisfatto.

Per me il punto di forza è nell’essere interamente sviluppato per il WEB, in questo modo la raggiungibilità è massima ( ormai sono pochi i punti in cui sia assente una rete WI-FI o la connettività dati sia assente ).

Il prodotto si presta inoltre a svariati tipi di utilizzo, e credo che anche questo sia un buon punto di forza, ossia nel mio caso l’ho utilizzato per valutare i carichi del mio gruppo di lavoro. E onestamente mi è bastato creare un CSV con i miei dati, impostare le mie regole d’analisi, e osservare i grafici.
Per altro se si è client oriented, o se si è sul pezzo in qualità di account è possibile dare una definizione dell’organigramma.

Organizzazione>Dipartimenti>Contratti.

Tramite questo tipo di gestione è facile organizzare una distribuzione dei dati a chi di competenza, o in base alla durata di un contratto.
Da oggi lascerò il link sul mio blog, per me è per chi vorrà approfondire.

Qui trovate il sito: GrandSLA

Galagone Graphics Tool

2013-04-26T06:59:00.001-07:00

Ciao a tutti...

Dato che un socio mi ha chiesto di fare qualcosa di assurdo .. bhe l'ho fatto.
Ecco il mio primo primissimo prodotto dedicato alla grafica, si chiama Galagone è il suo scopo è di rovinare il più possibile le vostre foto.

Gli effetti previsti sono pochi al momento ma di grande utilità per tutte le persone che hanno bisogno di creare degli errori sulle proprie immagini.

Download Galagone

Release Alfa 0.1

plugin presenti:
-BlackBlock ( crea blocchi neri casuali )
-ByteLine ( crea linee non omogenee con interruzioni )
-CircleMaker ( crea cerchi causali in base a colori impostabili )
-DotMacker ( crea punti in base a dei colori impostabili )
-Entropy ( effetto evidenziatore )
-NoiseBlock ( crea blocchi in sovrapposizione alla immagini )
-SimpleBlock ( duplica blocchi di immagine )
-Sobstitute ( cambia un colore con un altro )

Bug noti
non ci sono controlli sui parametri immessi.

E se volete rovinarvi le immagini buon divertimento ...

A tutti i partecipanti del blog se volete i sorgenti ... basta chiedere e come sempre ogni partecipazione è ben accetta !