Probando Firebird Embedded con C#

Bases de datos, Desarrollo de software, Windows October 14th, 2008

Desde hace mucho tiempo tengo planeado desarrollar una aplicación cuya versión 0.1 desarrollé hace ya varios años en C++ y Fox Toolkit, perdida ya en el museo del olvido.

La aplicación es muy sencilla.  Inicialmente son dos módulos pero la idea es agregarle después algunos otros.  El problema es que cada vez que me siento a pensar en ella termino haciendo un diseño complejo y lleno de cositas que me pondrían a estudiar.  Esto no sería malo sino fuera porque de esta manera se va a terminar cuando el tiempo tienda a infinito.

Por esto he cambiado mi plan.  Voy a hacer una aplicación pequeña y la voy a ir hacer creciendo, aunque esto signifique que alguna versión deba volverla a hacer desde scratch (cero).

Con respecto al lenguaje de programación había elegido Java para retomar mi estudio pero en medio de la moda local y temporal de .NET he decidido empezar a implementar en C#.

El primer reto a resolver es la escogencia de un motor de base de datos ya que la aplicación va a ser pequeña, me interesa que se pueda ejecutar en equipos no necesariamente robustos, no quiero despilfarrar recursos y quiero que la instalación y copia de seguridad sean fáciles: sólo copiar archivos.  Por esto he pensado en utilizar una base de datos basada en archivos o embedded.

Para Java hay varias de donde escoger, pero para .NET la oferta, al parecer, no es tan amplia.  Encontré SQLite (ya lo he utilizado varias veces pero he tenido problemas con bloqueos) VistaDB (comercial, no me sirve) y a SharpHSQL hermanita de HSQL (Java) para .NET, sin embargo no estoy seguro de cuan activo está ese proyecto.  Las mejores opciones por ahora parecen ser FireBird Embedded y SQL Server Compact, ambas prometen muchas cosas, incluyendo un bajo footprint ~ 2MB.

Para la primera prueba elegí a FireBird ya que esa fue la primera base de datos que utilicé en un proyecto después de graduado como ingeniero y me unen a ella emotivos recuerdos :-)

Instalación.

Para desarrollar una aplicación con FireBird inmerso se requieren dos recursos.

El FirebirdClient se instala como cualquier aplicación Windows sin ninguna opción específica.  Me imagino que habrá que instalarlo también en los clientes cuando se haga el despliegue (por confirmar).

La distribución se debe descomprimir y mover los siguientes archivo al mismo directorio donde se encontrará el archivo ejecutable de la aplicación: <ruta>\bin\Debug (desarrollo) o <ruta>\bin\Release (producción).

  • fbembed.dll
  • icudt30.dll
  • icuin30.dll
  • icuuc30.dll
  • firebird.conf
  • firebird.msg

Para la implementación del proyecto estoy utilizando Visual C# Express 2008 y en él es necesario incluír la referencia a FirebirdSql.Data.FirebirdClient instalada con el Data Provider.

Creación de la cadena de conexión.

Es fácil construír la ConnectionString con la ayuda del FbConnectionStringBuilder de la siguiente manera.

            FbConnectionStringBuilder csb = new FbConnectionStringBuilder();

            csb.ServerType = FbServerType.Embedded;
            csb.UserID     = "SYSDBA";
            csb.Password   = "masterkey";
            csb.Dialect    = 3;
            csb.Database   = @"data\database.fdb";
            csb.Charset    = "UTF8";

Sólo los parámetros ServerType y Database son obligatorios, los demás son opcionales y puede encontrarse mayor información sobre ellos en ConectionStringParameters, también se puede encontrar mayor información acerca de los Charset disponibles en Firebird Character Sets and Collations.

La ubicación de la base de datos (parámetro Database) es relativo a la ubicación del archivo fembed.dll, es decir, al ejecutable de la aplicación.

Creación de la base de datos.

Desde la misma aplicación es posible crear la base de datos (manera programática) a la cual hace referencia la cadena de conexión.

           FbConnection.CreateDatabase(csb.ToString());

Debe tenerse en cuenta que la ruta de directorios bajo la cual se ubicará la base de datos ya debe existir previa la creación del archivo de datos, de lo contrario la creación fallará.

Conexión a la base de datos.

          con = new FbConnection(csb.ToString());
          con.Open();

Verificación del estado de la conexión.

            if (con.State == System.Data.ConnectionState.Open)
                Console.WriteLine("Established");
            else
                Console.WriteLine("NOT established");

Otros posibles estados definidos por ConnectionState son Broken, Closed, Connecting, Executing y Fetching.

Verificación de la existencia de una tabla.

            FbCommand cmd = new FbCommand("SELECT COUNT(RDB$RELATION_NAME)" +
                                          "FROM RDB$RELATIONS WHERE (RDB$RELATION_NAME = 'users')" +
                                          "AND RDB$VIEW_SOURCE IS NULL", con);

            int tableCount = (int)cmd.ExecuteScalar();

            if (tableCount == 0)
                Console.WriteLine("No");
            else
                Console.WriteLine("Yes");

Verifica la existencia o no de la tabla users en la base de datos conectada.

Ejecución de un INSERT.

            String sql = "INSERT INTO \"users\" VALUES ('" + user[0] + "', '" + user[1] + "')";
            cmd = new FbCommand(sql, con);
            cmd.ExecuteNonQuery();

Ejecución de una consulta de datos.

            String select = "SELECT username, name FROM \"users\"";
            cmd = new FbCommand(select, con);
            FbDataReader reader = cmd.ExecuteReader();

            try
            {
                while (reader.Read())
                {
                    String username = reader.GetString(0).Trim();
                    String name = reader.GetString(1).Trim();

                    Console.WriteLine("\t{'" + username + "', '" + name + "'}");
                }
            }
            finally
            {
                reader.Close();
            }

Finalización de la conexión.

            con.Close();

Conclusiones.

Esta primera aproximación fue sencilla, práctica y funcional.  Se encuentra buena documentación del motor de base de datos y movimiento en los foros en su respecto.  A pesar de que, al menos por estas latitudes, no es muy utilizada Firebird parece ser que en otras partes si lo es.

Los archivos requeridos (dlls) ocupan 2.87MB mientras que todos los archivos, incluyendo los opcionales, ocupan 4.94MB.

Voy a revisar también cuan viable es utilizar el SQL Server Compact, sin embargo en los últimos días que hemos tenido un poco de contacto con SQL Server han aparecido con él algunos detalles desagradables que desde mi punto de vista de conocer poco acerca de este motor, me desaniman de utilizarlo.  Ya veremos.

Enlace: Aplicación de prueba - Firebird Embedded Demo 0.1.

Tags: , , ,

Mis primeras estrellitas

Desarrollo de software, Web, Windows September 28th, 2008

Entre viernes y sábado gané mis primeras estrellitas del Desarrollador Cinco Estrellas.  Pude sacar el tiempo para presentar los siguientes exámenes.

Estrella #0:

Fundamentos de la programación.

Estrella #1:

.NET Framework.

C#.

Estrella #2:

Aplicaciones web con ASP.NET.

Aplicaciones Windows con WinForms.

Mi segunda estrellita.

Esta semana va a estar un poco difícil que vuelva a dedicar un tiempo a estas labores astronómicas, sin embargo voy a hacer mi mejor esfuerzo.

Tags: , , ,

Resumen - Aplicaciones Windows con WinForms

Desarrollo de software, Windows September 27th, 2008

Winforms: .NET Framework Class Library -> aplicaciones de escritorio.


Diseñador de formularios:

  • Genera el código del formulario diseñado y de los componentes incluídos en él.
  • Partial Class permite separar la implementación de una clase en varios archivos fuente -> separar la lógica de la aplicación (organización).

Objeto Form:

  • Opacity: transparencia (int 0 - 1).
  • Size: tamaño (Size).
  • Location: ubicación (Location).
  • Show(): mostrar.  Permite especificar su propietario.
  • ShowDialog(): permite mostrar un diálogo de su propiedad, incluyendo uno modal (no permite tomar el foco por otro formulario mientras se esté mostrando).

Manejo de eventos:

  • Por cada evento generado es posible implementar varios métodos manejadores.
  • Un método manejador de eventos puede recibir notificaciones de eventos generados en varios objetos.
  • Es posible cancelar el tratamiento por defecto del evento manejado con e.Handled = true.

Eventos del Form: ciclo de vida.

  • Load: se encuentra recién cargado, aún no se muestra al usuario.
  • Paint: es dibujado incluyendo a sus controles recursivamente.
  • Activated: recibe foco.
  • FormClosing: el proceso de cierre a sido iniciado.  En este punto es posible manipularlo y si es necesario, cancelar el cierre.
  • FormClosed: ha sido cerrado.
  • Disposed: ha sido destruído.

Eventos del ratón:

  • MouseClick: se hizo click con el ratón.
  • MouseEnter: el puntero del ratón entró a un componente.
  • MouseMove: el puntero del ratón ha sido movido dentro del componente.

Eventos de teclado:

  • KeyPress: tecla presionada.  Representa una pareja de eventos Up y Down sucesivos.  e.KeyChar especifica cual.
  • KeyDown: tecla hundida.
  • KeyUp: tecla liberada.
  • HelpRequested: se presionó F1.

Manipulación del foco:

  • CanFocus: (true/false) puede el control tomar el foco ?
  • Focused: (true/false) tiene el control el foco ?
  • Focus(int): asigna el foco al componente especificado.
  • TabIndex: especifica el órden de movimiento del foco.

Controles WinForms:

  • MaskedEdit: máscaras para la entrada de datos.
  • Textbox: cuadro de texto con facilidad para autocompletar.
  • Label: etiqueta de texto.
  • Datagrid: tabla de datos.  Permite enlazar información de una base de datos de manera dinámica.
  • TreeView: estructura tipo árbol.

Controles contenedores:

  • Pueden contener a otros controles a su vez.
  • Heredan de ContainerControl.
  • Tienen acceso directo a los controles de primer nivel unicamente (acceso recursivo).
  • Ejemplo: Form, Panel, GroupBox.

Menús de un Form.

  • MenuStrip: es un contenedor de otros objetos: ToolStripMenuItem, ToolStripComboBox, ToolStripSeparator, ToolStripTextBox.
  • ContextMenuStrip: menú contextual (botón derecho del ratón).  Se puede componer de igual manera que el MenuStrip.
  • MergeAction/MergeIndex del ToolStripItem controlan la forma como se mezclarán las opciones del menú de dos ventanas.

Snaplines: líneas imaginarias que el diseñador de formularios muestra para ayudar con el diseño de los formularios.


Document Outline: permite visualizar la jerarquía de componentes del formulario.


Layout Panels: controla la disposición de elementos sobre el formulario.

  • TableLayoutPanel: ubica elementos al estilo tabla.  Redimensionable.
  • FlowLayoutPanel: los controles fluyen a medida que se van agregando.

Anchor: propiedad que permite 'anclar' a un componente a uno o varios bordes del formulario para modificar su presentación de acuerdo con el redimensionamiento de este último.

Dock: permite fijar un componente a uno de los bordes de la ventana para modificar su ubicación de acuerdo con el redimensionamiento de este último.


Controles ExtenderProviders: agregan nuevas propiedades a los componentes del formulario.

  • ErrorProvider: asocia un error a un componente -> ícono que parpadea.
  • HelpProvider: asocia una cadena de texto de ayuda a un componente -> presión de F1.
  • ToolTip: asocia un tip a un componente que se muestra cuando tenga el puntero del ratón encima.

Propiedades dinámicas:

  • Variables de configuración asociadas a la aplicación.
  • Incluyen nombre, tipo de datos, alcance (usuario/aplicación) y valor.
  • Se pueden relacionar (binding) con un componente.

Diálogos comúnes:

  • Tipos:
    • ColorDialog
    • PrintDialog
    • SaveDialog
    • OpenDialog
  • Permiten interactuar con el usuario para realizar acciones comúnes.
  • Basados en el sistema operativo.
  • Facilidad para el desarrollador: evita que deba desarrollarlos él mismo.
  • Facilidad para el usuario: acostumbrado a las interfaces del OS.

Enlace a datos:

  • El atributo DataSource define el orígen de una fuente de datos para un componente.
  • El objeto BindingSource permite el enlace con fuentes de tres tipos.
    • DataBase.
    • WebService.
    • Object: clase de negocio.
  • Trabajan muy bien en conjunto con DataBindingNavigator y DataGridView.
  • También es posible enlazar datos con ADO.NET.

ClickOnce: incorporado por .NET 2.0.

  • Distribución de la aplicación.
  • Instalación.
  • Actualización.
  • Versionado.
  • Rollback de la instalación.

Tags: ,

Resumen - Aplicaciones Web con ASP.NET

Desarrollo de software, Web September 27th, 2008

Aplicación web es un conjunto de páginas HTML transmitidas por HTTP.
ASP.NET es un framework/ambiente para el desarrollo de aplicaciones web de manera similar a las aplicaciones de escritorio.


IIS: FTP, SMTP, NNTP, HTTP/HTTPS.


HTML Forms -> <form></form>
Submit -> Postback
Method: {post, get}


Web Form componente fundamental de ASP.NET. (.aspx)

  • Es una página en lenguaje de marcas.
  • Indenpendencia del cliente.
  • Permite utilizar cualquier lenguaje .NET.
  • Permite desarrollar servicios web XML.
  • Es compilado.
  • Actualizado sin reiniciar.

Code Behind: asociados a las Web Forms con la implementación del comportamiento del lado del servidor.  Se enrriquece con el aprovechamiento de Partial Class.


Archivos de configuración en XML.

  • web.config: información común a toda la aplicación.
  • machine.config: por servidor.
  • global.asax: eventos a nivel aplicación: {Application_Start, Application_End, Session_Start, Session_End}

Controles de servidor HTML: componentes que se ejecutan del lado del servidor.

  • Encapsulan parte de la interfaz de usuario.
  • runat="server".
  • Mantienen su estado (Viewstate): a nivel de control, página o aplicación.
  • Atributos Id, Text.

El ViewState por defecto viene activo para formularios, puede activarse con la propiedad EnableViewState.


Controles de servidor Web: Web Controls.

  • Sólo accesibles desde el servidor.
  • No corresponden únicamente con los HTML.
  • Utilizan un namespace XML diferente del por defecto.

Validadores: validan el contenido de campos del usuario:

  • Validadores mas utilizados.

    • RequiredFieldValidator.
    • CompareValidator.
    • RangeValidator.
    • RegularExpressionValidator.
    • CustomValidator.
    • ValidationSummary.
  • Page.IsValid -> verifica si se cumplieron todas las validaciones.
  • No disponible en Init ni Load.

Controles de servidor: UI rica encapsulada.

Controles de usuario:

  • Reutilización de código y componentes UI.
  • Extensión .ascx.
  • Escritos en HTML y código xxx.NET.
  • <%@ Control Language="xxx" %>
  • Autocontenidos.
  • Escritos en diversos lenguajes.
  • Se deben registrar.
    <%@Register TagPrefix="MiPrefix" TagName="MiEtiqueta" Src="header.ascx" %>
  • Para ser utilizados.
    <MiPrefix:MiEtiqueta id=“MiId” runat=“server”> </MiPrefix:MiEtiqueta>
  • Se convierten en un objeto.

Eventos de un Web Form:

  • Evento en el cliente.
  • Envío de mensaje.
  • Procesamiento del mensaje.
  • Ejecución del manejador adecuado.
  • Envío de respuesta al cliente (Post Back).

Manejo de eventos:

  • Cliente: en el componente se especifica su manejador: onClick='botonClick'
  • Servidor: un método Code Behind maneja el evento: protected void botonClick(object sender, EventArgs e).

Ciclo de vida de una página:

  • Inicialización de objetos
  • Carga View State
  • Procesa datos del post
  • Carga de la página
  • Eventos Post Back
  • Graba View State
  • Render
  • UnLoad

Autenticación de usuario:

  • Windows.
  • Formularios (personalizado).
  • MS Passport.

Utiliza un ticket de autenticación -> cookie.


Mecanismos para mantener el estado:

  • Application state: global, accesible desde toda la aplicación.  Objeto Application.
  • Session state: limitado a la sesión del navegador.  Objeto Session.
  • View state: entre las solicitudes de la misma página (campos de formulario).  Implementado mediante un campo oculto del formulario.

Master Pages: plantillas generales.

  • Directiva @Master en lugar de @Page: <%@ Master Language="C#" CodeFile="MasterPage.master.cs"   Inherits="MasterPage" %>

Las páginas de contenido seleccionan su Master Page con el atributo MasterPageFile de la directiva @Page.


Skin: definiciones de formato y estilo para los controles de servidor.  Archivos .skin.
Themes: paquetes de skins.  Incluyen recursos: CSS, imágenes, etc.  Carpeta APP_Themes.
Son configurables a nivel de máquina (Machine.config), aplicación (web.config) o página (@Page).


Enlace de datos: relaciona a un control que despliega datos con el objeto que administra su fuente.

  • ObjectDataSource: control -> capa del negocio.
  • SqlDataSource: control -> base de datos relacional.
  • XmlDataSource: control -> fuente XML.

Controles visualizadores: DataGridView, DetailsView, FormView.


Compilación de sitios ASP.NET:

  • La compilación se realiza de manera automática según es solicitada por request del cliente.
  • Es posible realizar la pre-compilación del sitio con el comando Aspnet_compiler.exe para su distribución binaria.

Tags: ,

Serialización de objetos en XML con C#.NET

Desarrollo de software, Windows September 14th, 2008

De manera análoga a como en Java es posible realizar la serialización de clases a XML, encontré que también es posible hacerlo en C#.NET.  Para esto es necesario que la clase a ser serializada exponga los atributos que desea publicar a través de propiedades.

Para la demostración creé una clase XMLSerializable de la cual heredarán las otras que requieran de este tipo de serialización.  Esta clase abstracta provee los métodos load y save para realizar automáticamente la serialización de sus hijos.

La serialización de los objetos se realiza con el siguiente código.

        public void save(String filename)
        {
            // Creates the writing stream
 
            StreamWriter w = new StreamWriter(filename);
 
            // Creates the XML serializer with its type
 
            XmlSerializer s = new XmlSerializer(this.GetType());
 
            // Serializes the object (this self -&gt; son)
 
            s.Serialize(w, this);
 
            // Closes the output stream
 
            w.Close();
        }

La carga de objetos serializados requiere de un par de verificiones adicionales.

        public bool load(String filename)
        {
            bool success = false;
 
            // Checks if the source file exists, otherwise there is nothing to do
 
            if (File.Exists(filename))
            {
                // Creates the reading stream
 
                StreamReader sr = new StreamReader(filename);
 
                // Creates the text reader from the stream
 
                XmlTextReader xr = new XmlTextReader(sr);
 
                // Creates the XML (de)serializer with its type
 
                XmlSerializer xs = new XmlSerializer(this.GetType());
 
                // Temporary storage object
 
                object c;
 
                // Checks if the received data can be deserialized
 
                if (xs.CanDeserialize(xr))
                {
                    // Deserialize the incoming data
 
                    c = xs.Deserialize(xr);
 
                    // Gets the type (definition) of the object
 
                    Type t = this.GetType();
 
                    // Retrieve the exposed attributes by properties
 
                    PropertyInfo[] properties = t.GetProperties();
 
                    // Walks thru all properties and loads its values on
                    // the local attributes
 
                    foreach (PropertyInfo p in properties)
                    {
                        p.SetValue(this, p.GetValue(c, null), null);
                    }
 
                    success = true;
                }
 
                // Closes the reader and the stream
 
                xr.Close();
                sr.Close();
            }
 
            return success;
        }

Con estas facilidades se crea una clase Empleado con atributos básicos.

    public class Empleado : XMLSerializable
    {
        ////////////////////////////////////////////////////////////////
 
        private int      codigo;
        private String   nombre;
        private float    salario;
        private DateTime fechaNacimiento;
 
        ////////////////////////////////////////////////////////////////
 
        // Resto del codigo
    }

Es necesario para la serialización que el objeto tenga propiedades de los atributos a exponer.

        public int Codigo
        {
            get { return codigo; }
            set { codigo = value; }
        }
 
        public String Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }
 
        public float Salario
        {
            get { return salario; }
            set { salario = value; }
        }
 
        public DateTime FechaNacimiento
        {
            get { return fechaNacimiento; }
            set { fechaNacimiento = value; }
        }

También es necesario que la clase cuente con un constructor sin parámetros además de los que requiera normalmente.

        public Empleado()
        {
            this.codigo          = -1;
            this.nombre          = "Sin nombre";
            this.salario         = -1;
            this.fechaNacimiento = new DateTime(1990, 01, 01);
        }
 
        ////////////////////////////////////////////////////////////////
 
        public Empleado(int codigo, String nombre, float salario, DateTime fechaNacimiento)
        {
            this.codigo          = codigo;
            this.nombre          = nombre;
            this.salario         = salario;
            this.fechaNacimiento = fechaNacimiento;
        }

Por facilidad también se sobreescribió el método ToString() para generar su representación en cadena.

        override public String ToString()
        {
            return String.Format("[Empleado: codigo = {0}, nombre = \"{1}\", salario = ${2}, fechaNacimiento = {3}]",
                                    this.codigo, this.nombre, this.salario, this.fechaNacimiento);
        }

Con todo esto, la aplicación de prueba crea en el primer paso a un objeto Empleado y le da valores iniciales a sus atributos, después de esto solicita su serialización.

            Empleado empleado = new Empleado(123, "Pepito Pimentón", 123456.789f, DateTime.Now);
            empleado.save("empleado.xml");

Posteriormente se crea un segundo Empleado que almacenará la información recuperada de la serialización.  Si la prueba tiene éxito, la información de los dos Empleados deberá coincidir.

            Empleado empleado2 = new Empleado();
            empleado2.load("empleado.xml");

La información presentada a través de salida estándar al ejecutar la aplicación de demostración deberá ser algo similar a lo siguiente.

Writing Object: [Empleado: codigo = 123, nombre = "Pepito Pimentón", salario = $123456,8, fechaNacimiento = 14/09/2008 11:12:10 p.m.]
Read Object:    [Empleado: codigo = 123, nombre = "Pepito Pimentón", salario = $123456,8, fechaNacimiento = 14/09/2008 11:12:10 p.m.]

El documento XML generado es bastante explícito y fácil de realizar su manipulación manual si se llegara a requerir.

<?xml version="1.0" encoding="utf-8"?>
<Empleado xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Codigo>123</Codigo>
  <Nombre>Pepito Pimentón</Nombre>
  <Salario>123456.789</Salario>
  <FechaNacimiento>2008-09-14T22:39:52.888-05:00</FechaNacimiento>
</Empleado>

Enlaces:

Tags: , ,

Microsoft Kid’s Corner

Desarrollo de software, Web, Windows July 17th, 2008

Buscando información en internet para el próximo capítulo de la serie de documentos J2ME encontré algo interesante del otro lado de la de las plataformas de desarrollo.

Microsoft Kid's Corner es una sección de documentación para enseñarle a programar a niños pequeños utilizando, obviamente, las herramientas de .NET que el mismo Microsoft desarrolla.

Sin profundizar en estos temas por ahora, se encuentran ya disponibles dos libros electrónicos acerca de la programación con C# y VB, así como varios cursos didácticos relacionados con estas tecnologías y haciendo énfasis en el desarrollo de aplicaciones de escritorio y aplicaciones web.

Para algo podrán servir en el futuro estos documentos, todo lo relacionado con educación es siempre bienvenido.

Enlace: Microsoft Kid's Corner.

Tags: , ,

Servicio web entre C#.NET y Java

Desarrollo de software, Educación, Internet, Linux/Unix/FreeBSD, Web, Windows May 5th, 2008

Aproveché este fin de semana para en un par de horas desarrollar un ejemplo de servicio web escrito en C#.NET para ser consumido por un cliente desarrollado en Java, utilizando las herramientas gratuitas Microsoft Visual Web Developer 2008 Express Edition y NetBeans 6.0.1 respectivamente.

El servicio como tal es muy simple, envía correo a través de un servidor SMTP, sin embargo es un ejercicio académico interesante. La documentación del desarrollo la escribí a manera de guía así que podrá ser de utilidad para quienes esten interesados en aprender a desarrollar este tipo de aplicaciones.

Enlaces:

  1. Guía de desarrollo
  2. Código fuente.

Tags: , , , , , ,

ASP.NET Development Server desde línea de comando

Desarrollo de software, Humor, Personal, Software, Web, Windows April 27th, 2008

El ASP.NET Development Server es el pequeño servidor ASP.NET que trae consigo el Framework de .NET y el Visual Studio Express para realizar la depuración y pruebas de este tipo de aplicaciones. Esta semana descubrí que es posible ejecutarlo desde la línea de comando, es decir, no es necesario iniciar el Visual Web Developer Express completo para utilizarlo. Para esto se debe ejecutar el siguiente comando en una ventana de Símbolo del sistema.

prompt> set DEVSRV=C:\Program Files\Common Files\microsoft shared\DevServer\9.0\
prompt> "%DEVSRV%"\webdev.webserver.exe /port:8080 /path:"RUTA_PROYECTO" /vpath:/SERVICIO

Utilizo la variable %DEVSRV% para evitar digitar la ruta del servidor (webdev.webserver.exe) en cada llamado. Aparentemente su ubicación puede variar según la versión del .NET Framework que se tenga instalada.

En la segunda línea se debe reemplazar la cadena RUTA_PROYECTO con la ubicación del serivicio web: G:\Proyectos\WS_Taller\servicio por ejemplo y la cadena SERVICIO por la ruta virtual web bajo la cual quedará publicada el webservice. Si no se especifica un puerto se utiliza el puerto 80 por defecto.

Tags: ,