Corrado's BLogs

WCF: Invocare un metodo via URI usando WebHttpBinding

Corrado Cavalli — Sun, 05 Oct 2008 14:34:11 GMT

Sto analizzando della documentazione per un proof-of-concept richiestomi da un cliente, le varie features implicano la presenza di un servizio WCF ma la parte più “strana” è il fatto che il servizio possa essere invocato da dei micro-dispositivi custom sparsi in tutto il territorio, i quali, per una lunga serie di motivi, devono utilizzare un firmware proprietario.
Parlando del requisito con il team che si occuperà della parte firmware la risposta che ho avuto è: Il firmware è in grado di invocare una url ed eventualmente parsificarne il risultato ottenuto.
Ci sono varie soluzioni per arrivare al risultato, ad esempio si potrebbe creare una pagina web, fare il parsing dei parametri passati e invocare la parte che elabora le informazioni come fa la parte di servizio web consumata dall’applicativo SilverLight che rappresenta l’altro client del servizio WCF.
Riflettendo su possibili alternative mi sono ricordato di una interessante novità introdotta in WCF col Fx 3.5: il webHttpBinding.
WebHttpBinding consente l’esposizione di EndPoints che possono essere invocati via Http GET passando i parametri nella query string.

Esempio:

[ServiceContract]
public interface IMyService
{
  [OperationContract]
  [WebGet(UriTemplate="register?id={id}&name={name}&value={value}")]
  bool Register(int id, string name,string value);
}

public class MyService : IMyService
{
  public bool Register(int id, string name, string value)
  {
    bool status = false;
    if (id > 0)
    {
      //Do your stuff here...
      status=true;
    }
    return status;
  }
}

WebGet è l’attributo che indica com’è raggiungibile l’operazione e come sia formattata la relativa Uri attraverso il parametro UriTemplate, oltre a WebGet esiste anche WebInvoke che consente l’uso di altre azioni (POST,PUT,DELETE…)

A questo punto, è necessario agire sul file web.config indicando l’uso di webHttpBinding, notate come sia necessario utilizzare un custom behavior:

<system.serviceModel>
   <services>
     <service name="Service.MyService" behaviorConfiguration="ServiceBehavior">
       <endpoint address="" binding="webHttpBinding"
                            contract="Contracts.IMyService"
                            behaviorConfiguration="webBehavior" />
       <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
     </service>
   </services>
   <behaviors>
     <endpointBehaviors>
       <behavior name="webBehavior">
         <webHttp/>
       </behavior>
     </endpointBehaviors>
     <serviceBehaviors>
       <behavior name="ServiceBehavior">
         <serviceMetadata httpGetEnabled="true"/>
         <serviceDebug includeExceptionDetailInFaults="false"/>
       </behavior>
     </serviceBehaviors>
   </behaviors>
 </system.serviceModel>

Ospitato il servizio in IIS, per invocare il metodo è sufficiente aprire il browser e invocare la relativa URI:

Questa soluzione copre esattamente la mia necessità, spero possa essere utile anche a voi.

Technorati Tags: WCF,webHttpBinding

MVP 2009

Corrado Cavalli — Thu, 02 Oct 2008 06:29:57 GMT

Erano i primi giorni del 2002, non conoscevo nessuno di quelli che ora affollano il mio Facebook e stavo passando un periodo, dal punto di vista lavorativo, complicato, uno di quei momenti in cui senti il bisogno di cambiare strada ma il cambiamento ti fa un po paura.
Ricevo una mail da Fabio Santini che mi informa che ero stato scelto come MVP e mi chiedeva se avevo intenzione di accettare (ma che domande sono?!?) e questo per me è stato il primo stimolo per superare quel periodo e cambiare per certi aspetti ‘vita’ (devo ancora capire se in meglio o in peggio… )

Da allora sono cambiate parecchie cose, quella mail mi ha fatto conoscere un sacco di persone squisite e vivere un sacco di emozioni, una sola cosa non è cambiata: La voglia di condividere la passione per il mio lavoro con gli altri in tutte le sue forme.
Lo ammetto: Uno dei motivi per cui lo faccio è anche perchè questa condivisione è la quotidiana occasione per imparare qualcosa di nuovo, sicuramente senza i frequentatori dei newsgroup,forums, conferenze, emails e chat non conoscerei un sacco di argomenti.
Colgo quindi l’occasione di questo nuovo award per ringraziare tutti color che, senza saperlo, mi aiutano a tenere il cervello allenato (a una certà età, va lubrificato spesso…)
Non lo faccio (quasi) mai, ma credo sia giusto ringraziare lo special one (ormai parla solo Genovese e Inglese) che è sempre pronto a rispondere alle mie rotture di scatole: Thank you Ale!

Technorati Tags: MVP

Tech-Ed 08: I’ll be there!

Corrado Cavalli — Mon, 22 Sep 2008 04:34:14 GMT

Dopo qualche anno di assenza torno a Tech-Ed e, come Raf e Mauro, sarò parte dello staff dell’ ATE (Ask The Expert).

Se partecipate, passate a salutarci!.

Technorati Tags: Tech-Ed

LINQ e IEnumerable

Corrado Cavalli — Mon, 15 Sep 2008 20:26:22 GMT

Disquisendo di LINQ presso alcuni clienti mi sono reso conto che molti sviluppatori non ne hanno ben chiaro il funzionamento percui ricorre spesso la frase “Bello, ma LINQ costringe a inutili iterazioni”.

Esempio: Prendiamo un array di interi e supponiamo di volere enumerare i valori >10 interrompendo il ciclo quando il valore contenuto è uguale a 12.

foreach (int v in values)
{
  if (v > 10)
  {
    Console.WriteLine("Value is: {0}", v);
    if (v > 12)  break;
  }
}

in questo caso al terzo elemento l'enumerazione si interrompe.

Con LINQ il codice precedente può essere ricondotto a:

IEnumerable<int> query = values.Where(v => v > 10)
                               .Select(v => v);
foreach (int value in query)
{
  Console.WriteLine("Value is:{0}", value);
  if (value == 12) break;
}

A questo punto la critica è: “Ok, ma Where enumera tutti gli elementi e passa a Select quelli che soddisfano il criterio”
In realtà non è cosi e per dimostrarlo aggiungiamo al nostro esempio una classe con gli stessi extension methods esposti da Enumerable che, essendo in scope, verrano usati al posto di quelli presenti in System.Linq:

public static class Extensions
{
  public static IEnumerable<T> Where<T> (this IEnumerable<T> items, Func<T, bool> filter)
  {
    int count = 0;
    Console.WriteLine("*Entering Where*");
    foreach (T item in items)
    {
      Console.WriteLine("Where:{0}", count++);
      if (filter(item)) yield return item;
    }
  }

  public static IEnumerable<U> Select<T, U> (this IEnumerable<T> sequence, Func<T, U> selector)
  {
    int count = 0;
    Console.WriteLine("*Entering Select*");
    foreach (var item in sequence)
    {
      Console.WriteLine("Select: {0}", count++);
      yield return selector(item);
    }
  }
}

Eseguendo il codice l'output ottenuto è il seguente:

dal quale si denota:

La Select viene eseguita prima di Where.
La sequenza non viene completamente enumerata.
Ad ogni enumerazione dei risultati corrisponde uno step di enumerazione della query.

Seguendo step-by-step l'esecuzione della query il tutto è ancora più evidente.

In pratica, definendo Helper l'equivalente della classe Extensions che non fa uso di extension methods è come se scrivessimo:

IEnumerable<int> query=Helper.Select(Helper.Where(values,v=>v>10),v=>v);

Ovviamente questo non si applica nel caso si faccia uso di conversion operators tipo ToList();

Technorati Tags: LINQ,IEnumerable<T>

WPF Attached Behaviors

Corrado Cavalli — Mon, 01 Sep 2008 15:37:17 GMT

Una delle principali difficoltà nel passare dai Windows Forms a WPF è sicuramente quella di affrontare gli stessi problemi in maniera completamente diversa da come sono stati affrontati in passato, in pratica lo stesso problema di chi, dopo anni di VB6 decide di passare a VB 2008.
Tra le tecniche che, lentamente, stanno ottenendo parecchio successo tra gli sviluppatori WPF c’è sicuramente l' "Attached Behavior" ovvero il racchiudere in una classe esterna una o più funzionalità applicabili in base alla necessità ai vari elementi che compongono una UI WPF.
Consideriamo un caso tanto semplice, quanto frequente: Selezionare il contenuto di una TextBox quando questa ottiene il focus.
Se fossimo nel mondo WinForms avremmo diverse possibilità per raggiungere lo scopo, dal mappare l'evento Enter su una routine comune, al creare un controllo custom che arricchisce il controllo base con la nuova funzionalità.
Entrambe le soluzioni sono applicabili in WPF, entrambe però hanno, come nei WinForm, dei punti deboli: il primo non è molto riutilizzabile mentre il secondo è forse un pò troppo complesso per un operazione cosi banale.
In WPF si usa risolvere questo genere di problematiche utilizzando una tecnica denominata Attached Behavior che sfrutta le potenzialità offerte dalle Dependency Properties abbinando Attached Properties con PropertyChangedCallback.
Creiamo quindi una classe TextBoxBehavior e aggiungiamo a questa un attached property denominata AutoSelectText

public static class TextBoxBehavior
{ 
  public static bool GetAutoSelectText (TextBox textBox)
  {
    return (bool)textBox.GetValue(AutoSelectTextProperty);
  }
  public static void SetAutoSelectContents (TextBox textBox, bool value)
  {
    textBox.SetValue(AutoSelectTextProperty, value);
  }
  public static readonly DependencyProperty AutoSelectTextProperty =
      DependencyProperty.RegisterAttached(
      "AutoSelectedContents",
      typeof(bool),
      typeof(TextBoxBehavior), 
      new UIPropertyMetadata(OnAutoSelectedChanged));

  static void OnAutoSelectedChanged (DependencyObject sender, DependencyPropertyChangedEventArgs e)
  {
    //Get source
    TextBox source = (sender as TextBox);      
    //Null means property is not attached to a TextBox
    if (source == null) return;
    if ((bool)e.NewValue)
      source.GotFocus += HandleGotFocus;
    else
      source.GotFocus -= HandleGotFocus;
  }

  static void HandleGotFocus (object sender, RoutedEventArgs e)
  {
    TextBox source = (sender as TextBox);
    source.SelectAll();
  }
}

Come potete notare la ‘magia’ sta nel sottoscrivere gli eventi che ci interessando nel metodo associato a PropertyChangedCallback che verrà invocato non appena l' Attached Property verrà inizializzata dal parser XAML.
A questo punto non ci rimane che aggiungere la funzionalità alle textbox nello XAML (vedi sotto) estendendo, di fatto, il controllo con una soluzione riutilizzabile che non coinvolge la parte dichiarativa in dettagli legati alla funzionalità a run-time.

<Window x:Class="AttachedBehaviorDemo.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:m="clr-namespace:AttachedBehaviorDemo"
    Title="Window1" Height="300" Width="300">
  <StackPanel>
    <TextBox m:TextBoxBehavior.AutoSelectContents="True" Height="21" Margin="10,10" Text="Test1"  />
    <TextBox m:TextBoxBehavior.AutoSelectContents="True" Height="22" Margin="10,10" Text="Test2"  />
  </StackPanel> 
</Window>

Technorati Tags: WPF,Attached Behavior

XAML Power Toys

Corrado Cavalli — Mon, 01 Sep 2008 08:14:44 GMT

Il vulcanico Karl Shifflet, recentemente entrato a far parte del team di Cider, ha realizzato una serie di PowerToys con lo scopo di migliorare alcune delle (molte) aree scoperte dal designer per WPF di Visual Studio 2008.
Le principali caratteristiche sono:

Group Into-Permette di selezionare un gruppo di controlli e raggrupparli in un nuovo parent
Remove Margins-Rimuove i margini da uno o piu' controlli
Create Business Form-Permette di creare velocemente un form di immissione dati
Edit Grid-Permette di editare righe e colonne di ua griglia
Create Business Form for Class-Crea un form di immissione dati partendo dalla business class

Mi auguro che l'ingresso di Karl nel team contribuisca a far crescere un prodotto tanto interessante, quanto immaturo, qual'e' Cider.

.NET Framework: Le dimensioni contano…

Corrado Cavalli — Sun, 24 Aug 2008 19:42:44 GMT

Effettivamente c’è molta confusione sulle dimensioni reali del .NET Framework…, l’unica certezza è che, versione dopo versione, le dimensioni aumentano e, allo stato attuale, le dimensioni sembrerebbero circa 200 MB.
In realtà non è proprio così, o almeno non è vero che per installare da zero il .NET Framework SP1 sia necessario scaricarsi tutti i 200 MB.
Questo post di Scott Hanselman chiarisce ogni dubbio e, se volete capire quanti MB dovete scaricare per aggiornare una qualsiasi macchina, potete andare su www.smallestdotnet.com

Technorati Tags: .NET Framework

Reflector passa a Red-Gate

Corrado Cavalli — Wed, 20 Aug 2008 08:35:06 GMT

Il tool per .NET più famoso della terra abbandona il suo papà storico Lutz Roeder e passa al gruppo Red-Gate, la buona notizie è che in ogni caso, il tool rimarrà free.

Fonte: The future of .NET Reflector

Technorati Tags: .NET Reflector

WPF Text Clarity

Corrado Cavalli — Tue, 19 Aug 2008 20:35:17 GMT

Una delle maggiori lamentele rivolte a WPF riguarda il rendering del testo, sopratutto in caso di piccole dimensioni dove il testo appare effettivamente leggermente “sfuocato” rispetto alla controparte GDI+
Se siete curiosi di capire il perchè di questo problema ed eventualmente come ‘mitigarlo’ leggete questo articolo.

Technorati Tags: WPF Text Clarity

Client Profile Deployment Survival Guide

Corrado Cavalli — Tue, 19 Aug 2008 15:45:05 GMT

Se avete intenzione di utilizzare la nuova modalità di distribuzione Client Profile e sopratutto volete ridistribuire il Client Framework insieme alla vostra applicazione, non perdetevi questo link

Technorati Tags: Client Profile Deployment