Descriviamo un po’ la situazione in cui ci troviamo:

• abbiamo un web service (sviluppato in ASP.Net);
• vogliamo realizzare una libreria (class library .Net 3.5) per offrire una sorta di “interfaccia comune” verso il web service in modo tale che qualsiasi applicazione (in particolare applicazioni “stand alone” .Net) possa richiamare i servizi esposti senza troppi “grattacapi”.

Come si dovrebbe procedere: da Visual Studio (2008 SP1), nel progetto della nostra class library, si passa alla creazione di un “web-reference” (in relazione al web service in questione). Non serve fare altro: sulla carta non è necessaria alcuna particolare operazione sul progetto dell’applicazione che utilizza la nostra nuova class library. In realtà, se compilate ed eseguite il programma, potrete vedere da voi stessi che l’applicativo non è in grado di collegarsi al web service.

Qui di seguito il messaggio contenuto nell’eccezzione che viene generata quando tentate di accedere al web service: “Could not find default endpoint element that references contract ‘___’ in the ServiceModel client configuration section. This might be because no configuration file was found for your application, or because no endpoint element matching this contract could be found in the client element.”

Motivo? Diciamo che i “riferimenti” o (entry point) al web service non vengono “copiati” dalla class library all’applicazione che la utilizza. Questi riferimenti sono contenuti nel file .config della class library (in dettaglio possiamo trovare tutte le informazioni all’interno del tag <system.serviceModel>). Il file .config della class libray, purtroppo, non “segue” la libreria nell’applicazione che la utilizza (se andate a vedere nella cartella bin del vostro applicativo, troverete solo il fiel .config relativo  a quest’ultimo).

Il problema è aggirabile manualmente: basta copiare tutto il contenuto del tag <system.serviceModel> dal file .config della class library a quello dell’applicazione (operazione fattibile ma assai scocciante).

Qui di seguito un esempio della parte da copiare.

<system.serviceModel>
<bindings>
<basicHttpBinding>
<binding name="WebServiceSoap" closeTimeout="00:01:00" openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard" maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536" messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered" useDefaultWebProxy="true">
<readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384" maxBytesPerRead="4096" maxNameTableCharCount="16384" />
<security mode="None">
<transport clientCredentialType="None" proxyCredentialType="None" realm="" />
<message clientCredentialType="UserName" algorithmSuite="Default" />
</security>
</binding>
</basicHttpBinding>
</bindings>
<client>
<endpoint address="http://_/_.asmx" binding="basicHttpBinding" bindingConfiguration="WebServiceSoap" contract="_" name="_" />
</client>
</system.serviceModel>

Per poter “scrivere” nel file .config dell’applicazione andate nel Solution Explorer del Visual Studio: tasto destro del mouse sul progetto in questione, andate alla voce Add nel menù che via appare  ed a questo punto cliccate sulla voce New Item.

A questo punto vi apparirà una nuova finestra: selezionate General nella parte sinistra ed Application Configuration File in quella destra. Qui di seguito un’immagine che illustra le operazioni appena elencate.

Bene! Tutto il contenuto del nuovo file .config (che  ritroverete nella lista dei file del vostro progetto) sarà ricopiato nel file .config “ufficiale” dell’applicazione.

Il problema sembra essere ben conosciuto, ma al momento non ho letto ancora nulla in merito ad una sua soluzione nel futuro Visual Studio 2010. Ho letto che la gestione dei file .config è stata migliorata permettendo una sorta di “diversificazione” tra debug e release, ma nulla circa il problema qui sopra evidenziato.

Della serie “non si finisce mai di imparare”.

L’argomento in questione sono le WindowsForm del framework Microsoft .NET. Il soggetto, nel dettaglio, la funzione Application.Exit.

Ieri ho scoperto che invocare la funzione sopra citata all’interno del costruttore della finestra non porta ai risultati per cui la funzione è stata realizzata. A pensarci un attimo la cosa è anche ovvia, ma al momento di scrivere il codice, quasi mai affiorano alla mente gli eventuali “back side effects”.

Qui di seguito il codice originale.

using System;
using System.Windows.Forms;

namespace test
{
public partial class FormMain : Form
{
public FormMain()
{
InitializeComponent();

try
{
// ...
}
catch(Exception)
{
Application.Exit();
}
}
}
}

Come aggirare la cosa? Abbastanza semplice, e direi anche, molto spesso la via è facilmente percorribile: basta spostare il nostro codice “incriminato” nella funzione “allacciata” all’evento load della form stesa. All’interno di questo evento il metodo exit funziona correttamente in quanto, una volta che il costruttore della classe form ha terminato, la coda dei messaggi è attiva e, finalmente, può processare il messaggio generato dalla exit.

Qui di seguito il codice aggiornato.

using System;
using System.Windows.Forms;

namespace test
{
public partial class FormMain : Form
{
public FormMain()
{
InitializeComponent();
}
}

private void FormMain_Load(object sender, EventArgs e)
{
try
{
// ...
}
catch(Exception)
{
Application.Exit();
}
}
}

Della serie: quando ci si aspetta che le cose funzionino in ben altro modo!

In sostanza, quando lanciamo dalla nostra applicazione .Net un altro processo tramite la classe Process, possiamo benissimo “schematizzare” il funzionamento come un thread che controlla l’andamento del programma concorrente.

Consideriamo il seguente codice allora.

OtherProcess = new Process();

OtherProcess.StartInfo.FileName = "OtherProcess.exe";
OtherProcess.StartInfo.Arguments = "/someParameters";
OtherProcess.Exited += delegate(object sender, EventArgs e) { otherProcessTerminated(); };
OtherProcess.EnableRaisingEvents = true;

OtherProcess.Start();

Nella situazione sopra proposta, una volta che l’applicazione OtherProcess.exe termina verrà lanciato l’evento Exited che porterà all’esecuzione del relativo delegate e, per finire, alla chiamata della funzione otherProcessTerminated.

E fin qui nulla da obbiettare. La domanda è: in che modo viene “gestito” l’evento? Mi sarei aspettato che venisse messo in coda e processato ordinatamente (nel Main thread) dopo quanti lo precedevano. In realtà ciò non avviene, ma è lo stesso thread creato appositamente dalla classe Process che si prende in carico anche l’esecuzione del delegate, generando delle “race condition” che portano a side effects quasi mai considerati in fase di sviluppo.

Come poter aggirare la cosa, che risulta assai sgradevole se si è fatto di tutto al fine di evitare problemi di concorrenza? Molto semplice: prima di invocare il metodo Start, aggiungete la seguente linea di codice.

OtherProcess.SynchronizingObject = this;

Ovviamente il puntatore this dovrà far riferimento ad un controllo WindowsForm in grado di “gestire” i messaggi (per dirlo con terminologia Win32).

Qui la documentazione relativa alla proprietà SynchronizingObject della classe System.Diagnostics.Process.

P.s.: per questo post si ringrazia il Sig. Botsutoshi per il suo indispensabile contributo.

Della serie: come perdere più di un mese di sviluppo per arrivare pure ad avere una soluzione a dir poco orribile!

Lasciamo perdere i vari ricorsi storici… parliamo invece del namespace System.Diagnostics. Tale “libreria” .Net contiene un’utilissima classe chiamata Process. Attraverso un oggetto di questo tipo possiamo lanciare “in parallelo” altri processi e, soprattutto, possiamo in qualche modo controllarne il loro avanzamento.

D’indubbia utilità è l’evento Exited: viene invocato quando il relativo processo termina permettendomi di mantenere l’applicazione chiamante “event oriented” ed evitando la necessità di realizzare un orribile polling a tempo (magari pilotato da qualche bel timer) al fine “checcare” lo stato dell’applicazione lanciata.

Attenzione però: tal evento viene generato solo se la proprietà EnableRaisingEvents viene precedentemente settata a true. La relativa documentazione nel portale MSDN è fatta bene, ma se, come me, non si legge con attenzione…

Dopo mesi di inattività torno ad aggiornare il mio povero ed umile blog. Purtroppo gli impegni del periodo sono molti (sto tenendo un corso di Microsoft Office VISIO nelle sedi IAL di Pordenone e di Udine).

Mi preme però segnalarvi il prossimo super evento di 1nn0va: lo abbiamo chiamato WebCongress e prevede ben 4 ore di conferenze (3 interventi in totale)!

La serata è stata organizzata in strettissima collaborazione con i nostri amici di XeDotNet. Per l’eccezionalità dell’evento è stato anche “messo in piedi” un mini-sito ove potete trovare tutti i dettagli dei vari interventi, i relativi speaker, la location ed il modulo d’iscrizione.

Ovviamente e come sempre, la serata è aperta a tutti e la partecipazione è GRATUITA!

Il consiglio è, ovviamente, di non mancare!

Segnalo questo interessantissimo post di Raffaele Rialdi (MVP di Microsoft) che riporta una serie di utilissimi link per capire le novità del Microsoft .Net Framework 3.5 e del Visual Studio 2008. Come potrete leggere dal suo articolo, presto pubblicherà anche le novità riguardanti la programmazione nativa in C++ su Visual Studio 2008… e spero che le renda on-line quanto prima

Chi conosce Raffaele Rialdi può facilmente immaginare il livello di qualità dei link da lui segnalati