Exploración de propiedades a partir de un Control dado

Fecha: 13/Ene/2005 (12 de Enero de 2005)
Autor: Daniel Calvin [email protected]

 


Introducción

Muchas veces queremos automatizar determinadas operaciones que involucran explorar las propiedades de distintos controles en un formulario o contenedor dado. El ejemplo que desarrollaremos a lo largo de este artículo pretende proponer una metodología simple para ello.


Escenarios posibles

El problema que analizamos se podría resolver básicamente por dos caminos distintos.

1. Utilizando reflection.
2. Utilizando polimorfismo.

El primer caso lo dejaremos para un próximo artículo, lo único que mencionaremos es que el uso de reflection nos brindaría mucha versatilidad y nos permitiría trabajar en forma dinámica, por ejemplo recurriendo a parámetros en el archivo config que nos indiquen el tipo de los objetos a explorar, propiedades, etc.

El segundo caso es el que implementaremos en este artículo, el mismo exige que los objetos a explorar implementen una interface o hereden de una clase determinada. Nosostro hemos elegido System.Windows.Forms.Control .

Planteo

Nuestro problema hipotético es el de obtener una lista de las propiedades Type, Name, Text y Parent.Name de los controles incrustados en un formulario u otro tipo de contenedor.

Dado el planteo fácilmente podemos observar que mientras los objetos hereden de System.Windows.Forms.Control para nosotros será suficiente ya que dicha clase tiene las propiedades que nos interesan.

El siguiente problema a resolver es obtener la lista de todos los controles contenidos en otro control dado. Para esto también aprovecharemos las características de la clase Control, la misma nos provee adicionalmente las propiedades Controls y Parent.

Implementación

Crearemos una clase que llamaremos BasicInfo, la misma tendrá como propiedades las características que nos interesan explorar del objeto en cuestión.

public class BasicInfo
{
      Type type=null;
      string name=string.Empty;
      string text=string.Empty;
      string container=null;
      public BasicInfo(Type type,string name ,string text, string container)
      {
            this.type=type;
            this.name=name;
            this.text=text;
            this.container=container;
      }
      public Type Type{get{return this.type;}}       
      public string Name{get{return this.name;}}       
      public string Text{get{return this.text;}}       
      public string Container{get{return this.container;}}      
}

Ahora vamos a crear una clase, ObjectInspector, que nos provea los métodos necesarios para poblar la lista de valores que tanto nos interesa.

Nuestra clase expondrá un método que retornará en un ArrayList tantos objetos de la clase BasicInfo como controles incrustados contenga el objeto a explorar, adicionando el BasicInfo correspondiente a ese mismo objeto. 
Este método se llama GetContainerBasicInfoList .y el mismo es estático.

También contendrá un método que nos permitirá obtener cada uno de los BasicInfo correspondientes. 
Este método se llama GetInfoFronInstance el mismo es estático y recursivo.

public class ObjectInspector
{
      public static ArrayList GetContainerBasicInfoList(Control container)
      {
            ArrayList infos=new ArrayList();
            ObjectInspector.GetInfoFronInstance(container,infos);
            return infos;
      }
      private static BasicInfo GetInfoFronInstance(object subject, ArrayList infos)
      {
            if(subject is Control)
            {
                  Control myControl=subject as Control;               
                  foreach(Control c in myControl.Controls)
                  {
                  infos.Add(ObjectInspector.GetInfoFronInstance(c,infos));
                  }
                  return new BasicInfo(myControl.GetType(),myControl.Name,myControl.Text,( myControl.Parent==null ? "" : myControl.Parent.Name));
            }
            else
                  throw new System.Exception("Subject no es ni herada de Control");
      }
}

Ejemplo de uso 

Form1 f=new Form1();
f.Show();


ArrayList al;
al=ObjectInspector.GetContainerBasicInfoList(f);

En al tenemos ahora la lista de controles, su contendor y su texto.

Conclusión

Este artículo pretende mostrar una técnica simple para el acceso genérico a distintos tipos de objetos, su aplicación dependerá de la imaginación del desarrollador y sus necesidades.

 


Espacios de nombres usados en el código de este artículo:

System
System.Collections
System.Windows.Forms

 


ir al índice

Fichero con el código de ejemplo: DanielCalvin_Exploracionpropiedades.zip - 13 KB