Introduzione a WCF 4.0 - Il nostro primo servizio
Scritto da
Pietro Libro
il
mercoledì 20 ottobre 2010
Linguaggio:
•
Framework:
•
Livello: 100
Download sorgenti
Nel primo articolo "Introduzione a WCF 4.0" abbiamo introdotto i
principali concetti inerenti la programmazione di WCF
4.0 (sebbene molti degli argomenti siano applicabili anche alla
versione 3.5). In questo seconda puntata andiamo ad analizzare un
caso pratico progettando il nostro "primo servizio WCF".
Iniziamo a creare il nostro servizio aprendo Visual Studio 2010
(VS d'ora in avanti) e scegliendo il template di progetto WCF
Service Library. Piccola nota: avremmo potuto selezionare anche il
template WCF Service Application attraverso il quale VS avrebbe
creato in un'unica soluzione il codice per il servizio WCF ed
un'applicazione ASP.NET per eseguire l'hosting del servizio tramite
un ASP.NET Development Server. Utilizzeremo questa secondo tipo di
progetto nelle prossime occasioni.
Torniamo quindi alla creazione del nostro servizio impostando il
nome della solution in Domus.Wcf.Services e del progetto
in Domus.Wcf.CalculatorService. Ovviamente il nome della
soluzione non è fondamentale per la "buona riuscita" del
nostro progetto :-)
Una volta premuto "OK" VS aggiunge un progetto contenente due
file: IService1.cs e Service1.cs. Nel primo
troviamo la definizione del servizio , il Service Contract, e di
una classe marcata come DataContract che definisce il tipo
per il parametro d'ingresso e di ritorno del metodo
GetDataUsingContract (OperationContract)
descritto dall'interfaccia IService1.
[ServiceContract()]
interface ICalculator
{
[OperationContract()]
double Sqrt(double n);
[OperationContract()]
double Log10(double n);
[OperationContract()]
double Log(double n, double newBase);
[OperationContract()]
double Pow(double n, double p);
}
La nostra intenzione è quella di creare un nuovo servizio da
zero, quindi cancelliamo il contenuto del file
IService1.cs, la definizione dell'interfaccia
IService1 e della classe CompositeType.Uno degli
esempi classici in questi contesti è la realizzazione di un
servizio Calculator. Modifichiamo un po' questa "tradizione"
creando una versione "scientifica" della nostra calcolatrice:
creiamo un servizio che invece di esporre i metodi di
addizione e sottrazione, esponga dei metodi per l'esecuzione di
calcoli un po' più complessi come logaritmo (in base 10 e non),
elevamento a potenza e radice quadrata. Definiamo il contratto del
nostro servizio in questo modo:Il servizio espone quattro metodi,
che eseguono rispettivamente: radice quadrata (sqrt),
logaritmo in base 10 (Log10), logaritmo in base diversa da 10 (Log)
e potenza (Pow). Tutti i metodi sono marcati con l'attributo
OperationContract e quindi esposti come operazioni del servizio,
utilizzabili dal "pubblico".
Consideriamo il file Service1.cs e cancelliamo il codice
di definizione della classe presente, precedentemente
generata da VS. La scrittura della classe concreta Calculator
(che implementa ICalculator) è facilitata dall'utilizzo
dei metodi statici presenti in System.Math. Il codice è il
seguente:
public class Calculator : ICalculator
{
#region ICalculator Members
public double Sqrt(double n)
{
return Math.Sqrt(n);
}
public double Log10(double n)
{
return Log(n, 10);
}
public double Log(double n, double newBase)
{
return Math.Log(n, newBase);
}
public double Pow(double n, double p)
{
return Math.Pow(n, p);
}
#endregion
}
Siamo quasi giunti alla scrittura del codice nostro primo
servizio WCF. Spostiamo ora la nostra attenzione sul lato
configurazione. Apriamo il file App.Config presente nella
soluzione e modifichiamone il contenuto in tre punti:
1) Cambio del nome del servizio, da:
<service name="Domus.WCF.CalculatorService.Service1">
a
<service name="Domus.WCF.CalculatorService.Calculator">
2) Address del servizio, da:
<baseAddresses>
<add baseAddress ="http://localhost:8732/Design_Time_Addresses/Domus.WCF.CalculatorService/Service1/" />
</baseAddresses>
a
<baseAddresses>
<add baseAddress ="http://localhost:8732/Design_Time_Addresses/Domus.WCF.CalculatorService/Calculator/" />
</baseAddresses>
3) EndPoint, da :
Domus.WCF.CalculatorService.IService1
a
Domus.WCF.CalculatorService.ICalculator
A questo punto Il gioco è fatto. E' sufficiente premere F5
per eseguire l'hosting del nostro servizio tramite il client
"WCF Host" presente in VS (figura 2). Questo test client è molto
utile per testare i nostri servizi. Avremo modo di parlare più in
dettaglio di questo client nei prossimi articoli quando
parleremo delle diverse modalità di hosting.
Per testare una delle operazioni del nostro servizio è
sufficiente un doppio click nella struttura ad albero
presente a sinistra dello schermo. Proviamo ad esempio il metodo
Pow, con i valori 2 per la base e 3 per la potenza. Ci aspettiamo
che risultato sia 8. Dopo aver inserto questi valori, premiamo il
tasto "Invoke" (potrebbe essere visualizzato un messaggio di
notifica avvertendo che le informazioni potrebbero essere
inviate in chiaro sulla rete e quindi visualizzabili da altri
utenti).
Dopo qualche secondo vediamo come nella griglia presente sotto
la parte "Response" sia popolata con il risultato dell'operazione.
Per visualizzare il risultato in formato XML è sufficiente
selezionare la scheda (Tab) XML presente nella parte inferiore
della finestra.
Abbiamo così concluso lo sviluppo del nostro primo servizio WCF,
ma prima di concludere qualche osservazione, introduttiva agli
argomenti trattati nel prossimo articolo: come tutti noi ben
sappiamo, le applicazioni anche se ben scritte, non sono immuni da
errori. Cosa succede quando un'eccezione è sollevata dal nostro
servizio ? Quali e quante informazioni vogliamo comunicare al
client ? Possiamo centralizzare in qualche punto del codice del
servizio le informazioni da inviare all'amministratore si sistema
(Log) ? Daremo una risposta a queste domande nel prossimo articolo,
dove parleremo in dettaglio dell'attributo FaultContract, e di come
comunicare eventuali eccezioni lato server ai client.
In allegato il
codice sorgente VB.NET e C# del progetto sviluppato.
Tags: WCF,SOA