Paolo Pialorsi

Addio all'inventore dei Chupa-Chups

Non c'entra nulla con l'informatica, ma li mangio da quando sono nato e ancora oggi non mancano mai sulla mia scrivania in ufficio.
Mi dispiace molto che l'inventore dei Chupa-Chups sia mancato sabato 27, l'ho appreso solo oggi leggendolo sul giornale.

http://www.chupachups.com/

Link: http://www.repubblica.it/2003/l/sezioni/esteri/chupa/chupa/chupa.html

Web Service asincroni: sessione multimediale (ultima parte)

Eccoci! Anche il seminario multimediale sui Web Service asincroni è concluso. Sono molto soddisfatto del risultato anche perché il seminario, sia valutando il traffico web generato che le email che ho ricevuto, ha riscosso un notevole successo. Mi fa molto piacere!
Da molti di voi ho ricevuto esplicite richieste di un seminario, simile a questo come impostazione, a proposito di WSE 2.0 sia in termini di implementazioni di WS-Security che di servizi peer-to-peer su soap.tcp anziché su HTTP.
Se avete anche altre richieste .... battete un colpo (paolo@devleap.com).

Tra un panettone e l'altro .... cercherò di non deludere le vostre aspettative e richieste.

Link: http://www.devleap.com/SchedaArticolo.aspx?IdArticolo=10620

Buone Natale a tutti !!

Da questo pomeriggio inizierà il giro dei parenti, delle cene, delle bevute, ecc.

Non so se riuscirò a scrivere ancora qualcosa nel blog o se sarò costantemente in coma etilico ... quindi mi porto avanti e auguro a tutti un felice Natale, per l'anno nuovo ci sentiamo poi, dovrei riuscire ad uscire dal tunnel per allora!

Ovviamente non sarò molto costante nello scrivere il mio blog, né tantomeno nello scrivere informazioni su XSLT, ma penso che a Natale - per fortuna - non gliene freghi a nessuno di XSLT :-) !

Ciao a tutti e Bridge the Gap!

XSLT: attribute-set

A volte capita di dover inserire in una trasformazione XSLT un insieme di attributi su un tag, più volte, sempre uguali o simili. In XSLT possiamo utilizzare il comando attribute-set per definire un gruppo di attributi:

<xsl:attribute-set name="table-style">
<xsl:attribute name="border">0</xsl:attribute>
<xsl:attribute name="width">500</xsl:attribute>
<xsl:attribute name="height">100</xsl:attribute>
</xsl:attribute-set>

e poi utilizzarlo nella trasformazione XSLT dove serve di replicare quel set di attributi su un qualsiasi tag che stiamo generando in output:

<xsl:template match="/">
<table xsl:use-attribute-sets="table-style">
<xsl:apply-templates />
</table>
</xsl:template>

Come si vede la dichiarazione dell'attribute-set è a livello child di stylesheet/transform, mentre il suo uso è locale ad un qualsiasi elemento, tramite l'attributo qualificato xsl:use-attribute-set.

XSLT: La funzione document()

Vi è mai capitato di voler trasformare N documenti in input in un solo output? A prima vista sembra che non sia possibile perché tutti i motori XSLT più diffusi sulla piazza lavorano con un solo XSLT e un solo XML come input.

In realtà già nelle puntate precedenti abbiamo visto che gli XSLT possono essere inclusi e importati, quindi possiamo avere N XSLT in input.

Ma anche gli XML, a patto che ve ne sia uno principale, possono essere N. Per ottenere questo risultato c'è la funzione document() che accetta come argomento un nodo che contenga una stringa (il path del file) o direttemante il path di un file da caricare come stringa.

Possibili sviluppi:

• Caricare dinamicamente degli XML esterni
• Caricare degli XML esterni dinamici generati da pagine ASPX, ASP, SQLXML, ecc. Per la funzione document non conta l'estensione ma il content-type e il fatto che l'XML sia well-formed. Nessuno quindi ci impedisce di leggere un ASPX esterno che restituisca text/xml well-formed
• Possiamo anche fare riferimento al nostro stesso sorgente XSLT invocando la funzione document senza argomenti. La regola prevede che document() senza argomenti restituisca sotto forma di nodeset il documento XSLT sorgente

Come si usa? Possiamo assegnare il risultato di document ad una variabile, o utilizzarlo direttamente in una value-of per esempio. Di solito è comodo associarlo ad una variabile e poi richiamarlo dove serve tramite il nome della variabile. Ecco un esempio:

http://www.devleap.com/Downloads/Blogs/Paolo/TutorialXSLT/Books.xml

http://www.devleap.com/Downloads/Blogs/Paolo/TutorialXSLT/Authors.xml

http://www.devleap.com/Downloads/Blogs/Paolo/TutorialXSLT/BooksWithAuthors.xslt

Notare la funzione current() per distinguere l'attributo @idAuthor del nodo author da quello del nodo di contesto corrente (cioè book).

XPath Analyzer

Un collega ed amico, Davide Mauri, mi ha segnalato suo questo tool:

http://www.codeproject.com/useritems/advancedxpathanalyzer.asp

E' comoda il fatto che si possano aggiungere dei namespace xml per la definizione delle regole XPath. Se volete dargli un'occhiata anche voi...

 

WS-Security per AXIS. Fico! :-)

Per chi si fosse perso il post di Christian Weyer in merito, c'è qualcuno che sta sviluppando un motore WS-Security per Java, che si appoggia su AXIS, alternativo a ETTK di IBM.

Non vedo l'ora che arrivi Natale :-) per avere il tempo di provarlo!

Link: http://axis-wsse.sourceforge.net/#home

Win32 API per il CLR Hosting

Avevo l'esigenza di invocare un Web Service ASP.NET, in modo sicuro (WS-Security con WSE 2.0) da un client Win32 unmanaged che mi metteva a disposizione solo la possibilità di invocare API Win32 (le classiche e belle :-) DLL di una volta!).

Mettendo insieme un po' di pezzi trovati qua e là su Internet e dicendo qualche brutta parola ogni tanto ... sono giunto alla soluzione.

Ho dovuto sviluppare una DLL Win32 con Visual C++ .NET.
Al suo interno ho fatto riferimento a mscoree.dll per creare un Host del CLR, avviare un AppDomain e ottenere, sotto forma di interfaccia IDispatch, un riferimento all'oggetto .NET che per me rappresenta la classe proxy verso il Web Service sicuro.
A questo punto tramite Invoke di IDispatch ho chiamato il metodo di mio interesse e il gioco è fatto!

Ecco la parte di codice più importante:

---

__stdcall __declspec(dllexport) int ReadInteger(LPCTSTR name, VARIANT FAR *pResult)
{

 CComPtr spRuntimeHost;
 CComPtr<_AppDomain>   spDefAppDomain;
 
 // Ottengo un puntato all'interfaccia ICorRuntimeHost
 HRESULT hr = CorBindToRuntimeEx(
         NULL, // In questo modo prende sempre l'ultima versione del CLR
         L"wks", // Versione Workastation (cioè mono-processore)
         STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN | STARTUP_CONCURRENT_GC,
         CLSID_CorRuntimeHost,
         IID_ICorRuntimeHost,
         (void**)&spRuntimeHost // qui dentro troverò un riferimento all'host del CLR
         );

 if (FAILED(hr)) return hr;

 // Avvio il CLR Host
 hr = spRuntimeHost->Start();

 CComPtr pUnk;
 // Recupero l'AppDomain di default come IUnknown COM
 hr = spRuntimeHost->GetDefaultDomain(&pUnk);
 if (FAILED(hr)) return hr;

 // Faccio un QueryInterface su IUnknown
 hr = pUnk->QueryInterface(&spDefAppDomain.p);
 if (FAILED(hr)) return hr;

 CComPtr<_ObjectHandle> spObjectHandle;

 // Creo il tipo .NET che mi serve
 hr = spDefAppDomain->CreateInstance(
          _bstr_t("WSProxyDotNetLibrary"),
          _bstr_t("WSProxyDotNetLibrary.WSProxy"),
          &spObjectHandle
          );
 if (FAILED(hr)) return hr;

 CComVariant VntUnwrapped;
 hr = spObjectHandle->Unwrap(&VntUnwrapped);
 if (FAILED(hr)) return hr;

 // Testo l'implementazione dell'interfaccia IDispatch
 if (VntUnwrapped.vt != VT_DISPATCH) return E_FAIL;

 CComPtr pDisp;
 pDisp = VntUnwrapped.pdispVal;
 
 OLECHAR FAR* szMember = L"ReadInteger";
 DISPID dispid;

 // Ottengo il DISPID del metodo che voglio richiamare
 pDisp->GetIDsOfNames (
      IID_NULL,
      &szMember,
      1,
      LOCALE_SYSTEM_DEFAULT,
      &dispid
      );

 // Costruisco il DISPPARAMS dei parametri da passare al metodo
 DISPPARAMS dispparams = {NULL, NULL, 0, 0};

 // Nel mio caso ho un solo parametro, ma se ne avessi più d'uno dovrei
 // fornirli in ordine inverso, dall'ultimo al primo
 dispparams.rgvarg = new VARIANTARG[1];
 dispparams.rgvarg[0].vt = VT_BSTR;
 dispparams.rgvarg[0].bstrVal = bstr_t(name);
 dispparams.cArgs = 1;
 dispparams.cNamedArgs = 0;

 EXCEPINFO FAR *pExcepInfo = NULL;
 unsigned int FAR *puArgErr = 0;
 
 // Invoco il metodo su IDispatch con il metodo Invoke
 // in pResult (VARIANT) avrò il risultato
 hr = pDisp->Invoke (
    dispid,
    IID_NULL,
    LOCALE_SYSTEM_DEFAULT,
    DISPATCH_METHOD,
    &dispparams,
    pResult,
    pExcepInfo,
    puArgErr
    );

 // Fermo l'host del CLR che ormai non mi serve più
 spRuntimeHost->Stop();

 if (hr != S_OK) return(0);
 return(1);
}

---

Ed ecco uno ZIP con i sorgenti (scusate il disordine ma si tratta di una prova, non della soluzione definitiva). Magari servono anche ad altri.
ATTENZIONE: Non sono uno sviluppatore C++ :-) quindi il codice probabilmente potrebbe essere scritto molto ma molto meglio, accetto volentieri suggerimenti. Il contesto in cui andrò ad eseguirlo io non corre rischi di sicurezza quindi non ho messo nessun tipo di controllo su buffer-underrun o simili ...

Se vi serve ... buon divertimento! :-)

MSDN Subscriber Download

Oggi nel fare un download da MSDN ho trovato questo messaggio in home page:

Subscriber Download content will be retired on December 23rd
Due to a settlement agreement reached in January 2001, Microsoft is phasing out the Microsoft Virtual Machine from its products. As of 12:01 AM Pacific Time December 23rd, 2003, we will phase out several product families, and remove the Microsoft Virtual Machine from others. The major product families that will no longer be available are:

BackOffice Server 2000
MapPoint 2002
Office 2000 Suite and Products
Office XP Developer
SQL Server 7.0
Windows 98

Although these products will no longer be available for distribution from Microsoft, they can still be used in accordance with the terms of your MSDN Subscription license agreement.

Sono cose "strane" che mi lasciano sempre un po' perplesso ... comunque se dovete scaricare i suddetti prodotti e anche voi come me non vi eravate accorti sino ad oggi dell'annuncio ... avete poco più di due giorni per farlo.

XSLT: importare e includere altri XSLT

Quando scriviamo trasformazioni XSLT possiamo utilizzare delle libreri di "trasformazioni" per non dover riscrivere N volte le stesse cose.

Abbiamo a disposizione due istruzioni:

• xsl:import: importa un XSLT permettendoci di ridefinire parte del suo comportamento con dei template alternativi.
• xsl:include: importa un XSLT applicando i template in esso definiti, sempre che non ve ne siano di altri successivi

Come funzionano? Possiamo includere XSLT che dovranno avere il tag root come tutti i normali documenti XSLT e che dovranno presentare una lista di template, variabili e parametri.
Sia import che include devono essere indicati come figli di stylesheet o di template (quindi figli del root del XSLT padre). Gli elementi import vanno riportati prima di qualsiasi altro figlio del root, compresi gli elementi include.
Quando eseguiamo una import possiamo ridefinire dei template altrimenti definiti nel XSLT importato e poi richiamare, dal loro interno, il template originale.

Per esempio se abbiamo:

<xsl:template match="nodo">
<!-- Fai qualcosa -->
</xsl:template>

nel XSLT importato e nel XSLT principale abbiamo:

<xsl:template match="nodo">
<b>
<xsl:apply-imports />
</b>
</xsl:template>

con il tag apply-imports andremo a richiamare il template originale, che però non sarà chiamato direttamente perché la sua versione "derivata" (se ragioniamo in termini di OOP) vincerà su di lui.

Quando si dice che "il tempo vola" ...

Stasera ho realizzato il fatto che Visual Basic esiste da circa 12 anni ... mi sento vecchio ... considerando che ho iniziato ad "utilizzarlo" dalla versione 1.0 !

Microsoft .NET and J2EE Interoperability

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpag/html/jdni.asp
Link: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpag/html/jdni.asp

XSLT: call-template e apply-templates parametrici

In XSLT possiamo definire dei parametri con il comando param. I parametri possono essere globali per il documento XSLT, se sono definiti allo stesso livello dei template, oppure locali ad un template, se sono definiti come figli di un qualsiasi template.

Per definirli dobbiamo usare la sintassi:

<xsl:param name="NOME" select="XPath Expression" />

oppure semplicemente:

<xsl:param name="NOME" />

Nel primo caso forniamo un valore leggendolo da uno dei documenti in input (lo so, ho usato il plurale ... ci arriveremo). Nel secondo caso potremo valorizzare il parametro, se è globale, alla chiamata della trasformazione XSTL, da codice VB.NET, C#, VB6, VBScript, Java, ecc.
Oppure potremo utilizzare un parametro senza valore preassegnato per inserirlo come figlio di un template, per poi richiamare il template, come fosse una procedura, passandogli di volta in volta valori differenti per il parametro.

Per esempio:

<xsl:template name="ProvaTemplateParametrico">
<xsl:param name="Parametro" />
<xsl:value-of select="$Parametro" />
</xsl:template>

definisce un template denominato, si noti che non ha un match ma un name, il quale si aspetta un parametro di nome "Parametro" appunto che sarà letto come nodo pari a $[Nome Parametro], nel nostro caso "$Parametro".
Per chiamare un template come quello appena visto potremo scrivere:

<xsl:call-template name="ProvaTemplateParametrico">
<xsl:with-param name="Parametro" select="XPath Expression" />
</xsl:call-template>

Dove come si vede viene chiamato per nome il template, passandogli il parametro valorizzato. Si può fare altrettanto con apply-templates.

A volte questo modo di lavorare semplifica di molto le cose e in certi casi permette di implementare delle trasformazioni ricorsive (ma non abusatene!)

Web Service asincroni: sessione multimediale (terza parte)

Ho appena messo on-line la terza parte, di quattro totali, del seminario sui Web Service asincroni. Con questa si chiude la parte client.

Se avete ancora voglia di sentire la mia voce :-) ... buona visione!

 

Link: http://www.devleap.com/SchedaArticolo.aspx?IdArticolo=10610

XSLT: il comando text e l'output-escaping

A volte nello scrivere l'output di una trasformazione XSLT fa comodo anche generare del testo. Sembra una cosa normale, e tuttosommato anche facile.

In effetti è così, salvo quando per esempio vogliamo preservare dei caratteri in output, o vogliamo scrivere degli spazi o dei simboli di "a capo" che devono essere mantenuti come tali.

Il comando text serve per forzare in output del testo a nostra scelta, per esempio uno spazio, che altrimenti sarebbe ignorato di default dal parser. Inoltre possiamo chiedere al comando text, così come anche al comando value-of di disabilitare l'output-escaping. Che significa? Significa che se noi passiamo dei caratteri che in output sarebbe necessario presentare con dei simboli di escape come &lt; ed &gt; per esempio al posto di > e <, il comando produrrà invece in output proprio > e <.

Quando ci può servire? Un caso tipico è quando vogliamo scrivere in output del codice HTML letto dal contenuto di un nodo o di un attributo.

Pensiamo al seguente XML:

<?xml version="1.0"?>
<documento>
 <titolo>Titolo del documento</titolo>
 <contenuto>
  &lt;p&gt;Questo è un paragrafo HTML letto da un DB
  o da qualunque altra fonte e scritto nel tag di nome
  &lt;i&gt;contenuto&lt;/i&gt; come HTML Encoded. In output
  vogliamo però averlo come HTML normale&lt;/p&gt;
 </contenuto>
</documento>

Per ottenere in output:

<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-16">
<title>Titolo del documento</title>
</head>
<body>
  <p>Questo è un paragrafo HTML letto da un DB
  o da qualunque altra fonte e scritto nel tag di nome
  <i>contenuto</i> come HTML Encoded. In output
  vogliamo però averlo come HTML normale</p>
 </body>
</html>

dovremo dire alla trasformazione XSLT:

<?xml version="1.0"?>
<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="html" />

<xsl:template match="/">
 <html>
  <head>
   <title><xsl:value-of select="documento/titolo" /></title>
  </head>
  <body>
   <xsl:value-of select="documento/contenuto" disable-output-escaping="yes" />
  </body>
 </html>
</xsl:template>

</xsl:transform>

http://www.devleap.com/Downloads/Blogs/Paolo/TutorialXSLT/documento.xml

http://www.devleap.com/Downloads/Blogs/Paolo/TutorialXSLT/documento.xslt