Esta es la clase CustomerService:

    public class CustomerService : BaseService, ICustomerService
    {
	/// <summary>
        /// This field is inyected by IoC through the property.
        /// </summary>

        private ICustomerDao customerDao;        
 	public ICustomerDao CustomerDao {
            get { return customerDao; }
          set { customerDao = value; }
        }

#region ICustomerService Members

	public int CreateCustomer(string Name, string LastName) {

        	Customer customer = new Customer();

        	customer.FirstName = "Dario";

	        customer.LastName = "Quintana";

		CustomerDao.Save(customer);

		return customer.Id;

        }

	public void DeleteCustomer(int Id) {

            	Customer customer = CustomerDao.GetById(Id);

		CustomerDao.Delete(customer);

        }

#endregion

    }

Como se puede apreciar las clases CreateCustomer ó DeleteCustomer no están envueltas en un codigo Transactional o de UnitOfWork, tampoco el método Save(customer) en la clase CustomerDao.

Entonces… donde está el soporte transaccional? Spring + AOP es la respuesta. Spring envuelve a los metodos del Servicio entre transacciones. Y la respuesta para esto son los proxies.

Cuando se realiza la instanciación de la clase CustomerService, un proxy es instanciado. Con el proxy de nuestra clase Spring.Net puede envolver los metodos configurados dentro de transacciones. Muy bueno no ?

Otra cosa que pueden apreciar en el ejemplo es el uso de uNhAddIns en el repositorio. Con esta librería podemos usar queries "detachadas" o separadas de un contexto de persistencia por medio de la clase DetachedQuery. Con DetachedQuery podemos hacer uso indistinto de Hql/SqlNativo en NamedQueries, y esto es una buena práctica que debemos tratar de adoptar.

Descargar el ejemplo

Para dicha Inversion de Control (IoC) estoy usando Windsor Container.

Este caso todos los proveedores son inyectados, es decir, dejo que el container me entregue en mano, todas la implementaciones existentes de IProvider para la aplicación. Cada proveedor implementa la interfaz IProvider:

namespace Mono.Sms.Core.Provider
{
    public interface IProvider
    {
        string Name { get; set; }
        string Domain { get; set; }
        bool UseSmtp { get; set; }
        string HostName { get; set; }
        string DataPost { get; }
        string Sign { get; }
        string Message { get; set; }
        CelNumber CelNumber { get; set; }
        int NumberOfCharacters { set; get; }
        string Description { get; set; }
    }
}

 y luego configuro los proveedores para que Windsor sepa sobre ellos y pueda crear los objetos: 

  <castle>
    <components>
      <component
        id="ProviderPersonalPost"
        service="Mono.Sms.Core.Provider.IProvider, Mono.Sms"
        type="Mono.Sms.Core.Provider.PersonalProvider, Mono.Sms"
        lyfestyle="singleton"
        >
        <parameters>
          <Name>Personal</Name>
          <Domain>@personal-net.com.ar</Domain>
          <UseSmtp>false</UseSmtp>
          <HostName>host25.200-43-139.telecom.net.ar</HostName>
          <Port>80</Port>
          <NumberOfCharacters>138</NumberOfCharacters>
          <Description>Este proveedor permite la entrega de
          mensajes a un celular Personal</Description>
        </parameters>
      </component>

      <component
      id="ProviderPersonalMail"
      service="Mono.Sms.Core.Provider.IProvider, Mono.Sms"
      type="Mono.Sms.Core.Provider.PersonalProvider, Mono.Sms"
      lyfestyle="singleton"
        >
        <parameters>
          <Name>Personal</Name>
          <Domain>@personal-net.com.ar</Domain>
          <UseSmtp>true</UseSmtp>
          <HostName>host25.200-43-139.telecom.net.ar</HostName>
          <Port>80</Port>
          <NumberOfCharacters>110</NumberOfCharacters>
          <Description>Este proveedor permite la entrega de mensajes
          a un celular Personal utilizando mails.</Description>
        </parameters>
      </component>
    </components>
  </castle>

En este caso hemos creado 2 implementaciones para enviar mensajes a una misma empresa, una forma es haciendo un post, y la otra utilzando mails. Hablando en el idioma de Windsor container, hemos creado aquí 2 Componentes (ProviderPersonalPost y ProviderPersonalMail), para un mismo Servicio (IProvider).

Luego para pedirle al container que nos entregue todas las implementaciones de los servicios IProvider, realizo esta siguiente iteración:

  public IList<IProvider> GetAllProviders()
        {
            IHandler[] handles = container.Kernel.GetHandlers(typeof (IProvider));
            IList<IProvider> providersImpl = new List<IProvider>();

            foreach (IHandler hdlr in handles)
            {
                providersImpl.Add((IProvider)hdlr.Resolve(CreationContext.Empty));
            }

            return providersImpl;
        }

Se puede ver que agrego a una lista providersImpl todos los proveedores y los retorno. Y con esto tengo en mano a todos los proveedores con los que puedo mandar mensajes.

Se preguntarán: “Es necesario todo esto para una simple aplicación de sms?”, la respuesta es “No”. Como se sabe, IoC es un principio de diseño, y no un requerimiento indispensable.

Opiniones ? Sientanse como en casa