Spring.NET

[Spring.NET #33] Spring.Aop, Advice

Matteo Baglini — Sat, 10 May 2008 11:42:50 GMT

Rappresenta la modalità di intercettamento di un motodo e quindi la modalità di intruduzione del codice. I tipi di Advice sono quattro:

AroundAdvice: implementa l'interfaccia IMethodInterceptor e permette il massimo controllo su un metodo dato che possiamo aggiungere logica primo e dopo l'invocazione del metodo target. Questo è l'Advice più potente ma anche il più richioso, dato che possiamo dimenticare di chiamare il metodo Proceed() che rappresenta l'invocazione del metodo target.
BeforAdvice: implementa l'interfaccia IBeforAdvice e permette di introdurre codice soltanto prima dell'invocazione del metodo target.
AfterReturningAdvice: implementa l'interfaccia IAfterReturningAdvice e permette di introdurre codice soltanto dopo l'invocazione del metodo target.
ThrowAdvice: implementa l'interfaccia IThrowAdvice e permette di introdurre codice all'intercettazione di una eccezione.

L'ordine di esecuzione degli Advice dello stesso tipo può essere controllata se quest'ultimi implementano l'interfaccia IOrdered.

Gli Advice sono classificabili in due categorie: per classe e per istanza, differenti dal fatto che la seconda categoria dipende dallo stato interno della classe target mentre la prima no. Gli Advice elencati precedentemente fanno tutti parte della prima categoria. L'interfaccia IAdvice, invece, fa parte della seconda categoria e permette di creare dei mixin introducendo metodi e proprietà all'oggetto target.

Procediamo con l'esempio incominciato nel precedente post. In questo episodio estrapoliamo il codice per la validazione dell'utente dalla classe TransferService e lo inseriamo una classe Advice, creando la classe GenericPrincipalAroundAdvice. Il risultato sarà il seguente:

        1: public class TransferService : ITransferService

       2: {

       3:     public void Transfer(Account fromAccount, Account toAccount, int amount)

       4:     {

       5:         fromAccount.withdraw(amount);

       6:         toAccount.deposit(amount);

       7:     }

       8: }

       1: public class GenericPrincipalAroundAdvice : IMethodInterceptor

       2: {

       3:     private string _role = String.Empty;

       4:     public string Role

       5:     {

       6:         get { return _role; }

       7:         set { _role = value; }

       8:     }

       9:  

      10:     public object Invoke(IMethodInvocation invocation)

      11:     {

      12:         IPrincipal _currentPrincipal = Thread.CurrentPrincipal;

      13:         if (!_currentPrincipal.IsInRole(_role))

      14:             throw new SecurityException("The logged user can't perform Transfer Account operation.");

      15:  

      16:         object returnValue = invocation.Proceed();

      17:  

      18:         return returnValue;

      19:     }

      20: }

Notiamo alla riga 16 l'infocazione del metodo intercettato (Tansfer) tramite il metodo Proceed(). In fine aggiorniamo la configurazione dell'Advisor impostando la proprietà Advice:

<object id="aroundAdvisor" type="Spring.Aop.Support.NameMatchMethodPointcutAdvisor, Spring.Aop">
  <property name="Advice">
    <object type="SpringSeries.Aop.Advice.GenericPrincipalAroundAdvice, 02.Advice">
      <property name="Role" value="BankUser" />
    </object>
  </property>
  <property name="MappedName" value="Transfer" />
</object>

Technorati Tag: Spring.NET,AOP,Aspect Oriented Programming

[Spring.NET #32] Spring.Aop, Pointcut e Advisor

Matteo Baglini — Wed, 07 May 2008 20:25:38 GMT

Un Pointcut definisce una regola di individuazione di un Joinpoint. Spring.NET offre diverse implementazioni di Pointcut, forniti come moduli indipendendi, implementati come singole entità in modo da renderli riutilizzabili ed intersecabili per diversi Advice.

Ogni Pointcut implementa l'interfaccia IPointcut, la quale tramite i due membri ITypeFilter e IMethodMatcher permette di filtrare in base al tipo ed alla firma del metodo. Nella maggior parte dei casi le implementazioni dei Pointcut sono gestite in maniera statica (StaticPointcut), in modo da effettuare il caching del risultato di una valutazione di matching (operazione costosa in termini di performance) la prima volta che viene eseguita, questo permette di velocizzare la procedura di Weaving. Esiste un tipo di Pointcut non "cachabile", il DynamicPointcut, il quale effettua la valutazione di matching non solo in base al tipo ed alla firma del metodo, ma anche in base ai parametri passati al metodo stesso, quindi la valutazione avverrà ad ogni invocazione. Possiamo effettuare una operazione di unione dei Pointcut (verrà eseguito ogni Pointcut per il quale la valutazione di matching risulta vera), oppure una operazione di intersezione (verrà eseguito ogni Pointcut solo se la valutazione di matching risulta vera per tutti).

Spring.NET fornisce built-in i seguenti Pointcut:

Regular Expression: è un generico Regular Expression Pointcut, il quale permette di definire una lista di pattern da applicare per il matching. Perchè la valutazione del Pointcut sia vera devono "matchare" tutti i pattern. Questo Pointcut è di tipo statico.
Attribute: permette di effettuare il matching di un metodo marcato con un determinato Attribute. Anche questo Pointcut è di tipo statico.
Control Flow: permette di effettuare il matching di un metodo in base al suo StackTrace. Per esempio possiamo indicare di applicare un Advice ad un metodo A solo se esso è stato chiamato da B. Questo Pointcut è di tipo dinamico, quindi molto costoso, in termini di performance. In più questo Pointcut richiede un po di attenzione perchè può incontrare dei problemi che la funzionalità di Method Inlining del Jit Compiler applicato quando generiamo un assembly in Release mode. Per evitare problemi ci sono una serie di tecniche mostrate qui: Dynamic Pointcuts

Per implementare un nostro Pointcut baterà creare una classe che implementa l'interfaccia IPointcut oppure ereditare dalla classe base StaticMethodMatcherPointcut, la quale ci permette di risparmiare un po di codice di plumbing.

L'unione di Pointcut e Advice si chiama Advisor, il quale crea di fatto un Aspetto modularizzato e riutilizzabile nella nostra applicazione. Dato che nel file di cofigurazione dobbiamo sempre indicare un Pointcut più una serie di Advice, Spring.NET fornisce una classe Advisor per ogni classe Pointcut (es: RegularExpressionMethodPointcutAdvisor, AttributeMatchMethodPointcutAdvisor) più una classe DefaultPointcutAdvisor in modo da semplificare la configurazione.

Passiamo ad un esempio pratico, supponiamo di avere nel Service Layer una classe TransferService definita così:

        1: public class TransferService : ITransferService

       2: {

       3:     private string _role = String.Empty;

       4:     public string Role

       5:     {

       6:         set { _role = value; }

       7:     }

       8:  

       9:     public void Transfer(Account fromAccount, Account toAccount, int amount)

      10:     {

      11:         IPrincipal _currentPrincipal = Thread.CurrentPrincipal;

      12:         if (!_currentPrincipal.IsInRole(_role))

      13:             throw new SecurityException("The logged user can't perform Transfer Account operation.");

      14:  

      15:         fromAccount.withdraw(amount);

      16:         toAccount.deposit(amount);

      17:     }

      18: }

il nostro obbiettivo è di eliminare il codice di validazione dell'utente da questa classe per inserirlo in un aspetto. In questo post impostiamo solo l'Advisor che intercetterà l'invocazione del metodo, quindi nel file di configurazione inseriamo un NameMatchMethodPointcutAdvisor:

<object id="aroundAdvisor" type="Spring.Aop.Support.NameMatchMethodPointcutAdvisor, Spring.Aop">
  <property name="Advice">
  </property>
  <property name="MappedName" value="Transfer" />
</object>

Il NameMatchMethodPointcutAdvisor è una versione semplificata del RegularExpressionMethodPointcutAdvisor, il quale permette di definire un pattern di matching del metodo, che in questo caso è "Transfer".

Technorati Tag: Spring.NET,AOP,Aspect Oriented Programming

[Spring.NET #31] Spring.Aop, Aspect Oriented Programming Framework Overview

Matteo Baglini — Wed, 16 Apr 2008 09:03:35 GMT

Altra parte fondamentale di Spring.NET è l' AOP Framework. Questo post non vuole spiegare che cosa è o non è l'AOP, ma vuole focalizzarsi soltanto su gli strumenti forniti da Spring.NET per utilizzare questo paradigma di programmazione nelle nostre applicazioni .NET. Tutta via, un minimo di infarinatura è obbligatoria, in poche pareloe l'Aspect Oriented Programming è un paradigma complementare all'Object Oriend Programming e permette di modularizzare gli aspetti ed i comportamenti trasversali della nostra applicazione, separandoli dal dominio applicativo. L' AOP è composta da i senguenti concetti non legati al framework utilizzato ma al paradigma stesso:

Aspect: rappresenta il comportamento trasversale, crosscutting concern ( esempio: Caching, Logging, Transaction Management) .
Joinpoint: rappresenta un punto ben preciso durante l'esecuzione del programma, come l'invocazione di un metodo.
Advice: rappresenta l'operazione che effetturà il motore di AOP per ogni Joinpoint. Esistono diversi tipi di Advice: Before, AfterReturning, Around e Throw, i quali permettono rispettivamente di effettuare operazioni in diversi istanti rispetto al Joinpoint interessato.
Pointcut: è l'insieme di regole che definisce quale Advice eseguire per quale Joinpoint.
Target: la classe che soddisfa uno o più Joinpoint e che sarà sottoposta ad un Advice, essa viene anche chiamata Advised o Proxied Object.
Introduction: permette la creazione di mixin aggiungendo metodi e/o proprità ad un Advised Object.
Proxy: un proxy creato in maniera dimanica generando codice IL a runtime. Questo proxy sarà il risultato dell'assemblaggio fra gli Advice e l'oggetto Target.
Weaving: rappresenta l'operazione di assemblamento degli Aspect per un determinato Target generando l' Advised Object. Questa operazione può essere fatta sia a compile time, sia a run time. Spring.NET adotta quest' ultima motodologia.

Nei prossimo post descriverò le classi fornite da Spring.NET per la gestione di Pointcut, Advice, Aspects e Proxy.

Come per gli altri componenti di Spring.NET il modulo di AOP e quello di IoC non sono dipendenti fra loro, ma complementari, quindi possiamo usare il primo piuttosto che il secondo, però se usati insieme daranno il massimo della potenzialità.

Technorati Tag: Spring.NET,AOP,Aspect Oriented Programming

[Spring.NET #30] Spring.Core, Definire oggetti tramite ObjectDefinitionBuilder fluent interface

Matteo Baglini — Wed, 12 Mar 2008 01:51:55 GMT

Spring.NET grazie alla classe ObjectDefinitionBuilder espone delle flunt interface API che permettono di definire oggetti da registrare nell' ApplicationContext. Per mostrare questa funzionalità non documentata replicherò l'esempio mostrato nel post [Spring.NET #14] Spring.Core, IoC e DI (Setter Injection) :

        1: using System;

       2: using Spring.Context.Support;

       3: using Spring.Objects.Factory.Support;

       4:  

       5: namespace SpringSeries.Core.ObjectDefinitionBuilderFluentInterface

       6: {

       7:     class Program

       8:     {

       9:         static void Main(string[] args)

        {

            GenericApplicationContext _ctx = new GenericApplicationContext();

  

            _ctx.RegisterObjectDefinition("EngTranslator", ObjectDefinitionBuilder

                                        .RootObjectDefinition(new DefaultObjectDefinitionFactory(), typeof(EnglishToItalianTranslator))

                                        .SetSingleton(true)

                                        .ObjectDefinition);

  

            _ctx.RegisterObjectDefinition("SpaTranslator", ObjectDefinitionBuilder

                                        .RootObjectDefinition(new DefaultObjectDefinitionFactory(), typeof(SpanishToItalianTranslator))

                                        .SetSingleton(true)

                                        .ObjectDefinition);

  

            _ctx.RegisterObjectDefinition("ConsoleLog", ObjectDefinitionBuilder

                                        .RootObjectDefinition(new DefaultObjectDefinitionFactory(), typeof(ConsoleTranslatorLog))

                                        .SetSingleton(true)

                                        .ObjectDefinition);

  

  

            _ctx.RegisterObjectDefinition("Translator", ObjectDefinitionBuilder

                                        .RootObjectDefinition(new DefaultObjectDefinitionFactory(), typeof(PhraseTranslator))

                                        .AddConstructorArgReference("EngTranslator")

                                        .AddPropertyReference("Log","ConsoleLog")

                                        .SetSingleton(true)

                                        .ObjectDefinition);

  

            PhraseTranslator _translator = (PhraseTranslator)_ctx.GetObject("Translator");

            Console.WriteLine(_translator.Translate("Hello Spring.NET !!"));

            Console.WriteLine(_translator.Translate("Hola Spring.NET !!"));

            Console.Read();

        }

    }

}

L'esempio è abbastanza autoesplicativo, come prima cosa creo un ApllicationContext vuoto grazie alla classe GenericApplicationContext, in seguito registro la definizione degli oggetti tramite il metodo RegisterObjectDefinition, il quale accetta due parametri, l'identificativo di tipo stringa ed un'istanza di IObjectDefinition. Per ottenere le varie istanze di IObjectDefinition utilizziamo la classe ObjectDefinitionBuilder.

Technorati Tag: Spring.NET

[Spring.NET #29] Spring.Core, Loosely Coupled Event Wiring

Matteo Baglini — Sun, 09 Mar 2008 13:40:33 GMT

Grazie al motore di IoC, Spring.NET offre la funzionalità di Loosely Coupled Event Wiring, vale a dire la possibilità di scatenare ed intercettare eventi senza un legame diretto fra il publisher ed il subscriber. Il meccanismo avviene grazie ad un Registry mantenuto da Spring.NET, dentro al quale il publisher registra i propri aventi, rendendoli pubblici, a questo punto il subscriber potrà "dire" a Spring.NET quale eventi sottoscrivere. Passiamo subito ad un esempio pratico, creiamo una ConsoleApplication ed aggiungiamo la reference a Spring.Core.dll. Procediamo con l'oggetto publisher, come prima cosa aggiungiamo una classe CustomEventArgs, la quale sarà utilizzata nell'evento scatenato dalla classe EventPublisher:

        1: using System;

       2:  

       3: namespace SpringSeries.Core.EventWiring

       4: {

       5:     public class CustomEventArgs : EventArgs

       6:     {

       7:         private string _eventMessage;

       8:  

       9:         public CustomEventArgs(string eventMessage)

      10:         {

      11:             _eventMessage = eventMessage;

      12:         }

      13:  

      14:         public string EventMessage

      15:         {

      16:             get { return _eventMessage; }

      17:         }

      18:     }

      19: }

dopo creiamo la classe EventPublisher, la quale espone l'evento SimpleEvent:

       1: using System;

       2:  

       3: namespace SpringSeries.Core.EventWiring

       4: {

       5:     public delegate void SimpleEvent(object sender, CustomEventArgs args);

       6:  

       7:     public class EventPublisher

       8:     {

       9:         private string _publisherName;

      10:  

      11:         public event SimpleEvent _simpleEvent;

      12:  

      13:         public EventPublisher()

      14:         {

      15:         }

      16:  

      17:         public string PublisherName

      18:         {

      19:             get { return _publisherName; }

      20:             set { _publisherName = value; }

      21:         }

      22:  

      23:         public void RaiseSimpleEvent()

      24:         {

      25:             if (_simpleEvent != null)

      26:                 _simpleEvent(this, new CustomEventArgs("SimpleEvent raised from " + _publisherName));

      27:         }

      28:     }

      29: }

Fatto il publisher passiamo alla creazione della classe che farà da subscriber, EventSubscriber. Questa classe deve avere un metodo con la stessa firma dell'evento che vuote intercettare:

       1: using System;

       2:  

       3: namespace SpringSeries.Core.EventWiring

       4: {

       5:     public class EventSubscriber

       6:     {

       7:         private bool _eventHandled = false;

       8:  

       9:         public EventSubscriber()

      10:         {

      11:         }

      12:  

      13:         public void HandleSimpleEvent(object sender, CustomEventArgs args)

      14:         {

      15:             Console.WriteLine("Handled SimpleEvent event with args: " + args.EventMessage);

      16:             _eventHandled = true;

      17:         }

      18:  

      19:         public bool EventHandled

      20:         {

      21:             get { return _eventHandled; }

      22:         }

      23:     }

      24: }

Configuriamo il publisher ed il subscriber all'interno del file di configurazione:

<objects xmlns="http://www.springframework.net">
  <object name="MyEventPublisher" 
          type="SpringSeries.Core.EventWiring.EventPublisher, 21.EventWiring" 
          singleton="false">
    <property name="PublisherName" value="Matteo event publisher" />
  </object>
  <object name="MyEventSubscriber" 
          type="SpringSeries.Core.EventWiring.EventSubscriber, 21.EventWiring" 
          singleton="false" />
</objects>

Nel corpo del metodo Main registriamo l'evento SimpleEvent della classe EventPublisher in maniera programmatica, grazie al metodo PublishEvents dell' ApplicationContext. Creaiamo due istanze di EventSubscriber e registriamo solo la prima come subscriber. La sottoscrizione avviene grazie al metodo Subscribe dell' ApplicationContext.

       1: using System;

       2: using Spring.Context;

       3: using Spring.Context.Support;

       4:  

       5: namespace SpringSeries.Core.EventWiring

       6: {

       7:     public sealed class Program

       8:     {

       9:         [STAThread]

        public static void Main()

        {

  

            IApplicationContext _ctx = ContextRegistry.GetContext();

  

            EventPublisher _publisher = (EventPublisher)_ctx.GetObject("MyEventPublisher");

            // registro nel context gli eventi dell'oggetto EventPublisher

            _ctx.PublishEvents(_publisher);

  

            EventSubscriber _subscriber1 = (EventSubscriber)_ctx.GetObject("MyEventSubscriber");

            EventSubscriber _subscriber2 = (EventSubscriber)_ctx.GetObject("MyEventSubscriber");

            // registro nel context che il subscriber1 sottoscrive gli eventi dell'oggetto EventPublisher

            _ctx.Subscribe(_subscriber1, typeof(EventPublisher));

  

            Console.WriteLine("Publisher name: " + _publisher.PublisherName);

            

            Console.WriteLine("Subscriber 1 Event Handled: " + _subscriber1.EventHandled);

            Console.WriteLine("Subscriber 2 Event Handled: " + _subscriber2.EventHandled);

  

            // raises a publisher event...

            _publisher.RaiseSimpleEvent();

  

            Console.WriteLine("Subscriber 1 Event Handled: " + _subscriber1.EventHandled);

            Console.WriteLine("Subscriber 2 Event Handled: " + _subscriber2.EventHandled);

  

            Console.Read();

        }

    }

}

Technorati Tag: Spring.NET

[Spring.NET #28] Spring.Core, Validation Framework e WinForm

Matteo Baglini — Sat, 16 Feb 2008 18:53:58 GMT

Il framework di supporto per le WinForms si chiama Spring.NET RichClient ed è un progetto disponibile a parte rispetto a Spring.NET, sviluppato da Harald Radi. Ad oggi l'ultima versione scaricabile dal sito, la 0.2.1, è un po vecchiotta e presenta diversi problemi, quindi vi consiglio di scaricare l'ultima versione del codice sorgente direttamente dal trunk. Anche in questo questo post mi limiterò a parlare solo dell'integrazione fra le WinFroms ed il Validation Framework, altri aspetti riguardanti le applicazioni Windows e Spring.NET verrànno trattati in post futuri. Finite queste precisazioni iniziamo creando un'applicazione Windows ed aggiungendo i riferimenti alle librerie Spring.Core e Spring.Windows. Continuiamo aggiungendo le ormai consuete classi Person, AddressInfo, il file di risorsa Messages.resx ed il file App.config (contenente la solita configurazione del MessageSource e delle regole di validazione delle classi di domino). Il codice di tutti questi file è presente nei vari post precedenti.

A questo punto dobbiamo creare una nuova Form ereditando dalla ValidatingFrom fornita da Spring.NET, alla quale daremo il nome PersonEditForm. Per facilitare e velocizzare l'esempio utilizzeremo il DataBinding aggiuingendo alla Form un controllo BindingSource, tramite il wizard di Visual Studio impostiamo la proprietà DataSource su Person, quindi proseguiamo trasciniamo dalla Data Sources Toolbox i vari controlli necessari. Proseguiamo aggiungendo un nuovo controllo ValidatorAdapter (namespace Spring.Windows.Validation), collegandolo tramite la proprietà ValidatorName all'id della regola di validazione da utilizzare, in questo caso PersonValidator. Per le TextBox: FirstName, DateOfBirth, City e PostalCode, tramite la proprietà Providrs on ErrorRenderer, indichiamo quale gruppo (Provider) di ErrorMessage visualizzare, impostiamo rispettivamente: FirstNameMessage, DateOfBirthMessage, CityMessage e PostalCodeMessage. Al termine della procedura la Form risulterà simile a quella mostrata in figura.

Spostiamoci nel codice della Form, aggiungiamo un membro di tipo Person, usiamolo come DataSource ed impostiamo i metodi di risposta per l'evento Click di ogni Button:

   1:  using System;

   2:  using System.Windows.Forms;

   3:  using Spring.Windows.Forms;

4:

   5:  namespace SpringSeries.Core.ValidationWindowsForms{

   6:      public partial class PersonEditForm : ValidatingForm {

   7:          private Person _person = new Person(1);

8:

   9:          public PersonEditForm() {

  10:              InitializeComponent();

  11:          }

12:

  13:          private void PersonEditForm_Load(object sender, System.EventArgs e) {

  14:              personBindingSource.DataSource = _person;

  15:          }

16:

  17:          private void btnSave_Click(object sender, System.EventArgs e) {

  18:              this.DialogResult = DialogResult.OK;

  19:              this.Close();

  20:          }

21:

  22:          private void btnCancel_Click(object sender, System.EventArgs e) {

  23:              this.DialogResult = DialogResult.Cancel;

  24:              this.Close();

  25:          }

  26:      }

  27:  }

Effettuiamo, sempre nella Form, l'override del metodo GetFormBackingObject, all'interno del quale non facciamo altro che restituire l'oggetto da validare:

   1:  protected override object GetFormBackingObject() {

   2:      return _person;

   3:  }

Spring.NET si occuperàdi istanziare un Validator, il quale verrà utilizzato all'interno del metodo OnClosing della From per effettuare la validazione, passandogli come parametro l'oggetto restituito dal metodo GetFormBackingObject. E' importante sottolineare che la validazione verrà effettuata soltato quando il DialogResult della Form è diverso dallo stato di Cancel. La classe Program essere modificata in modo da ereditare dalla classe Application fornita da Spring.NET. Nel metodo Main invochiamo il metodo InitializeContext(), necessario per inizializzare correttamente l' ApplicationContext.

   1:  using System;

   2:  using Spring.Windows;

3:

   4:  namespace SpringSeries.Core.ValidationWinForm

   5:  {

   6:      public class Program : Application

   7:      {

   8:          [STAThread]

   9:          private static void Main()

  10:          {

  11:              Program _program = new Program();

  12:              _program.InitializeContext();

  13:              _program.Run(new PersonEditForm());

  14:          }

  15:      }

  16:  }

Eseguiamo l'applicazione, clicchiamo il pulsante OK e potremo notare un risultato simile a questo:

Technorati Tag: Spring.NET

[Spring.NET #27] Spring.Core, Validation Framework e ASP.NET

Matteo Baglini — Sat, 26 Jan 2008 21:24:05 GMT

In questo post affronteremo l'integrazione del Validation Framework di Spring.NET con le WebForm di ASP.NET. L'integrazione di Spring.NET con ASP.NET è molto ampia e non tocca solo il discorso della validazione, però in questo post mi limiterò su questo argomento.

Fatta questa premessa cominciamo creando in Visual Studio un nuovo progetto ASP.NET Web Application, aggiungiamo le classi Person, AnddressInfo utilizzate nei post precedenti. Facciamo uguale con il file di risorsa Message.resx (introdotto in questo post), aggiungendolo nella directory App_GlobalResources. Eliminiamo Default.aspx ed aggiungiamo le pagine PersonEdit.aspx e PersonValid.aspx, referenziamo gli assembly Spring.Core, Spring.Web, antlr.runtime, Common.Logging ed in fine aggiungiamo una cartella Images con un immagine da visualizzare nella pagina web accanto ad i controlli non validi. Il risultato finale sà a quello visualizzato nell'immagine laterale.terminata la parte di setup della solution procediamo con la modifica delle pagine aspx. Cominciamo con la pagina PersonEdit.aspx, aggiungiamo una serie di controlli ASP.NET per inserire i dati di Person, ed i controlli Spring.NET per il rendering dei messaggi e dell'immagine di errore:

        1: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="PersonEdit.aspx.cs" Inherits="SpringSeries.Core.ValidationWebForm.PersonEdit" %>

       2: <html xmlns="http://www.w3.org/1999/xhtml" >

       3: <head runat="server">

       4:     <title>Spring.NET Validation Framework Test</title>

       5:     <style type="text/css">

       6:         .validationError

       7:         {

       8:             font-size: 80%;

       9:             color: #DC143C;

        }

    </style>

</head>

<body>

    <h1>Spring.NET Validation Framework Test</h1>

    <form id="form1" runat="server">

    <table>

        <tr><td><asp:Label ID="Label1" runat="server" Text="First Name:"></asp:Label></td>

            <td>

                <asp:TextBox  ID="txtFirstname" runat="server"></asp:TextBox>        

                <spring:ValidationError id="FirstNameMessage" runat="server" />

            </td></tr>

        <tr><td><asp:Label ID="Label2" runat="server" Text="Last Name:"></asp:Label></td>

            <td>

                <asp:TextBox  ID="txtLastName" runat="server"></asp:TextBox>        

            </td></tr>

        <tr><td><asp:Label ID="Label3" runat="server" Text="Date Of Birth:"></asp:Label></td>

            <td>

                <asp:Calendar ID="clDateOfBirth" runat="server" ></asp:Calendar>

                <spring:ValidationError id="DateOfBirthMessage" runat="server" />

            </td></tr>

        <tr><td><asp:Label ID="Label4" runat="server" Text="Address:"></asp:Label></td>

            <td>

                <asp:TextBox  ID="txtAddress" runat="server"></asp:TextBox>        

            </td></tr>

        <tr><td><asp:Label ID="Label5" runat="server" Text="City:"></asp:Label></td>

            <td>

                <asp:TextBox  ID="txtCity" runat="server"></asp:TextBox>

                <spring:ValidationError id="CityMessage" runat="server" />        

            </td></tr>

        <tr><td><asp:Label ID="Label6" runat="server" Text="PostalCode:"></asp:Label></td>

            <td>

                <asp:TextBox  ID="txtPostalCode" runat="server"></asp:TextBox>        

                <spring:ValidationError id="PostalCodeMessage" runat="server" />

            </td></tr>   

        <tr><td></td>

            <td>

                <spring:ValidationSummary ID="validationSummary" runat="server" />

            </td></tr>  

        <tr><td></td>

            <td>

                <asp:Button ID="btnSave" runat="server" Text="Save" OnClick="btnSave_Click" />

            </td></tr>   

    </table>        

    </form>

</body>

</html>

leggendo il codice di markup notiamo l'utilizzo di due controlli forniti da Spring.NET:

ValidationSummary: Questo controllo viene utilizzato al posto di quello standard di ASP.NET e serve a visualizzare, in maniera ragruppata, tutti i messagi di errore generati dal validation framework.
ValidationError: Questo controllo viene utilizzato per visualizzare un errore di validazione a livello di elemento della pagina web.

per entrambi i controlli possiamo decidere la modalità di rendering. Quelle già fornite built-in sono:

SpanValidationErrorsRenderer: Questa implementazione renderizza i messaggi di errore racchiusi in un elemento span.
DivValidationErrorsRenderer: Questa implementazione renderizza i messaggi di errore racchiusi in un elemendo div.
IconValidationErrorsRenderer: Questa implementazione visualizza un immagine di errore con un tooltip per visualizzare il messaggio di errore.

per implementare un nostro particolare ValidationErrorsRenderer basterà creare una classe che implementi la relatia interfaccia IValidationErrorsRenderer. La configurazione di questi controlli verrà trattata più tardi. Continuiamo modificando la pagina PersonValid.aspx, in questo caso non facciamo altro che visualizzare un banale messaggio di avvenuta validatazione.

       1: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="PersonValid.aspx.cs" Inherits="SpringSeries.Core.ValidationWebForm.PersonValid" %>

       2: <html xmlns="http://www.w3.org/1999/xhtml" >

       3: <head runat="server">

       4:     <title>Validazione Effettuata Correttamente</title>

       5: </head>

       6: <body>

       7:     <h1>Person is valid!!</h1>

       8: </body>

       9: </html>

Spostiamoci nel code-behind della pagina PersonEdit.aspx, i passi da fare sono molto semplici, ereditare la pagina da Spring.Web.Page anzichè System.Web.Page, aggingere un field di tipo Spring.Validation.IValidator, esporlo tramite una setter property (questo permetterà al motore di IoC di iniettare il concreto validator all'interno della pagina) ed in fine effettuare la validazione tramite il metodo Validate della calsse base Page. Questo metodo ha due parametri, l'oggetto da validare (validationContext) ed il validator da utilizzare (validators). Validate verrà invocato nel metodo abbinato all'evento click del pulsante Save, dopo aver impostato i dati di Person, in seguito se l'istanza è valida faremo un redirect alla pagina PersonValid.aspx, altrimenti verranno automaticamente visualizzati i messaggi e le icone di errore. Il codice risulterà così:

       1: using System;

       2: using System.Web.UI;

       3: using Spring.Web.UI;

       4: using System.Reflection;

       5:  

       6: namespace SpringSeries.Core.ValidationWebForm{

       7:     public partial class PersonEdit : Spring.Web.UI.Page{

       8:         private Person _person;

       9:         private Spring.Validation.IValidator _personValidator;

  

        public Spring.Validation.IValidator PersonValidator{

            set { _personValidator = value; }

        }

  

        protected void btnSave_Click(object sender, EventArgs e){

            _person = new Person(1);

            _person.FirstName = txtFirstname.Text;

            _person.LastName = txtLastName.Text;

            _person.DateOfBirth = clDateOfBirth.SelectedDate;

            _person.AddressInfo.Address = txtAddress.Text;

            _person.AddressInfo.City = txtCity.Text;

            _person.AddressInfo.PostalCode = txtPostalCode.Text;

  

            if (Validate(_person, _personValidator))

            {

                Response.Redirect("PersonValid.aspx");

            }            

        }

    }

}

Ok, la pagina di validazione è pronta non ci resta che configurare l'ambiente nel file Web.config. Cominciamo aggiungendo nella sezione <system.web> l' HttpModule e l' HttpHandler necessari per l'abilitazione del Web Framework di Spring.NET, oltre a questi inseriamo una direttiva <pages> per la gestione di controlli taggati spring:

<system.web>
  <compilation debug="true" />
  <authentication mode="Windows" />
  <pages>
    <controls>
      <add tagPrefix="spring" namespace="Spring.Web.UI.Controls" assembly="Spring.Web"/>
    </controls>
  </pages>
  <httpModules>
    <add name="SpringModule" type="Spring.Context.Support.WebSupportModule, Spring.Web"/>
  </httpModules>
  <httpHandlers>
    <add verb="*" path="*.aspx" type="Spring.Web.Support.PageHandlerFactory, Spring.Web"/>
  </httpHandlers>
</system.web>

procediamo configurando l'ApplicationContext, inserendo nel tag objects, il MessageSource e le impostazioni di DI per la pagina PersonEdit.aspx :

<object id="messageSource" type="Spring.Context.Support.ResourceSetMessageSource, Spring.Core">
  <property name="ResourceManagers">
    <list>
      <value>Resources.Messages, App_GlobalResources</value>
    </list>
  </property>
  <property name="UseCodeAsDefaultMessage" value="true" />
</object>      
<object type="PersonEdit.aspx">
  <property name="PersonValidator" ref="personValidator" />
</object>

adesso tocca alle impostazioni di rendering per i controlli ValidationSummary e ValidationError, sempre tramite la DI, utilizzando rispettivamente un DivValidationErrorsRenderer (inidcando la CssClass da utilizzare) ed un IconValidationErrorsRenderer (indicando l'immagine da utilizzare) :

<object id="Spring.Web.UI.Controls.ValidationError" abstract="true">
  <property name="Renderer">
    <object type="Spring.Web.UI.Validation.IconValidationErrorsRenderer, Spring.Web">
      <property name="IconSrc" value="validation-error.gif"/>
    </object>
  </property>
</object>
<object id="Spring.Web.UI.Controls.ValidationSummary" abstract="true">
  <property name="Renderer">
    <object type="Spring.Web.UI.Validation.DivValidationErrorsRenderer, Spring.Web">
      <property name="CssClass" value="validationError"/>
    </object>
  </property>
</object>

ultima cosa da configurare sono le solite regole di validazione della classe Person utilizzati nel post precedente. Non ci resta che caricare la pagine nel Browser e cliccare il button Save per vedere il risultato dei due ValidationErrorsRenderer :

Technorati Tag: Spring.NET

[Spring.NET #26] Spring.Core, Validator Actions e Validation Errors

Matteo Baglini — Sun, 23 Dec 2007 18:25:48 GMT

Altro nodo molto importante del Validation Framework sono le Validator Actions, le quali permettono di eseguire un operazione come consequenza del risultato della validazione. Lo scenario più frequente è quello di utilizzare una Error Message Actions per aggiugre un messaggio di errore alla collezione degli errori, gestita da Spring.NET. Nell'esempio mostrato nel primo post sul Validation Framework ho volutamente omesso questa parte per far capire meglio le due fasi distinte del processo di validazione, la prima dove vengono applicate le regole e la seconda dove vengono eseguite una serie di operazioni di conseguenza. Come intuibile la seconda fase è dipendente dalla prima quindi possiamo aggiungerla solo se necessaria o in un secondo momento come faremo noi in questo esempio. Le Validator Actions fornite built-in sono due, Error Message Actions, già descritto in precedenza ed il Generic Actions il quale permette di effettuare qualsiasi altro tipo di operazione, per tutte le esigenze che Spring.NET non riesce a coprire basterà creare una nostra classe implementando l'interfaccia IValidationAction. Nell'esempio di oggi aggiungeremo una Error Message Actions a tutte le regole di validazione. La sintassi è molto semplice basta utilizzare il tag ad-hoc message indicando gli attributi id, il quale corrisponderà all''id di un messaggio in una MessageSource (vedi post precedenti qui e qui) ed il tag providers il quale indica uno o più contenitori di errori, per indicarne più di uno e bastera utilizzare la virgola come separatore, in fine se dobbiamo passare dei parametri basterà utilizzare il tag param ed impostare il suo unico attributo value. Se vogliamo, anche per le Validator Actions possiamo utilizzare l'attributo when in modo da renderne condizionale l'esecuzione. Vediamo come risulterà il file di configurazione dopo aver aggiunto una MessageSource e tutte le Error Message Actions:

<object name="messageSource" type="Spring.Context.Support.ResourceSetMessageSource, Spring.Core">
  <property name="resourceManagers">
    <list>
      <ref object="messagesResourceManager" />
    </list>
  </property>
</object>
<object name="messagesResourceManager" type="Spring.Objects.Factory.Config.ResourceManagerFactoryObject, Spring.Core">
  <property name="baseName" value="SpringSeries.Core.ValidatorActions.Messages" />
  <property name="assemblyName" value="23.ValidatorActions" />
</object>
<v:group id="PersonValidator">
  <v:required id="PersonFirstNameValidator" test="FirstName" >
    <v:message id="error.person.firstname.required" providers="FirstNameMessage" />
  </v:required>
  <v:condition id="PersonDateOfBirthValidator" test="DateOfBirth != DateTime.MinValue" >
    <v:message id="error.person.dateofbirth.required" providers="DateOfBirthMessage" />
  </v:condition>
  <v:regex id="PersonFirstNameContentValidator" test="FirstName" >
    <v:property name="Expression" value="[A-Za-z]*" />
    <v:message id="error.person.firstname.content" providers="FirstNameMessage" />
  </v:regex>
  <v:ref name="AddressInfoValidator" />
</v:group>
<v:group id="AddressInfoValidator">
  <v:required id="CityValidator" test="AddressInfo.City" when="AddressInfo.Address!=String.Empty" >
    <v:message id="error.city.required" providers="CityMessage" />
  </v:required>
  <v:required id="CapValidator" test="AddressInfo.PostalCode" when="AddressInfo.Address!=String.Empty" >
    <v:message id="error.cap.required" providers="PostalCodeMessage" />
  </v:required>
</v:group>

proseguiamo aggingiamo un file di risorsa contenente le stringhe:

Spring.NET inserisce automaticamente i messaggi di errore dell'ultimo oggetto validato, raggruppandoli per providers, all'interno di un oggetto ValidationErrors, quindi all'interno della calsse Program aggiugiamo un metodo per stampare i messaggi a video:

   1:  private static void PrintErrors(IApplicationContext _ctx,ValidationErrors _errors) {

   2:      if (!_errors.IsEmpty) {

3:

   4:          foreach (string _provider in _errors.Providers) {

   5:              foreach (ErrorMessage _error in _errors.GetErrors(_provider)) {

   6:                  Console.WriteLine(_error.GetMessage((IMessageSource)_ctx.GetObject("messageSource")));

   7:              }

   8:          }

9:

  10:          Console.WriteLine();

  11:      }

  12:  }

questo metodo non fa altro che ciclare tutti i providers e richiedere i messaggi di errore per ogniuno di essi, in fine gli stampiamo a video utilizzando la MessageSource come "fonte dati". La stampa dei messaggi è così intrigata perchè sto utilizzando una Console Application, per la quale non esiste nessuna integrazione da parte di Spring.NET, nel caso di applicazioni WinForm o WebFrom il discorso cambia e possiamo agganciare l'error provider presente nella Form o nella Web Page ai providers indicati nel file di configurazione, quindi i messaggi di errore verranno direttamente renderizzati senza nessuno sforzo da parte nostra. Nei prossimi post vedremo come fare in modo da capire meglio l'argomento. Per finire non ci resta che modificare il metodo Main dei precedenti post sul Validation Framework aggiungendo, per ogni caso di validazione, una istanza di ValidationErrors e la chiamata al metodo PrintErrors:

   1:  static void Main(string[] args) {

   2:      IApplicationContext _ctx = ContextRegistry.GetContext();

3:

   4:      IValidator _validator = (IValidator)_ctx.GetObject("PersonValidator");

   5:      ValidationErrors _errors1 = new ValidationErrors();

   6:      ValidationErrors _errors2 = new ValidationErrors();

   7:      ValidationErrors _errors3 = new ValidationErrors();

   8:      ValidationErrors _errors4 = new ValidationErrors();

   9:      ValidationErrors _errors5 = new ValidationErrors();

  10:      ValidationErrors _errors6 = new ValidationErrors();

11:

  12:      Person _p01 = new Person(1);

  13:      _p01.FirstName = "Matteo";

  14:      _p01.LastName = "Baglini";

  15:      _p01.DateOfBirth = new DateTime(1982, 11, 8);

16:

  17:      Person _p02 = new Person(2);

  18:      _p02.LastName = "Baglini";

  19:      _p02.DateOfBirth = new DateTime(1982, 11, 8);

20:

  21:      Person _p03 = new Person(3);

  22:      _p03.FirstName = "Matteo";

  23:      _p03.LastName = "Baglini";

24:

  25:      Person _p04 = new Person(4);

  26:      _p04.FirstName = "Matteo";

  27:      _p04.LastName = "Baglini";

  28:      _p04.DateOfBirth = new DateTime(1982, 11, 8);

  29:      _p04.AddressInfo.Address = "Via dei Sassi Sgonfi";

30:

  31:      Person _p05 = new Person(5);

  32:      _p05.FirstName = "Matteo";

  33:      _p05.LastName = "Baglini";

  34:      _p05.DateOfBirth = new DateTime(1982, 11, 8);

  35:      _p05.AddressInfo.Address = "Via dei Sassi Sgonfi";

  36:      _p05.AddressInfo.City = "Livorno";

  37:      _p05.AddressInfo.PostalCode = "57100";

38:

  39:      Person _p06 = new Person(6);

  40:      _p06.FirstName = "1234567890";

  41:      _p06.LastName = "Baglini";

  42:      _p06.DateOfBirth = new DateTime(1982, 11, 8);

  43:      _p06.AddressInfo.Address = "Via dei Sassi Sgonfi";

  44:      _p06.AddressInfo.City = "Livorno";

  45:      _p06.AddressInfo.PostalCode = "57100";

46:

  47:      Console.WriteLine(_p01.ToString());

  48:      Console.WriteLine("Is Valid? {0}", _validator.Validate(_p01, _errors1));

  49:      PrintErrors(_ctx,_errors1);

50:

  51:      Console.WriteLine();

  52:      Console.WriteLine(_p02.ToString());

  53:      Console.WriteLine("Is Valid? {0}", _validator.Validate(_p02, _errors2));

  54:      PrintErrors(_ctx, _errors2);

55:

  56:      Console.WriteLine();

  57:      Console.WriteLine(_p03.ToString());

  58:      Console.WriteLine("Is Valid? {0}", _validator.Validate(_p03, _errors3));

  59:      PrintErrors(_ctx, _errors3);

60:

  61:      Console.WriteLine();

  62:      Console.WriteLine(_p04.ToString());

  63:      Console.WriteLine("Is Valid? {0}", _validator.Validate(_p04, _errors4));

  64:      PrintErrors(_ctx, _errors4);

65:

  66:      Console.WriteLine();

  67:      Console.WriteLine(_p05.ToString());

  68:      Console.WriteLine("Is Valid? {0}", _validator.Validate(_p05, _errors5));

  69:      PrintErrors(_ctx, _errors5);

70:

  71:      Console.WriteLine();

  72:      Console.WriteLine(_p06.ToString());

  73:      Console.WriteLine("Is Valid? {0}", _validator.Validate(_p06, _errors6));

  74:      PrintErrors(_ctx, _errors6);

75:

  76:      Console.Read();

  77:  }

Technorati Tag: Spring.NET

[Spring.NET #25] Spring.Core, Impostare le regole di validazione in maniera programmatica

Matteo Baglini — Sun, 16 Dec 2007 15:24:41 GMT

Come già detto in un post precedente possiamo definire il set di regole di validazione anche in maniera programmatica utilizzando le API fornite da Spring.NET. Vediamo come creare via codice le regole dichiarate nel file XML nell'esempio del post precedente:

   1:  using System;

   2:  using Spring.Validation;

   3:  using Spring.Expressions;

4:

   5:  namespace SpringSeries.Core.ValidationObjectModel {

   6:      class Program {

   7:          static void Main(string[] args) {

   8:              RequiredValidator _reqVal1 = new RequiredValidator();

   9:              _reqVal1.Test = Expression.Parse("FirstName");

10:

  11:              ConditionValidator _conVal = new ConditionValidator();

  12:              _conVal.Test = Expression.Parse("DateOfBirth != DateTime.MinValue");

13:

  14:              RegularExpressionValidator _regexVal = new RegularExpressionValidator();

  15:              _regexVal.Test = Expression.Parse("FirstName");

  16:              _regexVal.Expression = "[A-Za-z]*";

17:

  18:              RequiredValidator _reqVal2 = new RequiredValidator();

  19:              _reqVal2.Test = Expression.Parse("AddressInfo.City");

  20:              _reqVal2.When = Expression.Parse("AddressInfo.Address!=String.Empty");

21:

  22:              RequiredValidator _reqVal3 = new RequiredValidator();

  23:              _reqVal3.Test = Expression.Parse("AddressInfo.PostalCode");

  24:              _reqVal3.When = Expression.Parse("AddressInfo.Address!=String.Empty");

25:

  26:              ValidatorGroup _personVal = new ValidatorGroup();

  27:              _personVal.Validators.Add(_reqVal1);

  28:              _personVal.Validators.Add(_reqVal2);

  29:              _personVal.Validators.Add(_reqVal3);

  30:              _personVal.Validators.Add(_conVal);

  31:              _personVal.Validators.Add(_regexVal);

32:

  33:              Person _p01 = new Person(1);

  34:              _p01.FirstName = "Matteo";

  35:              _p01.LastName = "Baglini";

  36:              _p01.DateOfBirth = new DateTime(1982, 11, 8);

37:

  38:              Person _p02 = new Person(2);

  39:              _p02.LastName = "Baglini";

  40:              _p02.DateOfBirth = new DateTime(1982, 11, 8);

41:

  42:              Person _p03 = new Person(3);

  43:              _p03.FirstName = "Matteo";

  44:              _p03.LastName = "Baglini";

45:

  46:              Person _p04 = new Person(4);

  47:              _p04.FirstName = "Matteo";

  48:              _p04.LastName = "Baglini";

  49:              _p04.DateOfBirth = new DateTime(1982, 11, 8);

  50:              _p04.AddressInfo.Address = "Via dei Sassi Sgonfi";

51:

  52:              Person _p05 = new Person(5);

  53:              _p05.FirstName = "Matteo";

  54:              _p05.LastName = "Baglini";

  55:              _p05.DateOfBirth = new DateTime(1982, 11, 8);

  56:              _p05.AddressInfo.Address = "Via dei Sassi Sgonfi";

  57:              _p05.AddressInfo.City = "Livorno";

  58:              _p05.AddressInfo.PostalCode = "57100";

59:

  60:              Person _p06 = new Person(6);

  61:              _p06.FirstName = "1234567890";

  62:              _p06.LastName = "Baglini";

  63:              _p06.DateOfBirth = new DateTime(1982, 11, 8);

  64:              _p06.AddressInfo.Address = "Via dei Sassi Sgonfi";

  65:              _p06.AddressInfo.City = "Livorno";

  66:              _p06.AddressInfo.PostalCode = "57100";

67:

  68:              Console.WriteLine(_p01.ToString());

  69:              Console.WriteLine("Is Valid? {0}", _personVal.Validate(_p01, null));

  70:              Console.WriteLine();

  71:              Console.WriteLine(_p02.ToString());

  72:              Console.WriteLine("Is Valid? {0}", _personVal.Validate(_p02, null));

  73:              Console.WriteLine();

  74:              Console.WriteLine(_p03.ToString());

  75:              Console.WriteLine("Is Valid? {0}", _personVal.Validate(_p03, null));

  76:              Console.WriteLine();

  77:              Console.WriteLine(_p04.ToString());

  78:              Console.WriteLine("Is Valid? {0}", _personVal.Validate(_p04, null));

  79:              Console.WriteLine();

  80:              Console.WriteLine(_p05.ToString());

  81:              Console.WriteLine("Is Valid? {0}", _personVal.Validate(_p05, null));

  82:              Console.WriteLine();

  83:              Console.WriteLine(_p06.ToString());

  84:              Console.WriteLine("Is Valid? {0}", _personVal.Validate(_p06, null));

85:

  86:              Console.Read();

  87:          }

  88:      }

  89:  }

Technorati Tag: Spring.NET

[Spring.NET #24] Spring.Core, Validators e Validator Groups

Matteo Baglini — Sat, 15 Dec 2007 17:22:31 GMT

La validazione di un'oggetto avviene grazie alla definizione di un insieme di regole. In Spring.NET la singola regola si chiama Validator e l'insieme di regole si chiama Validator Groups. Come è facile immaginare esistono già built-in diversi tipi di Validators e di Validator Groups adatti ai più disparati scenari di validazione però se in certi casi non sono adatti ai nostri bisogni possiamo sempre crearne di nostri implementando l'interfaccia IValidator oppure la classe base BaseValidator. Analiziamo i Validators cominciando dal più semplice, il Required Validator, il quale verifica che un determinato campo sia valorizzato:

<v:required id="PersonFirstNameValidator" test="FirstName" />

procediamo con il Condition Validator, il quale permette di esprimere la validazione tramite un espressione logica utilizzando il linguaggio SpEl,

<v:condition id="PersonDateOfBirthValidator" test="DateOfBirth != DateTime.MinValue" />

poi abbiamo il Regular Expression Validator, il quale permette di validare una stringa con una RegEx, molto utile qunado dobbiamo validare un formato ben definito, come un indirizzo email:

<v:regex id="PersonFirstNameContentValidator" test="FirstName" >
  <v:property name="Expression" value="[A-Za-z]*" />
</v:regex>

in fine abbiamo il Generic Validator, il quale permette di applicare un proprio validator creato implementando l'interfaccia o la classe indicate precedetenmente:

<v:validator id="MyId" typr="MyNamespace.MyCustomValidator, MyAssembly" />

Come spiegato inizialmente possiamo raggruppare i Validators e possiamo farlo in tre modalità logiche, mettendoli in AND utilizzando il Group:

<v:group id="AddressInfoValidator">
  <v:required id="CityValidator" test="AddressInfo.City" when="AddressInfo.Address!=String.Empty" />
  <v:required id="CapValidator" test="AddressInfo.PostalCode" when="AddressInfo.Address!=String.Empty" />
</v:group>

oppure mettendoli in OR utilizzando Any:

<v:any id="AddressInfoValidator">
  <v:required id="CityValidator" test="AddressInfo.City" when="AddressInfo.Address!=String.Empty" />
  <v:required id="CapValidator" test="AddressInfo.PostalCode" when="AddressInfo.Address!=String.Empty" />
</v:any>

ed in fine mettendoli in XOR utilizzando Exclusive:

<v:exclusive id="AddressInfoValidator">
  <v:required id="CityValidator" test="AddressInfo.City" when="AddressInfo.Address!=String.Empty" />
  <v:required id="CapValidator" test="AddressInfo.PostalCode" when="AddressInfo.Address!=String.Empty" />
</v:exclusive>

In fine ricordo che per ogni Validators o Validator Groups possiamo definire una condizione di esecuzione impostando il tag when:

<v:required id="CityValidator" test="AddressInfo.City" when="AddressInfo.Address!=String.Empty" />

Technorati Tag: Spring.NET