Aplicando Estructura Compuesta usando Visual C# 2005 Express Edition by aij20926

VIEWS: 18 PAGES: 6

									Patrón Estructural Composite usando C# 2.0                                     -1-6-



       Aplicando Patrón Estructural Composite usando C# 2.0


En este breve artículo veremos un ejemplo práctico de una estructura compuesta
solucionada por el patrón Compuesto (Com posite). Antes de empezar veamos un
pequeño f ragmento conceptual extraído del famoso libro Patrones de Diseño (Erich
Gamma, Richard Helm, Raplh Jonson, Jhon Vlissides). El objetivo al compartir uno a
uno los patrones más importantes con ustedes miembros y visitantes de FreedomDev
es tener presente estos al momento de desarrollar los proyectos open source de
nuestra organización, basándonos en estándares y patrones de software, tanto de
diseño, comportamiento ó estructurales.

NOTA: El código adjunto no está optimizado, la intención del código e s mostrar de
manera rápida y practica el armado de la estructura parte-todo y como trabaja el
patrón composite. No se maneja ningún tipo de técnica de control de recursos,
objetos en memoria, entre otros.

Para este ejemplo se ha utilizado el siguiente software:

      Microsoft Visual C# Express Edition 2.0 Beta 2.
      Microsoft .NET framework 2.0 Beta 2.
      Microsoft .NET Framework SDK.

Concepto

El patrón composite permite construir objetos complejos componiendo de forma
recursiva objetos similares en una estructura de árbol. Permite manipular todos los
objetos contenidos en el árbol de forma uniforme, ya que todos ellos poseen una
interfaz común def inida en la clase.

En conclusión este patrón tiene como propósito de representar estructuras parte -todo,
donde los clientes pueden tratar de la misma forma a los objetos compuesto y
individuos ó primitivos.

En el libro Patrones de Diseño podemos apreciar un buen ejemplo de un editor gráfico
que nos muestra como tratar de forma homogénea a los objetos individuales y a los
grupos de objetos.


El problema común con el que nos vamos a encontrar es ¿Cómo tener una interface
simple para todos los objetos y además poder distinguir entre “nodos” y “hojas”?
Patrón Estructural Composite usando C# 2.0      -2-6-



Para poder ver claramente la complejidad
de este patrón al momento de desarrollar
den una mirada al visor de clases de Visual
C# Express Edition Beta 2, es más al
momento de depurar van a poder ver la
jerarquía compuesta de los objetos.

Conclusiones

      Sirve para representar jerarquías
       parte-todo.
      Se quiere encapsular la diferencia
       entre objetos simples composiciones
       de objetos.
      Permite tratar de manera
       homogénea a objetos simples y
       compuestos.
      Simplif ica el código de los clientes,
       evitando distinciones de casos.
      Facilita la definición de nuevos tipos
       de componentes sin afectar a los
       clientes.
      Puede obligar a realizar un diseño
       demasiado generalista que dificulte
       la definición de compuestos donde
       se restrinja el tipo de componentes.
Patrón Estructural Composite usando C# 2.0                                 -3-6-




Creando la estructura de Objetos Parte-Todo

   1. Crear la interface.

      interface EmpleadoAbstracto
      {
          void Add(string nombre, float ingreso);
          void Add(Empleado _empleado);
          IEnumerator getSubordinados();
          IEnumerator getSubordinado(string _nombre);
          float getSalarios();
          float getSalario();
          string getNombre();
        }

   En .NET Framework 2.0 ya no necesitamos explícitamente implementar las
   interfaces Innumerable y IEnumerator, se sobrentiende que el patrón iterator es
   implícito en este ejemplo.

   2. Crear la clase que implementa la interface abstracta.

   public class Empleado:EmpleadoAbstracto
    {
        protected ArrayList aEmpleados;
        protected string nombre;
        protected float salario;
        int indice = 0;
        public Empleado(){}
        public Empleado(string _nombre,float _salario)
        {
            this.nombre = _nombre; this.salario = _salario;
            aEmpleados = new ArrayList();
        }
        public string getNombre(){return this.nombre;}
        public float getSalario(){return this.salario;}
        public virtual void Add(string _nombre, float _salario)
        {
            if (aEmpleados == null)
            {
                aEmpleados= new ArrayList();
            }
            this.nombre = _nombre; this.salario = _salario;
            aEmpleados.Insert(indice, this);
            indice++;
        }

         public virtual void Add(Empleado _empleado){}

         //Interface común entre los objetos
         public float getSalarios()
         {
             float total=0;
             EmpleadoAbstracto objAbstracto;
             IEnumerator iterador;
Patrón Estructural Composite usando C# 2.0                                -4-6-


               total = getSalario();
               try
               {
                   iterador = aEmpleados.GetEnumerator();
                   while (iterador.MoveNext())
                   {
                       objAbstracto = ((Empleado)(iterador.Current));
                       total+=objAbstracto.getSalarios();
                   }
               }
               catch (Exception ex)
               {throw ex;}
               return total;
           }

           public IEnumerator getSubordinados()
           {
               foreach (Empleado obj in aEmpleados)
                   yield return obj;
           }

           public void Quitar(Empleado _empleado){}

           public IEnumerator getSubordinado(string _nombre)
           {
               foreach (Empleado obj in aEmpleados)
               {
                   if (obj.nombre == _nombre)
                       yield return obj;
               }
           }

           public IEnumerator getEnumerator()
           {
               foreach (Empleado obj in aEmpleados)
               {
                   yield return obj;
               }
           }
       }

   Se ha omitido la implementación de algunas funciones, procedimientos ó rutinas
   de esta clase, ya que estas no son indispensables para mostrar este ejemplo.

   3. Crear una clase que herede la clase Empleado.

   public class Jefe : Empleado
    {
        int indice = 0;
        public Jefe(string _nombre, float _salario)
        {
            base.Add(_nombre, _salario);
            aEmpleados= new ArrayList();
        }
        public override void Add(string _nombre, float _salario)
Patrón Estructural Composite usando C# 2.0                                      -5-6-


           {
               this.nombre = _nombre; this.salario = _salario;
               aEmpleados.Insert(indice, this);
               indice++;
           }

           public override void Add(Empleado _empleado)
           {
               aEmpleados.Insert(indice, _empleado);
               indice++;
           }
       }

   Se ha omitido la implementación de algunas funciones, procedimientos ó rutinas de
   esta clase, ya que estas no son indispensables para mostrar este ejemplo.

   4. Todo listo, ahora a desarrollar un cliente simple, para este ejemplo utilizaremos
      una aplicación tipo consola.




La Aplicación Cliente

class Program
    {
        static void Main(string[] args)
        {
            Jefe objGerente = new Jefe("Mg. Sc. Alberto Arroyo Viale",
            10000);
            Jefe objSubgerente = new Jefe("Ing. Emilia Jesús Raygada
            Cabezudo", 8000);
            Jefe objJefeSistemas = new Jefe("BeyondNet", 6000);
            objGerente.Add(objSubgerente);
            objGerente.Add(objJefeSistemas);
            Jefe objJefeDesarrollo = new Jefe("Ing. Pedro Castañeda
            Vargas",5000);
            Jefe objJefeSoporte = new Jefe("Ing. Renzo Trillo Ramirez",
            5000);
            objSubgerente.Add(objJefeDesarrollo);
            objSubgerente.Add(objJefeSoporte);
            Empleado objProgramadorSenior1 = new Jefe("Ing. Carlos Manuel
            Vasquez Rosas", 3000);
            Empleado objProgramadorSenior2 = new Jefe("Ing. Andres
            Palomino Rodriguez", 3000);
            Empleado objProgramadorSenior3 = new Jefe("Ing. Luis Dorador
            Fernandez", 3000);
            Empleado objProgramadorSenior4 = new Jefe("Ing. Carlo Moran
            Gonzales", 3000);
            objJefeDesarrollo.Add(objProgramadorSenior1);
            objJefeDesarrollo.Add(objProgramadorSenior2);
            objJefeDesarrollo.Add(objProgramadorSenior3);
            objJefeDesarrollo.Add(objProgramadorSenior4);
            Empleado objSoporteSenior1 = new Jefe("Ing. Mario Ojeda
            Escudero", 3000);
            Empleado objSoporteSenior2 = new Jefe("Ing. Monica Arroyo
Patrón Estructural Composite usando C# 2.0                                     -6-6-


             Raygada", 3000);
             Empleado objSoporteSenior3 = new Jefe("Ing. Miriam Patricia
             Ocampo Cruz", 3000);
             Empleado objSoporteSenior4 = new Jefe("Ing. Denis Vasquez
             Ramirez", 3000);
             objJefeSoporte.Add(objSoporteSenior1);
             objJefeSoporte.Add(objSoporteSenior2);
             objJefeSoporte.Add(objSoporteSenior3);
             objJefeSoporte.Add(objSoporteSenior3);
             Console.WriteLine("El costo total de salarios en el Dpto. de
             Sistemas e Informática es: {0}",objGerente.getSalarios());
             Console.ReadLine();
         }

Ahora F5 y a probar la aplicación, esto debe mostrar la suma de los salarios asociados
al Gerente, la idea es tener una interface común con una función común
getSalarios(), si no me he equivocado en algo por ahí, esto debería tomar la
estructura y hacer el cálculo parte-todo.

Cualquier duda ó consulta estamos para apoyarnos.

www.FreedomDev.org – Promueve, Desa rrolla e Investiga Interoperabilidad
de Plataformas de Software.

Únete a nuestro proyecto Ope n Source:


 Open Source Terminal of Storage

Plataforma Inicial Base: Microsoft Windows.

Máquina Virtual Base: Microsoft .NET Framework 2.0 Beta 2.

IDE's de Desarrollo Base: Microsoft Visual C# Express Edition Beta 2.

Base de Datos Inicial: PostgreSQL 8.0.


Contacto: aarroyor@freedomdev.org

								
To top