miércoles, 5 de diciembre de 2012

Tranformando Contenido XML a HTML con XSL

En esta version, se ha mejorado considerablemente la transformacion de xml a html con XSL, pues ahora se maneja via un Database Object Type que puede ser un Table, View o un Stored Procedure.

el XSL se puede obtener de un archivo que tengamos en nuestro ordenador, o pedemos crear uno desde cero pues ahora se tiene un editor, y completado los pasos podemos ver el resultado en el navegador que tengamos por defecto.

Seleccionando un objeto:

lookup

Visualizando el xml:

xml

Obteniendo el XSL, en la cual podemos modificar y guardar los cambios

file

xsl

el resultado de la transformacion :

web

Esto tiene varias utilidades, como un visualizador de consultas o reportes, y exponerlo via web

lunes, 3 de diciembre de 2012

Implementado Template para Service Contracts en GenCode

 

Con el meta lenguaje creado para el GenCode, podemos hacer muchas cosas, entre ellas por ejemplo crear una plantilla para la generación de Service Contracts para poder usarlos en WCF

aca les pongo el template:

template

y una vez que hacemos el proceso de agregar proyectos y referenciarlos, vemos el proceso resultante en la generacion de una clase de tipo Interface, que se usa en WCF

code

El codigo resultante es lo que se define en el Template, en este caso optamos por las operaciones clasicas del patron CRUD, y vemos que tambien se sobreescriben los metodos obviamente con diferente firma.

jueves, 29 de noviembre de 2012

Data Contracts

Hoy por la tarde alguien de mis amigos me comento, se ve interesante pero generas Entidades clásicas pero nosotros usamos Data Contracts, … le dije entonces hagamos un template para ello.

using System;
using WcfSerialization = global::System.Runtime.Serialization;


namespace !namespace!
{
/// <summary>
/// Data Contract Class - DC!table_name!
/// </summary>
[WcfSerialization::DataContract(Namespace = "http://www.EmsvSoftware.com/DC!table_name!", Name = "DC!table_name!")]
public partial class !classname!
{

<region to="columns">
private !datatype! !colname!;
</region>


<region to="columns">
[WcfSerialization::DataMember(Name = "!colname!", IsRequired = false, Order = $index)]
public !datatype! !colname!
{
get{ return !colname!;}
set{!colname! = value;}
}
</region>
}
}

mejor una imagen para que se aprecie mejor
datacontracts

y bueno, en el GenCode, agregamos la solución y un proyecto de tipo entidad y le asignamos el template de Data Contracts que habiamos creado.


seldc


Y el resultado fue este:


Parte 1


dc1


Parte 2


dc2


Bueno se podría decir que esta en algo.

miércoles, 28 de noviembre de 2012

Espicificando un Template para uso del sp_xml_preparedocument con GenCode 2012 r 3.1

 

Tambien podemos agregar a nuestros templates de scripts de base de datos la generacion de procedimientos usando sp_xml_preparedocument, y asi poder hacer inserciones masivas a nuestras tablas mediante un xml

como seria el Template

template

La salida

resultado

jueves, 22 de noviembre de 2012

Video de como funciona GenCode 2012 r 3.1

Les doy a conocer la funcionalidad del nuevo generador en un video.

para que se visualize mejor en algunos casos hay que poner la calidad del video a 720 dpi HD

martes, 20 de noviembre de 2012

GenCode 2012 r 3.1 Test Stored Procedure

 

En este módulo a comparación de la version anterior no solo se ejecuta el stored procedure, si no que dependiendo del motor de base de datos nos va ha dar indicadores, por ejemplo en el caso de SQL las lecturas logicas y promedios de las lecturas y en el caso de Oracle podemos ver los números de las ejecuciones, el uso de la memoria entre otros.

Solamente hay que seleccionar el stored procedure y automaticamente se obtendrán los parámetros, en el cuál podemos editar y al momento de ejecutar podremos observar los resultados en la parte inferior en una grilla de datos y en la parte superior los indicadores.

Para SQL Server

llsql

Para Oracle

lloracle

martes, 13 de noviembre de 2012

Diccionario de Datos mejorado con GenCode

 

En las versiones anteriores sólo se limitaba a mostrar el nombre de la columna, el tipo de datos y la longitud, pues ahora esto ya no es así, pues tambien se ha incluido información de tipo de clave (PK, FK) y los comentarios que nos van a dar mayor información al momento de documentar nuestra base de datos o procesos que estemos generando código. En conclusion se mejora la herramienta para el desarrollador.

aca vemos el listado de tablas disponible al momento de seleccionar la base de datos

Capture

 

luego de ello, el resultado, ya que gracias  al rdlc, podemos exportar a Word, Excel y PDF

rep

sábado, 6 de octubre de 2012

GenCode 2012 r 3.1 (en construcción …..)

 

Demos una mirada a la nueva version del generador de código (en construcción).

Una de las caracteristicas principales es que se basa en plantillas (Template) en la que el usuario define el código que se va a generar ya sea en C# o VB.net.

Su diseño es más amigable y un entorno que es una fusión entre el IDE del SQL Server y características de Visual Studio.

Aca observamos el IDE principal con sus opciones de configuración con las cuales el motor del GenCode usa para poder generar código.

Capture

En esta imagen vemos la parametrizacion de los tipos de datos y sus equivalencias con el lenguaje de programación

datatype

 

Luego podemos configurar que libreria de acceso a datos queremos usar, como por ejemplo: DBType, SqlType, OracleType ya que es completamente configurable y asu vez definimos cual seria su parser segun el lenguaje de programación que definamos.

Ejemplos de Librarias, bueno podemos decidir entre usar ADO net clasico, Enterprise Library u Oracle Data Access Component, es completamente libre.

library

La parte más resaltante es el uso de template, como les mencione al inicio del post.

En esa sección se muestran las plantillas de proyecto (clases) a las cuales les definimos plantilla de código, que el Generador maneja con su propio motor y parser de lectura basado en XML y Regular Expresion

El parser del GenCode reconoce su propia sintaxis de marcado y sus propias funciones que devuelven los metadados que son reemplazados en las plantillas, haciendo al GenCode mas flexible.

template

templatedl

Aun estoy contruyendo las demas funciones, vamos lentos pero seguros.

Otra caracteristica que mencioné como fusion de Visual Studio, es que para generar código, tenemos que crear una Solucion y a esa solución empezamos a agregar los proyectos de clases donde se van a alojar con el codigo resultante, el acceso a la base de datos es muy similar a las versiones anteriores pero con ligeras variantes que poco a poco voy a mostrar.

solution

columns

Vamos viendo una de las mejoras en la opcion de conexion al servidor de datos, el cual es la base de la generación de código

gcEntity

gcdl

 

solexplorer

vale mas una imagen que mil palabras y observamos los resultados en el Solution Explorer en el que se van agregando las clases generadas

 

 

 

 

 

 

 

Como se agregan los proyectos a la solucion y definimos la plantilla a usar, pues en la siguiente imagen se los muestro

addprojectEntity

lunes, 13 de agosto de 2012

Crear un Web Test en VS 2010

Es común preguntarse si nuestras aplicaciones tienen un buen rendimiento, y para ello Visual Studio nos provee de herramientas que nos van a permitir generar indicadores para tomar desiciones y mejorar nuestros aplicactivos

para ello aca les pongo un ejemplo muy sencillo de una página que obtiene data Dummy.

 

dummy2

 

Primero agregamos un proyecto de Test

 

Capture

 

Luego agregamos el Test

addwebTest

 

Luego seleccionamos Web Performance Test

 

addwebTest2

 

 

y automaticamente se inicia Internet Explorer, que nos va a permitir capturar los Response y Request, de forma automática conforme naveguemos en la aplicación o en la páginas

para ello ingresamos la url del aplicativo y nos carga un grid con la data dammy, suficiente pare generar response y request.

 

capturewebtest

 

Para finalizar la captura hacemos click en el boton stop y los parámetros son obtenidos por el visual studio

stop

 

par

 

Ejecutar el webtest

 

runwebtest1

 

Resultado de correr el webtest, nos indicara si paso exitosamente

runwebtest

 

Request

request

 

Response

response

 

Context

context

 

Hasta aquí, solo muestro los pasos para generar un webtest, ya que nos brinda información valiosa,

ya que podemos hacer que se ejecute en un loop, por ejemplo podemos hacer que esta página de pruebas se ejecute en un loop de 100 y ver el comportamiento de la página

y la parte final de esto es generar los Load Test que nos brinda información de los contadores, ya que aqui es donde realmente se va a estresar la aplicacion con la cantidad de usuarios concurrentes que le indiquemos y para ellos necesitamos generar código de los webtest que es un paso muy sencillo que los tocaremos en otro momento.

 

Espero les sirva de ayuda

miércoles, 25 de abril de 2012

Consumiendo WCF con Web Client Software Factory

Anteriormente ya explicamos como implementar dicha arquitectura, y para este caso de ejemplo vamos a usar ASP.NET Web Application.

01

y busquemos tener esta estructura en la cual mas abajo explico como agregar las capas:

02

seguido, agreguemos una carpeta Solución a la Solución creada con el nombre Source y agregaremos las capas de datos, entidades, y logica (es decir agregamos proyectos)

 

03

 

de la misma manera agreguemos una carpeta solucion para los servicios WCF

04

la clase ICustomerServices va a contener la interfaz o el contrato que se va a exponer para el servicio

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using Test.Entity;

namespace Test.WCFServices
{
    [ServiceContract]
    public interface ICustomerServices
    {
        [OperationContract]
        List<e_Customer> GetCustomer();
    }
}

donde e_customer es la entidad definida en nuestra capa Entity ubicada en Source

y el Servicio WCF:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using Test.Entity;
using Test.BusinessLogic;

namespace Test.WCFServices
{
     public class CustomerServices : ICustomerServices
    {
        public List<e_Customer> GetCustomer()
        {
            List<e_Customer> objList = new List<e_Customer>();
            objList = new bl_Customer().GetCustomer();

            return objList;
        }
    }
}

Ahora tenemos que definir nuestro host, para levantar el servicio WCF, y esto lo creamos el la carpeta Host y agregamos una aplicación de tipo consola

05

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test.WCFServices;
using System.ServiceModel;
using System.ServiceModel.Description;

namespace ConsoleApplicationHost
{
    class Program
    {
        private static ServiceHost customerServices;

        static void Main(string[] args)
        {
            CreateServiceHost();
            OnStart();
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("\n\nPresione una tecla para finalizar el Service Host:");
            Console.ForegroundColor = ConsoleColor.White;
            Console.ReadKey();
            OnStop();
        }

        private static String GetEndpointAddresses(ServiceDescription svDescripcion)
        {
            StringBuilder ostringBuilder = new StringBuilder();
            foreach (System.ServiceModel.Description.ServiceEndpoint serviceEndPoint in svDescripcion.Endpoints)
                ostringBuilder.AppendFormat("\n\t{0}", serviceEndPoint.Address.ToString());

            return ostringBuilder.ToString();
        }

        private static void CreateServiceHost()
        {
            try
            {
                //variableServicio = new ServiceHost(typeof(nombreServicio_del_ServiceImplementation));
                customerServices = new ServiceHost(typeof(CustomerServices));


            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
            }
        }

        private static void OnStart()
        {
            try
            {
                customerServices.Open();
                OutputServiceInformation(customerServices);
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
            }
        }

        private static void OnStop()
        {
            try
            {
                customerServices.Close();

            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
            }
        }

        private static void OutputServiceInformation(ServiceHostBase serviceHost)
        {
            string endpointAddresses = GetEndpointAddresses(serviceHost.Description);
            Console.WriteLine(string.Format("\n\r El servicio {0} se está ejecutando en :{1}{2}", serviceHost.Description.Name, Environment.NewLine, endpointAddresses));
        }
    }
}

y asu vez tenemos que usar la herramienta de editar WCF o lo podemos hacer directamente editando el archivo app.config de la consola, donde definiremos los EndPoints, los binding (http y tcp)

<system.serviceModel>
      <behaviors>
        <serviceBehaviors>
          <behavior name="ServiceBehavior">
            <dataContractSerializer />
            <serviceDebug />
            <serviceMetadata httpGetEnabled="true" />
            <serviceTimeouts />
          </behavior>
        </serviceBehaviors>
      </behaviors>
      <services>
        <service behaviorConfiguration="ServiceBehavior" name="Test.WCFServices.CustomerServices">
          <endpoint binding="basicHttpBinding" bindingConfiguration=""
            name="http_customer" contract="Test.WCFServices.ICustomerServices" />
          <endpoint binding="netTcpBinding" bindingConfiguration="" name="tcp_customer"
            contract="Test.WCFServices.ICustomerServices" />
          <host>
            <baseAddresses>
              <add baseAddress="
http://localhost:9015/WCF/service/CustomerServices" />
              <add baseAddress="net.tcp://localhost:9016/WCF/service/CustomerServices" />
            </baseAddresses>
          </host>
        </service>
      </services>

    </system.serviceModel>

probando que funcione el Host: solo ejecutamos nuestra aplicación de consola en modo administrador y si todo esta correcto veremos la siguiente pantalla la cual quiere decir que nuestro servicio esta listo para consumirlo

06

Para consumir el servicio tenemos que referenciarlo al Module de la arquirectura que estamos WCSF usando y la ruta a usar es la de http:// ……..

07

Para consumir el Servicio, lo hacemos en la clase presentadora de la vista que queremos ejecutar, para este caso usaremos la pagina Default.aspx

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Practices.ObjectBuilder;
using Microsoft.Practices.CompositeWeb;
using Test.SolWCSF.Shell.SrvCustomer;


namespace Test.SolWCSF.Shell.Views
{
    public class DefaultViewPresenter : Presenter<IDefaultView>
    {
        public DefaultViewPresenter()
        {

        }

        public List<e_Customer> Get()
        {
            List<e_Customer> obje = new List<e_Customer>();
            using (CustomerServicesClient oProxy = new CustomerServicesClient("tcp_customer"))
            {

                obje = oProxy.GetCustomer();
            }
            return obje;
        }  
    }
}

como podrán observar creamos un proxy, en la cual le pasamos el nombre del EndPoint que definimos en el app.config

al hacer esto en la clase presentadora, ya lo tenemos referenciado en nustra pagina aspx, y poderlo utilizar, y con esta clase podemos pintar una grilla

 

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Test.SolWCSF.Shell.Views;
using Microsoft.Practices.ObjectBuilder;

using System.Collections.Generic;

public partial class ShellDefault : Microsoft.Practices.CompositeWeb.Web.UI.Page, IDefaultView
{
    private DefaultViewPresenter _presenter;

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!this.IsPostBack)
        {
            this._presenter.OnViewInitialized();
        }
        this._presenter.OnViewLoaded();

        this.GridView1.DataSource = _presenter.Get();
        this.GridView1.DataBind();
       
       
    }

[CreateNew]
    public DefaultViewPresenter Presenter
    {
        get
        {
            return this._presenter;
        }
        set
        {
            if (value == null)
                throw new ArgumentNullException("value");

            this._presenter = value;
            this._presenter.View = this;
        }
    }
}

El resultado se veria asi:

08

viernes, 20 de abril de 2012

Web Client Software Factory

WCSF, es una arquitectura de desarrollo  que incorpora buenas practicas y patrones de diseño tales como Application Controller, que se encarga de la logica de navegacón de las páginas asi como el flujo. el MVP (Model View Presenter) para el despliegue visual y el manejo de eventos, donde la vista maneja los controles de la página.

A mi parecer es una buena opcion para controlar nuestras UI en nuestros proyectos web, y ahora veamos los pasos de instalación.

  1. Tener instalado el Service Pack del Visual Studio 2010
  2. Instalar el SDK.
  3. Instalar el GAX2010.VSIX
  4. Instalar el GAT2010.VSIX
  5. Instalar el WCSF2010.VSIX

todo esto lo pueden descargar de la siguiente página:  patterns & practices Developer Center

Ahora, como usarlo:

 

Creamos una nueva Solucion

de tipo Web Client Software Factory, esto se encuentra en la sección de Guidance Packages.

1

y nos muestra como se estructura la solucion y los assemblies a cargar

2

Seguido de esto se autogenera la arquitectura.

3

Podemos observar las carpetas que se generan con los proyectos que forman parte de esta arquitectura MVP.

 

 

 

 

 

 

 

 

 

 

 

 

 

Agregando una nueva Página

Damos click derecho en el proyecto web, o en la carpeta donde queremos alojar nuestra nueva página aspx. y seleccionamos la opcion Web Client Software Factory / Add Page (with presenter)

4

y nos muestra una UI, para colocar el nombre de la pagina, y en donde se va alojar el Presenter de la pagina asi como su interfaz (IView)

5

y veremos que se generan dentro del proyecto Shell la clase presentadora y su interfaz

6

 

El resultado de la vista lo vemos en el explorador

7