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
