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 tod@s,
Hoy voy a hablarles de un problema que se presenta en algunos casos, cuando desarrollamos una aplicación y nuestros assemblies o dll no están firmados o no tienen un nombre único (fuerte) en inglés Strong Name.
Al intentar compilar nuestra solución con estos assemblies nos arroja un mensaje de error: “Assembly generation failed -- Referenced assembly does not have a strong name”.
Un ejemplo es cuando se desarrolla un Web Part, para SharePoint, si utilizamos un esquema de N-Capas, nuestros assemblies deben estar firmados para que reconozca Visual Studio que los dll tienen un Strong Name.
Para ello debemos primero hacer uso de una utilidad que nos genera un archivo que asegura que nuestro Assembly tiene un Strong Name.
Lo primero entonces, es ir al Inicio, Todos los programas, Visual Studio 2010, Visual Studio Tools, y aquí seleccionar Visual Studio Command Prompt, con esto nos aseguramos que la instrucción va a funcionar.
En la ventana de comando escribimos la siguiente instrucción:
[Code]
sn –k ejemplo.snk
[/Code]
En nuestro caso, ejemplo, representa el nombre de nuestro assembly, la instrucción anterior, genera un archivo con la extensión .snk, la cual debemos copiar de la ruta donde ejecutamos el comando anterior y pegarlo dentro de nuestro proyecto.
En la consola de comandos nos muestra el siguiente mensaje:
[Code]
C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC>sn -k SDP.Indicadores.Negocio.snk
Microsoft (R) .NET Framework Strong Name Utility Version 4.0.30319.1
Copyright (c) Microsoft Corporation. All rights reserved.
Key pair written to SDP.Indicadores.Negocio.snk
[/Code]
Al pegar los archivos .snk en nuestro proyecto, observará algo similar a la siguiente imagen:
Ahora debemos especificar en las propiedades del proyecto que nuestro proyecto se va a firmar o va a tener un Strong Name.
En la ventana de propiedades del proyecto, ubicamos la pestaña de firma o Signing, como lo apreciamos en la imagen:
Aquí seleccionamos el check. "”Sign the assembly” y en la lista desplegables ubicamos el archivo .snk que ya incluimos en el proyecto.
Grabamos y compilamos.
Luego compilamos la solución completa, o el proyecto con los nuevos assemblies generados de esta manera y firmados, con esto desaparece el error al momento de compilar.
Espero esto solucione sus problemas a este respecto.
Hasta la próxima!!!!
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!