Programmazione e dintorni...

C++ e C# a confronto

2011-04-13T13:17:00.002+02:00

Molto spesso si è portati a pensare che C#, il linguaggio "di punta" del framework .NET, sia un C++ "migliore", un "C++++" come suggerisce l'immagine, in realtà le differenze sono profonde, più che da un punto di vista sintattico, da un punto di vista concettuale.

Vediamo di seguito una tabella sulle maggiori differenze riguardo i due linguaggi.

C++	C#
I riferimenti ad un’altra classe in un altro file del progetto richiedono un #include	Nessun #include è richiesto
I riferimenti ad una classe in una libreria dinamica (dll) richiedono di includere un file e il link ad una libreria statica (lib)	Non ci sono più le librerie statiche. Si possono aggiungere i riferimenti alle dll (assemblies) direttamente da progetto
I simboli esportati da una libreria devono essere dichiarati come declspec o in un .DEF file	Basta dichiarare i simboli come pubblici nella libreria. I simboli privati non vengono esportati.
Se ci si riferisce ad una classe/struttura prima che venga dichiarata, bisogna fare una forward declaration	Non esistono le forward declarations e l’ordine di dichiarazione non è importante
Passando tra stringhe Unicode/16-bit si richiede: entry point differenti (main/wmain) Prefissi non standard “L” or “_T”, oppure gestione STL con string/wstring Le stringhe vengono manipolate da differenti funzioni	Unicode è il formato nativo
NULL è un concetto, non fa parte del linguaggio. È tipicamente definito come 0 e quindi è l'equivalente di 0.	null è una parola chiave. Non è equivalente a 0.
I tipi di dato base (int, float, char, ecc) non possono accettare un valore "NULL". Solo i puntatori possono avere un valore "NULL".	Tutti i tipi C # possono accettare null come valore • T, con il supporto null è “T?”, ad es. int con il supporto null è “int?”
Nessun supporto per “foreach”	Supporto di foreach per iterare su una collezione
Supporto per try e catch. Nessun supporto per "finally”	Supporto per try-catch-finally
Nessuna notifica su operazioni di overflow. Per esempio: unsigned x = UINT_MAX; x++; // x == 0 nessuna exception lanciata	Usando le parole chiave checked/unchecked puoi ottenere comportamenti differenti (exception/overflow)
Nessun supporto nativo per sezioni critiche o multithreading	Parola chiave lock per le critical sections, oggetti Thread built-in
All’interno di uno switch, il break è opzionale	Il break dentro lo switch è obbligatorio
Nessuna documentazione built-in. Esite la possibilità di usare tools esterni come doxygen	Documentazione XML con “///”. Riconosciuto da IntelliSense in Visual Studio
Non si può suddividere la definizione di una classe su più file	Le classi parziali permettono di suddividere la definizione di una classe su più source files.
Nessun supporto per mix di librerie di versioni differenti	Si può fare un mix di librerie di versioni differenti
Lo sviluppatore deve gestire la memoria direttamente (new/delete)	Supporto di Garbage collection
Si ha maggiore controllo sulla distruzione degli oggetti, possibilità di memory leaks se non ben gestita	Minore controllo sulla distruzione degli oggetti, ma più sicurezza a causa della gestione automatica del GC
Gli oggetti “reference” possono essere allocati sia nell’heap che nello stack della memoria dichiarandoli come locali o con una new	Gli oggetti “reference” vengono sempre allocati nell’heap
Supporto per classi o metodi “friend”	Non esiste il concetto di friend, ma questo è stato in qualche modo sostituito dalle Proprietà di una classe
I tipi non condividono un tipo root comune	Tutti i tipi derivano dalla classe “Object”

Pensandoci bene e leggendo vari articoli sull’argomento, ci si rende conto che in realtà la differenza tra un linguaggio come C++ e uno come C# (o Java), è ben più profonda e parte dalla base stessa di come è stato creato il linguaggio.

Il C++ si potrebbe definire come un linguaggio a due livelli di astrazione:

Livello 1 (low level): gestione diretta della memoria e dell’allocazione delle risorse attraverso i puntatori . A questo livello viene definita la classe come detentrice delle risorse che verranno rilasciate nel suo distruttore. L’acquisizione-inizializzazione-distruzione delle risorse usate dalla classe è completamente a carico del programmatore che deve essere quindi sufficientemente esperto per progetti di medie-grosse dimensioni.
Livello 2 (high level): a questo livello si vedono solo gli “oggetti” e si possono usare le risorse solo attraverso i metodi esposti dagli “oggetti”. Non esistono puntatori e nemmeno “delete” o “free”: al limite esistono puntatori “intelligenti” detti smart_pointer che si auto gestiscono e distruggono. Si richiede un grado di esperienza del programmatore anche inferiore perché la gestione “delicata” delle risorse è fatta al livello sottostante. Questo livello è molto simile a quello offerto da C#/Java.

Le origini del C++ non partono esclusivamente dal C, di cui comunque si è scelto di mantenere la compatibilità, ma soprattutto da un’idea di Stroustrup che il linguaggio stesso potesse essere esteso, partendo da un nucleo decisamente ridotto all'osso. Il programmatore può decidere di costruire sul linguaggio nativo estensioni difficilmente distinguibili dal linguaggio stesso. Un chiaro esempio di ciò è la libreria STL.

Il C#, come il Java, lasciano meno possibilità e libertà al programmatore, che probabilmente però ne guadagna in “sicurezza”e velocità di apprendimento. C# come Java partono da un livello di astrazione superiore al C++ e però se da un lato ciò comporta l’evitare tutte quelle problematiche che possono insorgere quando si programma a basso livello, dall’altro ne perde in flessibilità e potenza espressiva. C’è da dire che probabilmente la scelta di Java/C# è oculata perchè il target dei linguaggi è molto differente: nel caso di Java/C# si hanno linguaggi destinati ad applicazioni che devono interagire pesantemente col mondo della rete, del web, dei database, delle applicazioni distribuite ecc., per cui si è scelto di semplificare la vita del programmatore dando un livello di astrazione maggiore: in questo modo è stato possibile costruire e far apprendere in tempi relativamente rapidi ambienti quali .NET o Java (inteso come ambiente). Il C++ è stato pensato invece per andare a coprire target quali applicazioni time critical o sistemi embedded: target per cui è conveniente poter agire a differenti livelli di astrazione. Dire che C# è un C++ "migliorato" non è corretto, è più corretto dire che C# è stato pensato per scopi differenti, usare l'uno o l'altro dipende da ciò che dobbiamo costruire.

Videosorveglianza fai-da-te!

2011-04-08T21:16:00.007+02:00

Vediamo oggi come sia possibile creare una semplice applicazione per fare videosorveglianza “fai-da-te” completamente gratuita! Ciò che otterremo alla fine sarà una semplice applicazione che manda immagini prese da una webcam ad un web server a cui possiamo collegarci per visualizzare cosa sta succedendo magari a casa nostra, in nostra assenza. Và detto che questa semplice applicazione è a solo scopo “didattico” e può essere arricchita a vostro piacimento.

Il nostro progetto è così architettato:

In pratica un “Frame Grabber” prende le immagini da un webcam e le salva su di un file, un “Image Sender” manda tali immagini ad un Web Server remoto che le pubblicherà. A questo punto le immagini della webcam saranno disponibili ad un qualsiasi browser remoto che si collega al web server permettendoci di fare videosorveglianza. Per divertirmi ho scelto di utilizzare linguaggi diversi per ciascun modulo:

Frame Grabber: grabbing di immagini da webcam tramite librerie Open CV (C++)
Image Sender: classe Java che effettua una POST dell’immagine tramite una Http connection
Image Receiver: script PHP che salva sul web server l’immagine ricevuta
Web Page: pagina HTML che visualizza l’immagine

Come si nota, l’applicazione viene sviluppata parte in C/C++ , parte in PHP e parte in Java: in pratica una webcam riprende una scena, le immagini vengono grabbate e salvate ad intervalli regolari su un file del pc di casa tramite le librerie Open CV (librerie largamente utilizzate nel campo della computer vision). Una semplice applicazione Java, prende tale immagine e la spedisce (POST) ad un web server. Il web server a questo punto pubblicherà l’immagine tramite un semplice script PHP e sarà visibile tramite per esempio un semplice browser.

Per sviluppare l’applicazione ho usato ambienti di sviluppo per C/C++ e Java quali Visual Studio 2010 ed Eclipse, ma ciò non è vincolante poichè tutto il codice è completamente portabile su qualsiasi SO. Si noti che sul pc di casa (quello su cui gira l’Image Sender), è necessario avere installato una Java Virtual Machine scaricabile da qui.

Image Receiver (PHP)

Prima di tutto bisogna scegliere un web server (free!) che supporti Scripting PHP. Qui potete trovare una lista di esempio. Sceglietene uno, registratevi e createvi un sito. A questo punto mettete sul server (p.es. via FTP) il seguente file PHP:

recv.php

<?php

/**

* Save the submitted file to disk

if (is_uploaded_file($_FILES['img']['tmp_name'])) {

move_uploaded_file($_FILES['img']['tmp_name'], "img.jpg");

}

Questo script non fa altro che salvare su disco l’immagine che proviene da un client tramite HTTP POST su un file “img.jpg”. In questo modo potete pubblicare un’immagine su web. Sostituite la pagina di default del sito con la seguente:

index.html

<html>

<head>

<title>Remote Surveillance System</title>

</head>

<body>

function showFrame() {

document.images.frame.src = "img.jpg?" + Math.random();

setTimeout("showFrame()", 3000);

}

showFrame();

</script>

</body>

</html>

In pratica la pagina effettua il refresh automatico dell’immagine “img.jpg” ogni 3 secondi escludendo la cache. Il file index.html dovrebbe essere la pagina di default del nostro sito e deve risiedere sulla stessa cartella del file recv.php. La parte da caricare sul web server è terminata. Passiamo ora ad implementare le 2 applicazioni che gireranno sul pc di casa.

Image Grabber (C/C++)

A questo punto siamo pronti per scrivere il codice che grabba le immagini da una semplice webcam e le salva su disco su un file “img.jpg”. Utilizzeremo le Open CV, librerie che vengono utilizzate per la computer vision. In pratica è un pò riduttivo usare le Open CV solo per grabbare delle immagini da una web cam, ma ciò potrebbe rivelarsi utile nel caso si voglia arricchire l’applicazione con funzionalità quali motion detection, object tracking ecc. Scarichiamo e compiliamo le Open CV dal sito. Per la compilazione delle librerie lib e dll possiamo utilizzare CMake o direttamente Visual Studio secondo queste istruzioni. Una volta che ci siamo installati le Open CV, creaiamo un nuovo progetto con Visual Studio, una semplice Console Application, chiamiamolo “VideoSorveglianza”. Includiamo le directory di include opportune di Open CV nella sezione “C/C++ -> Additional Include Directories” (p.es. “..\OpenCV2.2\include\opencv”) e tutte le librerie statiche nella sezione “Linker -> Input->Addicional Dependencies” (p.es. ..\lib\cv220.lib ecc.). Copiamo le librerie dinamiche delle Open CV (p.es. cv220.dll ecc.) nella cartella Debug e/o Release del nostro progetto. Creiamo un nuovo file all’interno del progetto:

VideoSorveglianza.cpp

#include <stdio.h>

#include "cv.h" /* file include Open CV */

#include "highgui.h" /* file include Open CV */

int main(int argc, char** argv)

{

CvCapture *capture;

IplImage *frame;

double t, ms = 0;

int key;

/* inizializza la webcam */

capture = cvCaptureFromCAM(0); /* cattura il flusso video dal primo device del pc*/

cvNamedWindow("video", 1);

while (key != 'q') {

t = (double)cvGetTickCount();

/* display a video */

frame = cvQueryFrame(capture); /* grabba l’immagine */

cvShowImage("video", frame);

key = cvWaitKey(1); /* aspetta input da tastiera 1 sec */

/* calcola il tempo trascorso */

t = (double)cvGetTickCount() - t;

ms += t/((double)cvGetTickFrequency() * 1000.0);

/* autosave dell’immagine ogni 3 secondi */

if (ceil(ms) >= 3000) {

cvSaveImage("img.jpg", frame);

ms = 0;

}

/* free memory */

cvReleaseCapture(&capture);

cvDestroyWindow("video");

return 0;

}

A questo punto, dopo aver compilato il progetto e collegato la webcam, possiamo lanciare l’eseguibile da console tramite il comando: “VideoSorveglianza.exe”. Il risultato è il seguente:

Tale immagine verrà salvata sul file locale “img.jpg” ad intervalli regolari di 3 secondi.

Image Sender (Java)

Il prossimo passo consiste nel creare il sender che spedirà le immagini ad un web server. Si noti che la spedizione deve avvenire come se fosse un HTTP POST. La classe Java (che girerà anch’essa sul nostro pc di casa), semplicemente legge l’immagine dal file “img.jpg”, apre una connessione URL col web server e la spedisce in formato binario. Apriamo Eclipse e creiamo un nuovo progetto, chiamiamolo p.es. “VideoSorveglianzaSender”. Creiamo una classe Sender con questo codice:

Sender.java

import java.net.*;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.io.*;

import javax.imageio.ImageIO;

public class Sender

{

static URL u;

private final String CrLf = "\r\n";

void updateImage(){

URLConnection conn = null;

OutputStream os = null;

InputStream is = null;

try{

//Qui va sostituito l’indirizzo del web server: attenzione recv.php va lasciato

URL url = new URL("http://<webserverURL>/recv.php");

System.out.println("url:" + url);

conn = url.openConnection();

conn.setDoOutput(true);

// legge l’immagine da file e la mette su un array di byte

File file = new File("img.jpg");

Image image = ImageIO.read(file);

BufferedImage bu = new

BufferedImage(image.getWidth(null),image.getHeight(null),BufferedImage.TYPE_INT_RGB);

Graphics g = bu.getGraphics();

g.drawImage(image,0,0,null);

g.dispose();

ByteArrayOutputStream baos = new ByteArrayOutputStream();

ImageIO.write(bu, "jpg", baos);

byte []imgData = baos.toByteArray();

// crea la request http

String message1 = "";

message1 += "-----------------------------4664151417711" + CrLf;

message1 += "Content-Disposition: form-data; name=\"img\"; filename=\"img.jpg\"" + CrLf;

message1 += "Content-Type: image/jpeg" + CrLf;

message1 += CrLf;

// l’immagine viene spedita come multipart message.

String message2 = "";

message2 += CrLf + "-----------------------------4664151417711--" + CrLf;

conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=---------------------------4664151417711");

conn.setRequestProperty("Content-Length", String.valueOf((message1.length() + message2.length() + imgData.length)));

System.out.println("open os");

os = conn.getOutputStream();

System.out.println(message1);

os.write(message1.getBytes());

// SEND THE IMAGE

int index = 0;

int size = 1024;

do{

System.out.println("write:" + index);

if((index+size)>imgData.length){

size = imgData.length - index;

}

os.write(imgData, index, size);

index+=size;

}while(index<imgData.length);

System.out.println("written:" + index);

System.out.println(message2);

os.write(message2.getBytes());

os.flush();

// legge la risposta del web server

System.out.println("open is");

is = conn.getInputStream();

char buff = 512;

int len;

byte []data = new byte[buff];

do{

System.out.println("READ");

len = is.read(data);

if(len > 0){

System.out.println(new String(data, 0, len));

}

}while(len>0);

System.out.println("DONE");

}catch(Exception e){

e.printStackTrace();

}finally{

System.out.println("Close connection");

try{

os.close();

}catch(Exception e){}

try{

is.close();

}catch(Exception e){}

}

public static void main(String args[]) throws IOException

{

while (true)

{

Sender send = new Sender();

send.updateImage();

try {

// manda un immagine ogni 2 secondi

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

Sostituire nel punto segnato <webserverURL>, l’indirizzo URL del web server che abbiamo scelto all’inizio, avendo cura di chiamare lo script recv.php. La classe non fa altro che leggere il file img.jpg e metterlo dentro un byte array. A questo punto viene aperta una HTTP connection verso il web server e viene spedita l'immagine come "multipart message". L'image sender scriverà a video la risposta ottenuta dal web server.

A questo punto compiliamo la classe e copiamo il file “Sender.class” nella stessa directory Debug/Release di dove girerà il grabber “VideoSorveglianza.exe”.

Test finale

Proviamo il tutto: lanciamo l’eseguibile del grabber (dentro la cartella Debug/Release della solution di Visual Studio): “VideoSorveglianza.exe”. A questo punto lanciamo il sender tramite il comando “java Sender” lanciato dalla stessa cartella del progetto VideoSorveglianza. Aprendo un browser all’indirizzo del nostro sito vedremo le immagini provenienti dalla webcam che si aggiorneranno automaticamente. In questo modo potremmo controllare casa nostra magari direttamente dall’ufficio aprendo semplicemente un browser.

Shallow Copy e Deep Copy in C++

2011-03-31T21:12:00.000+02:00

In questo articolo cercheremo di capire cosa si intende per shallow copy e deep copy di un oggetto: tali concetti saranno validi per tutti i linguaggi di programmazione ad oggetti, ma nel linguaggio C++, che fa uso di puntatori e della copia implicita di oggetti, rivestono un’importanza maggiore. Iniziamo a definire cosa è un costruttore di copia in C++: un costruttore di copia è un costruttore speciale, utilizzato per creare un nuovo oggetto-copia di un oggetto esistente. Ma perchè ne abbiamo bisogno? Se noi non definiamo un costruttore di copia sarà il compilatore a crearne uno per noi, ossia creerà un costruttore di copia di default. Con tale costruttore di copia, la copia avverrà “bit a bit”, brutto modo per dire che che si avrà una copia superficiale dell’ oggetto (shallow copy). Se noi vogliamo ottenere una copia dell’oggetto differente e in profondità (deep copy), dobbiamo crearcene uno.

Supponiamo inizialmente di avere la seguente classe C++:

File A.h

class A

{

public:

A(int i) { a = i; }

~A(void) { }

int get_a() { return a; }

private :

int a;

};

Supponiamo che adesso si effettui una copia di un oggetto in un altro oggetto in un programma che usa tale classe:

#include "A.h"

#include <iostream>

using namespace std;

…

A x(10);

A y(20);

x = y; //shallow copy

cout << x.get_a()<<" "<< y.get_a() << endl;

Tutto è corretto: l’oggetto “y” viene copiato in “x” bit a bit, ossia il valore dell' attributo intero di y di valore 20 viene copiato in quello di x, cosicchè il programma stamperà 20 20.

Ma cosa succederebbe se al posto di un intero avessimo un puntatore? Si consideri ora la stessa classe A, dove abbiamo sostituito l'attributo intero con un puntatore ad un intero:

class A

{

public:

A(int i)

{

a = new int;

*a = i;

}

~A(void) { delete a;}

int get_a() { return *a; }

private :

int* a;

};

Se provo a lanciare il programma esso stampa ancora 20 20, quindi sembra che tutto sia andato bene, ma non è così! Ciò che succede quando eseguo x = y, è che viene copiato il puntatore di y in quello di x:

Questo, oltre ad essere sbagliato concettualmente (non si effettua una reale copia dell’oggetto), dà vita anche ad un bel memory leak!

Si noti che nell’esempio con l’istruzione x = y, abbiamo chiamato l’operatore “=” effettuando una shallow copy, ma se per esempio avessimo usato una funzione f, che accetta in ingresso un oggetto A passato per valore, il discorso non cambierebbe perché in quel caso verrebbe creato automaticamente un oggetto A locale su cui verrà copiato l’oggetto passato:

A x(10);

f(x); //questa funzione "distrugge" l'intero puntato dal membro di x

cout << x.get_a()<< endl;

...

void f(A y)

{

//qui y è una shallow copy di x

}

In questo caso verrà chiamato automaticamente il costruttore di copia di default della classe A (definito dal compilatore), che effettua anch’esso una copia bit a bit. Se proviamo a stampare il valore dell'intero puntato dal membro di x dopo la chiamata a f(x), vedremo che tale valore è stato "cancellato" dalla delete dentro il distruttore chiamato sull'oggetto locale y all'uscita dalla funzione.

Il problema si risolve dichiarando esplicitamente il costruttore di copia e l’operatore di uguaglianza e copiando “manualmente” i valori puntati dai membri puntatore. Nel nostro caso ci servirà definire dentro la classe A i due metodi:

A(const A& val); //costruttore di copia

A& operator=(const A& val); //sovraccaricamento operatore =

La classe A diventerà:

class A

{

public:

A(int i)

{

a = new int;

*a = i;

}

~A(void) { delete a;}

int get_a() { return *a;}

A(const A& val) //costruttore di copia

{

a = new int;

*a = *(val.a);

}

A& operator=(const A& val) //sovraccaricamento operatore =

{

*a = *(val.a);

return *this;

}

private :

int* a;

};

Come si nota, sia il costruttore di copia che l’operatore “=” accettano entrambi una reference ad un altro oggetto A e copiano manualmente il valore intero, in modo da avere una copia effettiva:

Bisogna fare molta attenzione al distruttore della classe A: esso giustamente distrugge il puntatore “a” quando l’oggetto A viene distrutto: se si omette la delete dentro il distruttore, potremmo avere “piacevoli” sorprese: a volte si sa che in informatica c’è la regola “bug + bug = funziona tutto”! Facciamo un esempio, supponendo che nella classe A senza costruttore di copia e operatore =, manchi pure la delete e che vogliamo effettuare lo swap di due oggetti (ossia del contenuto dell’intero puntato da “a”):

A x(10);

A y(20);

cout << "x=" << x.get_a()<<" y="<<y.get_a() << endl;

A::swap(x,y);

cout << "x=" << x.get_a()<<" y="<<y.get_a() << endl;

dove abbiamo definito in A il metodo statico:

static void swap(A& x, A& y)//passaggio per reference, nessuna copia!

{

A tmp = x; //questo chiama il costruttore di copia bit a bit

x = y; //questo chiama l’operatore = bit a bit

y = tmp; /questo chiama l’operatore = bit a bit

}

Con somma meraviglia notiamo che effettivamente la funzione swap effettua lo scambio delle variabili intere nonostante la shallow copy e il programma sopra stampa:

x=10 y=20

x=20 y=10

Ma vediamo graficamente cosa avviene. Dopo l’istruzione A tmp = x si avrà:

Naturalmente il fatto che swap funzioni è solo un caso e resta il fatto che le variabili intere puntate, in questo modo non verrebbero mai eliminate. Provando ad aggiungere nuovamente la delete al distruttore di A (ma senza aggiungere anche il costruttore di copia e l’operatore =), otterremmo dal programma precedente:

x=10 y=20

x=20 y= -17891602

Questo perchè all’uscita della funzione swap, l’intero puntato da tmp (oggetto locale alla funzione), viene cancellato dalla delete (in rosso in figura), lasciando “flottante” anche il puntatore contenuto dentro y, tale comportamento può considersi della categoria "effetti collaterali". Questo esempio è stato fatto solo per far capire che con i puntatori a volte anche se le cose sembrano “funzionare”, in realtà non è affatto così.

La regola che si deve tenere dovrebbe essere: “se una classe non alloca nei propri membri memoria in maniera dinamica (new, malloc ecc.), allora possiamo affidarci alla shallow copy, altrimenti è necessaria la deep copy”

In C++ la deep copy consiste in:

Creazione di un costruttore di copia che allochi la memoria e copi i valori delle variabili dell’oggetto da copiare.
Sovraccaricamento dell’operatore = che copi i valori delle variabili da un oggetto all’altro
Creazione di un distruttore che deallochi tutte le variabili allocate dinamicamente

Per approfondimenti sulla Shallow Copy e Deep Copy, anche in altri linguaggi, si legga qui.

Parliamo un pò di SOA (Service Oriented Architecture)

2011-03-08T22:58:00.000+01:00

Dopo aver visto un’introduzione alle EAI, veniamo al passo successivo che si è avuto nel panorama dell’integrazione dei sistemi informativi: le soluzioni SOA (Service Oriented Architecture). La grande diffusione del Web ha portato le architetture legate ad esso a grandi trasformazioni passando dalla costruzione di semplici siti web, ai portali aziendali fino alle soluzioni che integrassero le infrastrutture IT.

Agli inizi degli studi dei problemi di integrazione di applicazioni si avevano le cosiddette applicazioni distribuite (Object Oriented Architecture, OOA): componenti realizzati con tecnologie differenti potevano cooperare tra di loro dando vita ad un’applicazione unica secondo protocolli standard (es. CORBA, DCOM). A questo livello agivano le EAI: far interagire tra loro applicazioni/componenti del tutto eterogenee.

Ci si è resi conto però dei vantaggi di un approccio differente, a servizi distribuiti (web services): si poteva accedere a tali servizi usufruendo dell’interfaccia che tali web services fornivano secondo un contratto (WSDL) e un protocollo (SOAP) standard. Eventualmente tali servizi potevano essere ricercati e scoperti (discovered) in una lista di servizi disponibili (UDDI). Il vantaggio di questo approccio (SOA) rispetto a quello precedente (OOA) consisteva nel fatto che veniva posto il focus sulle funzionalità e non sulle tecnologie.

In altre parole l’approccio SOA mette in evidenza un’entità nota maggiormente al management aziendale di quanto lo fossero le implementazioni tecnologiche, ossia metteva al centro dell’attenzione il processo di business.

Un’architettura SOA è qualcosa di più complesso di un’architettura a WS, nonostante possiamo affermare che essa si possa anche fondare sui concetti tecnologici dei WS. In realtà un’architettura SOA sta ad un livello di astrazione superiore di una struttura a WS: possiamo affermare che un’architettura SOA è

“Un paradigma per l'organizzazione e l'utilizzazione delle risorse distribuite che possono essere sotto il controllo di domini di proprietà differenti. Fornisce un mezzo uniforme per offrire, scoprire, interagire ed usare le capacità di produrre gli effetti voluti consistentemente con presupposti e aspettative misurabili” - Reference Model for Serviced Oriented Architecture 1.0.”, OASIS,12 ottobre 2006 (Oasis è un consorzio mondiale fondato nel 1993 che regolamenta le convergenze degli sviluppi e l’adozione di standard di e-business).

SOA è pertanto un paradigma che si traduce in un’architettura dinamica con la quale il progetto e lo sviluppo delle soluzioni sono portate a livelli di ragionamento più elevati. Tali ragionamenti permettono di valutare in modo più completo i processi aziendali, considerandoli nel loro insieme e non solo singolarmente, e, quindi, a ricercare lo sviluppo della migliore soluzione possibile che realizzi le operazioni di business richieste .

Quindi SOA non è una tecnologia, ma un approccio architetturale costruito attorno alle tecnologie esistenti. Promuove un insieme di pratiche, discipline, modalità di disegno e linee-guida che possono essere applicate usando una o più tecnologie. SOA propone lo sviluppo di nuovi servizi basati su funzionalità già offerte da un’applicazione. Altre applicazioni che desiderano comunicare con questa applicazione, faranno uso di uno o più servizi per realizzare il compito desiderato.

Il paradigma SOA si basa su tre concetti basilari:

Visibilità: capacità di trovare il servizio più idoneo alle proprie necessità
Interazione: capacità di richiesta di un servizio e conseguentemente di esaudizione della richiesta mediante scambio di messaggi.
Effetti reali: capacità di dare i risultati dell’interazione.

Si nota come tali concetti non definiscano altro che le proprietà di un servizio: un servizio viene erogato quando si svolgono attività per conto di un richiedente (service consumer). Il servente (service provider) garantisce la propria offerta di servizio, la propria capacità di svolgerlo e la descrizione delle specifiche con le quali si può invocare correttamente il servizio offerto. La descrizione del servente viene resa pubblica mediante una discovery agency (service broker), un repository o una directory.

SOA è uno degli ultimi paradigmi della Web Engineering: generazione di servizi e creazione delle condizioni per la meccanizzazione dei processi all’interno degli asset informativi aziendali attraverso delle composite applications. Scegliere una soluzione SOA rispetto ad una OOA significa assumere per l’architettura queste proprietà:

Effettivo riuso e migliore “granularità” del servizi
Interoperabilità dei servizi e loro componentizzazione in servizi più semplici (composite application)
Assunzione di standard generici e/o specifici di certi domini
Identificazione e accessibilità ai servizi standardizzata
Monitoraggio della soluzione (IT governance)
Incapsulamento dei servizi
Accoppiamento debole tra i servizi (loose coupling) mediante messaggi XML standard
Regole di interazione tra i servizi mediante contratti definiti
Maggiore astrazione dalle logiche di implementazione
Possibilità di suddivisone dei servizi per macro-funzionalità
Autonomia di ciascun servizio nel definire la propria logica implementativa
Rintracciabilità dei servizi mediante costrutti noti e standard

Semplificando possiamo dire che SOA ricontestualizza il paradigma nato con le OOA alla rete e ad Internet. I nuovi livelli di astrazione introdotti permettono di ridurre notevolmente il gap presente tra le logiche dei processi di business e i sistemi IT.

Schema modulare di un'architettura SOA

Ready. Run Codemotion.

2011-03-07T23:05:00.000+01:00

Sabato 5 Marzo si è tenuto a Roma, presso l’Università di Ingegneria Informatica Roma 3, il Codemotion, che “rimpiazza” il classico Javaday. La manifestazione prevedeva una serie di talk che riguardano le ultime novità nel mondo della programmazione, dell’informatica e della tecnologia. Dai talk presenti mi è smbrato che il focus fosse incentrato maggiormente su due argomenti hot: l’HTML 5 e i Database NoSQL. La manifestazione ha avuto un gran successo e afflusso di persone. Oltre ai talk erano presenti anche i classici stand con le aziende ICT sponsor dell’evento tra i quali nomi grossi come Oracle, IBM, Sony, Samsung, Almaviva, Adobe. Ho notato con piacere che l’afflusso agli stand maggiore si è avuto in quello della O’Really , che per l’occasione dava uno sconto del 40% sui titoli presenti sul banco (in realtà i titoli non erano numerosissimi, ma qualcosa di interessante si poteva trovare): impazzita la povera signora di lingua inglese che vendeva i libri e che non riusciva a tenere a bada orde di nerd che volevano comprare libri di informatica a prezzo stracciato (tra i quali c’ero anche io). Mio giudizio personale sull’evento: in generale ottimi gli argomenti trattati, mi è piaciuta molto l’idea di generalizzare l’evento a tutti i linguaggi e tecnologie, molto buona l’organizzazione globale della manifestazione, buona anche l’idea di far incontrare addetti ai lavoratori/appassionati di tecnologia con il mondo del lavoro. Per quanto riguarda i talk direi buon alcuni, ma un pò troppo bassa la qualità di alcuni altri che ho seguito (c’è da dire a parziale giustificazione che il tempo a disposizione degli oratori era poco). Nel complesso è stata una bella giornata, esperienza sicuramente da ripetere. A questo link le foto dell’evento: in una foto, guardando attentamente, potete pure verificare che “io c’ero” J... mentre se aguzzate la vista noterete che il mio nome compare tra gli autori dei “codicilli” stampati sulle colonne: che onore! J

Apache Logging Services: A Log 4 All Languages

2011-03-04T15:23:00.019+01:00

Molto spesso, durante lo sviluppo dei nostri progetti, ci viene richiesto di fornire dei file di log. Apache Software Foundation fornisce quattro librerie dedicate al logging per Java, .NET,C++,PHP. Tali librerie hanno tutte in comune gli stessi concetti. L’obiettivo di tali librerie è gestire il log in tutti i suoi aspetti in modo facile, efficiente e flessibile . Inoltre il formato prodotto dei messaggi è visualizzabile tramite dei tool già esistenti. Tali librerie sono inoltre state ottimizzate per ridurre al minimo l’overhead sulle prestazioni delle nostre applicazioni.

Una delle caratteristiche distintive di tali librerie è il concetto di ereditarietà : per ciascuna classe del nostro progetto è possibile definire un “logger” con una sua granularità e uscita che può essere un file, un OutputStream, un Writer, un server remoto ecc. E’possibile avere numerosi livelli di tracing: la seguente tabella definisce i livelli di log dei messaggi, in ordine decrescente di gravità. La colonna di sinistra è la denominazione del livello, la colonna di destra fornisce una breve descrizione di ogni livello di log.

Livello	Descrizione
OFF	Il grado più alto possibile. Disattiva l’output.
FATAL	errori gravi che causano cessazione anticipata.
ERRORE	Altri errori di runtime o condizioni inaspettate.
WARN	Messaggi a cui prestare particolare attenzione
INFO	Interessanti eventi di runtime (avvio / arresto).
DEBUG	Informazioni dettagliate
TRACE	Informazioni più dettagliate possibile

Ci sono due modi per configurare la libreria: uno è con un file di proprietà (chiave=valore) e l'altro è con un file XML . All'interno di entrambi è possibile definire tre componenti principali: Loggers, Appenders e Layouts.

Loggers: possiamo definire una gerarchia di nomi di logger secondo un principio di ereditarietà: un logger child eredita le proprietà dal logger parent. Ogni logger è configurabile in modo indipendente.
Appenders: configurano gli output. Ci sono numerosi appenders supportati, con nomi descrittivi, come ad esempio FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, NTEventLogAppender e SMTPAppender. Appenders multipli possono essere collegati a qualsiasi Logger, quindi è possibile registrare le stesse informazioni su più uscite, per esempio su un file locale e su un socket listener su un altro computer.
Layouts: sono usati per definire il formato dei messaggi. Un layout noto (one-line-at-a-time) è il PatternLayout. Per definire un layout si utilizza una “stringa modello”, molto simile alla funzione printf del C / C + + . Ci sono anche gli XMLLayout per formattare i messaggi in XML/HTML.

Facciamo adesso degli esempi concreti di utilizzo delle librerie con i linguaggi relativi.

Java e log4j

La libreria che si occupa di produrre log in Java (usabile su qualsiasi tipologia di progetto) è log4j. Vediamo un esempio semplice di utilizzo all’interno di un progetto Java creato con eclipse.

· Dopo aver scaricato lo zip/tar.gz dal sito, estrarre il contenuto e copiare il log4j*.jar che si trova nella radice della cartella unzippata, nella directory del nostro progetto (p.es. log4j-1.2.16.jar). Fare un Refresh sul Package Explorer di eclipse in modo che la libreria venga rilevata. Potremmo mettere il jar anche in un’altra cartella (es. lib) , ma ciò richiederà di aggiungere tale cartella al build path.

· Dalle proprietà del progetto (tx destro) scegliere Java Build Path ->Libraries -> Add JARs, aggiungere log4j-1.2.16.jar

· A questo punto il gioco è fatto, si possono usare liberamente le log4j. Ad esempio:

import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.Logger;

public class EsempioLog4j {

static final Logger logger = Logger.getLogger(EsempioLog4j.class);

public static void main(String[] args) {

BasicConfigurator.configure();

logger.debug("Hello World!");

}

Mandando in esecuzione avremo il seguente output su consolle:

2011-03-03 23:30:00,709 [main] DEBUG EsempioLog4j - debug

0 [main] DEBUG EsempioLog4j - debug

2011-03-03 23:30:00,711 [main] INFO EsempioLog4j - info

2 [main] INFO EsempioLog4j - info

2011-03-03 23:30:00,711 [main] WARN EsempioLog4j - warning

2 [main] WARN EsempioLog4j - warning

2011-03-03 23:30:00,711 [main] ERROR EsempioLog4j - error

2 [main] ERROR EsempioLog4j - error

2011-03-03 23:30:00,711 [main] FATAL EsempioLog4j - fatal

2 [main] FATAL EsempioLog4j - fatal

Il caso mostrato utilizza una configurazione di base. Tale configurazione può essere anche personalizzata mediante un file di configurazione XML o un file equivalente di Properties. Per esempio possiamo creare in eclipse un file xml log4j.xml nella cartella src del progetto e copiare ed incollare questa configurazione:

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

</layout>

</appender>

</logger>

<root>

<appender-ref ref="A1" />

</root>

</log4j:configuration>

Nella classe precedente al posto della riga:

BasicConfigurator.configure();

mettere:

URL url = Loader.getResource("log4j.xml");

DOMConfigurator.configure(url);

importando le classi necessarie. L’output sarà il seguente:

2011-03-03 23:20:25,891 [main] DEBUG EsempioLog4j - debug

2011-03-03 23:20:25,892 [main] INFO EsempioLog4j - info

2011-03-03 23:20:25,892 [main] WARN EsempioLog4j - warning

2011-03-03 23:20:25,892 [main] ERROR EsempioLog4j - error

2011-03-03 23:20:25,892 [main] FATAL EsempioLog4j – fatal

Naturalmente è possibile customizzare il file di configurazione a piacere, mandando per esempio l’output su file anzichè su consolle, in questo caso dovremmo definire un apposito appender.

C/C++ e log4cxx

Una volta scaricata/compilata la libreria log4cxx, dobbiamo includerla all’interno del nostro progetto. Va detto che compilare la log4cxx non è così banale, soprattutto sotto windows (cygWin/Visual Studio), mentre su linux è tutto molto più semplice col gcc.

Sotto linux, installare le librerie apr e apr-util tramite p.es. apt-get, successivamente:

$ tar xzf apache-log4cxx-0.10.0.tar.gz

$ cd apache-log4cxx-0.10.0/

$ ./configure --prefix=/usr

$ make

$ make install

Questo dovrebbe generare le opportune librerie da includere nel nostro Makefile.

Vediamo il caso Windows con VS 2008/2010:

1. Andare nel repository di APR di Apache (p.es. http://download.nextag.com/apache/apr/)

2. Fare il download della libreria APR ed estrarla. Rinominare la cartella apr.

3. Fare il download libreria APR-Util ed estrarla. Rinominare la cartella apr-util.

4. Fare il download dal sito “Apache Logging Services”, di Log4CXX ed estrarla. Al termine di queste operazioni dobbiamo avere una cartella apache-log4cxx-0.10.0 con le sottocartelle log4cxx, apr e apr-util

5. Download di GNU Sed (setup.exe per Win) e installarlo (mettere la cartella di sed.exe nella variabile di ambiente “Path” di Windows)

6. Andare nella directory apache-log4cxx-0.10.0

7. Esegui configure.bat

8. Esegui configure-aprutil.bat

9. Apri la solution log4cxx.dsw e convertirla ad una sln VS 2008/2010

10. Selezionare i progetti apr, apr-util e il progetto log4cxx e compilarli in ordine.

Al termine della procedura dovremmo ottenere la libreria statica log4cxx.lib e quella dinamica log4cxx.dll.

A questo punto il gioco è fatto. Basta includere nel nostro progetto la libreria log4cxx.lib e la cartella include di \apache-log4cxx-0.10.0\src\main\log4cxx nelle opzioni del Linker e in quelle di inclusione dalle Proprietà del progetto. Inoltre aggiungiamo anche log4cxx.dll nella cartella del nostro progetto. Facciamo un esempio di codice C++:

#include <log4cxx/logger.h>

#include <log4cxx/xml/domconfigurator.h>

#include <iostream>

using namespace log4cxx;

using namespace log4cxx::xml;

using namespace log4cxx::helpers;

using namespace std;

// Define static logger variable

LoggerPtr loggerMyMain(Logger::getLogger( "main"));

LoggerPtr loggerFunctionA(Logger::getLogger( "functionA"));

void functionA()

{

LOG4CXX_INFO(loggerFunctionA, "Executing functionA.");

}

int main(int argc, const char* argv[] )

{

// Load configuration file

DOMConfigurator::configure("Log4cxxConfig.xml");

LOG4CXX_TRACE(loggerMyMain, "debug message (detailed)");

LOG4CXX_DEBUG(loggerMyMain, "debug message");

LOG4CXX_INFO (loggerMyMain, "info message");

LOG4CXX_WARN (loggerMyMain, "warn message");

LOG4CXX_ERROR(loggerMyMain, "error message");

LOG4CXX_FATAL(loggerMyMain, "fatal message!!!");

functionA();

}

Il file log4cxxConfig.xml deve essere creato nella cartella principale del nostro progetto e rappresenta la configurazione del log. Per esempio:

<?xml version="1.0" encoding="UTF-8" ?>

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

</layout>

</appender>

</layout>

</appender>

<root>

<appender-ref ref="appxNormalAppender"/>

<appender-ref ref="appxConsoleAppender"/>

</root>

<appender-ref ref="appxNormalAppender"/>

<appender-ref ref="appxConsoleAppender"/>

</category>

</log4j:configuration>

L’output del programma sarà il seguente:

TRACE main - this is a debug message for detailed code discovery.

DEBUG main - this is a debug message.

INFO main - this is a info message, ignore.

WARN main - this is a warn message, not too bad.

ERROR main - this is a error message, something serious is happening.

FATAL main - this is a fatal message!!!

INFO functionA - Executing functionA.

Il logger oltrechè su consolle scriverà anche su file (appxLogFile.log)

.NET (C#/VB.NET/ASP.NET) e log4net

Vediamo un esempio di utilizzo di log4net dentro un normale progetto .NET (Console Application), usando Visual Studio 2010.

Per inserire log4net dentro un progetto .NET (C#,VB.NET,ASP.NET) è sufficiente effettuare i seguenti passi:

Una volta scaricata/compilata log4net.dll, copiarla nella directory di progetto.
In Visual Studio cliccare col tasto destro e aggiungere un nuovo riferimento (aggiungi Riferimento/Reference dal menù contestuale) a log4net.dll: scegliere sfoglia e selezionare log4net.dll.
Aggiungere un file App.config al progetto (tasto destro sul progetto in VS -> Aggiungi Nuovo Elemento->General->Application Configuration File)
Copiare ed incollare in App.config il seguente contenuto xml che rappresenta la configurazione di log4net:

File App.config

<?xml version="1.0" encoding="utf-8" ?>

<section name="log4net"

type="log4net.Config.Log4NetConfigurationSectionHandler,

log4net"/>

</configSections>

<root>

<appender-ref ref="LogFileAppender" />

<appender-ref ref="ColoredConsoleAppender" />

</root>

</layout>

</appender>

</mapping>

</mapping>

</mapping>

</mapping>

</layout>

</appender>

</log4net>

</configuration>

Come si vede in questo file decidiamo il formato dei messaggi, i loro colori ecc.

· Fare attenzione al profilo scelto per il progetto. Non usare un Client Profile che di solito è quello di default nel caso di Console Application in VS 2010. Ciò non è possiblie a causa della dipendenza di log4net dall’assembly System.Web. Scegliere come Target Profile per esempio .NET Framework 4 (dalle proprietà del progetto). Usando il Client Profile si possono avere problemi di riconoscimento della libreria log4net col seguente errore : “The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly reference?)”

· Utilizzare ora liberamente log4net, ad esempio:

using System;

using log4net;

using log4net.Config;

namespace EsempiodiUsoLog4Net

{

class Program

{

private static readonly ILog logger = LogManager.GetLogger(typeof(Program));

static void Main(string[] args)

{

ILog log = LogManager.GetLogger("MyLogger");

XmlConfigurator.Configure();

log.Error("Error");

log.Warn("Warning");

log.Info("Info.");

log.Debug("debug..");

Console.ReadLine();

}

L’output sarà:

.NET (C++/CLI) e log4net

Utilizzare log4net all’interno di un progetto C++/CLI è leggermente più oneroso rispetto al caso C#/VB.NET/ASP.NET.

· Una volta scaricata/compilata log4net.dll, copiarla nella directory di progetto.

· In Visual Studio cliccare col tasto destro e aggiungere un nuovo riferimento (aggiungi Riferimento/Reference dal menù contestuale) a log4net.dll: scegliere sfoglia e selezionare log4net.dll.

· Aggiungere un file app.config al progetto (tasto destro sul progetto in VS -> Aggiungi Nuovo Elemento -> Utilità->File di configurazione in VS 2008/ Application Configuration File in VS 2010). Copiare ed incollare il contenuto del file App.config visto nel caso C#/VB.NET/ASP.NET .

· Copiare l’app.config nella directory di output aggiungendo la riga di comando “copy app.config "$(TargetPath).config” come evento di post-compilazione del progetto. Ciò creerà un file <nome_mia_app>.config nella directory di output del progetto.

· Aggiungere /SUBSYSTEM:CONSOLE tra le opzioni del Linker (Linker->Sistema->Sottosistema) nel caso si voglia l’output a consolle.

· Leggere le considerazioni sul Target Profile fatte nel caso C#/VB.NET/ASP.NET.

· Ora possiamo usare log4net all’interno del progetto C++/CLI. Facciamo un esempio:

File Log.cpp

#include "StdAfx.h"

#include "Log.h"

using namespace log4net;

using namespace log4net::Config;

Log::Log(void)

{

log4net::ILog^ log = LogManager::GetLogger("MyLogger");

XmlConfigurator::Configure();

log->Error("Error");

log->Warn("Warning");

log->Info("Info.");

log->Debug("debug..");

}

L’output sarà lo stesso visto nel caso C#.

PHP e log4php

Log4php è la libreria di log dedicata agli sviluppatori PHP. In pratica ha le stesse proprietà comuni alle altre librerie e la stessa struttura. Supporta i seguenti appenders: File, RollingFile, DailyFile, Echo, Console, Mail, PDO, PHP error, Syslog or NT events e Socket; nonchè i seguenti layouts: Simple, TTCC, Pattern, Html e Xml.

L’installazione consiste nei seguenti semplici punti:

Scaricare la libreria e unzipparla
Copiare la cartella src/main/php in quella dell’applicazione, p.es. $YOURAPP/log4php
Includere (require) la classe log4php/Logger.php nell’applicazione

L’esempio d’uso è quasi banale:

require_once dirname(__FILE__).'/../../main/php/Logger.php';

Logger::configure(dirname(__FILE__).'/../resources/layout_simple.xml');

$logger = Logger::getRootLogger();

$logger->info("Hello World!");

Proprietà dinamiche

Qualcuno si chiederà come sia possibile dare proprietà dinamiche agli appenders: per esempio dare un nome a un log file dinamico. Le librerie supportano le proprietà dinamiche settabili via codice. Per esempio se volessimo un nome di file dinamico possiamo mettere nel file di configurazione (nella sezione appender):

Tale proprietà potrà essere settata via codice. Per esempio in C#:

log4net.GlobalContext.Properties["LogName"] = "file1.log";

Ricordarsi di settare le proprietà del GlobalContext prima di richiamare il logger, ossia prima della riga

ILog log = LogManager.GetLogger("MyLogger");

Insieme alle proprietà dinamiche possiamo definire anche dei PropertyFilter. Per esempio definendo nel file di configurazione:

</filter>

Possiamo scegliere via codice la versione del file di log sul quale mandare i messaggi:

log4net.ThreadContext.Properties["Version"] = "1";

log.Warn("Warning on the version 1 of the log file");

ci sono ancora molte proprietà che contraddistinguono le librerie di log di Apache, ma elencarle tutte sarebbe troppo lungo in questo articolo. Si rimanda quindi alla relativa documentazione sul sito.

Tools di visualizzazione

Uno dei vantaggi di utilizzare una libreria di Apache Logging Services è che esistono una serie di tool di visualizzazione dei log prodotti da tali librerie. Uno è per esempio fornito da Apache stesso: Chainsaw.

Chainsaw è stato pensato per log4j ma è possibile interfacciarlo anche con le altre librerie della famiglia per mezzo dell’UdpAppender. Si rimanda alla relativa documentazione per il suo utilizzo e configurazione.

Passaggio di parametri ai metodi in Java e C#

2011-02-28T23:55:00.000+01:00

Diamo oggi un’occhiata ad un argomento che ho notato solleva dubbi ai programmatori principianti: come vengono trattati gli oggetti e le variabili passati come argomenti ai metodi, per riferimento o per valore e quali sono le differenze tra i due linguaggi C# e Java.

Iniziamo col dire cosa significa passaggio “per valore” e passaggio “per riferimento” (indipendentemente dal linguaggio utilizzato):

Valore: viene creata una copia di una variabile al momento della chiamata, per cui il metodo non agisce direttamente sulla variabile originale ma solo sulla sua copia, quindi all’uscita di tale metodo la variabile originale rimarrà immutata
Riferimento: viene passato un riferimento (indirizzo) alla variabile per cui il metodo chiamato agirà direttamente sulla variabile originale tramite il suo riferimento.

Anche le variabili si suddividono principalmente in due tipologie:

ValueTypes: sono i cosiddetti tipi primitivi. Vengono usualmente allocati nello stack. Esempi di tipi primitivi sono int, double, float e le strutture (p. es. la struttura Int32 per .NET)
ReferenceTypes: sono i cosiddetti tipi complessi. Sono tutti gli oggetti definiti tramite una “class”. Usualmente tali tipi vengono allocati nel Managed Heap tramite una new. Esempi sono le classi che noi creiamo, oppure quelle preesistenti nel framework (p.es. la classe Integer in Java è un Reference Type)

In Java e C# tutte le variabili (ValueTypes o ReferenceTypes) vengono passate ai metodi, di default, per valore. Sfatiamo il mito che dice che in Java le variabili primitive sono passate per valore e gli oggetti per riferimento: è corretto invece dire che in Java (come in C#), vengono passati i riferimenti agli oggetti per valore, così come confermato dallo stesso James Gosling, uno degli inventori di Java:

“Some people will say incorrectly that objects are passed “by reference.” In programming language design, the term pass by reference properly means that when an argument is passed to a function, the invoked function gets a reference to the original value, not a copy of its value. If the function modifies its parameter, the value in the calling code will be changed because the argument and parameter use the same slot in memory…. The Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode — pass by value — and that helps keep things simple.”

James Gosling – The Java Programming Language, 4th Edition

Java e C# hanno quindi lo stesso comportamento. Vediamo un esempio in Java sui tipi primitivi:

public class A{

...

void A_method(int k){

int i=10*k; //questa i è locale al metodo e non ha niente a che fare con quella esterna

k=5; //qui si modifica il valore di una variabile locale al metodo (k)

...

}

...

int i=2;

A a;

a.A_method(i);

int j=i;//qui si avrà j=i=2 e non 5!

...

La chiamata al metodo passando per valore la variabile i, non sortisce su questa alcun effetto anche se A_method copia il valore di i su un’altra variabile k. In C# il discorso è analogo.

Il discorso per i ReferenceTypes è invece differente e merita un pò di attenzione.

Soprattutto in C#, il passaggio per valore di un oggetto (che è quello di default), può creare qualche confusione iniziale e qualche sorpresa. Abbiamo visto che passare un oggetto per valore significa che verrà creata una copia non dell’oggetto stesso, ma del suo riferimento. Ciò significa che se io chiamo un metodo e gli passo un oggetto, verrà creata una copia del riferimento e cioè tale copia del riferimento punterà all’oggetto stesso: il risultato è che le modifiche apportate ad un oggetto dentro al metodo in C# saranno persistenti.

Si considerino le seguenti classi C#:

class A

{

public int val {get;set;}

}

class Class1

{

public void A_byVal1(A k)

{

k.val = 10; //qui i riferimenti di k e ag sono gli stessi e l’istruzione agisce su ag

A b = new A(); //questo new crea un nuovo riferimento

b.val = 100;

k = b; //questo copia il riferimento di b in k

k.val = 200; //qui k.val e b.val valgono entrambi 200, ma ag.val vale sempre 10!

}

con le seguenti istruzioni:

Class1 c1 = new Class1();

A ag1 = new A();

ag1.val = 1;

c1.A_byVal1(ag1); //all’uscita ag1.val vale 10: non 1, non 100 e nemmeno 200!

All’uscita del metodo A_byVal1, ag1.val vale 10 perchè al momento della chiamata di A_byVal1 viene creata una copia della reference di ag1 (ref_ag1), chiamiamola ag1_ref_copy: ma allora ref_ag1 e ag1_ref_copy puntano entrambe ad ag1 e da ciò si capisce come k.val = 10; vada a modificare il reale valore dell’oggetto ag1 originale. La new dentro il metodo crea un altro oggetto b nel Managed Heap, ne inizializza il valore a 100 e copia il riferimento dell’oggetto b in k: ciò significa che l’oggetto originale ag non viene più modificato poichè il riferimento di k punta ad una variabile locale b, che verrà segnata per l’eliminazione all’uscita del metodo dal GC.

Il meccanismo per passare variabili (primitive e non) ad un metodo per riferimento in C# prevede l’utilizzo della parola chiave ref (tale metodologia ha origini probabilmente dal C++ in cui si usava il carattere & per indicare il passaggio per riferimento di una variabile):

public void A_byRef2(ref A k)

{

//qui k e ag puntano alla stessa locazione (ag.val = 0)

A b = new A(); //questo new crea un nuovo riferimento

b.val = 10;

k = b; //questo copia il riferimento di b in k, ma quindi anche ag punta a b

}

Class1 c1 = new Class1();

A ag1 = new A();

ag1.val = 0;

c1.A_byRef2(ref ag); //all’uscita ag1.val vale 10, non 0!

Come si nota, pur creando un riferimento locale, all’uscita del metodo ag.val varrà 10: ciò avviene perchè al momento della chiamata non viene fatta una copia del riferimento di ag, ma viene usata proprio quella locazione: per cui quando copio b in k, sto copiando proprio sulla locazione di memoria puntata da ag. A differenza del caso del passaggio per valore (metodo A_byVal1), all’uscita del metodo la locazione creata nello heap con la new (b), non verrà segnata per la distruzione dal GC perchè puntata ancora da ag. Qualcuno potrebbe chiedersi come mai l’operatore di assegnamento delle variabili ReferenceType agisce sui riferimenti e non sui valori: il motivo è che quando usiamo gli operatori noi passiamo le variabili per valore e se usiamo i ReferenceTypes passeremo per valore i riferimenti alle variabili contenenti i valori. In .NET e Java i vari operatori (=,+=,-= ecc.), come tutti i metodi che ricevono ReferenceTypes, agiscono sull'indirizzo di memoria dell'oggetto, ovvero l'indirizzo che fa riferimento all'oggetto. Come noto invece, i ValueTypes contengono invece direttamente il valore e non sono sotto il controllo del GC. La differenza tra ValueTypes e ReferenceTypes spesso viene mascherata dal meccanismo di boxing - unboxing (wrapping – unwrapping in Java) che consiste nell’incapsulare il ValueType dentro un ReferenceType. Proviamo a sottoporre alle stesse operazioni due variabili, una ValueType e una ReferenceType.

Data la classe A vista prima, si consideri il seguente esempio in C#:

A d_ref1 = new A(); // Allocato nell'heap

double d_val1; // Allocato nello stack

d_ref1.val = 10; // Cambia il riferimento a cui punta

d_val1 = 10; // Cambiato il valore nello stack

A d_ref2 = d_ref1; // Copia il solo riferimento (puntatore)

double d_val2 = d_val1; // Alloca nello stack e copia il valore

d_ref1.val = 20;

d_val1 = 20;

Console.WriteLine("d_ref1.val = {0}, d_ref2 = {1}", d_ref1.val, d_ref2.val);

Console.WriteLine("d_val1 = {0}, d_val2 = {1}", d_val1, d_val2);

Eseguendo questo codice si otterrà il seguente output:

d_ref1.val = 20, d_ref2.val = 20

d_val1 = 20, d_val2 = 10

Ossia quando si applica l’operatore di assegnamento (cfr. metodo) ai ValueTypes e ai ReferenceTypes si ha un comportamento differente perchè l’operatore di assegnamento agisce direttamente sui valori dei primi e sugli indirizzi dei secondi (d_val1 = 20 non interferisce con d_val2, mentre d_ref1.val = 20; fa in modo che pure d_ref2.val punti alla locazione contenente 20. Nota: in questo esempio C# non potevamo usare Double al posto di A perchè essa, pur effettuando il boxing di double, è una structure che comunque viene allocata nello stack di default.

Anche in Java gli oggetti Reference sono passati ai metodi per valore dei riferimenti, perciò l'oggetto referenziato può essere modificato dal metodo. Il comportamento è del tutto simile al C#. Per verificarlo facciamo un esempio.

Supponiamo di avere le seguenti classi Java:

public class A {

int val=0;

...

}

public class Class1

{

void A_byRef(A k) {

k.val=20; //qui i riferimenti di k e ag sono gli stessi e l’istruzione agisce su ag

...

k= new A(); //qui viene creato un nuovo riferimento per k

k.val=100; //questa istruzione agisce solo su k locale

}

Effettuiamo una chiamata al metodo A_byRef:

Class1 c1 = new Class1();

A ag = new A();

ag.val = 5;

c1.A_byRef(ag);

int i = ag.val; //i vale 20 non 5 e nemmeno 100

Il caso di Java è del tutto simile a quello di C#: il riferimento di ag viene passato per valore cosicchè alla chiamata viene fatta una copia di ref_ag, ref_ag_copy. A questo punto l’istruzione (e solo quella) k.val=20; agirà sull’istanza di ag originale, mentre la copia creata successivamente con la new crea un nuovo riferimento ad un’altra istanza di oggetto nello heap di tipo A, per cui k.val=100 non ha ripercussioni su ag.

A questo punto nasce una domanda spontanea: si possono passare variabili in Java per riferimento come in C#? La risposta è no! Non esiste in Java l’equivalente della parola chiave ref e ciò spiega come mai non potremmo mai scambiare due variabili int dentro un metodo Java senza l’utilizzo della tecnica del boxing!

public void badSwapInJava(int var1, int var2)

{

int temp = var1;

var1 = var2;

var2 = temp;

}

Il metodo badSwapInJava() non altera le variabili passate. Facendo il boxing (alias wrapping) otteniamo il risultato voluto:

public void boxingSwapInJava(MyInteger rWrap, MyInteger sWrap) {

int t = rWrap.getValue();

rWrap.setValue(sWrap.getValue());

sWrap.setValue(t);

}

Interfacce grafiche in .NET con il linguaggio XAML

2011-02-24T23:35:00.000+01:00

Quando si vogliono realizzare delle applicazioni in .NET con Silverlight, oppure delle presentazioni WPF (Windows Presentation Forms) si ha bisogno di conoscere il linguaggio XAML (eXtensible Application Markup Language). XAML è un linguaggio sviluppato all'interno del .NET Framework, che ci permette di descrivere delle interfacce utente per mezzo di un documento XML in modo schematico.

Quali sono le proprietà e perchè è stato scelto di usare XAML?

Come per gli altri linguaggi .NET, XAML viene compilato in codice intermedio (IL).
Utilizza grafica vettoriale.
Le proprietà di presentazione sono parte del linguaggio (a differenza di XUL che utilizza i CSS). Ciò lo rende più facile da scrivere, ma più difficile da modificare.
XAML utilizza le librerie e le classi .NET come un vero e proprio linguaggio del Framework
XAML dà possibilità di includere codice C# associato (XUL usa Javascript)
Gli eventi sono proprietà dei tag e i tag sono widget.

Le regole di XAML sono semplici:

Ciascun elemento di un documento XAML viene mappato ad una classe in .NET (es. Button)
Gli elementi hanno una struttura gerarchica in modo tale che gli elementi contengono o sono contenuti da altri elementi (es. Button dentro una Window)
Si può accedere alle proprietà “semplici” di una classe per mezzo degli attributi di un elemento (es. Button “Content”), oppure, se la proprietà è a sua volta un oggetto, tramite un mappaggio proprietà-elemento (es. Button.Background)

Supponiamo di voler creare un bottone contenuto in una finestra che abbia un certo titolo. In C# scriveremo:

namespace PED.Demo
{

class Program

{

[STAThread]

static void Main()

{

var b = new Button

{

Content = "Click Me!"

};

var w = new Window

{

Title = "XAML Demo",

Content = b

};

var app = new Application();

app.Run(w);

}

Tale finestra può essere espressa anche in linguaggio XAML:

File MainWindow.xaml

<Window x:Class="WpfApplication1.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="XAML Demo" Height="350" Width="525">

<Grid>

</Grid>

</Window>

Si noti come sia necessario includere i namespaces di XAML.

La finestra dovrà essere poi inclusa all’interno di un’applicazione:

File App.xaml:

<Application x:Class="WpfApplication1.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

StartupUri="MainWindow.xaml">

<Application.Resources>

</Application.Resources>

</Application>

Questo semplice esempio ci fa capire come le classi in .NET possano essere mappate in XAML e viceversa. E’ possibile anche usare classi custom all’interno di XAML. Per esempio:

<Window x:Class="WpfApplication1.MainWindow"
xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”

xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”

Title=”XAML Demo” Height=”350” Width=”525”>

<local:Person FirstName=”Mario” LastName=”Rossi” />

<local:Person FirstName=”Gino” LastName=”Bianchi” />

</ListBox>

</StackPanel>

</Window>

In questo esempio abbiamo inizializzato una classe Person definita localmente e che possiede due proprietà “FirstName” e “LastName”. Implementando il metodo ToString() della classe Person potremo riempire la ListBox con nomi e cognomi. In poche righe di codice C# la classe Person è così definita:

public class Person
{

public string FirstName { get; set; }

public string LastName { get; set; }

public override string ToString()

{

return string.Format("{0} {1}", FirstName, LastName);

}

Per utilizzare XAML dobbiamo creare un progetto in Visual Studio che utilizzi tale linguaggio (per esempio un'applicazione WPF o Silverlight). Una volta creato un nuovo progetto in Visual Studio, tale IDE ci creerà automaticamente lo scheletro dell'applicazione con i file App.xaml e MainWindow.xaml visti in precedenza, nonchè i file C# (.cs) ad essi collegati (code behind). Realizzare una GUI con XAML/WPF in Visual Studio è del tutto simile a crearne una in Windows Forms o ASP.NET, dato che vi è il "solito" sistema WYSIWYG col drag & drop, affiancato però dal codice XAML.

Si voglia ora per esempio creare un bottone colorato con un certo gradiente: dalla toolbox di VS poniamo un bottone nella MainWindow, analizzando il codice XAML possiamo accedere alle proprietà del bottone come se fossero elementi del documento (VS ci permette di accedere a tali proprietà anche in una finestra separata):

<Window x:Class="WpfApplication1.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="MainWindow" Height="350" Width="525">

<Grid>

<Button Content="Click Me!" Height="23"

HorizontalAlignment="Left"

Margin="129,36,0,0"

Name="button1"

VerticalAlignment="Top"

Width="75" Click="button1_Click">

<Button.Background>

<LinearGradientBrush.GradientStops>

</GradientStopCollection>

</LinearGradientBrush.GradientStops>

</LinearGradientBrush>

</Button.Background>

</Button>

</Grid>

</Window>

Si noti come si definiscono le proprietà del bottone dentro dei tag annidati i cui nomi sono quelli definiti all’interno della classe Button. Il risultato è un bottone del genere:

Come visto, in XAML gli oggetti possono contenere altri oggetti per cui potremmo pensare di dichiarare allo stesso modo array o collezioni di oggetti:

<x:Array Type="local:Person">
<local:Person FirstName="Mario" LastName="Rossi" />

<local:Person FirstName="Gino" LastName="Bianchi" />

</x:Array>

Definisce un array di oggetti Person (x:array è un'estensione di Markup per il supporto alle matrici).

Supponiamo ora di voler collegare l’evento “click” del bottone a del codice C# che visualizzi un messaggio a video. Cliccando due volte sul bottone dell'anteprima in Visual Studio, verrà creato l'evento button1_Click nel Code Behind associato:

public partial class MainWindow : Window

{

public MainWindow()

{

InitializeComponent();

}

private void button1_Click(object sender, RoutedEventArgs e)

{

MessageBox.Show("Click!");

}

In questo semplice esempio abbiamo visto un modo per utilizzare XAML. In realtà XAML ha diversi “dialetti”: WPF XAML (XAML per WPF), XPS XAML (XAML per descrivere documenti elettronici), Silverlight XAML (subset di XAML per Silverlight), WF XAML (XAML per Windows Workflow Foundation). XAML ha dei meccanismi quali:

- Markup Extensions: estensioni utilizzate per settare dinamicamente i valori delle proprietà degli oggetti grafici in funzione di altri oggetti esistenti.

Vediamo un esempio con una StaticResourceExtension:

<Window x:Class="WpfApplication1.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="XAML Demo" Height="350" Width="525">

<StackPanel.Resources>

<SolidColorBrush

x:Key="TextBackBrush"

Color="LightBlue"

</StackPanel.Resources>

<TextBlock Background="{StaticResource TextBackBrush}">Hello!</TextBlock>

</StackPanel>

</Window>

Questo codice disegnerà la scritta "Hello!" su uno sfondo azzurro chiaro: per cambiare il colore dello sfondo basterà modificare la proprietà Color di SolidColorBrush. Ci sono altri modi per creare delle MarkupExtension, ma tralascerò per ora questo argomento.

- Attached Properties: sono delle proprietà che si possono applicare a più controlli differenti, ma la cui definizione è data a livello di classe. Inoltre permettono di creare proprietà “virtuali” che di fatto estendono quelle già presenti in una certa classe. La sintassi da usare è AttachedPropertyProvider.PropertyName.

Per esempio:

<CheckBox DockPanel.Dock="Top">Hello</CheckBox>

</DockPanel>

DockPanel.Dock è una proprietà valida per tutti gli oggetti DockPanel. Si noti come il concetto è simile alle proprietà statiche delle classi: in C# questo può essere descritto per esempio con:

DockPanel.SetDock(myCheckBox, Dock.Top);

Qui si possono trovare alcune utili risorse che parlano di XAML:

XAML Overview
WPF Tutorial
Markup Extensions and XAML
Creating a Simple MarkupExtension
Attached Properties Overview

Sviluppare RIA con Flash, Silverlight o Java: tecnologie a confronto

2011-02-18T23:46:00.000+01:00

Mi sono domandato quale fosse la tecnologia migliore da adottare attualmente per realizzare una piccola presentazione grafica su un sito.
Quando navighiamo in internet ormai ci troviamo di fronte a delle vere e proprie applicazioni interattive graficamente accativanti: sono le cosiddette Rich Internet Applications (RIA).
Ho fatto delle ricerche in internet e mi si sono presentate cinque opzioni accettabili:

Adobe Flash: è la tecnologia che c'è da più tempo per fare applicazioni grafiche leggere di proprietà di Adobe-Macromedia. Fondamentalmente i sorgenti si basano su un linguaggio di script detto ActionScript. Gli ambienti di sviluppo più usati sono Adobe Flash Builder (versione trial gratuita oppure la "Premium" a pagamento), Adobe Air o Flash Develop (open source, gratuito). Richiede l'installazione di un plugin sul browser dell'utente finale.

Microsoft Silverlight: tecnologia Microsoft secondo cui un plugin può essere sviluppato mediante linguaggi XAML (eXtensible Application Markup Language) e C#: si integra perfettamente all'interno del .NET Framework e Visual Studio, essendo XAML il linguaggio usato per decrivere le interfacce grafiche in WPF (Windows Presentation Foundation). Richiede l'installazione di un plugin sul browser dell'utente finale.

JavaFX: famiglia di software applicativi, basati sulla Piattaforma Java, creato da Sun Microsystems e divenuto un prodotto Oracle. Lo sviluppo delle applicazioni si basa su un linguaggio che ha alcuni scostamenti da Java detto "JavaFX script", ma pienamente supportato dalla Sun. L'ambiente di sviluppo rimane quello classico di Java: Eclipse o NetBeans. L'applicazione si integra al browser come fosse un'applet, per cui sul client vi deve essere una JRE installata.

Javascript: si raggiungono risultati ammirevoli per mezzo di tecnologie AJAX e librerie quali JQuery, Prototype, Ext JS ecc. L'ambiente di sviluppo è quello classico di Java (p.es. NetBeans/Eclipse) anche se il debugging è più laborioso. Il vantaggio consiste nel non dover scaricare alcun plugin o ambiente sul client, ma basta attivare Javascript. Uno svantaggio di questo approccio è che il risultato finale non è indipendente dal browser sul quale girerà la presentazione, ma bisognerà tener conto della piattaforma client.

OpenLaszlo: è una piattaforma open source per lo sviluppo di applicazioni web, è basato sui linguaggi Java/LZX e su un OpenLaszlo Server. In pratica l'applicazione web viene rilasciata come una normale servlet che gira sull'OpenLaszlo Server.Il risultato è un DHTML oppure un normale file Flash SWF. Questa tecnologia, dal punto di vista di un browser, in realtà non presenta niente di nuovo rispetto alle altre tecnologie esistenti, mi pare più che altro un modo alternativo per creare file Flash.

Ci sono anche altre tecnologie adottabili, ma queste esulano dagli scopi di creare una semplice presentazione di immagini che sia leggera, economica di risorse e semplice da realizzare (vedi p.es. la piattaforma open source Flex o Java Swing).
Dopo una breve indagine, ho decretato che le opzioni sono abbastanza equivalenti per ciò che riguarda il risultato finale (l'aspetto grafico). Ho trovato interessanti siti in cui le tecnologie vengono messe a confronto (per esempio questo confronta Flash con Silverlight, mentre questo esegue un benchmark tra le diverse tecnologie). Quest'altro link evidenzia la richiesta del mercato delle tre tecnologie Flash, Silverlight e JavaFX. Un punto a favore di Flash lo si ha andando a guardare quale sia la penetrazione attuale nei browser tra Flash, Silverlight e Java. Due interessanti siti sono RIAStats e StatOwl. Nonostante Silverlight stia aumentando la sua popolarità e area di mercato, la sua penetrazione si aggira intorno al 61.11%, ancora Flash risulta il plugin più installato (96.12%), mentre Java rimane costante (78.54%).
Credo che ad oggi la scelta di Adobe Flash, a meno di altri fattori, sia ancora quella più azzeccata.

Un'introduzione alle EAI (Enterprise Application Integration)

2011-02-14T23:45:00.000+01:00

Sempre più si sente parlare in ambito IT di integrazione di sistemi informativi: si pensi per esempio a diversi sistemi che devono scambiarsi informazioni tra loro, ma spesso sono completamente eterogenei per tecnologie, funzionalità, ambienti in cui vivono. Lo scenario è quello in cui diverse applicazioni (con scopi, tempistiche e tecnologie eterogenee), sviluppate magari in .NET piuttosto che in Java o C/C++, devono interagire tra loro su macchine differenti (p.es. 32/64 bit) e su SO differenti.
Per ovviare a tali problematiche si ricorre spesso a piattaforme standard di integrazione dette appunto EAI.
Diamo una definizione formale:

Fonte Wikipedia:
"Enterprise Application Integration (EAI) (integrazione d'applicazioni di impresa) si riferisce al processo d'integrazione tra diversi tipi di sistemi informatici attraverso l'utilizzo di software e soluzioni architetturali".

L'integrazione può essere semplice (trasferimento di dati tra due applicazioni, diverso posizionamento "fisico" dei sistemi), o complessa (esigenze di riservatezza nel trasferimento dei dati, garanzia di consegna, sicurezza ecc.). Le piattaforme EAI si occupano di risolvere l'integrazione semplice (solitamente è un integrazione interna all'azienda).
L'esigenza di avere piattaforme EAI è nata proprio dalla complessità di far interagire tra loro sistemi eterogenei: inizialmente l'interazione avveniva con soluzioni punto-punto, ossia i sistemi dialogavano tra loro a due a due con soluzioni più o meno customizzate. Tutto ciò introduceva un grosso problema architetturale detto "degli spaghetti", ossia una proliferazione di collegamenti diretti tra i sistemi e la perdita di controllo del trasferimento dell'informazione. Una prima risposta a tale "caos" si è avuta introducendo un primo livello di astrazione (Connectors e Data Transport) dello strato "fisico" di trasporto: avere un layer di comunicazione uguale per tutti per mezzo di costrutti informatici detti connectors e adapters. Tali costrutti vengono realizzati mediante framework che implementano i vari connettori alle applicazioni oppure, se l'integrazione avviene tra due prodotti, mediante adattatori ad hoc. La distinzione tra connector e adapter veniva fatta in base al loro impiego per interfacciare tra loro tecnologie diverse, diversi prodotti o diversi database. Questo livello di astrazione introdotto è in pratica uno strato che si occupa di interfacciare tra loro diverse tecnologie e diverse infrastrutture al livello più basso. Un secondo livello di astrazione deve essere introdotto per ovviare al problema dei "dialetti": si pensi ad esempio a due database che girano su DBMS diversi che devono dialogare tra loro, ciascuno col proprio "dialetto" SQL. Lo strato delle "Trasformazioni" serve proprio per cercare di astrarre le comunicazioni tra sistemi che hanno linguaggi o parti del linguaggio differenti.
Le piattaforme EAI di prima generazione solitamente implementano questi due livelli di astrazione.
Le piattaforme di seconda generazione implementano un ulteriore livello di astrazione detto del "flusso dei processi": si può avere non solo un'astrazione del trasferimento di informazioni tra le applicazioni, ma anche delle loro funzionalità e quindi della logica su come vengono integrate.

Livelli di astrazione:

Connectors & Data Transport (connectors e adapters)
Transformations (conversioni tra dialetti)
Process Flows (logica di integrazione)

Ci sono principalmente due tipi di piattaforma EAI:

Broker Engine: questo tipo di piattaforme si concentra sul far comunicare applicazioni eterogenee. Esse consistono in un componente detto "broker engine" che si occupa di trasferire i dati da un'applicazione all'altra, ma senza entrare nei dettagli della connettività. In pratica un broker engine utilizza diversi "connector" e "adapter" che si occupano della comunicazione tra il broker e l'applicazione ad un livello di astrazione più basso. In pratica il livello di astrazione (Connectors e Data Transport) introdotto dai connector e dagli adapter permette al broker engine di dedicarsi all'esclusivo instradamento dei flussi di dati.

Process Mapper Engine: sono le piattaforme EAI di ultima generazione. Tali EAI si occupano della gestione dei processi. Oltre al livello di astrazione dei connectors e degli adapters viene introdotto un ulteriore livello di astrazione detto Process Flow: in pratica viene astratta la logica di integrazione (composition logic). In tale scenario si può scegliere come integrare i diversi sistemi secondo una logica dei servizi da essi offerti. Da qui alle architetture SOA (Service Oriented Architecture) il passo è breve.

Un esempio di Broker Engine è il Message Broker che si occupa di smistare messaggi tra diverse applicazioni: un Message Broker è in grado di fornire a ciascuna applicazione un adapter ad hoc, inoltre la logica di instradamento dei messaggi può essere comandata tramite una logica programmabile (composition logic). Tale logica può essere implementata tramite un WfMS (Workflow Management System).

Il Message Broker come Broker Engine

Interfacciare Liferay con LDAP

2011-02-12T23:44:00.000+01:00

Liferay è una applicazione web open source basata sul linguaggio Java per la gestione e la customizzazione di portali.
Liferay sfrutta la gestione delle portlet (supporta lo standard portlet API JSR-168). Esso permette di creare facilmente da un normale sito web a un complesso portale di servizi. Una caratteristica interessante di Liferay è che esso può essere interfacciato con un preesistente sistema di autenticazione quale LDAP, NTLM ecc.
Liferay può essere personalizzato per ciascun utente che si logga al portale con una granularità molto fine: per esempio posso decidere per ciascun utente o gruppi di utenti quali portlet, documenti, contenuti ecc. può vedere o con quali può interagire.
Tutti gli accessi al portale (profilazione utente con i suoi privilegi) saranno pilotati dal nostro sistema di autenticazione centralizzato.

Vediamo un esempio di integrazione con LDAP: una volta loggati come utente administrator di Liferay (utente Administrator locale), andare nel Pannello di Controllo di Liferay nella sezione Portale -> Configurazione -> Autenticazione -> LDAP. Chekkare il flag "Abilitato", mentre quello "Richiesto" abilitarlo solo nel caso che tutti gli utenti che si dovranno loggare a Liferay siano solo di LDAP. Premere il bottone "Aggiungi" Server LDAP. A questo punto dobbiamo configurare l'autenticazione:

Configurazione

Nome del server (immettere un nome simbolico del server)

Valori Predefiniti (selezionare il tipo server LDAP)

Scegliere il tipo di server tra quelli a disposizione, per esempio se abbiamo in azienda un Active Directory con LDAP selezionare "Microsoft Active Directory Server", introdurre l'IP e la porta del servizio LDAP (ricavabile dal server), di default vale "ldap://localhost:10389".

Apache Directory Server

Fedora Directory Server

Microsoft Active Directory Server

… ecc.

Connessione - Base Provider URL, Il formato dell'URL del LDAP Base Provider è ldap://host:port.- Base DN specifica il contesto di ricerca iniziale per gli utenti ed è opzionale. Ad esempio, usare ldap://localhost:389 e ou=Users,o=Example come valori - Il formato dell'URL del LDAP Base Provider è ldap://host:port. Il Base DN specifica il contesto di ricerca iniziale per gli utenti ed è opzionale. Ad esempio, usare ldap://localhost:389 e ou=Users,o=Example come valori.- Immetere le credenziali di un amministratore (ad esempio admin,dc=local)

Utenti

- Filtro di Ricerca Autenticazione. Inserisci il filtro di ricerca che sarà utilizzato per verificare la validità di un utente. I campi @company_id@, @email_address@ e @user_id@ sono sostituiti a runtime con i valori corretti. Ad esempio (mail=@email_address@)- Importa Filtri di Ricerca: ad esempio (objectClass=person), filtro di ricerca per utente

Mappatura dell'Utente

Immetere i valori dei campi che a runtime verranno sostituiti con quelli trovati sul server:

Nome Utente: cn

Password: userPassword

Indirizzo Email: userPrincipalName

Nome Completo:

Nome: givenName

Secondo Nome:

Cognome: sn

Job Title: title

Gruppo: memberOf

Gruppi

Filtro per importare i gruppi:

Importa Filtri di Ricerca: (objectClass=groupOfUniqueNames)

Tracciato del Gruppo

Nome del Gruppo: cn

Descrizione: description

Utente: uniqueMember

Esporta

Esporta i dati su Liferay

DN Utenti: ou=users,dc= company_domain,dc=local

Classi Oggetto Predefinite per l'Utente: top,person,organizationalPerson,inetOrgPerson

Gruppi DN: ou=groups,dc= company_domain,dc=local

Codici categoria di oggetto di difetto del gruppo: top,groupOfUniqueNames

Questo potrebbe essere un esempio di configurazione di Liferay. In pratica Liferay si connetterà al nostro server LDAP e importerà gli utenti e i gruppi che soddisfano i criteri di ricerca indicati nei filtri. Alla fine della procedura tali utenti compariranno come utenti di Liferay veri e propri.

Dopo aver testato la connessione al server LDAP e testato i vari filtri su gruppi e utenti tramite i relativi bottoni, salviamo la configurazione del server e torniamo alla schermata di LDAP.

A questo punto possiamo settare le rimanenti opzioni:

Importa / Esporta

Importazione Abilitata (importa gli utenti LDAP al primo login)

Importazione all'Avvio Abilitata (importa tutti gli utenti LDAP all'avvio)

Esportazione Abilitata (esporta gli utenti LDAP)

Politica per le Password

Usa la Politica per le Password di LDAP (abilita la politica LDAP delle password come per esempio la scadenza ecc.)

Salviamo le modifiche effettuate, delogghiamo l'utente corrente di Liferay e proviamo ad effettuare un login con utente LDAP: se tutto andrà bene ci verrà chiesta per questo utente la domanda segreta per il ripristino della password. L'utente avrà i permessi indicati per il gruppo LDAP, se si vogliono dare permessi diversi andare in Pannello di Controllo->Portale->Ruoli e dopo aver selezionato un ruolo in Azioni cliccare su Assegna membri -> disponibili. Naturalmente nella sezione Utenti di Liferay (Pannello di Controllo ->Portale ->Utenti), dopo il login dovranno comparire tutti gli utenti LDAP importati e che soddisfano i criteri dei filtri che abbiamo immesso. A questo punto Liferay è stato interfacciato con LDAP ed è pronto all'uso con un sistema di autenticazione centralizzato.

Dizionari, Lookup e Dizionari Ordinati di oggetti in C#

2011-02-08T13:33:00.010+01:00

Il linguaggio C# supporta una vasta gamma di collezioni di oggetti. Alcune di queste strutture dati sono funzionano come delle mappe hash con chiave valore, ad accesso rapido:

- Dictionary: struttura del tipo<chiave, valore>, a ciascuna chiave corrisponde un singolo valore
- Dictionary Lookup: come il Dictionary, ma a ciascuna chiave possono corrispondere più valori
- Sorted Dictionary: come il Dictionary, ma è ordinato.

Quando usare un Dictionary? In pratica è conveniente usarlo in tutti in quei casi che si hanno dati nella forma chiave - valore e si vuole un accesso veloce. In pratica a ciascuna chiave viene fatto corrispondere un valore
univoco (hash), a valori simili corrispondono valori hash molto diversi e la distribuzione dei valori hash deve essere uniforme.

Non abbiamo particolari restrizioni sugli oggetti usabili come valori di un Dictionary, ma le si hanno invece per gli oggetti che dobbiamo usare come chiavi. Una chiave di un Dictionary deve essere comparabile, o meglio deve derivare dalla interfaccia IEquatable e implementare il metodo Equals.

Questo perchè altrimenti verrebbe usato il metodo Equals della classe Object che restituisce true solo se l'oggetto da comparare è l'oggetto stesso. Un altro metodo fondamentale che si deve implementare per l'oggetto da usare per la chiave è GetHashCode() che restituisce il codice hash che come detto deve far corrispondere valori diversi per chiavi diverse.

Si noti che se usiamo come chiave un oggetto String, non abbiamo bisogno di reimplementare alcun metodo poichè questi sono già implementati nella classe. Anche la classe Int32 sovrascrive Equals() e GetHashCode() implementando IEquatable, ma quest'ultimo non soddisfa la proprietà di distribuire uniformemente i valori di hash poichè restituisce il valore stesso (ad es. se Int32 key = 10, key.GetHashCode() restituisce 10).

Vediamo un esempio d'uso di Dictionary:

var employees = new Dictionary<EmployeeId,Employee>(100); //Dictionary iniziale di 100 elementi

dove EmployeeId è definita come

public struct EmployeeId : IEquatable<EmployeeId>{
...
private readonly int number;
public EmployeeId(string id)
{
    if (id == null) throw new ArgumentNullException("id");
    number = int.Parse(id);
    ...
}

public bool Equals(EmployeeId other)
{
     //i due Employee sono uguali se il campo number è uguale
     if (other == null) return false;
       return (number == other.number);
}

public override int GetHashCode()
{
    //questa funzione è arbitraria ma deve essere di tipo hash
return ((int)number ^ (int)(number >> 32));
}
...
}

Per aggiungere elementi al Dictionary si può usare il metodo Add(chiave,valore), mentre per cercare un valore si può usare il metodo TryGetValue(chiave, out valore)) che restituisce false se l'elemento non
è presente, oppure si usa Contains(chiave) (senza farsi restuire il valore). Il metodo Remove(chiave) serve invece per eliminare degli elementi.

Un Dictionary Lookup è simile al Dictionary, ma supporta più valori con la stessa chiave. A differenza del Dictionary non c'è una classe "contenitore ad hoc" ma ne viene sfruttata una già esistente, inoltre gli elementi vengono aggiunti mediante il metodo ToLookup()che restituisce un oggetto Lookup < TKey, TElement >. Il metodo ToLookup accetta un delegato che serve per selezionare la chiave. Per esempio:

var racers = new List <Racer > ();
racers.Add(new Racer("Jacques", "Villeneuve","Canada", 11));
racers.Add(new Racer("Alan", "Jones","Australia", 12));
racers.Add(new Racer("Jackie", "Stewart", "United Kingdom", 27));
racers.Add(new Racer("James", "Hunt", "United Kingdom", 10));
racers.Add(new Racer("Jack", "Brabham", "Australia", 14));

var lookupRacers = racers.ToLookup(r = > r.Country);

Crea una Lookup in cui la chiave risulta il campo Country della classe Racer. Si noti come ToLookup venga chiamato come un metodo di List.

Per selezionare gli elementi usiamo l' accesso alla lista per mezzo della chiave:

foreach (Racer r in lookupRacers["Australia"])
{
Console.WriteLine(r);
}
Si noti che l'accesso alla lista è di tipo hash! Il metodo ToLookup è disponibile in tutte le classi C# che implementano l'interfaccia IEnumerable < T >.

Infine il SortedDictionary < TKey, TValue > non è altro che un albero binario ordinato in cui ciascuna chiave deve implementare IComparable < TKey >.

SortedDictionary<string, string> dic =

new SortedDictionary<string, string>();

...

Per approfondimenti vedi:

Dictionary (classe) : http://msdn.microsoft.com/it-it/library/xfhwa508(v=vs.80).aspx
Lookup: http://msdn.microsoft.com/en-us/library/bb460184.aspx
SortedDictionary: http://msdn.microsoft.com/it-it/library/f7fta44c.aspx

IIS 7.0 su Seven: installazione di ASP.NET

2011-02-01T15:51:00.000+01:00

State sviluppando la vostra applicazione web in ASP.NET e ad un certo punto volete pubblicarla con IIS 7.0, magari sotto Windows Seven o Vista. Vi renderete subito conto che la cosa non è così banale come con le versioni precedenti di IIS magari perchè ASP.NET non è automaticamente installato con IIS. Se trovate un errore del genere:

IIS 7.0
Riepilogo errori
Errore HTTP 404.3 - Not Found
La pagina richiesta non può essere servita a causa della configurazione
estensioni. Se la pagina è uno script, aggiungere un gestore. Se il file
deve essere scaricato, aggiungere una mappa MIME (Multipurpose Internet
Mail Extensions).
Informazioni dettagliate sull'erroreModulo StaticFileModule
Notifica ExecuteRequestHandler
Gestore StaticFile
Codice errore 0x80070032
URL richiesto http://localhost:80/hello_word.asp
Percorso fisico C:\inetpub\wwwroot\hello_word.asp
Metodo di accesso Anonima
Utente accesso Anonima

Cause più probabili:
È possibile che manchi un mapping del gestore. Per impostazione
predefinita, il gestore di file statici elabora tutti i contenuti.
La funzionalità che si sta tentando di utilizzare potrebbe non essere
installata.
Il mapping MIME appropriato non è abilitato per il sito Web o
l'applicazione. Avviso: non creare un mapping MIME per contenuti che gli
utenti non devono scaricare, ad esempio pagine .ASPX o file .config.
Se ASP.NET non è installato.

Molto probabilmente si tratta proprio del fatto che ASP.NET non è installato. Lo si può anche vedere tra le opzioni che offre IIS Manager: aprite IIS Manager da Pannello di Controllo -> Strumenti di Amministrazione -> Gestione Internet Information Services (IIS): alla voce IIS (in visualizzazione funzionalità) deve comparire ASP Se così non è allora installare ASP in questo modo:
- Pannello di controllo->Programmi e funzionalità
- clicchiamo su Attivazione o disattivazione delle funzionalità di Windows
- Scorriamo fino a trovare Internet Information Services
- Abilitiamo le funzionalità che ci interessano (ASP, ASP.NET, CGI, Estensioni ISAPI, Filtri ISAPI, ecc...):
- Sempre sotto il nodo Internet Information Services espandiamo il nodo Servizi Web, quindi Protezione e spuntiamo cio che ci interessa (solitamente basta Autenticazione di base per poter amministrare il sito web in locale)
- clicchiamo su OK ed attendiamo che la configurazione di IIS sia portata a termine.

Lo scopo di questo blog...

2011-02-01T14:28:00.004+01:00

... è quello di mantenere degli appunti: i famosi tips & tricks che possono però diventare pericolosamente tics & trips informatici. Molto spesso mi è capitato di trovare soluzioni a problemi che dovevo affrontare direttamente in internet e molto spesso trovavo queste soluzioni in forum o blog o comunque non su siti ufficiali. Spero allora che questo blog possa risolvere problemi che possono sorgere nel mondo della programmazione o comunque in campo informatico. Innanzitutto mi presento col dire di cosa mi occupo tutti i giorni: programmo dalla tenera età di 14 anni quando i miei genitori mi regalarono il buon vecchio Commodore 64 e già allora mi rendevo conto di avere due passioni: l'informatica e la scrittura. Ho coltivato la prima passione proseguendo gli studi diventando prima perito informatico, poi ingegnere elettronico e poi ancora (ad oggi) con 10 anni di esperienze lavorative nel mondo ICT. La seconda passione invece, quella per la scrittura, l'ho un pò tralasciata, se non qualche parentesi nella stesura di qualche articolo per la rivista .DEV di Infomedia. Oggi vorrei unire l'utile al dilettevole scrivendo appunti "a mano libera", senza un filo logico apparente, su problematiche che mi capitano tutti i giorni e che possono essere di aiuto a qualcun altro, almeno spero.
Ogni vostro contributo sarà utile e prezioso... saluti!