José Jorge Márquez Gómez

Un patrón factoría nos sirve para canalizar todas las creaciones de objetos en un solo punto. Esto es útil para un diseño robusto de nuestro sistema y ágil al cambio.

El patrón factoría se puede combinar con el patrón singleton ya que es más cómodo su uso y útil su forma de usar. En este ejemplo pondremos un factoría sin singleton.

Decir que el patrón factoría es del tipo patrones creacionales, que este tipo de patrón abstrae la forma de crear objetos concretos, dando así un soporte para crear objetos de forma abstracta.

Para empezar un patrón factoría debe cumplir:
- Una función o método el cual se encarga de crear objetos de un tipo dado.
- No es obligatorio pero si recomendable que dicha función o método devuelva una abstracción (interfaz o clase abstracta).

Imaginemos que una tienda de pizzas requiere de un software que necesita que tengan una serie de productos (pizzas variadas). Como buenos diseñadores que somos, la creación de objetos de pizzas se podrá hacer desde cualquier parte el proyecto, pero el problema es que hay muchos tipos de pizzas. El crear cada pizza de cada tipo en distintos puntos del programa sería lo primero que pensaríamos, pero… ¿si en vez de eso usamos sentido común y aplicamos el factoría?, esto nos permitiría que dado un nuevo producto o un cambio en alguno de ellos, que solo cambiemos en un solo lugar, teniendo más controlado dicho código. Incluso si os dais cuenta la agilidad al cambio es mucho mayor que ir cambiando todas las posibles apariciones de nuestras pizzas por el código.
Pues bien, el factoría se encargaría de crear todo tipo de pizzas y las ofrecería a todos los posibles puntos del programa.

Nuestro ejemplo sería el siguiente:

- La interfaz IPizza:

    interface IPizza
    {
        void quienSoy();
    }

- Las pizzas concretas:

    public class PizzaBarbacoa: IPizza
    {
        #region Miembros de IPizza

        public void quienSoy()
        {
            Console.WriteLine("Soy una pizza de Barbacoa");
        }

        #endregion
    }

    public class PizzaMargarita: IPizza
    {
        #region Miembros de IPizza

        public void quienSoy()
        {
            Console.WriteLine("Soy una pizza de Margarita");
        }

        #endregion
    }

    public class PizzaPepperoni: IPizza
    {
        #region Miembros de IPizza

        public void quienSoy()
        {
            Console.WriteLine("Soy una pizza de Pepperoni");
        }

        #endregion
    }

- La factoría en cuestión:

    public class PizzaFactory
    {
        public enum tipoPizza
        {
            Pepperoni,Margarita,Barbacoa
        }

        public IPizza getPizza(tipoPizza tipo)
        {
            switch (tipo)
            {
                case tipoPizza.Barbacoa:
                    return new PizzaBarbacoa();
                    break;
                case tipoPizza.Margarita:
                    return new PizzaMargarita();
                    break;
                case tipoPizza.Pepperoni:
                    return new PizzaPepperoni();
                    break;
                default:
                    return new PizzaBarbacoa();
            }
        }
    }

- Un pequeño test:

    public class Test
    {
        public void testPizza()
        {
            //ejemplo no usando factoría
            IPizza pizza1 = new PizzaBarbacoa();
            pizza1.quienSoy();
            IPizza pizza2 = new PizzaMargarita();
            pizza2.quienSoy();
            IPizza pizza3 = new PizzaPepperoni();
            pizza3.quienSoy();
            IPizza pizza4 = new PizzaBarbacoa();
            pizza4.quienSoy();
            IPizza pizza5 = new PizzaMargarita();
            pizza5.quienSoy();

            //ejemplo usando factoría
            PizzaFactory factory = new PizzaFactory();
            IPizza pizza6 = factory.getPizza(PizzaFactory.tipoPizza.Barbacoa);
            pizza6.quienSoy();
            IPizza pizza7 = factory.getPizza(PizzaFactory.tipoPizza.Margarita);
            pizza7.quienSoy();
            IPizza pizza8 = factory.getPizza(PizzaFactory.tipoPizza.Pepperoni);
            pizza8.quienSoy();
        }
    }

Como veis la forma de uso y sus ventajas son mejores. Espero que os sirva!!. Hasta luego!

Bueno hoy os voy a contar un poco como configurar log4net para c#. Pero antes deciros que es log4net.

Log4Net es un framework portado de la librería log4java, el cual te ofrece todas las herramientas posibles para poder hacer un logging, control de errores, monitorización de aplicaciones para todas tus aplicaciones posibles. A mi modo de ver, es el log más bueno que he probado hasta ahora y es bastante fácil de configurar. Ofrece bastantes modos de monitorización e incluso el crearte los tuyos propios. Dicha librería la podeis obtener de http://logging.apache.org/log4net/index.html.

Explicaremos algunos conceptos referentes al log4net.

Log4NET ofrece distintos niveles de monitorización predefinidos como son:

1. Debug: Se suele usar para líneas de debug.
2. Info: Se suele usar para dar información relativa de vuestra aplicación.
3. Warn: Son posibles puntos de ruptura de vuestro software, osea, posibles alertas importantes.
4. Error: Se usa para detectar errores de vuestro software.
5. Fatal: Se usa para detectar posibles errores importantes de software, es decir, que impidan el funcionamiento del mismo por ejemplo.

Estos niveles son los que trae predefinidos log4net, pero se pueden crear niveles personalizados.

Otro punto a destacar son los Appenders, esto no es sino el modo en que los distintos niveles del log4net van a ser monitorizados/logeados, en log4net existen estos entre otros:

1. FileAppender: Logea el nivel definido en la configuración en fichero.
2. RollingFileAppender: Logea el nivel definido en la configuración en un fichero que va rotando dependiendo de su peso.
3. SmtpAppender: Logea el nivel definido en la configuracion y es enviado a un destinatario de correo.

Más adelante en un ejemplo de configuración veréis estos niveles configurados. Para más detalles de todas sus propiedades de los appenders podéis ver la web que tenéis a continuación.

Todos los podéis ver detallados en esta web http://logging.apache.org/log4net/release/config-examples.html.

Comencemos.

El primer paso es descargaros la librería de la web anterior, una vez descargada dicha librería debéis agregarla a las referencias de vuestro proyecto. Seguidamente vamos a configurar el log4net en el fichero de configuración de vuestra aplicación, en caso de una aplicación web será el web.config, en caso de una aplicación consola el app.config, etc…

En el tag “configuration” –> “ConfigSection” –> agregad la siguiente línea:

<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net, Version=1.2.10.0, Culture=neutral, PublicKeyToken=1b44e1d426115821"/>

A continuación en un tag nuevo que creemos llamado “<log4net>” se configuran allí los appenders. Cada uno tiene su propia configuración en la web anterior se pueden ver todas. Adjunto Ejemplo log4net

Una vez tenemos esto configurado ya podemos hacer uso de nuestro log4net en nuestra aplicación. Un requisito que debe cumplir es que cada clase debe inicializar el log4net en su constructor tal que quede como pone en el siguiente código:

class test
{
private ILog log;
public test()
{
log4net.Config.XmlConfigurator.Configure();
log = LogManager.GetLogger(this.GetType()); //aquí procedemos a inicializar el objeto log.
}

Para hacer uso de nuestro log es simple, solo deberemos llamar a los distintos niveles de alerta que posee a través del objeto log.

Espero que os sirva como inicialización con el log4net.

Saludos!