PEB

Configuración de Variables de Entorno JAVA_HOME y PATH

2013-06-26T23:51:00.003-03:00

Introducción

Esta es un tema mas bien básico pero que no esta del todo bien documentado así que pongo mi aporte a beginners: El JDK (Java Development Kit) requiere por parte de las herramientas que lo usan (por ejemplo, ECLIPSE, MAVEN, GRAILS, etc) que se encuentren disponibles y bien configuradas dos variables de entorno: JAVA_HOME y PATH. A continuación se muestra la configuración paso a paso bajo Windows XP.

Configuración de Variables de Entorno JAVA_HOME y PATH

Primero que nada, debemos ir a Mi PC, presionar botón derecho y en el menú contextual seleccionar Propiedades:

Se presentara la pantalla de Propiedades del sistema; esta es una ventana con varias lenguetas. Seleccionamos la lengueta llamada Opciones avanzadas. Allí seleccionamos Variables de entorno como indica la siguiente imagen:

Se presenta la ventana de Variables de entorno, donde configuraremos las mismas. Para ingresar una nueva variable de entorno, En la misma, en la sección Variables del sistema seleccionamos Nueva:

En la nueva ventana, ingresaremos en el campo Nombre de variable, el texto JAVA_HOME, y en el campo Valor de variable, ingresaremos el path a donde tenemos instalado el JDK. En mi caso lo tengo enC:\Archivos de programa\Java\jdk1.7.0_09\; usted verifique el path de la versión que posea instalado e ingréselo del siguiente modo:

Una vez terminado, presione Aceptar.

Seguidamente, editaremos el valor de la variable Path existente. Identifiquela en la sección Variables del sistema como indica la siguiente imagen:

Selecciónela haciendo doble click sobre la misma. Se presentara una ventana de Modificar la variable del sistema. Vaya al final de la linea y agregue el texto ;%JAVA_HOME%\bin , quedando del siguiente modo:

Presione Aceptar y cierre todas las ventanas.

Para probar el funcionamiento, abra una nueva consola y escriba: java -version. Si todo quedó correctamente configurado, deberá ver un mensaje como el siguiente:

fuente: http://davidg-tech.blogspot.com.ar/2012/12/java-configurar-variables-de-entorno-javahome-y-path.html

Review sobre Android Studio | Androideity

2013-06-10T16:34:00.001-03:00

Review sobre Android Studio | Androideity: "Review sobre Android Studio"

'via Blog this'

C# IoC – Inyección de Dependencias con Unity 2.0

2012-06-11T11:40:00.001-03:00

C# IoC – Inyección de Dependencias con Unity 2.0 | DevNinja's Blog:

En el presente post vamos a realizar una implementación básica del desacoplamiento entre componentes en una arquitectura N-Capas. La inyección de dependencias se usa en aquellas ocasiones en las que deseamos que nuestros componentes trabajen de una manera genérica controlando la ejecución de aquellos específicos y maximizando la coherencia entre ellos, también para simplificar el diseño, la implementación y el mantenimiento de las aplicaciones.

Actualmente existe una variedad de frameworks que nos permiten realizar inyección de dependencias entre ellos Unity que viene incluido en la Enterprise Library para este ejemplo vamos a utilizar EntLib 5.0 la cual incluye Unity 2.0.

Unity es un contenedor de inyección de dependencias ligero y extensible, en pocas palabras Unity no es un framework robusto o pesado. Soporta inyección en el constructor, inyección en propiedades, inyección en llamadas a métodos y contenedores anidados. Unity permite mapear Interfaces hacia clases las que podemos instanciar bajo demanda. Entre las diferentes ventajas que ofrece Unity tenemos:

Proporciona una creación de objetos simplificada en estructuras de objetos con dependencias lo cual simplifica el código de la aplicación.
Incrementamos la flexibilidad al mover la configuración de los componentes al contenedor de inyección de dependencias.

Bien ahora veamos un ejemplo, supongamos que tenemos una aplicación N-Capas donde cargaremos información de una base de datos cualquiera a través de una tecnología de acceso a de datos X, implementando algunos de los patrones de diseño de arquitectura para una aplicación N-Capas a manera de ejemplo didáctico, vamos a crear un nuevo proyecto en mi caso he optado por una aplicación de consola a la cual le agregaré una referencia Unity que se encuentra entre los ensamblados de la Enterprise Library.

El siguiente paso es crear nuestra implementación del contenedor de Unity para resolver las dependencias, lo que voy a hacer es encapsular los métodos necesarios para dicho fin, al ser un objeto que utilizaré a lo largo de toda la aplicación éste será un aspecto transversal de mi aplicación N-Capas.

Lo que haré en la clase FabricaIoC será registrar todos aquellos tipos los cuales quiero que Unity se encargue de la creación de los específicos, por ejemplo voy a registrar el tipo IRepositorioUsuarios e indicarle a Unity que cuando le pida resolver este tipo el deberá crear una nueva instancia de un objeto CsvRepositorioUsuarios donde dicho objeto implementa los métodos para la gestión de usuarios con una tecnología de acceso a datos específica. De igual manera tambíen aislamos a Unity dado el caso que cambiemos el framework de inyección de dependencias nuestra aplicación sigue funcionando igual.

Código:

1: // -----------------------------------------------------------------------

2: //

3: // Copyright (c) SCI Software 2011. Todos los derechos reservados.

4: //

5: // Jhonnys Lopez Celedon

6: // -----------------------------------------------------------------------

7: using Microsoft.Practices.Unity;

8: using SCI.Unity.Aplicacion.ModuloPrincipal;

9: using SCI.Unity.Dominio.ModuloPrincipal.Repositorios;

10: using SCI.Unity.Infraestructura.Datos.Repositorios;

11:

12: namespace SCI.Unity.Infraestructura.Transversales

13: {

14:     ///

15:     /// Fabrica Singleton para la inyeccion de dependencias con Unity

16:     ///

17:     public class FabricaIoC

18:     {

19:         private static readonly FabricaIoC _contenedor = new FabricaIoC ();

20:         private readonly IUnityContainer _unityContainer;

21:

22:         private FabricaIoC()

23:         {

24:             _unityContainer = new UnityContainer ();

25:

26:             // Registrar los tipos utilizados en la aplicacion.

27:

28:             //_unityContainer.RegisterType();

29:             _unityContainer.RegisterType<IRepositorioUsuarios , CsvRepositorioUsuarios >();

30:             _unityContainer.RegisterType<IServicioUsuarios , ServicioUsuarios >();

31:         }

32:

33:         public static FabricaIoC Contenedor

34:         {

35:             get { return _contenedor; }

36:         }

37:

38:         ///

39:         /// Crear una instancia de un objeto que implemente un tipo TServicio.

40:         ///

41:         /// name = "TServicio">Tipo de servicio que deseamos resolver

42:         ///

43:         public TServicio Resolver() where TServicio : class

44:         {

45:             return _unityContainer.Resolve();

46:         }

47:     }

48: }

49:

Lo que logramos con esta implementación sencilla es olvidarnos de como se realizarán las operaciones dentro de mis repositorios en pocas palabras mi aplicación en las capas superiores como Dominio y Aplicación ignoran como se realiza el acceso a los datos, concentrando toda la atención únicamente en que operaciones realizan dichos objetos.

Tambíen tengo un servicio de aplicación al que he llamado ServicioUsuarios el cual implementa el contrato o interfazIServicioUsuarios en el cual a manera de Facade podemos exponer uno mas métodos de nuestro subsistema en una operación más sencilla, tambíen será el encagardo de tomas decisiones como si una operación necesita ir al dominio para ser validada o ir directamente a los orígenes de datos, en fin dicho servicio “depende” de un IRepositorioUsuarios el cual ya tengo registrado en mi contenedor de Unity.

Las operaciones que realizará mi servicio están en el contrato o interfaz IServicioUsuarios:

1: // -----------------------------------------------------------------------

2: //

3: // Copyright (c) SCI Software 2011. Todos los derechos reservados.

4: //

5: // Jhonnys Lopez Celedon

6: // -----------------------------------------------------------------------

7: using System.Collections.Generic;

8: using SCI.Unity.Dominio.ModuloPrincipal.Entidades;

9:

10: namespace SCI.Unity.Aplicacion.ModuloPrincipal

11: {

12:     public interface IServicioUsuarios

13:     {

14:         ///

15:         /// Obtener todos los registros de la tabla Usuarios.

16:         ///

17:         /// Coleccion de usuarios registrados.

18:         IList <Usuario > Obtener();

19:     }

20: }

21:

La manera de como se realizan estas operaciones se encuentran definidas en la clase ServicioUsuarios:

1: // -----------------------------------------------------------------------

2: //

3: // Copyright (c) SCI Software 2011. Todos los derechos reservados.

4: //

5: // Jhonnys Lopez Celedon

6: // -----------------------------------------------------------------------

7: using System.Collections.Generic;

8: using SCI.Unity.Dominio.ModuloPrincipal.Entidades;

9: using SCI.Unity.Dominio.ModuloPrincipal.Repositorios;

10:

11: namespace SCI.Unity.Aplicacion.ModuloPrincipal

12: {

13:     public class ServicioUsuarios : IServicioUsuarios

14:     {

15:         private readonly IRepositorioUsuarios _repositorioUsuarios;

16:

17:         public ServicioUsuarios(IRepositorioUsuarios repositorioUsuarios)

18:         {

19:             _repositorioUsuarios = repositorioUsuarios;

20:         }

21:

22:  #region IServicioUsuarios Members

23:

24:         public IList <Usuario > Obtener()

25:         {

26:             return _repositorioUsuarios.Obtener();

27:         }

28:

29:  #endregion

30:     }

31: }

32:

Una de las grandes ventajas de Unity es que puede resolvernos grafos de dependencias como el que observamos enIServicioUsuarios que para instanciar un objeto ServicioUsuarios necesitamos pasarle como parámetro en el constructor una instancia de un objeto que implemente IRepositorioUsuario lo cual ya hemos registrado en el contenedor Unity de manera tal que el pedir resolver una instancia de nuestro servicio Unity estará en capacidad de resolver completamente todo el grafo de dependencias.

En la práctica sería:

Código:

1: // -----------------------------------------------------------------------

2: //

3: // Copyright (c) SCI Software 2011. Todos los derechos reservados.

4: //

5: // Jhonnys Lopez Celedon

6: // -----------------------------------------------------------------------

7: using System;

8: using System.Collections.Generic;

9: using SCI.Unity.Aplicacion.ModuloPrincipal;

10: using SCI.Unity.Dominio.ModuloPrincipal.Entidades;

11: using SCI.Unity.Infraestructura.Transversales;

12:

13: namespace SCI.Unity

14: {

15:     public class Program

16:     {

17:         private static void Main(string [] args)

18:         {

19:             // Declaramos un IServicioUsuarios y le pedimos a nuestra fabrica de inyeccion de dependencias

20:             // que resuelva de menera automatica dicha peticion.

21:             IServicioUsuarios servicioUsuarios = FabricaIoC .Contenedor.Resolver<IServicioUsuarios >();

22:

23:             // Utilizar uno de los metodos contenidos dentro el contrato.

24:             IList <Usuario > usuarios = servicioUsuarios.Obtener();

25:

26:             foreach (var usuario in usuarios)

27:             {

28:                 Console .WriteLine(usuario.Login);

29:             }

30:

31:             Console .ReadKey();

32:         }

33:     }

34: }

35:

Podemos observar que nuestro contenedor realiza correctamente su labor:

La variable servicioUsuarios ahora tiene una instancia de un ServicioUsuarios que a su vez depende de unIRepositorioUsuario:

De manera sencilla Unity ha resuelto el grafo de dependencias. Si bien ahora supongamos que hemos migrado la información a otro motor de base de datos lo que significa que la tecnología de acceso a datos también pudo haber cambiado, pues con ésta técnica podemos implementar una nueva clase que cumpla con el contratoIRepositorioUsuarios con la tecnología de acceso a datos especifica para el nuevo motor de bases de datos y solo tenemos que modificar el contenedor al momento de registrar los tipos y como resolverlos:

Código:

1: // -----------------------------------------------------------------------

2: //

3: // Copyright (c) SCI Software 2011. Todos los derechos reservados.

4: //

5: // Jhonnys Lopez Celedon

6: // -----------------------------------------------------------------------

7: using Microsoft.Practices.Unity;

8: using SCI.Unity.Aplicacion.ModuloPrincipal;

9: using SCI.Unity.Dominio.ModuloPrincipal.Repositorios;

10: using SCI.Unity.Infraestructura.Datos.Repositorios;

11:

12: namespace SCI.Unity.Infraestructura.Transversales

13: {

14:     ///

15:     /// Fabrica Singleton para la inyeccion de dependencias con Unity

16:     ///

17:     public class FabricaIoC

18:     {

19:         private static readonly FabricaIoC _contenedor = new FabricaIoC ();

20:         private readonly IUnityContainer _unityContainer;

21:

22:         private FabricaIoC()

23:         {

24:             _unityContainer = new UnityContainer ();

25:

26:             // Registrar los tipos utilizados en la aplicacion.

27:

28:             // Especificamente con una nueva tecnologia de acceso a datos.

29:             _unityContainer.RegisterType<IRepositorioUsuarios , XmlRepositorioUsuarios >();

30:             // _unityContainer.RegisterTypeCsvRepositorioUsuarios>();

31:             _unityContainer.RegisterType<IServicioUsuarios , ServicioUsuarios >();

32:         }

33:

34:         public static FabricaIoC Contenedor

35:         {

36:             get { return _contenedor; }

37:         }

38:

39:         ///

40:         /// Crear una instancia de un objeto que implemente un tipo TServicio.

41:         ///

42:         /// name = "TServicio">Tipo de servicio que deseamos resolver

43:         ///

44:         public TServicio Resolver() where TServicio : class

45:         {

46:             return _unityContainer.Resolve();

47:         }

48:     }

49: }

50:

Donde hemos cambiado que instancia de que tipo devolverá nuestro contenedor Unity a momento de pedirle que resuelvaIRepositorioUsuarios, podemos observar que ahora la instancia del repositorio usuarios que tiene el servicio de usuarios implementa XmlRepositorioUsuarios.

Hemos desacoplado la tecnología de acceso a datos en nuestra aplicación por medio de Unity, lo cual en el futuro nos facilitará el mantenimiento de dicha aplicación al momento de reemplazar una tecnología por otra sin que el comportamiento de nuestra aplicación cambie.

Solución:

Decargar: SCI.Unity.zip

fuente:
C# IoC – Inyección de Dependencias con Unity 2.0 | DevNinja's Blog

Una introducción a MongoDB

2012-06-11T10:45:00.001-03:00

Una introducción a MongoDB:

'via Blog this'

Neluz: Empenzando con jquery mobile

2012-06-08T16:45:00.001-03:00

Neluz: Empenzando con jquery mobile:

'via Blog this'

Neluz: Mvc4 y jquerymobile

2012-06-08T15:52:00.001-03:00

Neluz: Mvc4 y jquerymobile:

'via Blog this'

Instalación de Seagate Crystal Report 7 en Windows 7 de 32bits

2012-02-29T17:03:00.000-03:00

Hace algún tiempo, programé algunas aplicaciones en el tradicional Visual Basic 6, ambiente de desarrollo con algunas librerías adicionales que compilaban muy bien sobre Windows XP de 32 bits.

Recientemente, decidí utilizar Windows 7 de 32 bits y me encontré con algunos inconvenientes al optar por la decisión de mantener las versiones funcionales de mis sistemas, sin migrar a net.

Al instalar Visual Basic 6, la versión empresarial me daba un error con una librería del OLE Viewer (iviewers.dll), al parecer por temas de incompatibilidad con el Windows 7. Conseguí solucionar el problema, al correr el instalador desmarcando de la opción de Herramientas, el Visor de objetos OLE y Com.

Herramientas de Instalación Visual Studio 6

Desactivar Visor de objetos OLE y Com.

El asunto de levantar el ambiente de desarrollo de los sistemas no terminaba ahí, aún tenía que compilar componentes adicionales con los que no tuve mayores inconvenientes, hasta que me encontré con la instalación del Crystal Reports 7.

Para dar solución apliqué un criterio muy similar al de la instalación de Visual, respecto al tema del registro de alguna librería que debió estar causando conflicto.

Dado que Crystal trae soporte para algunas herramientas de desarrollo y la de mi interés era Visual Basic descarté las que no me sirvieran para mi propósito.

Y efectivamente encontré la solución para Windows 7 que a continuación detallo:

Inicié el instalador de Seagate Crystal Report 7 desde el CD y seleccioné install (Win32), es recomendable iniciar SETUP en modo de compatibilidad para Windows XP(Service Pack 2).

Instalación de Crystal Report 7 en Windows 7 de 32 bits

En el diálogo de Installation Options, en Installation Mode seleccioné Custom.

Opciones de instalación de Crystal Reports 7

En Custom Installation Options, en Choose Which item to install seleccioné Developer’s Files y Seagate Crystal Reports Programs.

Personalizar opciones de instalación de Crystal Reports 7

Utilice el botón Change Option para seleccionar los items de instalación, tanto de Developer’s Files y de Seagate Crystal Reports Programs, para Developer’s Files seleccioné Microsoft Visual Basic y Report Designer Component.

Selección de archivos de desarrollo

Para Seagate Crystal Reports Programs seleccioné Crystal Report Designer.

Selección de Diseñador de Crystal Reports

Luego de haber seleccionado cuidadosamente las opciones anteriores, damos clic en siguiente hasta finalizar la instalación de Crystal.

Con esto, tenemos funcionando tanto el diseñador de Crystal Reports 7, los archivos de desarrollo Visual Basic y el componente de diseñador de reportes.

Diseñador Crystal Reports

Crystal Reports 7 en Visual Basic

Fuente: http://tecnopeninsula.com/crystal-report7-windows7/

Saltando de ASP.net WebForms a MVC 3

2012-01-13T09:48:00.001-03:00

Actualmente y desde hace tiempo, existe un debate comparativo importante con metodologías y patrones a emplear con tecnologías ASP .net. Específicamente con ASP.net WebForms y MVC.

Tras la aparición de MVC surgió la duda en la comunidad de programadores Microsoft: ¿MVC reemplazará WebForms?. Microsoft aclaró que únicamente iba a representar una opción más para el desarrollo web.

Con el trascurso del tiempo, la tecnología MVC pasó a colocarse en una posición ventajosa respecto a la utilización de WebForms, siendo la tecnología más apropiada y utilizada para el desarrollo web de proyectos de gran envergadura.

Tras aproximadamente medio año, me encuentro abordando la tecnología ASP.net MVC 3, desarrollando y asistiendo a un curso. Teniendo en cuenta los más de ocho años programando y escalando versiones en ASP.net WebForms. Iré recopilando puntos de vista y experiencias en lo que concierne a dichas tecnologías, en varios escenarios de desarrollo. Aún teniendo en cuenta que pueda dejarme muchos conceptos, que os animo a discutir. Y que poco a poco, con el transcurso del tiempo iré comentando.

Empecemos haciendo un poco de memoria:

Antes del tremendo cambio conceptual que supuso ASP.net, recuerdo haber programado con PHP / ColdFusion / JSP / ASP, tareas tan problemáticas como:

Peticiones asíncronas manuales mediante iframes ocultos.
Proxy Webservices XML/RPC.
Utilización de POO mediante clases contenidas en inclusiones de archivos.
Generación de librerías COM.
Etc.

Con la entrada de ASP.net

Nos solucionó la inmensa mayoría de todos los problemas. Supuso cambiar la filosofía, metodología y patrón de desarrollo, facilitando en gran medida la programación, organización y clasificación, en todos los aspectos.

En posteriores versiones, introdujo la librería de código cliente AJAX, incluyendo componentes cómo el ScriptManager, ScriptResource, UpdatePanel, etc. Facilitando más aún el desarrollo.

Versión a versión, Microsoft priorizó la rapidez, estandarización y automatización en el desarrollo de cualquier tipo de aplicación, en el menor tiempo posible. Mediante wizards y código auto-generado.

Toda esa facilidad y auto-generación de código, con el tiempo y observación, se convirtió en un problema de rendimiento para los proyectos web de gran envergadura, alto rendimiento y gran concurrencia de usuarios.

Dichos proyectos web necesitan/requieren una rápida y optimizada ejecución, tanto en el cliente como en el servidor, obligando a tener un control absoluto del HTML y archivos JS y CSS enviados al navegador.
Con esa básica e importante prioridad, ASP.net WebForms, no te lo pone sencillo.

Por cada problema, tanto la comunidad de programadores, como Microsoft propusieron soluciones y recursos que evitaban la automatización, mediante prácticas para la mejora del rendimiento para ASP.net WebForms.

Dichas soluciones, Microsoft fue incluyéndolas en posteriores versiones:

ASP .net 4.0 nos facilita la optimización de JS/AJAX mediante jQuery y MS AJAX Content Delivery Network.
Output Caching Extensible con ASP.net 4.0
Optimizando el rendimiento de ASP .net
Optimizando el rendimiento de JS/AJAX

Viendo esta evolución, no es de extrañar que Microsoft brindara una nueva opción en los desarrollos web, planteando un nuevo patrón, mediante una nueva metodología. Intentando extraer la ventaja del rápido desarrollo de ASP.net WebForms, con el control absoluto de código: ASP.net MVC. Aunque siempre, de una forma u otra, consumiendo todo el potencial del Framework 4.0.

Arquitectura: Modelo Vista Controlador:

Modelo: Representa la lógica de negocio de la aplicación. Más comúnmente: BLL (Business Logic Lager) y DAL (Data Access Layer).
Vista: Representan la presentación de la aplicación. Más comúnmente: GUI (Graphical User Interface).
Controlador: Recogen y procesan las acciones del usuario, mediante el Modelo. Devolviendo la Vista determinada y procesada.

De modo que tenemos una nueva óptima solución, a barajar ante nuevos proyectos Web.

Desde mi experiencia, la adaptación inicial en el desarrollo de ASP.net WebForms a MVC, fue rápida, aunque teniendo siempre presente los principales cambios conceptuales que repercuten en cada tecnología.

Realmente lo importante no es “qué” herramienta vamos a utilizar, sino el “cómo” vas a emplearla (teniendo en cuenta que el “cómo” es directamente proporcional al “quien”). Destaco la frase sentenciadora existente en el post de ScottGu´s – About Technical Debates (and ASP.net Web Forms and ASP.net MVC debates in particular:

“Great developers using bad tools/frameworks can make great apps. Bad developers using great tools/frameworks can make bad apps.”

Puedes encontrar infinidad de links interesantes que hablan del tema. En los que podrás obtener información más detallada. Destaco algunos:

Social MSDN – MVC vs WebForms
Magazine MSDN – Building Web Apps without Web Forms
WebForms vs ASP.net MVC

fuente: http://www.josecuellar.net/js-ajax/saltando-de-asp-net-webforms-a-mvc-3

recuperar samsung i5500 sin señal señal

2012-01-01T16:39:00.000-03:00

abro este post para explicar como recuperar la senal del servidor
en caso de que tu android la haya perdido
les comento que cambie el firmware
de froyo i5500L (latinoamerica) I5500LUYJP2 x una mas nueva i5500B(brasil) I5500BVJJP7
perdiendo la conexion con el servidor (personal en mi caso)
por si a alguien mas le paso asi pude solucionarlo...

colocar *#1575# , les aparecera la pantalla de gps

palanca hacia la derecha, les aparecera "common"

palanca hacia la derecha y luego ingresan a [1] debug screen

luego [8] phone control

[7] network control

[2] band selection

[3]gsm band preference

[7] gsm all

y a los pocos segundos (menos de 10) retornara la señal son el servidor

espero que les sirva
esto lo descubri solo
y ya que no encontre ningun foro con la solucion para este problema lo posteo

saludos

WebGrid en MVC 3, paso a paso

2011-10-26T14:22:00.000-03:00

Una de las preguntas que recibo con más frecuencia vía formulario de contacto en el blog, en sus comentarios, y en los cursos de MVC es cómo implementar grids, las habituales rejillas de datos que se suelen utilizar en interfaces de gestión de datos, con capacidades de paginación y ordenación.

Dado que hasta MVC 3 no había un soporte oficial para implementar esta funcionalidad desde la propia plataforma, nos veíamos obligados a buscarnos un poco la vida, y o bien usar el andamiaje generado por Visual Studio y desarrollar a mano las paginaciones y ordenaciones (¡uf!), o utilizar componentes externos (como el de MVCContrib, Telerik, jqGrid u otros).

La última versión de ASP.NET MVC, de la mano de la tecnología WebPages, nos trae un nuevo conjunto de helpers de productividad bastante interesantes en el espacio de nombres System.Web.Helpers, entre los cuales encontramos WebGrid, que por fin ofrece una solución “de serie” potente y flexible para ayudarnos a implementar esta funcionalidad de uso tan frecuente en nuestras aplicaciones.

Vamos a ver, paso a paso y de forma totalmente práctica, cómo utilizar WebGrid. Al final de post, además, encontraréis un enlace para descargar el proyecto completo para VS2010+SQL Express.

1. Lo primero: el Modelo

Lo primero que necesitamos antes de empezar a profundizar en el helper WebGrid es un Modelo, las entidades de datos de nuestra aplicación, así como los mecanismos que nos permitan hacer persistente y recuperar la información desde el sistema de almacenamiento que estemos utilizando.

En este caso, vamos a utilizar como almacén una base de datos SQL Express con una única tabla, en la que hemos creado una tabla para guardar datos de personas; esta colección es la que pretendemos mostrar en forma de rejilla de datos, por lo que necesitamos poblarla con algunos datos para probar más adelante.

Para acceder a la base de datos vamos a utilizar Entity Framework, por lo que necesitaremos también un Entity Data Model, un modelo conceptual de entidades, que podemos agregar a la carpeta Models del proyecto utilizando la opción “Agregar nuevo elemento” del menú contextual. En el asistente que aparece, sólo debemos indicarle que vamos a generar el modelo desde una base de datos existente, seleccionamos la tabla Personas, y listo.

Con esto tenemos ya la infraestructura básica de datos de nuestra aplicación. El siguiente paso será crear una clase de servicios, que será la que provea la lógica de negocio y acceso a datos para nuestro sistema.

Obviamente esto no tiene por qué ser siempre así, depende de nuestras necesidades y de la arquitectura del software, y en nuestro ejemplo van a ser ambos aspectos bastante simples.

El código inicial de nuestra clase de servicios es el siguiente:

public class ModelServices: IDisposable {     private readonly DatosEntities _datos = new DatosEntities();       public IEnumerable<Persona> ObtenerPersonas()     {         return _datos.Personas.ToList();     }       public void Dispose()     {         _datos.Dispose();     } }

Como se puede observar en el código anterior, tenemos un único método, llamado ObtenerPersonas(), que retorna el conjunto completo de personas almacenadas en la base de datos.

Y de momento, he aquí todo el Modelo que necesitamos de momento.

2. El controlador

Nuestra clase del controlador, que llamaremos PersonasController, en este primer acercamiento va a ser realmente sencilla. Una única acción, Index(), que retornará una vista a la que suministraremos la colección de datos obtenida desde el Modelo:

public class PersonasController : Controller {     public ActionResult Index()     {         var datos = new ModelServices().ObtenerPersonas();         return View(datos);     } }

Y esto es todo: una acción con dos líneas. Vale, podría haber sido una única línea, pero así el código me parecía más legible ;-)

3. La vista, toma primera: WebGrid entra en escena

Ahora es cuando vamos a empezar a notar las ventajas de utilizar WebGrid respecto a las opciones disponibles hasta MVC y que ya hemos citado al principio del post.

Observad el siguiente código, una vista Razor que recibe una enumeración de objetos Persona desde el controlador y genera un grid completo:

@model IEnumerablePersona> @{     ViewBag.Title = "Personas";     WebGrid grid = new WebGrid(Model); } <h2>Personash2> @grid.GetHtml()

Impresionante, ¿eh? Aunque pueda parecer increíble, el código anterior es todo lo que necesitamos para montar un grid funcionalmente completo, con paginación y ordenación por columnas: ¡dos líneas! En la primera de ellas instanciamos el WebGrid suministrándole la colección de datos sobre la que debe iterar, y en la segunda (ya al final) generamos el marcado HTML que enviaremos al cliente.

El resultado en ejecución lo podemos ver en la siguiente captura de pantalla:

Aunque todavía queda algo lejos de la perfección, el resultado es espectacular.

El helper, en su comportamiento por defecto, muestra una columna por cada propiedad que encuentra en la clase sobre la que itera, eso sí, ordenándolas alfabéticamente. Además, ha utilizado el nombre de las propiedades como encabezado de columna, y las muestra como enlaces para forzar la ordenación por cada una de ellas, e incluso ha introducido en el pie un sistema completo de navegación por las páginas de datos.

Y lo mejor que todo esto funciona directamente, sin necesidad de añadir una línea de código más :-)

Sin embargo, como siempre, estos automatismos tienen su precio. Por un lado, no estamos controlando las columnas a mostrar, ni el formato en que sus valores son presentados (observad, por ejemplo, la fecha de nacimiento), ni sus encabezados… Normalmente, necesitaremos esforzarnos algo más (aunque no demasiado) para dejarlo todo perfecto.

Además, existe un serio problema de rendimiento cuando el número de elementos del grid sea importante: tanto la ordenación como la paginación se realizan en memoria con el número total de elementos. Exagerando, si tenemos un millón de filas en la base de datos, se materializarán en memoria un millón de objetos, serán ordenados según el criterio actual y, finalmente, sólo serán mostrados al cliente los diez objetos que contiene una página de datos. Veremos más adelante que hay fórmulas para gestionar de forma eficiente estos escenarios.

4. La vista, toma segunda: las columnas que yo quiera, por favor

Existen distintas fórmulas para especificar las columnas a mostrar en un WebGrid. La primera de ellas, es mediante exclusión sobre el conjunto total de propiedades. Entre muchos otros aspectos, en el método GetHtml() podemos especificar un array de nombres de propiedad que no deben mostrarse como columnas. Por ejemplo, sobre el ejemplo anterior, si no nos interesa mostrar la propiedad IdPersona, podríamos haber sustituido la última línea de la vista por:

@grid.GetHtml(exclusions: new[] {"IdPersona"})

Sin embargo, el enfoque anterior no es demasiado útil, puesto que normalmente querremos indicar el orden de aparición de las columnas, especificar sus encabezados, determinar si las columnas pueden ser utilizadas como criterios de ordenación, etc. Toda esta información se define en objetos WebGridColumn.

Aunque hay otras formas de hacerlo, habitualmente encontraremos en el parámetro columns de la llamada a GetHtml() un array con el detalle de las columnas del grid, como en el siguiente ejemplo:

@grid.GetHtml(columns: new [] {     grid.Column("Nombre"),     grid.Column("Apellidos"),     grid.Column("EMail"),     grid.Column("FechaNacimiento"),     grid.Column("NumeroDeHijos"), })

Como se puede observar, estamos pasando en el parámetro columns un array en el que cada elemento lo estamos generando mediante una llamada al método Column() de WebGrid, en cuyo primer parámetro indicamos el nombre de la propiedad a la que corresponde la columna.

El resultado de la ejecución del código utilizando este último código sería:

Algo ha mejorado la cosa, aunque todavía tenemos que afinar algo más en cuanto a la presentación.

5. La vista, toma tercera: las columnas como yo quiero, por favor

Todavía nos quedan varios detalles por apuntalar para que el grid, al menos a efectos visuales, cumpla un mínimo razonable. Para personalizar cada columna, podemos utilizar los parámetros del método generador de columnas Column() que ya hemos visto anteriormente:

header, que permite indicar el texto mostrado en el encabezado,
canSort, que indica si la columna puede ser utilizada como criterio de ordenación,
format, que permite indicar un formato personalizado para el contenido de la columna,
style, que indica la clase CSS que se aplicará a todas las celdas de la columna.

De todas ellas, sólo merece una especial mención la propiedad format. En ella podemos indicar, bien mediante un bloque de marcado Razor, bien mediante una función lambda, cómo debe formatearse el contenido de la propiedad vinculada a la columna.

En el primer caso, debemos comenzar el bloque de marcado con el carácter de escape de Razor (@) y seguirlo del código que queremos enviar al cliente. Desde su interior podemos hacer referencia al objeto que está siendo evaluado utilizando @item, como en el siguiente ejemplo, donde se muestra cómo formatear la columna EMail para que sea mostrada como un hiperenlace de tipo mailto:

    grid.Column("EMail",                   format: @<a href="mailto:@item.Email">@item.Emaila>     )

Para profundizar en la "magia" que hace posible la utilización de bloques de marcado donde debería haber código, no os perdáis este magnífico post de Eduard Tomás sobre Razor Templates.

También podemos utilizar una función lambda, que recibe como parámetro el objeto actual y retorna una cadena (o un IHtmlString si no debe ser codificada). Por ejemplo, a continuación vemos cómo utilizar esta posibilidad para dar formato a la columna FechaNacimiento:

    grid.Column("FechaNacimiento",                  format: p=>p.FechaNacimiento.ToShortDateString()     )

Por tanto, teniendo en cuenta todo lo anterior, podemos tunear un poco el grid utilizando el siguiente código. Como recordatorio, mostraré de nuevo el código completo de la vista, para que podáis observar en su conjunto cómo va quedando:

@model IEnumerablePersona> @{     ViewBag.Title = "Personas";     WebGrid grid = new WebGrid(Model); } <h2>Personash2> @grid.GetHtml(columns: new [] {     grid.Column("Nombre", canSort: false),     grid.Column("Apellidos"),     grid.Column("EMail",                   format: @<a href="mailto:@item.Email">@item.Emaila>     ),     grid.Column("FechaNacimiento",                  header: "Fecha de nacimiento",                 format: p=>p.FechaNacimiento.ToShortDateString()     ),     grid.Column("NumeroDeHijos",                  header: "Número de hijos",                 style: "a-la-derecha"     ) })

En ejecución ya sí que podemos ver algo más terminado:

6. La vista, toma cuarta: ¿y no puedo añadir columnas personalizadas?

¡Pues claro!

De hecho, basta con añadir columnas exactamente igual que las anteriores, excepto en que no las vincularemos a ninguna propiedad de la clase del Modelo. Esto, combinado con la flexibilidad del formateo personalizado (parámetro format), nos ofrece ya todo lo que necesitamos para crear columnas totalmente a nuestro antojo.

El siguiente código muestra cómo añadir una columna adicional con enlaces hacia las acciones que permitirían, por ejemplo, editar o eliminar una Persona:

@grid.GetHtml(columns: new [] {      ... // Resto de columnas del grid, vistas anteriormente     grid.Column(           "",            header: "Acciones",           format: @                     @Html.ActionLink("Editar",   "Edit",   new { id=item.IdPersona} )                     |                     @Html.ActionLink("Eliminar", "Delete", new { id=item.IdPersona} )                        ) })

Observad que esta vez, para incrementar la legibilidad del código, estamos utilizando el tag especial de Razor, que nos permite crear bloques de marcado de varias líneas.

Y el resultado, como el siguiente:

7. La vista, toma quinta: mejor casi que lo quiero todo a mi gusto

El helper WebGrid ofrece multitud de opciones de personalización adicionales que podemos establecer tanto al llamar a sus distintos métodos como de forma directa. Por ejemplo, GetHtml() permite indicar los siguientes parámetros, además de los ya vistos:

headerStyle, footerStyle, rowStyle, alternatingRowStyle, y selectedRowStyle permite indicar las clases CSS a aplicar a las filas de encabezado, pie, filas de datos alternativas, y fila seleccionada, respectivamente.
caption, para especificar un título para la tabla, que será incluido en una etiqueta en el encabezado.
fillEmptyRows, establecido a true hace que cada página tenga siempre el mismo número de filas, creando filas en blanco si fuera necesario.
emptyRowCellValue indica el valor a mostrar en las celdas de filas vacías.
mode, permite especificar el tipo de paginador a generar, eligiéndolo mediante una combinación de elementos de la enumeración WebGridPagerModes:
- WebGridPagerModes.Numeric: el paginador mostrará enlaces directos a páginas cercanas a la actual.
- WebGridPagerModes.FirsLast: se mostrarán enlaces para ir a la primera y última página de datos.
- WebGridPagerModes.NextPrevious: aparecerán enlaces para desplazarse a la página anterior y siguiente.
- WebGridPagerModes.All: todos los anteriores al mismo tiempo.
numericLinksCount: indica el número de páginas que aparecerán, siempre que mode contenga el valor WebGridPagerModes.Numeric.
firstText, previousText, nextText, lastText, permite sustituir los textos que aparecen por defecto en los enlaces de ir a la primera, anterior, siguiente y última página respectivamente. Inicialmente son los habituales “<<”, “<”, “>”, y “>>”.

Por ejemplo, observad el siguiente código, y su resultado en ejecución una vez hemos creado un par de reglas en la hoja de estilos del sitio web:

... <h2>Personash2> @grid.GetHtml(     fillEmptyRows: true,     alternatingRowStyle: "fila-alternativa",     headerStyle: "encabezado-grid",     footerStyle: "pie-grid",     mode: WebGridPagerModes.All,     firstText: "<< Primera",     previousText: "< Anterior",     nextText: "Siguiente >",     lastText: "Última >>",     columns: new [] {      ... // Definición de columnas vista anteriormente })

Asimismo, el propio constructor de WebGrid permite modificar también numerosos aspectos funcionales del grid mediante los siguientes parámetros:

defaultSort, que indica la columna que actuará como ordenación por defecto mientras no se especifique otra.
rowsPerPage (por defecto, 10), define el número de filas que aparecerán en cada página.
canPage, canSort, indican respectivamente si el grid va a permitir paginación y ordenación. Por defecto, true en ambos casos.
fieldNamePrefix, que permite indicar el prefijo que será utilizado en los parámetros del query string utilizados por el grid. Esto, por ejemplo, permitiría mostrar varios grids simultáneamente sobre la misma página, sin interferir en su funcionamiento.
selectionFieldName, sortFieldName, sortDirectionFieldName permiten indicar el nombre de los parámetros usados para mantener el estado de, respectivamente, la fila seleccionada, el campo de ordenación y el sentido de la ordenación.

WebGrid permite incluso el funcionamiento en modo Ajax, es decir, es capaz de mostrar las distintas páginas de datos sin necesidad de recargar la página completa. En este caso, podemos utilizar los parámetros ajaxUpdateContainerId y ajaxUpdateCallback, que permiten indicar respectivamente el elemento de la página donde serán mostrados los datos y una función callback que será llamada tras actualizar el elemento. Esto, si no se me olvida, lo veremos en otro post más adelante.

Y recapitulando…

A lo largo de este artículo hemos ido profundizando en el uso de WebGrid de forma progresiva, partiendo de un ejemplo realmente simple hasta abordar escenarios de personalización más avanzados. Espero que sirva para mostrar el uso y principales características de este útil y potente helper, que con toda seguridad nos ahorrará bastante trabajo en los proyectos MVC 3.

Sin embargo, ya he comentado anteriormente que no es oro todo lo que reluce… la paginación implementada por defecto por WebGrid es bastante ineficiente, puesto que necesita tener en memoria el conjunto de datos completo para ordenarlo y extraer únicamente la página solicitada. No es nada complicado implementar de forma correcta esta paginación, pero dado que este post ya ha quedado lo suficientemente extenso, dejaremos su explicación para un artículo posterior.

Ah, podéis descargar el proyecto de demostración desde mi Skydrive (requiere VS2010, MVC 3 y SQL Express).

Publicado en: Variable not found.

MVC 3 - Scaffolding - EF Code First SQL Compact

2011-10-25T15:39:00.000-03:00

MVC 3 - Scaffolding - EF Code First SQL Compact from Moisés Rivas on Vimeo.

Tutorial Nerddinner ASP.NET MVC 1

2011-10-25T15:32:00.001-03:00

El tutorial comienza en el ménu File->New Proyect de Visual Studio para crear un proyecto nuevo de ASP.NET MVC, y luego le vamos añadiendo funcionalidades y características de manera incremental. Entre otras cosas veremos cómo:

Crear una base de datos
Construir un modelo con validaciones y reglas de negocio.
Implementar listados/detalles de datos en la UI de un sitio con Controladores y Vistas.
Permitir el trabajo con datos (Crear, Actualizar, Eliminar)
Usar el patrón ViewModel para pasar información desde un controlador a una vista.
Reusar UI en un sitio con clases parciales y master pages.
Implementar paginado eficientes de datos.
Securizar una aplicación usando autenticación y autorización.
Usar Ajax para actualizaciones dinámicas.
Usar ajax para añadir mapeos interactivos.
Crear test unitarios automáticos (incluidos injección de dependencias y objetos mock).

La aplicación que creamos en el tutorial se llama “NerdDinner”. Permite una forma de organizar, hostear y buscar sitios en los que cenar online:

Scott Hanselman ha estado hosteando Nerddinners durante años, y viene con la idea de crear el tutorial sobre la aplicación que facilita esta tarea. También hostea una versión maquillada de la aplicación en www.nerddiner.com

Enlaces de descarga

El tutorial en PDF
Código fuente + test unitarios de la aplicación completa.
Para aprender más sobre el libro en la página oficial de Wrox.
Pedir el libro en Amazon.

Saludos!!

Herencia de clases y el "Principio de Liskov"

2011-10-12T15:03:00.000-03:00

En realidad se llama "Principio de sustitución de Liskov" y el nombre completo es Bárbara H. Liskov (sí, hay mujeres en la informática y han hecho grandes aportes ;-)).

A grandes rasgos dice que el famoso "es un" (is_a) que generalmente usan los docentes para enseñarnos "herencia de clases" no es suficiente.

No basta con "ser" hay que "comportarse como tal".

Generalmente hago el mismo chiste cuando trato el tema en un curso: "un docente es una persona, pero no basta, debe comportarse como tal".

Un ejemplo más real: Sistema de liquidación de sueldos

Si tienes un sistema que liquida sueldos, una clase base Empleado (con atributos como "sueldo" que se usa para calcular su pago) y subclases Gerente, Desarrollador, Administrativa y Becario (asumamos que el último no recibe ninguna remuneración).

Usas polimorfismo y en tu clase Administracion tienes un método liquidarSueldo donde recibirás objetos de tipo Empleado. Bien, cuando en un momento recibes de tu lista de empleados un becario... ¿qué debe hacer el sistema? (ya que haces el cálculo en base al valor que viene en el atributo sueldo y este es heredado por todos desde la clase Empleado).

¿Emitir un comprobante impreso pero con valor 0?
¿Agregar un "if" preguntando si es becario, y no hacer nada?
etc

Supongamos que el 1) no es aceptable por el gasto de papel y te piden que no se impriman (no tiene sentido), pasamos al punto 2), agregamos un "if".

¿No estamos "codificando a fuego" nuestro sistema para un comportamiento particular?

Estamos rompiendo el polimorfismo, justamente, el patrón estratégico más importante que tiene la POO. Cada vez que tenemos que cambiar nuestro código generamos nuevos costos y nuevos posibles errores.

Por eso cada vez nos cuesta más desarrollar un sistema, hasta que tenemos que tirarlo y desarrollar otro de cero... y empezamos otra vez con los problemas del mal diseño (code smell).

La base teórica

Los principios de diseño te dicen que "desarrolla cerrado al cambio y abierto a la extensión" (Principio Open/Closed, "Abierto / Cerrado").

Por ejemplo, tu código debe ser reutilizable (¿no es la idea esencial de la OO?) y con solo agregar código -sin tocar el existente- lograrás adecuarte a los cambios, a los nuevos requerimientos. No te olvides que nuestro código lo usan muchos otros objetos, si este cambiara, generaría un efecto en cadena, posiblemente, dejando de funcionar lo ya existente y tener que modificar más objetos.

Esta forma de "extensión" es agregar más clases a la herencia y el método liquidarSueldo no se modifica, pero si tu no haces correctas herencias, no puedes hacer lo primero, por lo tanto tu sistema se degradará en cascada.

Esta simple tontería el autor demuestra con muchos ejemplos que hacer "herencia por herencia", "por reutilizar código", no es suficiente y genera grandes problemas en los diseños.

Es una de las razones que me ven de mal humor cuando veo que implementan herencia a los golpes, prueba y error, con el argumento solo de "reutilizar código"

La conclusión final es...

El problema es que la herencia está mal formulada y que el Becario no se comporta como un Empleado, por lo tanto no puede ir en esa estructura jerárquica, de lo contrario nos va a obligar a desarmar nuestro sistema para tratar de ajustarlo a un comportamiento no adecuado (agregando condiciones explícitas para el mismo, hardcode) y este empezará a dejar de ser reusable.

No se puede hacer herencia por herencia, para reusar código. No se puede hacer herencia simplemente por que un "Becario es un Empleado", hay que estar seguro que además de "ser" se comporte como tal.

Nuestro becario, ya que no cobra una remuneración, no pude pasar por el sistema de liquidación de sueldos. La solución no es ajustar el sistema de sueldos para que lo permita.

Anexo otro artículo relacionado: Herencia Múltiple en PHP5

Nota: este post está basado en una discusión presentada en Foros del Web

Fuente: http://phpsenior.blogspot.com/2007/10/herencia-de-clases-y-el-principio-de.html

PATRONES DEFINIDOS POR MARTIN FOWLER

2011-10-10T19:19:00.003-03:00

Ver Pdf

Fuente

El patrón Modelo-Vista-Presentador (MVP)

2011-10-05T22:44:00.000-03:00

Desde hace tiempo llevo enfrentándome con diversos patrones de diseño cuyo objetivo principal es el de separar la interfaz de usuario de la lógica de las aplicaciones. Desde mis años de estudiante universitario con Smalltalk y el patrón Modelo-Vista-Controlador (MVC), hasta MVVM con WPF, pasando por MVP, MP y sus variaciones.

Cada vez que he tenido que me embarcaba a usar uno de estos patrones de diseño me encontraba con la misma curva de aprendizaje. Un concepto bastante sencillo pero que ante ciertos escenarios que encontraba en proyectos reales uno no sabe exactamente qué solución tomar.

En esta entrada quiero centrarme en el patrón de diseño Modelo-Vista-Presentador (MVP), pero yendo más allá de la descripción académica de este patrón y enfocándome en cómo puede ser aplicado en aplicaciones reales.

Como he comentado antes, MVP es otro patrón de diseño que tiene como objetivo separar la interfaz de usuario de la lógica de las aplicaciones.

Básicamente este patrón consiste en 3 componentes:

La vista. Compuesta de las ventanas y controles que forman la interfaz de usuario de la aplicación.
El modelo. Que es donde se lleva a cabo toda la lógica de negocio.
El presentador. Escucha los eventos que se producen en la vista y ejecuta las acciones necesarias a través del modelo. Además puede tener acceso a las vistas a través de las interfaces que la vista debe implementar.

El concepto de este patrón es bastante sencillo. Por un lado tengo la vista, que se encarga de mostrar la información al usuario y de interactuar con él para hacer ciertas operaciones. Por otro lado, tenemos el modelo que, ignorante de cómo la información es mostrada al usuario, realiza toda la lógica de las aplicaciones usando las entidades del dominio. Y por último tenemos al presentador que es el que “presenta” a ambos actores sin que haya ningún tipo de dependencia entre ellos.

El propósito del presentador tal y como se ha definido en este patrón no establece de manera clara el grado de control que este puede hacer de la vista.

Dependiendo de este grado de control podemos encontrarnos variaciones en la manera de ver MVP. De hecho, algunas de ellas, dejan de ser MVP para convertirse en MVC, por lo cual debemos tener cuidado.

MVP como Controlador Supervisado

Por un lado, podemos tener un presentador que no gestione la forma en que la información es mostrada en la vista. Es la vista quien define la lógica de cómo la información es formateada y mostrada en la pantalla a partir de los controles que contiene. En este caso, el presentador únicamente los casos más complejos para facilitar el trabajo de la vista. Martin Fowler llama a esta variación Controlador Supervisado.

Cuando la vista recibe algún evento de ratón o teclado por parte del usuario, delega el control del evento en el presentador. Este puede realizar ciertas operaciones relacionadas con la vista como el control del estado de los controles y después realizar la llamada a algún comando en el modelo que realice la operación requerida por el usuario. El modelo realiza las operaciones pudiendo realizar cambios en su estado generando el evento correspondiente, el cual es manejado por la vista para actualizar los controles de la pantalla.

Hay que tener en cuenta de que el hecho de que la vista pueda hacer referencia al modelo nos da como resultado un diagrama muy parecido al de MVC. Aunque este enfoque nos permita el uso de técnicas de Data Binding. Con lo cual la cantidad de código que la vista y presentador necesitan, se disminuye.

Este enfoque nos va a permitir el uso de técnicas de Data Binding sobre el modelo. Por tanto, la cantidad de líneas de código fuente en la vista y el presentador disminuyen. Si nos fijamos en el diagrama, este es similar al de MVC por lo que hay que tener mucho cuidado en no caer en un cambio de patrón.

MVP como Vista Pasiva

Por otro lado, podemos hacer que el presentador gestione totalmente cómo la información se muestra en la vista. Es decir, tenemos una vista "tonta", sin ningún tipo de lógica, cuya única función es la de mostrar la información que se le pasa a través de la interfaz de la vista. Martin Fowler llama a esta variación Vista Pasiva.

En este caso, cuando un usuario realiza alguna operación sobre la interfaz de usuario, la vista delega los eventos sobre el presentador. Este realizará algún cambio sobre la vista para indicar el cambio de estado y hará las llamadas a los comandos sobre el modelo para llevar a cabo la operación requerida por el usuario. Cuando el modelo provoque cambios en su estado, estos serán recogidos por el presentador (al contrario que en el controlador supervisado, que era la vista quien atendía a estos cambios de estado en el modelo), el cual pedirá al modelo los cambios realizados para luego actualizar la vista acorde a los cambios recibidos.

Ejemplo

Supongamos el siguiente ejemplo: Un programa que para una fecha que le introduzcamos, te diga si es pasado, futuro o la fecha del día actual.

Cuando el usuario introduce la fecha y pulsa el botón OK, la vista delega el evento de pulsación de botón sobre el presentador. El presentador toma la fecha introducida del cuadro de texto y valida que el contenido tiene el formato de fecha correcto.

Nota: He obviado la posibilidad de usar un control específico para introducir fechas y así ver en qué lugar se pude hacer la validación de datos.

Si la fecha introducida no fuera correcta, el presentador comunicaría al usuario este hecho a través de la vista.

En caso de que la fecha fuese correcta, el presentador realizaría la operación de comprobar la fecha usando el modelo. Al recibir el resultado de la operación, el presentador mostraría el resultado a través de la vista. Por ejemplo, modificando el texto de la etiqueta con el resultado.

En el siguiente diagrama vemos la secuencia de llamadas realizada para el caso de Vista Pasiva:

En caso de usar la variación de Controlador Supervisado, supondría que la vista toma el resultado directamente del modelo y que además, la vista define la lógica de cómo el resultado se muestra en la pantalla. En el caso de que la validación de la fecha fallara, el presentador podría, por ejemplo, enviar una excepción hacia la vista que al capturarla decidiría como se mostraría al usuario.

Actualización:
He creado en Codeplex un proyecto que hace uso de este patrón. Se trata de un sencillo ejemplo de máquina tragaperras sobre Windows Forms. El enlace al proyecto es este.

Fuente: http://theartoftheleftfoot.blogspot.com/2010/10/el-patron-modelo-vista-presentador-mvp.html

Patron Type Object

2011-10-05T20:43:00.000-03:00

(updated version in spanish here)

Desacopla instancias de sus clases para que estas puedan ser implementadas como una instancia de una clase. Type Object permite crear nuevas clases dinámicamente en tiempo de ejecución porque estas son instancias, y también permite al sistema crear instancias de esas class-like instancias.
A veces una clase no solo requiere un numero desconocido de instancias, sino que tambien una cantidad desconocida de subclases, Un objecto puede crear nuevas instancias, pero usualmente no puede crear nuevas clases sin tener que recompilar.

Cuando usar este patron?
-Las instancias de una clase necesitan estar agrupadas para implementar el comportamiento o los atributos del grupo.
-La clase necesita una subclase por cada grupo para implementar los atributos/comportamientos del grupo.
-La clase requiere una gran cantidad de subclases y/o la variedad total de subclases que quizas se requieren se desconoce
-Se necesita poder crear nuevas agrupaciones en tiempo de ejecucion que quizas no se predijeron durante el diseño.
-Se necesita poder cambiar una subclase de un objeto despues de que se instancio sin tener que mutar a una nueva clase.
-Se necesita jerarquizar los grupos recursivamente de modo que ese grupo sea a su vez un item de otro grupo.

Android Commander y QtADB: los 2 mejores programas para controlar Android desde el PC

2011-09-28T12:27:00.001-03:00

Uno de los puntos más flacos en Android es un buen programa para controlar nuestro teléfono desde cualquier PC. Por controlar me refiero a administrar archivos, aplicaciones, realizar capturas de pantalla, obtener información del sistema y demás. En varias ocasiones os hemos hablado de diferentes opciones, pero hoy os traigo dos señores programas.

Con todos vosotros, Android Commander y QtADB, canela fina señor@s.

Android Commander

Empezamos con este señor programa. Android Commander nos va a permitir hacer todo lo que queramos con nuestro teléfono y más. El programa está disponible tanto para Windows como Linux, y aunque está aún en versión beta, su rendimiento es muy alto. Os explico brevemente que hace cada una de las opciones de las que dispone

Administrador de archivos: Android Commander nos permite gestionar de manera sencilla el traslado de archivos entre nuestro PC y el Android. Una sencilla interfaz con dos ventanas nos va a permitir realizar dichas transferencias de la manera más sencilla y ordenada posible
Administrador de aplicaciones: Desde AC podremos instalar, desinstalar y administrar en general todas las aplicaciones que tenemos en nuestro teléfono
Shell Console: Para los usuarios más avanzados. Genial consola para controlar nuestro teléfono a nuestro antojo. Dispone además de una opción para ejecutar Shell Scripts con un sencillo click
Logcat: Para poder informar a los desarrolladores de lo que pasa en nuestro teléfono. La mayoría de nosotros no lo vamos a utilizar pero nunca está de menos tenerlo a mano
Flash/update image: Una de las opciones más útiles de AC. Con Flash/update image podremos flashear imágenes, updates y ROMs a nuestro teléfono directamente. Dispone de varias opciones de configuración, como la de poder realizar un wipe previo.
SingApk: A más de uno nos ha salido el mensaje de “No se puede flashear la rom por que no está firmada”. Pues con esta utilidad solventaremos ese problema en un plis ;)
Screenshot: Para realizar todo tipo de capturas de pantalla de nuestro teléfono. Fácil, sencillo, efectivo.
Virtual Input: Si no tienes ganas de ponerte a escribir con tu Android no hay problema. Con virtual input podrás controlar tu teléfono e introducir texto directamente desde tu PC.
Información de aplicaciones: Para obtener toda la información de cualquier aplicación (permisos, nombre, tamaño,etc)
SD Card: Un poco de información acerca de tu tarjeta de memoria
Modo Wifi: Si no quieres utilizar siempre tu cable, puedes utilizar Android Commander mediante WiFi

No está nada mal ¿no? Recordad que Android Commander está disponible tanto para Windows como Linux y de manera gratuita :D

Descarga Windows

Descarga Linux

Web Oficial

QtADB

QtADB es otra aplicación parecida a Android Commander. Dispone de un poco menos de opciones pero lo compensa siendo compatible con Windows, Linux y Mac. No me detengo a explicarlas, pero dispone de las siguientes funciones

Gestor de Archivos
Gestor de Aplicaciones
Shell
Capturas de pantalla
Recovery
Opciones varias

No está nada mal la aplicación, así que os recomiendo que le echéis un vistazo.

Descargas desde la web oficial

Fuentes: AddictiveTips por descubrirnos el genial AndroidCommander y hacer esas capturas y XDA por el gran QtADB

Primeros Pasos con Maven

2011-09-26T17:36:00.000-03:00

Pueden ver el siguiente articulo en :

http://www.chuidiang.com/java/herramientas/maven.php

Saludos

Google Maps con Android

2011-09-17T16:30:00.004-03:00

Todo el tutorial lo segui de :

http://codemagician.wordpress.com/2010/05/06/android-google-mapview-tutorial-done-right/

pero con algunos cambios, use api google 8 (la que es compatible con android 2.2) en la creacion del proyecto y en la creacion del disco ADV

Con respecto al codigo que copian en la pagina en la clase Hellogooglemaps2

deben remplazar la linea public class HelloGoogleMaps extends MapActivity POR

public class HelloGoogleMaps2 extends MapActivity

Si la aplicación les inicia correctamente pero con el mapa vacio, se debe a que la api key no es correcta. En mi caso me baje el SDK 7 y lo genere de la siguiente manera.

1-abren un cmd

C:\Program Files\Java\jdk1.7.0\bin>keytool -list -alias androiddebugkey -keystore "C:\Users\Rody\.android\debug.keystore" -storepass android -keypass android -v

Y Copian el que dice MD5:

el parametro -V es para que arroje el MD5 si no esta version de java no lo hace.

con el md5 brindado pude generar una key (se genera ACA) que me funciono a la perfección.

Les adjunto mi proyecto en Eclipse por las dudas.

Saludos

Como hacer un blog con ASP.NET y SQL Server 2005

2011-09-17T13:38:00.001-03:00

http://mredison.wordpress.com/2009/01/24/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-1/

http://mredison.wordpress.com/2009/01/24/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-2/

http://mredison.wordpress.com/2009/01/24/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-3/

http://mredison.wordpress.com/2009/01/24/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-4/

http://mredison.wordpress.com/2009/01/27/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-5/

http://mredison.wordpress.com/2009/01/28/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-6/

http://mredison.wordpress.com/2009/02/02/como-hacer-un-blog-con-aspnet-y-sql-server-2005-parte-7/

Pasar Musica del Iphone a la PC

2011-08-26T00:00:00.001-03:00

El unico programa que me resulto fue SharePOD y encima es GRATIS

http://es.kioskea.net/download/descargar-2801-sharepod

Saludos

Comprimir y Descomprimir archivos en .NET

2011-07-28T16:35:00.002-03:00

Public Class CompresionArchivos

Public Shared Sub ComprimirArchivos(archivoEntrada As String, archivoSalida As String)

Using SourceFile As FileStream = File.OpenRead(archivoEntrada)

Using DestFile As FileStream = File.Create(archivoSalida)

Using CompStream As GZipStream = New GZipStream(DestFile, CompressionMode.Compress)

Dim data(SourceFile.Length) As Byte

SourceFile.Read(data, 0, data.Length)

CompStream.Write(data, 0, data.Length)

End Using

End Sub

Public Shared Sub DescomprimirArchivos(archivoEntrada As String, archivoSalida As String)

Using SourceFile As FileStream = File.OpenRead(archivoEntrada)

Using DestFile As FileStream = File.Create(archivoSalida)

Using CompStream As GZipStream = New GZipStream(DestFile, CompressionMode.Decompress)

Dim data As Integer

data = CompStream.ReadByte()

While (data <> -1)

DestFile.WriteByte(CByte(data))

data = CompStream.ReadByte

End While

End Using

End Sub

http://carloslone.wordpress.com/2007/08/27/comprimiendo-archivos-en-net-20/

Niveles de Aislamiento

2011-07-18T11:54:00.002-03:00

http://zonacodigos.com/index.php/sql/66

Conexión remota a instancias de Windows Azure

2011-05-10T00:37:00.002-03:00

http://geeks.ms/blogs/ilanda/archive/2010/12/09/conexi-243-n-remota-a-instancias-de-windows-azure.aspx

Base de Datos SQL Server DB en la nube con SQL Data Sync

2011-05-10T00:37:00.001-03:00

http://comunidadwindows.org/blogs/sql/archive/2010/04/20/base-de-datos-sql-server-db-en-la-nube-con-sql-data-sync.aspx