Ejemplo usando Spring.Net – Parte III

La versatilidad de Spring.Net  nos permitirá cambiar la implementación del servicio utilizado por la clase controladora sin alterar un ápice el código de programación, en este caso le indicaremos que en lugar de usar el ServicioFinancieroSimple tal como se aprecia en el post anterior, lo modificaremos como se muestra a continuación:

 

<object id=«ControladorFinanciero« type=«SpringExample.ControladorFinanciero, SpringExample« >

       <property name =«Servicio« ref =«ServicioFinancieroEspecial«>property>

 object >

 

Como se podrá notar le indicaremos a la propiedad Servicio de la clase ControladorFinanciero que se instancie con el ServicioFinancieroEspecial,  ejecutamos y tenemos el siguiente resultado.

Ejemplo02

Ejemplo02

 Como nota adicional quiero hacer énfasis en que el proceso de instanciación al que me refiero es el momento cuando concretizamos una clase especifica, en el caso del ejemplo anterior sin la ayuda de Spring.Net, hubiésemos tenido utilizar el operador new cuando necesitáramos una instancia de la clase controladora, y dentro de ella para especificar el servicio especifico a utilizar.

Ejemplo usando Spring.Net – Parte II

A continuación llevaremos a cabo la codificación en C#.Net (VS 2K5)

 Interface:

 namespace SpringExample.Abstract

{

    public interface IServicioFinanciero

    {

        string Operacion();

    }

}

  

 Servicios:

 namespace SpringExample.Concrete

{

    public class ServicioFinancieroEspecial : IServicioFinanciero

    {

        public ServicioFinancieroEspecial() { }

       

        public string  Operacion()

        {

           return string.Format(«{0}», «Servicio Financiero Especial.»);

        }

    }

}

   

namespace SpringExample.Concrete

{

    class ServicioFinancieroSimple : IServicioFinanciero

    {

        public ServicioFinancieroSimple() { }

 

        public string Operacion()

        {

            return string.Format(«{0}», «Servicio Financiero Simple.»);

        }

    }

}

 

 Controlador:

 

using System;

using System.Collections.Generic;

using SpringExample.Abstract;

 

namespace SpringExample

{

    public class ControladorFinanciero

    {

        IServicioFinanciero _servicio;

               

        public IServicioFinanciero Servicio

        {

            set { _servicio = value; }

        }

 

        public ControladorFinanciero() {}

 

        public string OperacionFinanciera()

        {

            return string.Format(«Controlador Ejecutando: {0} «, _servicio.Operacion());   

        }

 

    }

}

 

El programa principal de la aplicación.

 

using System;

using System.Collections.Generic;

using Spring.Context;

using Spring.Context.Support;

 

namespace SpringExample

{

    class Program

    {

        static void Main(string[] args)

        {

            IApplicationContext ctx = ContextRegistry.GetContext();

            ControladorFinanciero controlador = ctx.GetObject(«ControladorFinanciero») as ControladorFinanciero;

           

            Console.WriteLine(controlador.OperacionFinanciera());

            Console.ReadLine(); 

        }

    }

}

 

Tal como se muestra en  el código, el primer paso es tener una referencia al contenedor de objetos, y posteriormente solicitarle al contenedor de objetos el objeto deseado, en este caso ControladorFinanciero, el cual será instanciado según las especificaciones que se muestran en el archivo de configuración detallado a continuación.

 

Finalmente definimos el archivo de configuración de la aplicación (App.config), de la siguiente manera:

 

<?xml version=«1.0« encoding=«utf-8« ?>

<configuration>

      <configSections>

            <sectionGroup name=«spring«>

                  <section name=«context«

                     type=«Spring.Context.Support.ContextHandler, Spring.Core«/>

                  <section name=«objects« type=«Spring.Context.Support.DefaultSectionHandler, Spring.Core« />

            </sectionGroup>

      </configSections>

 

      <spring>

        <context>

                  <resource uri=«config://spring/objects«/>

        </context>

 

        <objects xmlns=«http://www.springframework.net«>

         <object id=«ServicioFinancieroSimple« type=«SpringExample.Concrete.ServicioFinancieroSimple, SpringExample« />

         <object id=«ServicioFinancieroEspecial« type=«SpringExample.Concrete.ServicioFinancieroEspecial,SpringExample«/>

         <object id=«ControladorFinanciero«  type=«SpringExample.ControladorFinanciero, SpringExample« >

                        <property name =«Servicio« ref =«ServicioFinancieroSimple«></property>

        </object >

                 

        </objects>

      </spring>

</configuration>

 

Ejecutamos nuestra aplicación y tendremos el siguiente resultado obtenido por el controlador:

   

Ejemplo01

Como habrán podido apreciar no se ha codificado la instanciación del servicio desde dentro del la clase controladora, todo a ha sido hecho usando Dependency Injection, en este caso específicamente a través de Setter Injection (Inyección a través de propiedades).

Ejemplo usando Spring.Net – Parte I

Se ha definido un ejemplo bastante sencillo con el cual configuraremos Spring.Net,  y demostraremos el uso de Dependency Injection, donde el objetivo a alcanzar es demostrar que podemos codificar nuestras aplicaciones alcanzando el principio de alta cohesión y bajo acoplamiento, derivando la  responsabilidad de instanciación de ciertas clases a un Framework empresarial como Spring.Net,  tal como podrán apreciarlo en el desarrollo de este post.

 

En primer lugar necesitamos  descargar la última versión del framework  Spring.Net  desde la siguiente dirección:

 

http://www.springframework.net/download.html

Después de haber instalado el framework,  creamos un proyecto de Aplicación de Consola y hacemos una referencia al  assembly Spring.Core.

 

Nuestro sencillo ejemplo se definirá siguiendo el siguiente esquema:

 

SpringEjemplo

 

En nuestro esquema tenemos una clase controladora que es la responsable de operar distintos servicios financieros, basándonos en la premisa de que estos servicios son mutuamente excluyentes, cada uno de los cuales tiene por finalidad la de ejecutar una determinada operación y retornar un resultado bajo criterios específicos, razón por la cual el modelo incluye una interface o contrato que regirá la implementación de todos los servicios financieros, a su vez ésta nos permitirá desacoplar nuestra clase controladora de la implementación de los servicios permitiéndonos llevar a cabo una simple referencia a la interface desde la clase controladora; ahora es donde Spring.Net  toma su lugar, pues éste  será el responsable de instanciar el servicio correspondiente de acuerdo a las indicaciones que le vamos a proveer a  través del archivo de configuración.

Convertidor de Números a Letras

Hace un tiempo escribí un programa en C# con el objeto de convertir números a letras, la intención era que fuese lo suficientemente modular para poder extenderlo, lo cual involucraba no alterar la lógica del programa en la interpretación del numero a definir en palabras, y que a su vez ésta definición fuera lo más posible abierta para su configuración y necesidades de la aplicación.

 

Tras un breve análisis, se aplicó un método bastante sencillo, si analizamos un número en particular, digamos el número 2’467,335 nos daremos cuenta que podemos descomponerlo fácilmente en grupos de tres  con una secuencia constante de unidades, decenas y centenas, que de acuerdo a su posición ya serán cientos de unidades, miles de unidades, miles de decenas, millones de centenas y así sucesivamente, de esta manera resultaba lógico generar una tabla de descomposición del número  de esta manera:

 

Digito

Exponente

Iteración

Palabra

2

6

1

dos millones

4

5

3

cuatrocientos

6

4

3

sesenta y

7

3

3

siete mil

3

2

3

trescientos

3

1

3

treinta y

5

0

3

cinco

 

Al descomponer el número en grupos de tres dígitos  (unidades, decenas, centenas), la iteración me indica si este grupo forma parte de una centena, decena o simplemente una unidad, esto con el fin de manejar ciertos requisitos del lenguaje.

 

Una vez descompuesto el número quedaba definir una serie de equivalencias básicas entre números y letras, lo cual implicaba elaborar una tabla de equivalencias como la siguiente:

 

Numero

Equivalencia

Simple

Compuesto

1

uno

un

2

dos

dos

10

diez

dieci

100

cien

ciento

 

Ahora teniendo el exponente y la iteración correspondiente dentro de su grupo de unidades, decenas y centenas, solo bastaba encontrar su equivalencia y establecer un grupo de excepciones para finalmente tener nuestro número en palabras.

 

El código de la aplicación puede bajarse de la siguiente dirección:

 

http://www.codeplex.com/NumberToLetter

Configurando Spring.Net en nuestra aplicación

El objetivo de este post es hacer una breve descripción de como configurar  una aplicación usando Spring.Net, lo cual nos implica abordar el modulo Spring.Core el cual está catalogado como la parte fundamental del framework  Spring.Net y es el que provee de los mecanismos de configuración para el uso de Dependency Injection.
Dependency Injection:
Es un patrón de arquitectura orientado a objetos, en el que se inyectan objetos a una clase en lugar de ser la propia clase quien cree el objeto.
Para cumplir con el patrón de diseño denominado Dependency Injection es necesario que el framework, en este caso Spring.Net cuente con un contenedor de objetos que se encargará de la instanciación, configuración y administración de una diversidad de objetos, el mecanismo más común que se utiliza para alcanzar dicho objetivo es a través de un archivo de configuración en XML en el cual le especificaremos a Spring.Net como llevar a cabo dicha misión.
 
Para la creación del contenedor de objetos en nuestra aplicación es recomendable el uso de una sección personalizada dentro del archivo de configuración de la misma aplicación (App.config ó Web.config), tal como se muestra a continuación:
 
<sectionGroup name="spring">
 <section name="context"
          type="Spring.Context.Support.ContextHandler,
          Spring.Core"/>
.
.
.
</sectionGroup>
 
Esta declaración nos permitirá usar el contenedor de objetos y a su vez definir otras secciones personalizadas dentro del archivo de configuración de la aplicación a través de la cual le indicaremos como deberá crear, manipular, etc. nuestros objetos, tal como se muestra a continuación:
 
<configSections>

    <sectionGroup name="spring">
<section name="context"
   type="Spring.Context.Support.ContextHandler,
Spring.Core"/>
      <section name="objects"
               type="Spring.Context.Support.DefaultSectionHandler,
 Spring.Core" />
    </sectionGroup>
  </configSections>
 
  <spring>
    <context>
      <resource uri="config://spring/objects"/>
    </context>
   
    <objects xmlns="http://www.springframework.net"&gt;
          
      <!– Prototype –>
     
      <object id="FrmExample"
  type="FormulaCSharp.FrmExample, FormulaCSharp" />
            .
            .
            .
    </objects>
  </spring>
 
 
Finalmente la sección denominada objects es donde definiremos cada uno nuestros objetos de la aplicación, tal como lo mostraremos más adelante en un posterior post.

¿ Que es Spring.Net ?

En la actualidad se habla mucho sobre el uso de frameworks que facilitan la implementación de aplicaciones empresariales, los cuales nos proveen de ciertos patrones de diseño ya implementados en lo referente a la solución de problemas específicos, tales como Validaciones, Acceso a Datos, Caching, Unit Testing, AOP, etc. y que nos hacen la vida más fácil al momento de codificar una aplicación, como es el caso de Enterprise Library, CSLA.Net, Spring.Net, etc.

 

Spring.Net tiene sus orígenes en una versión diseñada e implementada en el mundo Java, la cual es ampliamente usada en aquella comunidad y con múltiples muestras de sus beneficios, razón muy importante que ha motivado su implementación para la comunidad Net., el cual está conformado por diversos módulos cada uno de los cuales aborda la solución a problemas determinados,  los módulos actuales se muestran en la siguiente grafica:

overview

Spring.Core es la más importante parte del framework el cual permite la configuración de la aplicación para el uso de Dependency Injection. Spring.Aop – este modulo está diseñado para llevar a cabo el uso de la Programación Orientada a Aspectos (AOP).

Spring.Data –  su objetivo es alcanzar gran eficiencia y consistencia en la implementación del acceso a datos usando ADO.Net en forma conjunta con un manejo declarativo de transacciones.

Spring.Data.NHibernate – este modulo tiene por finalidad permitir la integración entre Spring y Nhibernate.

Spring.Web – el propósito de este modulo es proveer una capa de abstracción en la construcción de aplicaciones ASP.NET  permitiendo afrontar problemas comunes en lo que respecta a data binding, validaciones, etc.

Spring.Web.Extensions – el objetivo de este modulo es permitir la integración de ASP.Net AJAX con spring.

Spring.Services  – este modulo tiene por finalidad adaptar los objetos planos viejos (PONO – plain old .Net objects) para ser usados bajo alguna tecnología de comunicación distribuida tal como .NET Remoting, Enterprise Services, y ASMX Web Services. Estos servicios pueden  ser configurados vía dependency injection y  ‘decorados’ usando AOP.

Spring.Testing.NUnit Su finalidad es permitir la integración con NUnit.