Ese no tan desconocido: Object Data Source para Aplicaciones de Escritorio

No hace mucho encontre un artículo acerca del control Object Data Source, solo que estaba enfocado para aplicaciones Web, esta vez les presento el “mismo” control pero para escritorio. Vayan sabiendo que aunque el control se llama igual, dista mucho de su primo que vive en la versión Web. La principal diferencia radica en que esta versión de ODS, no puede ejecutar métodos, solo recibe una fuente de datos. Eso si, cuando ODS trabaja enlazado con grillas, nos damos cuenta de su poder y de cómo nos facilita el desarrollo de aplicaciones.

Empezando
Deberán remitirse a este tutorial para crear la base de datos de prueba y junto con ella la tabla de personas, además aquí usaremos esta tabla también:

img001.jpg

La cual es llamada Temporal, y posee un campo llamado idrelacion, que será el que nos permita crear un maestro/detalle, me tome la molestia de llenar la tabla temporal con algunos datos:img002.jpg

Idrelacion especifica que deberá existir una fila en la tabla Personas que posea ese ID.
Construyendo la aplicación en .NET
Crearemos una aplicación que luce así:
img003.jpg

Es por ello que deberán agregar al formulario dos grillas (no por ahora, ya veremos mas adelante como) y un botón (el código fuente de esta nota se encuentra adjunto así que no teman); esas grillas están relacionadas a un ODS, y el movimiento entre filas para refrescar una grilla o la otra lo hace automáticamente el ODS.
Empezaremos por crear la clase Persona, que contendrá los campos que figuran en la tabla del tutorial anterior pero que además contara con un miembro del tipo lista, llamado Childs.
Pongo aquí una porción de código para que lo tengan como referencia:

public class EntityPersona
{
private int _id;
private string _nombre;
private string _apellido;
private string _telefono;
private List _childs = new List(); …

}

Esa es la clase entidad que representa a la tabla personas, como ya se habrán dado cuenta me gusta trabajar en capas, mas adelante quizás haga un tutorial sobre el trabajo en capas y como nos puede facilitar la vida…aunque su mal uso nos puede traer muchas complicaciones.
La lista que allí figura es del tipo “Temporal” que es una clase muy similar a la que acabamos de ver, es así:
public class Temporal
{
private int _id;
private string _nombre;
private string _apellido;


}
Pasaremos a crear las clases mapeadoras (aquellas que se encargan de acceder a la base de datos), para este articulo no habrá otro tipo de acceso a la base de datos sino para obtenerlos de la misma, es decir, no hay nada de inserciones ni modificaciones; aunque para aquellos que estén leyendo esto seria una buena practica; de hecho pueden tomar como referencia el tutorial anterior de ODS.

public class MapperPersona
{
public DataTable Select()
{
string cmdText = “select * from personas”;
DataTable dt = new DataTable();
SqlCommand cmd = new SqlCommand();
SqlDataAdapter sqlDa = new SqlDataAdapter();
SqlConnection cnn = new SqlConnection(“User ID=sa;Initial Catalog=BaseDePrueba;Data Source=.”);
cnn.Open();
cmd.Connection = cnn;
cmd.CommandText = cmdText;
cmd.CommandType = CommandType.Text;sqlDa.SelectCommand = cmd;
sqlDa.Fill(dt);
cnn.Close();return dt;

}
}
public class MapperTemporal
{
public DataTable Select(int id)
{
string cmdText = “select * from temporal where idrelacion = ” + id.ToString();
DataTable dt = new DataTable();
SqlCommand cmd = new SqlCommand();
SqlDataAdapter sqlDa = new SqlDataAdapter();
SqlConnection cnn = new SqlConnection(“User ID=sa;Initial Catalog=BaseDePrueba;Data Source=.”);

cnn.Open();
cmd.Connection = cnn;
cmd.CommandText = cmdText;
cmd.CommandType = CommandType.Text;

sqlDa.SelectCommand = cmd;
sqlDa.Fill(dt);
cnn.Close();

return dt;

}
}

Ambos mapeadores son listados en todo su esplendor, el mapeador de Persona trae todas las filas de la tabla, mientras que el mapeador de la tabla Temporal en su método Select recibe un ID, pues bien, dado que en este caso la tabla temporal actúa como “hija” de la tabla personas, la forma de acceder a las hijas dado un padre es a través del id del padre, que es justamente lo que recibe.
Por ultimo crearemos la clase de servicio, que hará de osquertador entre los mapeadores (recuerden que esta clase tranquilamente puede tener lógica de negocio incluida):

public List FetchAll()
{
try
{
List entities = new List();
MapperPersona mapper = new MapperPersona();
MapperTemporal mapperT = new MapperTemporal();
EntityPersona entity;
DataTable dt = mapper.Select();foreach (DataRow dr in dt.Rows)
{
entity = new EntityPersona((int)dr[“id”], (string)dr[“nombre”], (string)dr[“apellido”], (string)dr[“telefono”]);
dt = mapperT.Select(entity.Id);
foreach (DataRow dr1 in dt.Rows)
{
entity.Childs.Add(new Temporal((int)dr1[“id”], (string)dr1[“nombre”], (string)dr1[“apellido”]));
}
entities.Add(entity);
}
return entities;
}
catch
{
throw;
}
}

En este caso la clase cuenta con un método llamado FetchAll, que devuelve una lista de entidades del tipo “EntityPersona” junto a la lista de tipo “Temporal” de cada una.

Agregando el control ODS
A continuación procederemos a agregar una nueva fuente de datos, para ello nos dirigimos al menú Data y de allí a Add New Data Source:

img004.jpg

En la ventana que sigue seleccionaremos que la fuente será de un objeto, y luego seleccionamos el tipo de objeto del cual obtendremos los datos:

img005.jpg

Presionamos finalizar y eso es todo. Lo que sigue es pedirle al IDE que nos muestre las fuentes de datos disponibles, así que del menú Data seleccionamos Show Data Source, un panel se desplegara y debería ser como sigue:

img006.jpg

Desde ese panel solo habrá que arrastrar hacia el formulario desde EntityPersona y desde Childs, ambas al ser arrastradas aparecerán como grillas enlazadas.
Vayamos al código fuente de la pantalla, y peguemos esto en el evento Load del formulario:
ServicePersona srv = new ServicePersona();
this.entityPersonaBindingSource.DataSource = srv.FetchAll();
Esas simples líneas nos permitirán enlazar ambas grillas, notaran que cuando se muevan en la grilla padre, se refrescaran los datos en la grilla de las hijas, de manera automática; y como si esto fuera poco, el ODS nos brinda de manera totalmente transparente la adición de nuevas entidades, tanto padres como hijas:

img007.jpg

En el botón Save deberán tener el siguiente código en el evento clic para que vean que no les miento:
EntityPersona entity = (EntityPersona) this.entityPersonaBindingSource.Current;
Pongan un punto de corte allí y vean como la entidad seleccionada se ha modificado sin que ustedes tengan que poner una sola línea de código:

img008.jpg

Luego ustedes tranquilamente podrían mandar a actualizar la entidad, ya que esta habría sido cargada de manera automática.
Espero este artículo les haya sido útil Saludos CVVA.

Link a la descarga.

Fuente: Aquí

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s