Hola a tod@s,
Esta vez es para invitarlos este 30 de Junio a una Programathon de Windows Phone, en este momento es solo presencial en Bogotá, Pueden inscribirse en: http://www.meetup.com/BDotNet/events/69979492/
Estamos haciendo arreglos para que podamos trasmitirla en video o por Live Meeting, les estaré avisando, o en la misma pagina de meetup les avisare si esto lo logramos.
Los espero!!!
Saludos!!!
Hola a todo@s nuevamente,
Hoy quiero compartir con ustedes como es el proceso para generar el contexto que se utiliza para utilizar bases de datos locales en Windows Phone 7.5.
Crear Contexto de datos para Bases de datos Locales en Windows Phone 7.5
Es necesario indicar que los motores de bases de datos que podemos utilizar locales en Windows Phone 7.5 son:
Debemos crear un contexto de datos (DataContext) para poder tener acceso a la base de datos local en Windows Phone 7.5 conocido también como Windows Phone Mango, aquí es necesario aclarar, que no podemos utilizar ADO.NET de manera directa para este acceso a la base de datos local en el dispositivo.
Por la razón anterior debemos crear un contexto de datos de la base de datos a utilizar en nuestro desarrollo para Windows Phone 7.5, este DataContext, no es mas que una clase en uno de los lenguajes de la plataforma .NET (VB.NET o C#), en la cual se encuentran métodos que permiten las operaciones CRUD, clases de tipo entidad que representan un registro de cada una de las tablas, clases de tipo colección que representan la tabla o un conjunto de registros de la tabla.
Para muchos de los que venimos del mundo de Windows Mobile, desarrollo ASP.NET o Windows Forms es un cambio brusco, ya que estábamos acostumbrados a tener todo controlado desde ADO.NET.
La razón principal de la reflexión anterior es que al no tener el manejo de las operaciones de la base de datos a través de ADO.NET las cosas como que se nos complican. Sin embargo, el manejo de las operaciones de la base de datos locales en Windows Phone 7.5 se realiza a través de LinQ y un DataContext, este DataContext es el que vamos a aprender a construir en este post.
Algo que debemos tener claro es que nuestra base de datos local de SQL Server Mobile se almacena en el almacenamiento privado del dispositivo, esto es lo que conocemos como “Isolated Storage”.
En la imagen anterior podemos observar como se almacena nuestra base de datos en el Isolated Storage y que a través de LINQ to SQL nos comunicamos con ella utilizando el DataContext desde nuestra aplicación de Windows Phone 7.5.
Esta es una clase que contiene de todas las operaciones CRUD (Create, Read, Update, Delete) basada en la base de datos para realizar operaciones sobre la Base de Datos. En la cual utilizando LINQ to SQL accedemos a todas las operaciones que necesitemos realizar sobre la base de datos.
Muy bien, ya teniendo claro todo lo anterior, lo primero que debemos hacer es definir el modelo de datos en nuestra base de datos SQL Mobile, para esto vamos a utilizar SQL Server Management Studio para crear la base de datos y la estructura de las tablas de nuestra base de datos.
Si se preguntan si podemos utilizar Entity Framework 4.1 para realizar esta operación, la respuesta es SI, lo importante es definir el modelo de nuestro repositorio de datos y generar el archivo .SDF de la base de datos SQL Server Mobile.
Ahora vamos a mostrar como crear una base de datos desde el SQL Server Management Studio, al iniciar esta aplicación nos vamos a encontrar con la siguiente pantalla:
En el tipo de Servidor vamos a abrir la lista de selección y seleccionar SQL Server Compact, con esto nos aseguramos crear la base de datos que podemos utilizar en Windows Phone 7.5.
Al seleccionar el tipo de base de datos, seleccionamos en el archivo de la base de datos, para crear nuestra base de datos SQL Server Compact:
Vamos a crear una nueva base de datos, entonces de la lista que nos muestra, que son las bases de datos que hayamos utilizado, vamos a seleccionar la opción <New Database…> para crear una nueva base de datos.
Esta acción nos abre una nueva pantalla en la cual podemos darle un nombre a nuestra base de datos, colocarle un nombre, etc.
Como observamos podemos seleccionar la ruta y colocar el nombre de la base de datos .SDF que vamos a crear, esto lo hacemos en el primer cuadro de texto de la ventana, en donde dice “Enter the new SQL Server Compact database filename”, el botón que se encuentra junto a la caja de texto con el texto “Browse…” nos permite explorar el sistema de archivos de nuestra PC para seleccionar la ruta que nosotros deseemos y colocar allí la base de datos.
Luego hay un Check que nos permite sobre escribir la base de datos si esta ya existe.
También podemos escoger en este punto, el tipo idioma que va a manejar nuestra base de datos.
Si deseamos que nuestra base de datos haga diferencia entre mayúsculas y minúsculas podemos seleccionar el Check de “Case sensitive” que aparece bajo el Collation que hayamos seleccionado para nuestra base de datos.
La siguiente configuración de creación, es si deseamos asignarle una clave para poder acceder a nuestra base de datos.
También podemos seleccionar un método de encriptación de los datos para nuestra base de datos, si no deseamos encriptar nuestra base de datos seleccionamos la opción por defecto : “UNENCRYPTED”.
Vamos a crear una BD que se llame DBWinPhone.sdf, con los parámetros por defecto, como lo podemos apreciar en la imagen anterior.
Al presionar el botón de OK, nos muestra una ventana de confirmación indicando que la base de datos no tiene una clave de protección.
Seleccionamos el botón Yes para que nos muestre la pantalla para abrir nuestra base de datos y empezar a diseñar y crear nuestras tablas.
En esta pantalla ya tenemos el botón de “Connect” con el cual abrimos y nos conectamos a la base de datos.
Nos abre la ventana del SQL Server Management Studio y en el explorador de Objetos nos muestra algo como la siguiente imagen:
Vamos a crear una nueva tabla para nuestra base de datos, para esto, damos clic derecho sobre la carpeta de las tablas “Tables”, esto lo podemos apreciar en la siguiente imagen:
Al seleccionar la opción “New Table” nos abre la pantalla de creación de una nueva tabla para nuestra base de datos:
En la caja de texto “Name” colocamos el nombre de nuestra tabla, el la parte inferior vamos creando cada una de las columnas de nuestra base de datos.
En la caja de texto debajo de “Column Name” colocamos el nombre de las columnas, el tipo de dato para el campo, la longitud si aplica y si acepta o no nulos.
Vamos a crear una tabla llamada Pais, con dos campos: Id de tipo auto numérico y el campo Pais de tipo nvarchar (texto) para almacenar el nombre del país.
En la imagen anterior podemos observar la estructura de la tabla Pais que creamos para nuestra base de datos.
Al darle clic al botón de OK de la pantalla se graba la estructura de la tabla y se ve de la siguiente forma en el SQl Server Management Studio:
Ya tenemos nuestra base de datos .SDF creada, ahora vamos a realizar el proceso de la creación de la clase que forma el DataContext para poder utilizarlo en nuestra aplicación de Windows Phone 7.5.
Para poder realizar el proceso necesitamos un programa que se instala con el SDK de Windows Phone 7.5, este programa se llama SQLMetal.
Para ejecutarlo, vamos a abrir una ventana de comandos del sistema operativo, pero la ventana de comandos a abrir es la que se encuentra en la sección de Visual Studio 2010, como lo podemos apreciar en la siguiente imagen:
Esto nos abre una ventana de comandos:
Ahora si podemos ejecutar el comando SQLMetal que nos permite generar la clase que representa el DataContext para acceder a nuestra base de datos.
El comando a utilizar para generar nuestra clase es el siguiente:
SQLMETAL D:\Roberto\Projects\Silverlight\DBWinPhone.sdf
/code:D:\Roberto\Projects\Silverlight\DBWinPhone.cs
/language:csharp
/namespace:LocalDBDemo
/context:DBWinPhoneDataContext
/pluralize
En nuestra ventana de comandos colocamos nuestra sentencia para ejecutarla:
Iniciando la ejecución del comando:
Al terminar la generación nos muestra lo siguiente:
Esto lo que hace es generarnos el archivo DBWinPhone.cs en la ruta especificada como lo podemos apreciar en la siguiente imagen:
Al verificar la clase DataContext generada con el nombre DBWinPhone.cs podemos observar lo siguiente en el código:
#pragma warning disable 1591
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.239
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace LocalDBDemo
{
using System.Data.Linq;
using System.Data.Linq.Mapping;
using System.Data;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;
using System.ComponentModel;
using System;
[global::System.Data.Linq.Mapping.DatabaseAttribute(Name="DBWinPhone")]
public partial class DBWinPhoneDataContext : System.Data.Linq.DataContext
{
private static System.Data.Linq.Mapping.MappingSource mappingSource
= new AttributeMappingSource();
Como se observa en el código el namespace es el mismo que colocamos en la sentencia de la ventana de comandos, de igual manera podemos ver le nombre de la clase que también corresponde al nombre utilizado en la sentencia.
Lo siguiente que debemos hacer con la clase DataContext generada es eliminar dos de los cuatro constructores de la clase, si los dejamos, al compilar la clase en nuestro proyecto vamos a tener errores pues estos constructores no son soportados por el espacio de nombres System.Data.Linq.
public DBWinPhoneDataContext(string connection) : base(connection, mappingSource)
{
OnCreated();
}
public DBWinPhoneDataContext(System.Data.IDbConnection connection) : base(connection, mappingSource)
{
OnCreated();
}
public DBWinPhoneDataContext(string connection,
System.Data.Linq.Mapping.MappingSource mappingSource) : base(connection, mappingSource)
{
OnCreated();
}
public DBWinPhoneDataContext(System.Data.IDbConnection connection,
System.Data.Linq.Mapping.MappingSource mappingSource) : base(connection, mappingSource)
{
OnCreated();
}
Los constructores señalados en color amarillo son los que deben eliminarse de la clase de DataContext generada, al eliminarlos y compilar, los errores van a desaparecer.
Al finalizar, grabamos la clase y la adicionamos a nuestro proyecto de manejo de bases de datos locales en Windows Phone 7.5.
Bien, este es el primer artículo sobre este tema, en próximos días estaré publicando la manera como vamos a utilizar y como incorporar esta clase a nuestro proyecto de Windows Phone 7.5
Hasta la próxima! Feliz desarrollo!
Tengo el gusto de invitarlos al Evento ExpertDay que se realizara en Bogotá el 8 de octubre de 9am a 5pm con la participación de expertos en los diferentes temas a tratar.
Registro:
http://expertday.org/registro/?utm_source=blogs&utm_medium=miembrosbdotnet&utm_campaign=expertday
Pueden registrarse para asistir de manera virtual también al evento.
La lista de conferencias la encuentran en:
Si asistes presencialmente puedes participar en el concurso para ganar un XBOX 360 con Kinet:
http://expertday.org/xbox.html?utm_source=blogs&utm_medium=miembrosbdotnet&utm_campaign=expertday
Los espero a tod@s, para que disfruten de este gran evento!
Hola a tod@s,
Los invito a esta teleconferencia sobre como empezar a desarrollar con Windows Phone 7.5 o mas conocido como Mango!
El día 22 de Septiembre de 2011 a las 4 pm –5 GMT.
El link en el cual pueden ver esta conferencia es: Ingreso a la TeleConferencia
Hasta la Próxima!!!
Hola a tod@s,
Hoy quiero invitarlos a este evento que se realizará el próximo 9 de Julio de 2011 en las instalaciones de Microsoft Colombia, Bogotá, donde al comunidad de desarrolladores profesionales BogotaDotNet.
El evento también lo podrán apreciar vía internet a través de Live Meeting para aquellos que no puedan o no se encuentren en la ciudad.
El horario de de 8:30 de la mañana a 12 m, los espero a tod@s!!!!!
El link para el registro tanto presencial como virtual los pueden encontrar aquí: http://bogotadotnet.org
Los espero!!!!!!
Hola a tod@s!
Hoy quiero invitarlos al web cast de construcción de aplicaciones Windows Phone 7 con Windows Azure, es el próximo viernes 3 de junio del 2011 a las 10 AM ( GMT –5 Bogotá,Lima).
Aqui les dejo el link de inscripciones al webcast https://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032475415&EventCategory=4&culture=es-AR&CountryCode=AR
Los espero a tod@s para ayudarles a desarrollar para esta plataforma.
Hasta el viernes, si Dios me lo permite !!!
Hola a tod@s,
Esta es una noticia que muchos de los desarrolladores profesionales para Windows Mobile estábamos esperando, pues con todo el empuje que se ha dado a Windows Phone 7, no sabíamos que pasaría con nuestras aplicaciones de esta plataforma, aquí les dejo un video sobre la evolución de Windows Mobile.
Pronto más noticias al respecto….
Happy development!
Hola a tod@s,
Para compartirles este concurso de Microsoft Colombia, no pierdan la oportunidad de poderse ganar un teléfono de última generación y además aprendiendo a cómo hacerlo.
Go Ninja, Go!!!!
Hola a tod@s nuevamente, hoy vamos a hablar como implementar este modelo de N-Capas en nuestra aplicación.
Tomando nuestro mismo ejemplo del articulo “Operaciones CRUD con SQL Mobile y ADO.NET en Windows Mobile” que lo pueden encontrar en este enlace. Y aplicando la estructura de N-Capas del articulo anterior, aquí lo pueden consultar.
Lo primero es crear una solución en VS2008 que vamos a llamar WMBDNNCapas, y el tipo de proyecto a seleccionar es un proyecto Windows Mobile Application (Aplicación de Dispositivo).
Como se puede observar en al imagen, seleccionamos la plataforma de destino para la cual vamos a desarrollar, en este caso "WM 6 Professional SDK” y la versión del Compact Framework para la cual vamos a desarrollar: 3.5.
Este proyecto de tipo aplicación Windows, es nuestra capa superior o capa de presentación.
Ahora vamos a proceder a crear 4 proyectos de tipo librería de clases, que representen las capas de Negocio (BL 0 Business Logic), Manejo de Datos (DM = Data Management), Acceso a Datos (DA = Data Access) y la capa de Infraestructura Transversal (Entities). Los datos entre paréntesis, son los sufijos de los nombres de los proyectos que vamos a crear y los cuales indicaran cada una de las diferentes capas del modelo N-Capas a desarrollar.
Mi practica personal es utilizar el mismo nombre del proyecto principal, y agregarle el sufijo indicado en los paréntesis a los diferentes proyectos a crear.
En otras palabras voy a crear un proyecto de tipo librería de clases llamado WMBDNNCapasBL que representa la capa lógica, un proyecto de tipo librería de clases llamado WMBDNNCapasDM que representa la capa de manejo de datos, un proyecto de tipo librería de clases llamado WMBDNNCapasDA que represente el acceso a los datos y por último un proyecto de tipo librería de clases llamado WMBDNNCapasEntities que representa la capa de las entidades y colecciones donde se transportan los datos entre las diferentes capas del modelo.
Para crear los diferentes proyectos y adicionarlos a la solución que ya hemos creado, para esto, damos clic derecho en el nombre de la solución y en menú contextual que aparece, seleccionamos Agregar y Nuevo proyecto…
Le damos el nombre al proyecto y lo configuramos de la manera correcta:
Después de crear todos los proyectos en la solución, nuestra solución quedaría de la siguiente manera:
La primera capa que vamos a desarrollar es la capa de Acceso a Datos, o sea el proyecto WMBDNNCapasDA, este proyecto en nuestro caso solo va a contener 1 clase para el manejo al acceso de la bases de datos tipo SQL Mobile, en algunos casos de aplicaciones móviles he tenido la necesidad de manejar varios tipos de bases de datos, en ese caso en este proyecto existe mas de una clase para el manejo y acceso a los datos.
Lo primero es eliminar del proyecto la clase que se crea por defecto Class1.cs , luego creamos una nueva clase a la cual le vamos a signar el nombre DBSQLMobileDA.cs.
Si se fijan como regla tengo que a las clases también les coloco el mismo sufijo que utilizo en el proyecto.
Lo siguiente que vamos a hacer es agregar la referencia para System.Data.SqlCeServer que es la clase que me permite acceder a bases de datos Microsoft SQL Mobile.
Para esto debemos dar clic derecho sobre la carpeta de References del proyecto, y escogemos Agregar Referencia:
Al hacer esto Visual Studio nos muestra una ventana con la lista de las referencias que podemos utilizar para nuestro proyecto:
Buscamos en la lista System.Data.SqlServerCe y lo seleccionamos, presionamos el botón Aceptar para asegurar esta selección.
Al hacer esto la lista de las referencias se actualiza y debe aparecer de la siguiente manera:
Como observamos la referencia fue adicionada a la lista.
Aquí es muy importante resaltar que esta referencia solo se realizara en este proyecto,NO se realizara en los demás proyectos, pues solo este proyecto es el único que interactúa de manera directa con la base de datos.
Si en nuestra solución necesitamos de otra referencia a una base de datos diferente, se agregará la nueva referencia también en este proyecto y en ningún otro de la solución.
Esto es súper importante en la arquitectura de N-Capas, porque estamos aislando en las diferentes capas las funcionalidades, en este caso particular la capa de acceso a la base de datos.
Muy bien, ya entendiendo esto, vamos a codificar nuestra clase de conexión y de interactuación directa con la base de datos y sus objetos.
Lo primero es en nuestra clase colocar la palabra public para que esta clase sea publica y la podamos utilizar.
public class DBSQLMobileDA
El primer método a desarrollar es el método Open, este método abre una conexión a la base de datos, además verifica si ya esta abierta la conexión no realiza la operación.
A esta clase debemos indicar al principio de esta los using que vamos a utilizar:
using System.Data.SqlServerCe;Lo primero que vamos a hacer es crear una propiedad para la Conexión pues es posible que necesitemos pasar la conexión de un método a otro.
/// <summary>Propiedad que almacena el objeto de Conexion a la BD
/// </summary>
public SqlCeConnection Conexion { get; set; }
Además debemos crear otra propiedad de tipo String para almacenar la ruta en la cual va a estar el archivo .sdf con la base de datos.
/// <summary> Ruta en donde va a quedar la base de datos
/// </summary>
public String Ruta { get; set; }
Esta sintaxis es para el Compact Framework 3.5, recuerden estas son propiedades auto implementadas del lenguaje C#, para Visual Basic.NET esto solo es posible con el Framework .NET 4.0.
Algo que debemos hacer es inicializar esta propiedad en el constructor de la clase:
public DBSQLMobileDA()
{
Conexion = new SqlCeConnection();
}
Y ahora si nuestro método de conectarse a la base de datos:
/// <summary>Metodo que abre la conexion a la Base de datos
/// </summary>
public void Open()
{
// Si hay una conexion abierta la mantengo
if (Conexion.State == System.Data.ConnectionState.Open)
return;
// Armo la cadena de conexion
Conexion.ConnectionString = "Data Source=" + Ruta + "DemoBD.sdf;";
// Abro la conexion
try
{
Conexion.Open();
}
catch (SqlCeException ex)
{
throw ex;
}
}
En el código verificamos si ya la conexión esta abierta y salimos del método, si no está abierta, le asignamos la cadena de conexión al objeto de conexión y llamamos al método Open().
En la propiedad Ruta, vamos a tener la ruta del sistema de archivos en el cual esta el archivo de la base de datos, y de esa manera armamos la cadena de conexión.
Vamos a crear un método que es el que inicializa el objeto comando y es el que necesitamos para ejecutar todas las operaciones necesarias de la base de datos.
Este método lo vamos a llamar CreateComando, para esto también necesitamos una propiedad de tipo SqlCeCommand que vamos a llamar Comando.
La propiedad seria:
/// <summary>Propiedad que devuelve un objeto SqlCeCommand
/// </summary>
public SqlCeCommand Commando { get; set; }
Y el código del método CreateComando es el siguiente:
/// <summary>Crea un Objeto SqlCeCommand para ser utilizado
/// </summary>
public void CreateComando()
{
try
{
Commando = Conexion.CreateCommand();
}
catch (Exception ex)
{
throw ex;
}
}
Simplemente lo que hace este método es inicializar el objeto SqlCeCommand y a través de él manejar las diferentes operaciones contra la base de datos.
Ahora vamos a crear un método que me permita leer o extraer datos de la base datos, nuestro método se llama ExecuteReader, pues los datos nos los va a devolver en un IDataReader, esto nos asegura que la lectura de los datos va a ser bastante rápida.
Lo primero es crear la propiedad de tipo IDataReader, para esto necesitamos también tener el using System.Data:
/// <summary>Propiedad que Expone el DataReader en donde se encuentran los datos leidos
/// </summary>
public IDataReader DataReader;
Y el código del método ExecuteReader es el siguiente:
/// <summary>Ejecuta sentencias SQL en la BAse de datos SQL Mobile
/// </summary>
/// <param name="tipoComando">Un CommandType para saber que se hace con la instruccion</param>
/// <param name="query">La sentencia SQL a Ejecutar</param>
/// <returns>Un Datareader para ser recorrido</returns>
public IDataReader ExecuteReader(CommandType tipoComando, String query)
{
DataReader = null;
Commando.Connection = Conexion;
Commando.CommandType = tipoComando;
Commando.CommandText = query;
try
{
DataReader = Commando.ExecuteReader();
}
catch (SqlCeException ex)
{
throw ex;
}
return DataReader;
}
Este método recibe dos parámetros, uno es el tipo de comando a ejecutar, y el otro una cadena con la sentencia SQL a ejecutar, se le asigna al objeto Commando la Conexión, el tipo de comando y la sentencia a ejecutar, luego en bloque try.. catch de ejecuta la sentencia llamando al método ExecuteReader del objeto SqlCeCommand.
El método devuelve un objeto IDataReader con los datos que devuelve al base de datos.
Por último tenemos el método ExecuteNonQuery para ejecutar las sentencias SQL que afectan los datos en la tabla de la base de datos.
/// <summary> Ejecuta sentencias de INSERT, DELETE y UPDATE
/// </summary>
/// <param name="tipoComando">Tipo de comando a Ejecutar</param>
/// <param name="query">Instruccion SQL a Ejecutar</param>
/// <returns>Un entero con el numero de registros Afectados</returns>
public Int32 ExecuteNonQuery(CommandType tipoComando, String query)
{
Commando.Connection = Conexion;
Commando.CommandType = tipoComando;
Commando.CommandText = query;
Int32 stReturn;
try
{
stReturn = Commando.ExecuteNonQuery();
}
catch (SqlCeException ex)
{
throw ex;
}
return stReturn;
}
El código completo de nuestra clase es el siguiente:
using System;using System.Linq;using System.Collections.Generic;using System.Text;using System.Data.SqlServerCe;using System.Data;namespace WMBDNNCapasDA{public class DBSQLMobileDA
{ #region Propiedades /// <summary>Propiedad que almacena el objeto de Conexion a la BD /// </summary> public SqlCeConnection Conexion { get; set; } /// <summary> Ruta en donde va a quedar la base de datos /// </summary> public String Ruta { get; set; } /// <summary>Propiedad que devuelve un objeto SqlCeCommand /// </summary> public SqlCeCommand Commando { get; set; } /// <summary>Propiedad que Expone el DataReader en donde se encuentran los datos leidos /// </summary> public IDataReader DataReader; #endregion public DBSQLMobileDA() { Conexion = new SqlCeConnection(); Commando = new SqlCeCommand();}
/// <summary>Metodo que abre la conexion a la Base de datos /// </summary>public void Open()
{ // Si hay una conexion abierta la mantengo if (Conexion.State == System.Data.ConnectionState.Open) return; // Armo la cadena de conexionConexion.ConnectionString = "Data Source=" + Ruta + "DemoBD.sdf;";
// Abro la conexion try {Conexion.Open();
}
catch (SqlCeException ex) { throw ex;}
}
/// <summary>Crea un Objeto SqlCeCommand para ser utilizado /// </summary>public void CreateComando()
{ try {Commando = Conexion.CreateCommand();
}
catch (Exception ex) { throw ex;}
}
/// <summary>Ejecuta sentencias SQL en la BAse de datos SQL Mobile /// </summary> /// <param name="tipoComando">Un CommandType para saber que se hace con la instruccion</param> /// <param name="query">La sentencia SQL a Ejecutar</param> /// <returns>Un Datareader para ser recorrido</returns> public IDataReader ExecuteReader(CommandType tipoComando, String query) { DataReader = null;Commando.Connection = Conexion;
Commando.CommandType = tipoComando;
Commando.CommandText = query;
try {DataReader = Commando.ExecuteReader();
}
catch (SqlCeException ex) { throw ex;}
return DataReader;}
/// <summary> Ejecuta sentencias de INSERT, DELETE y UPDATE /// </summary> /// <param name="tipoComando">Tipo de comando a Ejecutar</param> /// <param name="query">Instruccion SQL a Ejecutar</param> /// <returns>Un entero con el numero de registros Afectados</returns> public Int32 ExecuteNonQuery(CommandType tipoComando, String query) {Commando.Connection = Conexion;
Commando.CommandType = tipoComando;
Commando.CommandText = query;
Int32 stReturn;
try {stReturn = Commando.ExecuteNonQuery();
}
catch (SqlCeException ex) { throw ex;}
return stReturn;}
}
}
En resumen :
Esta clase que hemos creado solo se encarga y esta especializada en la conexión a la base de datos y de ejecutar las diferentes operaciones contra la base de datos, de esta manera aislamos en esta capa y específicamente en esta clase las diferentes operaciones contra la base de datos.
Nuestra clase tiene los siguientes métodos:
Podemos incluir algunos otros métodos que consideremos necesarios, como por ejemplo para controlar una transacción, si definitivamente necesitamos devolver datos en un objeto DataTable pues también podemos crear un método que nos devuelva este tipo de objeto.
Si necesitamos una conexión a una base de datos diferente, crearemos una nueva clase para el manejo de esta y agregaremos la referencia necesaria para que esto funcione, los métodos deberían ser los mismos que hemos desarrollado en esta clase.
En el próximo artículo veremos como utilizar esta clase y esta capa con la capa de manejo de datos.
Espero que haya sido lo suficientemente explicito en esta clase y si tienen preguntas no duden en colocarlas aquí en el blog para responderlas.
Enjoy develop!
Hasta la próxima!!!!
Hola a tod@s nuevamente, el título de este post me lo han pedido que lo explique muchas veces, me preguntan si es posible desarrollar una aplicación para dispositivos móviles por capas y la respuesta es Sí.
A continuación voy a explicar como es la arquitectura de una aplicación de N-Capas, al decir N-Capas, podemos pensar en 2, 3, 4, o más capas, ya depende de organicemos nuestro trabajo y lo que necesitamos desarrollar.
En primera instancia un desarrollo con una arquitectura por capas tenemos que concientizarnos de partir las diferentes funcionalidades que deseemos realizar en nuestro desarrollo en varias partes y ubicarlos dentro de una de las capas que hayamos definido dentro de nuestra arquitectura.
Particularmente, yo me baso en el siguiente esquema para los desarrollos por capas de mis aplicaciones:
Como podemos observar de arriba hacia abajo tenemos una serie de capas, en donde la capa inicial es la capa de presentación o de interface de usuario, esta capa esta conformada por los formularios de la aplicación Windows o por las páginas .aspx o web forms de una aplicación ASP.NET. En cuanto al tema de las aplicaciones para dispositivos móviles nuestra capa de Presentación será también nuestra aplicación Windows Mobile.
Esta capa hablando en términos de desarrollo con Visual Studio, es el proyecto de tipo Windows Application, o Web Application, o aplicación Windows para Windows Mobile.
Para el caso de una aplicación que es un Web Service o un Servicio de Windows Communication Foundation (WCF), esta capa seria el servicio como tal que es quien expone al mundo los métodos a consumir o a utilizar por las aplicaciones que consuman dichos servicios.
Esta capa es la segunda en la estructura de la imagen, en esta capa es donde debemos colocar el código de nuestra aplicación que se encargue de realizar las operaciones inherentes al negocio o tipo de aplicación que estemos desarrollando.
Algunos se preguntarán, pero cuales son esas tareas del negocio? esto a veces es un poco subjetivo y algunos no alcanzamos a descubrir línea que nos permite saber que es lo que debe ir en esta capa.
Bueno, vamos a tratar de aclarar este punto, en esta capa se definen las operaciones o cálculos que se necesiten realizar para las operaciones de nuestra aplicación.
En esta capa se arman las interfaces para llamar los diferentes métodos que devuelven datos a nuestra aplicación, porque esta es la capa con al cual interactuaremos desde la capa de Presentación.
Esto quiere decir que desde la presentación no estaremos en contacto directo con la capa que maneja los datos de nuestro repositorio de datos.
Esta capa también es la encargada de solicitar los datos a la capa del manejo de los datos y los entrega a la capa de Presentación.
Recuerden en esta capa si necesitamos realizar alguna operación como el calculo de un total, un promedio, etc., aquí es donde debemos realizar esa operación y devolverla a la capa de presentación.
Espero que en el ejemplo esto lo pueda explicar mucho mejor y sea mas claro para todos. En nuestra solución de Visual Studio esta capa es un proyecto de tipo librería de clases que agrupa todas las clases necesarias.
Esta es una de las capas mas importantes, esta capa es la encargada de la creación de los diferentes “querys” o consultas a la base de datos para obtener los datos que necesitamos en nuestra aplicación.
Esta capa también es la encargada de convertir los datos que devuelve la capa que interactúa con nuestra base de datos, o sea un datatable, un datareader o un dataset, en una lista genérica o una colección de objetos de tipo entidad como veremos mas adelante en una de las capas ( la capa transversal).
Esta capa esta representada por un proyecto de tipo librería de clases dentro de nuestra solución de Visual Studio.
Esta capa es un proyecto de tipo librería de clases en nuestra solución de Visual Studio, en esta capa vamos a tener una clase que se conecte a la base de datos que vayamos a utilizar y se encarga de realizar todas las operaciones contra la base de datos seleccionada como repositorio de datos de nuestra solución.
La importancia de esta capa radica en que si cambian el motor de base de datos el impacto en nuestra aplicación va a ser mínimo pues solo hay que modificar o corregir esta capa para el acceso y conexión a la nueva base de datos.
En esta capa vamos a definir las clases de tipo entidad en la cual vamos a transportar los datos entre las diferentes capas de nuestra solución.
Las clase de tipo entidad son una copia de la estructura de nuestras tablas de la base de datos a utilizar, o de acuerdo a las necesidades que tengamos.
Por ejemplo los resultados que necesitamos para un reporte impreso por lo general son muy variables y toca crear una entidad única para ellos.
Bueno esto no es una ley, como dije antes todo depende de nuestro proyecto y de la manera que queramos hacer las cosas, muchas veces las primeras dos capas se unen y quedan en una sola, todo depende de cada uno de nosotros.
Bueno por hoy, hasta aquí, pronto haremos un ejemplo de una aplicación usando esta metodología.
Hasta la próxima!
Enjoy develop!
Hola a tod@s, hoy quiero explicarles como utilizar ADO.NET en Windows Mobile contra una base de datos SQL Mobile.
Este artículo va a ser un poco largo, pero quiero responder aquí muchas de las preguntas que me hacen en los foros donde participo: ¿Cómo creo una base de datos SQL Mobile, cómo inserto registros en esa base de datos, como elimino registros de esa base de datos, como edito o modifico la información, como muestro la información en una grilla?
A muchos les parecerá mucho mas fácil trabajar con el control enlazado a datos de Windows Mobile BindingSource, pero considero que no se tiene todo el control que uno debe tener con los datos con este control. Sin embargo como dice un refrán aquí en Colombia “Entre gustos no hay disgustos…”, los que desean hacerlo lo utilizan y cuando una consulta hay que cambiarla se enfrentan a inconvenientes para poder crearla como se necesita.
Estos son mis puntos de vista y todos pensamos y hacemos las cosas diferentes, así que no tomen esto como una regla en sus desarrollos.
Este artículo va a tratar de utilizar todas las funciones necesarias de ADO.NET para Windows Mobile a partir del código.
Bueno, entonces empecemos con este tema, lo primero que vamos a hacer es definir una estructura de una tabla a la cual vamos a aplicar las operaciones del CRUD (Create, Remove, Update, Display) por sus siglas en inglés.
Nuestra tabla es una tabla de contactos personales la cual va a contener las siguientes columnas:
Habiendo definido nuestra tabla o nuestras tablas, vamos a recordar como crear por código la base de datos en la PDA, y luego como aplicar los diferentes métodos de ADO.NET para el manejo de los datos.
Empecemos, abrimos nuestro ambiente de desarrollo Visual Studio 2008, para esto y seleccionamos crear un nuevo proyecto:
No muestra la pantalla de seleccionar el tipo de proyecto a crear:
En esta pantalla seleccionamos el lenguaje sobre el cual vamos a trabajar, también el tipo de proyecto a desarrollar, como vemos en la imagen seleccionamos Smart Device, que es el tipo de proyecto para Windows Mobile.
Además le asignamos un nombre al proyecto, pueden observar en la imagen que en las plantillas solo aparece una como “Proyecto de Smart Device”, en el siguiente paso vamos a seleccionar ya el tipo de proyecto dentro de esta plantilla.
Al presionar el botón Aceptar nos muestra la siguiente pantalla :
En la parte superior y esto solo es a partir de Visual Studio 2008, nos permite seleccionar la plataforma de destino ( Platform Target) y la versión del .NET Compact Framework para el cual vamos a desarrollar.
Luego de haber seleccionado estos datos vamos seleccionar el tipo de aplicación a desarrollar, como vamos a crear una aplicación para windows mobile, debemos seleccionar la plantilla de Aplicación de Dispositivo.
De acuerdo a los diferentes SDK de Windows Mobile instalados en nuestro PC de desarrollo, esta lista puede tener las opciones que aparecen o menos, en mi caso tengo instalados los SDK de Windows Mobile versión 2003, 5 y 6 Professional y Standard (antes llamado smart phone).
Vamos a seleccionar la plataforma Windows Mobile 6 Profesional SDK.
Para el caso de la versión del CF.NET sobre la cual vamos a desarrollar, vamos a seleccionar la versión 3.5, y le damos clic al botón de Aceptar de esta pantalla para que nos abra nuestro ambiente de desarrollo y el formulario para empezar a desarrollar nuestra aplicación.
Como podemos apreciar en la imagen el formulario creado por default en su parte superior derecha tiene una equis “X”, esto significa que se va a minimizar el formulario al presionarla, no se va a cerrar la aplicación como deseamos, para esto vamos a ir al panel de propiedades y vamos a cambiar la propiedad MinimizeBox a False.
Con esto nuestro formulario muestra un botón de OK, que si permite cerrar la aplicación cuando hagamos clic sobre el.
Después de haber configurado nuestro formulario, lo primero que debemos hacer es adicionar a nuestra solución la referencia al espacio de nombres que maneja las bases de datos SQL Mobile, por defecto esta referencia no viene en los proyectos.
Para adicionar la referencia hacemos clic derecho sobre “References” y nos muestra la lista de todos los assemblies que podemos utilizar en nuestro desarollo.
Y ubicamos en la lista System.Data.SqlServerCe, lo seleccionamos y presionamos el botón de Aceptar de la ventana:
Con esto este Espacio de nombre ya queda incluido en las referencias:
Hacemos doble clic sobre el formulario para que se abra la ventana de código en el evento load de la forma, aquí vamos a verificar que exista la base de datos .sdf, que es la extensión de los archivos de SQL Mobile.
Para esto necesitamos incluir el using de System.IO al principio de la clase que maneja el formulario, para poder hacer uso de la función que verifica si un archivo existe o no en el sistema de archivos de Windows Mobile.
Además necesitamos los using de System.Configuration y System.Reflection, para obtener la ruta en la cual se encuentra el ejecutable de la aplciación y verificar que el archivo .sdf se encuentre en esa misma ruta.
Por ultimo necesitamos el using de System.Data.SqlServerCe, para poder tener acceso al proveedor de datos y realizar las operaciones necesarias sobre la base de datos.
Verificar si el archivo .sdf existe
using System.IO;
using System.Configuration;
using System.Reflection;
using System.Data.SqlServerCe;
namespace CRUDWMCS
{
public partial class Form1 : Form
{
// Obtengo por Reflexion la ruta completa del archivo .exe
String nombreExe = Assembly.GetExecutingAssembly().GetName().CodeBase;
String ruta = String.Empty;
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
// Obtengo la ruta del archivo .exe
ruta = nombreExe.Substring(0, nombreExe.LastIndexOf(@"\") + 1);
if (!File.Exists(ruta + "DemoBD.sdf"))
{
// Instancio SqlCeENgine para crear la base de datos .sdf
SqlCeEngine engine = new SqlCeEngine("Data Source= " + ruta + "DemoBD.sdf;"););
}
}
}
}
Crear la base de datos:
Creamos el archivo de base de datos con estas instrucciones:
// Instancio SqlCeENgine para crear la base de datos .sdf
SqlCeEngine engine = new SqlCeEngine("Data Source= " + ruta + "DemoBD.sdf;"););
engine.CreateDatabase();
engine.Dispose();
A continuación como queda el código del evento Load de la forma en la cual se crea la base de datos y la tabla a utilizar:
private void Form1_Load(object sender, EventArgs e)
{
// Obtengo la ruta del archivo .exe
ruta = nombreExe.Substring(0, nombreExe.LastIndexOf(@"\") + 1);
if (!File.Exists(ruta + "DemoBD.sdf"))
{
// Instancio SqlCeEngine para crear la base de datos .sdf
SqlCeEngine engine = new SqlCeEngine("Data Source= " + ruta + "DemoBD.sdf;");
engine.CreateDatabase();
engine.Dispose();
// Instancio la conexion a la base de datos
SqlCeConnection conn = new SqlCeConnection();
StringBuilder sbQuery = new StringBuilder();
SqlCeCommand cmd = new SqlCeCommand();
try
{
// Indico la cadena de conexion a utilizar para abrir la base de datos SQL Mobile
conn.ConnectionString = "Data Source= " + ruta + "DemoBD.sdf;";
// Abro la conexion a la base de datos
conn.Open();
// Creo la sentencia SQL a utilizar
sbQuery.Append("CREATE TABLE Contactos( ");
sbQuery.Append(" Id int IDENTITY(1,1) NOT NULL ");
sbQuery.Append(" ,Nombre nvarchar(150) NOT NULL ");
sbQuery.Append(" ,Direccion nvarchar(150) NOT NULL ");
sbQuery.Append(" ,Telefono nvarchar(10) NOT NULL ");
sbQuery.Append(" ,Celular nvarchar(10) NOT NULL ");
sbQuery.Append(" , CONSTRAINT CONTACTOS_PK PRIMARY KEY ");
sbQuery.Append(" ( ");
sbQuery.Append(" Id ");
sbQuery.Append(" ) ");
sbQuery.Append(" ) ");
// Configuro el objeto commando para ejecutar la sentencia SQL
cmd.CommandText = sbQuery.ToString();
// Asigno la conexion al objeto commando
cmd.Connection = conn;
// Ejecuto la instruccion
cmd.ExecuteNonQuery();
conn.Close();
conn.Dispose();
}
catch (SqlCeException sqlEx)
{
MessageBox.Show("Ha ocurrido una excepción:\r\n" + sqlEx.Message, "Abriendo Base de Datos");
return;
}
}
}
Si ejecutamos nuestra aplicación hasta este momento vamos a observar en el directorio el archivo de la base de datos.
En las imágenes anteriores podemos observar que la base de datos se creo de manera correcta al igual que la tabla.
Recapitulando un poco:
Para crear la base de datos: se necesita el objeto SqlCeEngine de ADO.NET para SQL Mobile.
Para crear la tabla por código: Se necesita:
Ahora que ya tenemos la base de datos con su tabla creada, vamos a crear una opción en el menú para adicionar registros a nuestra tabla, para esto vamos a adicionar al menú la opción Adicionar y vamos a crear un panel para la captura de los datos.
Además vamos a adicionar un Panel que nos servirá para simular una ventana con los datos a capturar.
Dentro del panel vamos a colocar controles label y controles TextBox que nos permitan capturar los datos de diferentes datos de la tabla. Nuestro panel de captura va a quedar de al siguiente manera:
En el evento click del botón grabar vamos a colocar toda la lógica de la grabación de los datos, a continuación el código del botón:
// Grabar los datos en la tabla
private void btnGrabar_Click(object sender, EventArgs e)
{
SqlCeConnection conn = new SqlCeConnection();
StringBuilder sbQuery = new StringBuilder();
SqlCeCommand cmd = new SqlCeCommand();
try
{
// Indico la cadena de conexion a utilizar para abrir la base de datos SQL Mobile
conn.ConnectionString = "Data Source= " + ruta + "DemoBD.sdf;";
// Abro la conexion a la base de datos
conn.Open();
// Creo la sentencia SQL a utilizar
sbQuery.Append("INSERT INTO Contactos ( ");
sbQuery.Append(" Nombre ");
sbQuery.Append(" ,Direccion ");
sbQuery.Append(" ,Telefono ");
sbQuery.Append(" ,Celular ");
sbQuery.Append(" ) VALUES ( ");
sbQuery.Append(" '" + txtNombre.Text + "'");
sbQuery.Append(" ,'" + txtDireccion.Text + "'");
sbQuery.Append(" ,'" + txtTelefono.Text + "'");
sbQuery.Append(" ,'" + txtCelular.Text + "'");
sbQuery.Append(" ) ");
// Configuro el objeto commando para ejecutar la sentencia SQL
cmd.CommandText = sbQuery.ToString();
// Asigno la conexion al objeto commando
cmd.Connection = conn;
// Ejecuto la instruccion
cmd.ExecuteNonQuery();
LimpiarCampos();
}
catch (SqlCeException sqlEx)
{
MessageBox.Show("Ha ocurrido una excepción:\r\n" + sqlEx.Message, "Grabando Datos");
}
finally
{
conn.Close();
conn.Dispose();
}
}
El método LimpiarCampos() lo que hace es limpiar los controles textbox utilizados.
Para la edición de los datos, vamos a crear un nuevo Panel y dentro colocar los controles necesarios para poder realizar estas modificaciones al registro, además un campo para pedir el ID del registro y traer los datos y editarlos.
La pantalla de edición queda de esta manera:
El botón buscar ejecuta una sentencia SELECT contra la tabla de Contactos para ubicar el ID digitado, si no lo encuentra muestra un mensaje indicando esta situación, si lo encuentra rellena los controles con los valores obtenidos de la base de datos.
Para realizar esta operación, abrimos la conexión ala base de datos a través de SqlCeConnect, y utilizando un SqlCeCommand ejecutamos una sentencia contra la base de datos, como esta sentencia a diferencia de las anteriores si devuelve un resultado, que será el registro que estamos buscando, utilizamos el método ExecuteReader del objeto Comando para esta operación.
En nuestro programa declaramos una variable de tipo IDataReader para que pueda recibir los datos y procesarlos de acuerdo a nuestras necesidades.
Una vez tenemos los datos en el DataReader los leemos y llenamos los controles textbox con sus correspondientes valores.
A continuación el código del botón Buscar:
// Boton Buscar un registro de acuerdo al id
private void btnBuscar_Click(object sender, EventArgs e)
{
SqlCeConnection conn = new SqlCeConnection();
StringBuilder sbQuery = new StringBuilder();
SqlCeCommand cmd = new SqlCeCommand();
IDataReader dr;
try
{
// Indico la cadena de conexion a utilizar para abrir la base de datos SQL Mobile
conn.ConnectionString = "Data Source= " + ruta + "DemoBD.sdf;";
// Abro la conexion a la base de datos
conn.Open();
// Creo la sentencia SQL a utilizar
sbQuery.Append("SELECT Id ");
sbQuery.Append(" ,Nombre " );
sbQuery.Append(" ,Direccion ");
sbQuery.Append(" ,Telefono " );
sbQuery.Append(" ,Celular " );
sbQuery.Append("FROM Contactos ");
sbQuery.Append(" WHERE ID = " + txtID.Text);
// Configuro el objeto commando para ejecutar la sentencia SQL
cmd.CommandText = sbQuery.ToString();
// Asigno la conexion al objeto commando
cmd.Connection = conn;
// Ejecuto la instruccion
dr = cmd.ExecuteReader();
while (dr.Read())
{
txtEditNombre.Text = dr["Nombre"].ToString();
txtEditDireccion.Text = dr["Direccion"].ToString();
txtEditTelefono.Text = dr["Telefono"].ToString();
txtEditCelular.Text = dr["Celular"].ToString();
}
// Cierro el DataReader
dr.Close();
if(txtEditNombre.Text == String.Empty)
MessageBox.Show("Registro no Existe, Verifique.", "Editar Contactos");
}
catch (SqlCeException sqlEx)
{
MessageBox.Show("Ha ocurrido una excepción:\r\n" + sqlEx.Message, "Grabando Datos");
}
finally
{
// Cierro la conexion
conn.Close();
conn.Dispose();
}
}
Ahora que ya podemos ubicar o buscar un registro dentro de nuestra tabla de contactos, podemos cambiar los diferentes datos del registro y grabar las modificaciones, para esto vamos a codificar el botón grabar del panel de Edición de los datos.
A continuación el código para grabar los datos modificados:
// Boton grabar los cambios en el registro
private void btnEditGrabar_Click(object sender, EventArgs e)
{
SqlCeConnection conn = new SqlCeConnection();
StringBuilder sbQuery = new StringBuilder();
SqlCeCommand cmd = new SqlCeCommand();
try
{
// Indico la cadena de conexion a utilizar para abrir la base de datos SQL Mobile
conn.ConnectionString = "Data Source= " + ruta + "DemoBD.sdf;";
// Abro la conexion a la base de datos
conn.Open();
// Creo la sentencia SQL a utilizar
sbQuery.Append("UPDATE Contactos SET ");
sbQuery.Append(" Nombre " + "= '" + txtNombre.Text + "'");
sbQuery.Append(" ,Direccion " + "= '" + txtDireccion.Text + "'");
sbQuery.Append(" ,Telefono " + "= '" + txtTelefono.Text + "'");
sbQuery.Append(" ,Celular " + "= '" + txtCelular.Text + "'");
sbQuery.Append(" WHERE ID = " + txtID.Text);
// Configuro el objeto commando para ejecutar la sentencia SQL
cmd.CommandText = sbQuery.ToString();
// Asigno la conexion al objeto commando
cmd.Connection = conn;
// Ejecuto la instruccion
cmd.ExecuteNonQuery();
LimpiarCamposEdit();
MessageBox.Show("Registro Editado de manera Correcta", "Editar Contactos");
}
catch (SqlCeException sqlEx)
{
MessageBox.Show("Ha ocurrido una excepción:\r\n" + sqlEx.Message, "Grabando Datos");
}
finally
{
conn.Close();
conn.Dispose();
}
}
Como podemos apreciar en el código anterior, armamos un sentencia SQL UPDATE para modificar los datos de nuestra tabla, aquí una de las´partes más importantes es el WHERE, tengan muy presente que si hacemos una sentencia UPDATE sin un WHERE se aplicaran los cambios a todos los registros de la tabla, por esto es muy importante esta sentencia en un UPDATE.
Para eliminar los registros, vamos al menú y creamos una nueva opción de Eliminar, esta opción va a llamar nuevamente al panel de edición, pues todo nos sirve, el botón de buscar, la rutina que rellena los controles con al información guardada en la base de datos, el botón de cancelar o salir, únicamente vamos a crear un código que si se llama desde al opción Eliminar el texto del botón grabar cambia a “Eliminar” y se realizará la acción de eliminar el registro.
Al eliminar vamos a verificar que el campo de Nombre no este vacío, esto nos garantizará que no ocurra un error al intentar eliminar un registro sin verificarlo. A continuación el código de eliminar:
else
{
// VERIFICO QUE HAYA CONSULTADO A ALGUIEN
if (txtEditNombre.Text == String.Empty)
{
MessageBox.Show("No ha Seleccionado un Contacto para eliminar", "Eliminando Contactos");
return;
}
// Eliminar el registro de la Tabla de Contactos
try
{
// Indico la cadena de conexion a utilizar para abrir la base de datos SQL Mobile
conn.ConnectionString = "Data Source= " + ruta + "DemoBD.sdf;";
// Abro la conexion a la base de datos
conn.Open();
// Creo la sentencia SQL a utilizar
sbQuery.Append("DELETE FROM Contactos ");
sbQuery.Append(" WHERE ID = " + txtID.Text);
// Configuro el objeto commando para ejecutar la sentencia SQL
cmd.CommandText = sbQuery.ToString();
// Asigno la conexion al objeto commando
cmd.Connection = conn;
// Ejecuto la instruccion
cmd.ExecuteNonQuery();
LimpiarCamposEdit();
MessageBox.Show("Registro Eliminado de manera Correcta", "Eliminar Contactos");
}
catch (SqlCeException sqlEx)
{
MessageBox.Show("Ha ocurrido una excepción:\r\n" + sqlEx.Message, "Eliminando Datos");
}
finally
{
conn.Close();
conn.Dispose();
}
}
Como se puede apreciar es el else del botón de Editar, pues recuerden que estamos utilizando la misma forma que en editar.
Por último vamos a crear una nueva opción en el menú que nos permita listar todos los registros de la tabla para colocarlos dentro de un control ListView, que de acuerdo a las pruebas que yo he realizado es mucho mas rápido en Windows Mobile que un control datagrid, aquí nuevamente, les digo si necesita o prefieren utilizar un control datagrid lo pueden utilizar pues este si puede ser enlazado a datos (Bindable), esto queire decir que cuenta con una propiedad DataSource, mientras que el control ListView, no cuenta con esta propiedad.
Para esto vamos a agregar un nuevo panel al formulario llamado panDisplay y cuya propiedad Visible la vamos a colocar a false igual que los otros, al cual le vamos a asociar un control ListView.
El control ListView lo vamos a configurar para que muestre una lista pues este control puede comportarse para mostrar los mismos datos de diferentes maneras. Para hacer esto, vamos a cambiar la propiedad View del control al valor Details, al hacer esto, aparece una barra de títulos en el control.
También vamos a ubicar la propiedad FullRowSelect y la vamos a colocar a True.
El siguiente paso es configurar las diferentes columnas que va a mostrar el control, para esto vamos a ir a la propiedad Columns, como lo muestra la siguiente imagen:
Esto nos muestra una ventana para configurar las diferentes columnas que queremos tenga nuestro control.
Utilizamos el botón Agregar para adicionar las columnas que queremos muestre nuestro control ListView.
Como se puede apreciar en la imagen, por cada columna podemos cambiar las propiedades que aparecen a la derecha, las propiedades más importantes a cambiar son: Text, que indica el texto de esa columna dentro del control, y Width, que indica el ancho que va a tener esa columna para mostrar los datos, también podremos controlar el alineamiento que va a tener esa columna, por defecto será a la izquierda.
Nuestro formulario se verá de al siguiente forma:
Agregamos un botón de Cerrar para cerrar esta pantalla y regresar a la pantalla principal.
El código del ítem del menú que llama esta opción es el siguiente:
// Menu Mostrar la lista de Contactos en Grilla
private void menuItem6_Click(object sender, EventArgs e)
{
panDisplay.Location = new Point(3, 3);
panDisplay.Visible = true;
CargarDatosGrilla();
}
El método CargarDatosGrilla, se encarga de llenar el control ListView con los datos que existan en la tabla de contactos.
A continuación el código para llenar el ListView con los datos de la tabla
/// <summary>
/// Metodo que carga los datos de Contactos en al Grilla
/// </summary>
private void CargarDatosGrilla()
{
SqlCeConnection conn = new SqlCeConnection();
StringBuilder sbQuery = new StringBuilder();
SqlCeCommand cmd = new SqlCeCommand();
IDataReader dr;
try
{
// Indico la cadena de conexion a utilizar para abrir la base de datos SQL Mobile
conn.ConnectionString = "Data Source= " + ruta + "DemoBD.sdf;";
// Abro la conexion a la base de datos
conn.Open();
// Creo la sentencia SQL a utilizar
sbQuery.Append("SELECT Id ");
sbQuery.Append(" ,Nombre ");
sbQuery.Append(" ,Direccion ");
sbQuery.Append(" ,Telefono ");
sbQuery.Append(" ,Celular ");
sbQuery.Append("FROM Contactos ");
// Configuro el objeto commando para ejecutar la sentencia SQL
cmd.CommandText = sbQuery.ToString();
// Asigno la conexion al objeto commando
cmd.Connection = conn;
// Ejecuto la instruccion
dr = cmd.ExecuteReader();
// Declaro un objeto ListViewItem, para cargar lso registros en el Control ListView
ListViewItem lvItem = new ListViewItem();
// Limpio el control Listview, antes de empezar a llenarlo
listView1.Items.Clear();
// recorro el dataReader para leer todos los registros
while (dr.Read())
{
// Inicializo el Control
lvItem = new ListViewItem();
// Lleno los datos de la fila del control
lvItem.Text = dr["Id"].ToString();
lvItem.SubItems.Add( dr["Nombre"].ToString());
lvItem.SubItems.Add( dr["Direccion"].ToString());
lvItem.SubItems.Add( dr["Telefono"].ToString());
lvItem.SubItems.Add( dr["Celular"].ToString());
// Agrego la fila al control
listView1.Items.Add(lvItem);
}
// Cierro el DataReader
dr.Close();
}
catch (SqlCeException sqlEx)
{
MessageBox.Show("Ha ocurrido una excepción:\r\n" + sqlEx.Message, "Grabando Datos");
}
finally
{
// Cierro la conexion
conn.Close();
conn.Dispose();
}
}
Bueno espero que con este artículo se aclaren muchas dudas al respecto de como hacer o utilizar ADO.NET en Windows Mobile con el Compact Framewok .NET.
En un próximo artículo explicare como utilizar la arquitectura de N-Capas en aplicaciones para Windows Mobile.
Saludos y que lo disfruten!!!