Script sharp JavaScript o C#?

Programar en javascript puede ser dificil para los que nos dedicamos a la programación en lenguajes como C#, además el codigo es dificil de mantener y de seguir, para estos casos tenemos compiladores como script# que nos permiten escribir el codigo de las páginas en C# y luego el compilador convertira el código en javascript dandonos todas las ventajas de C# para usar en javascript, por supuesto estamos limitados por lo que puede hacer javascript pero en general este compilador es de mucha ayuda.

El ejemplo: un simple hola mundo en script#

using System;

using System.Collections.Generic;

using System.Html;

namespace SC {

    public static class DefaultPage {

        public static void HelloWorld() {

            Script.Alert("Hello World");

        }

    }

}

Esto nos genera un script que podemos incluir en una página y usar el código que escribimos en C#, tal cual si lo hubieramos escrito en javascript:

<%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"

    CodeBehind="Default.aspx.cs" Inherits="WTests._Default" %>

<asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">

    <script type="text/javascript" src="/Scripts/mscorlib.js"></script>

    <script type="text/javascript" src="/Scripts/SC.js"></script>

</asp:Content>

<asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">

    <input id="Button1" type="button" value="button" onclick="SC.DefaultPage.helloWorld();" />

</asp:Content>

Hay que notar que debemos incluir otro script que viene con el compilador: mscorlib.js, aunque no siempre es necesario, también vemos que nos cambio la máyuscula al pricipio de la función pero este y otros aspectos de la programación se pueden configurar.

Script# se puede obtener en esta dirección: http://projects.nikhilk.net/ScriptSharp y tiene integración con Visual Studio 2010
De momento la documentación del proyecto es escasa y puede costar un poco de trabajo empezar a usarlo por lo que seguire publicando más tutoriales cortos acerca del tema en este blog.

Web Services sin code behind

Hace unos días me encontré con la situación de querer publicar un servicio web sin tener que recompilar todo el sitio pues es un sitio muy complejo y un cambio muy pequeño no ameritaba subir todo otra vez.
Bueno afortunadamente se pueden escribir servicios sin code behind y al subir el archivo Asp.Net como todos sabemos lo compila automáticamente y queda disponible para su uso al instante.
Sin embargo si usas Visual Studio no permite crear este tipo de servicios directamente así que la forma de crearlo es agregar el servicio de la forma normal, cortas todo el contenido del code behind sin dejar ni una linea de código y el truco es abrir el archivo .asmx con el editor de xml (clic derecho al archivo  en el explorador de soluciones y seleccionar abrir con) y pegar el código copiado abajo de la única linea que tiene el archivo, también debemos quitar el atributo que hace referencia al code behind.

Aquí esta el ejemplo:

<%@ WebService Language="C#" Class="WebTest.HelloWorld" %>

using System;
using System.Web.Services;

namespace WebTest
{
    
    [WebService]
    internal class HelloWorld
    {
        [WebMethod]
        public string SayHello() {
            return "Hello World";
        }
    }
}

Nunit - modelo basado en restricciones (constraint)

Desde la versión 2.4 de Nunit se tiene una nueva sintaxis llamada constraint-model, que tiene como mayor ventaja una claridad mayor en la lectura del código (por supuesto esto mas cierto si hablas ingles).
Esta nueva sintaxis es tan fácil de usar como la anterior basada en afirmaciones (assert) y supuestamente es más poderosa, aunque según los autores de Nunit no se recomienda la una o la otra preferentemente, en realidad es más cuestión de gusto, aunque puede ser preferible el uso de la nueva sintaxis al usar junto con otros frameworks,
En fin les dejo un ejemplo básico del tema:

   1:  [TestFixture]

   2:  public class UserTestConstraint {

   3:      [Test]

   4:      public void ConstructorTest() {

   5:          User user = new User("Pedro", "secreto");

   6:          Assert.That(user.Name, Is.EqualTo("Pedro"));

   7:          Assert.That(user.Password, Is.EqualTo("secreto"));

   8:          Assert.That(user.Password, Is.Not.EqualTo("secreto1"));

   9:      }

  10:  }

Para aprender más acerca de las pruebas unitarias con .Net Framework visita:
Lista de artículos acerca de pruebas unitarias con .Net Framework

Tips y errores del control WebBrowser (Windows.Forms)

Te manda una excepción FileNotFoundException al usar la propiedad DocumentText, y estas seguro de que el documento ya se termino de cargar correctamente.

Este es un bug del control WebBrowser y al parecer Microsoft no tiene pensado arreglarlo, afortunadamente hay otras formas de obtener el código fuente de la pagina sin tener este error para ello debes usar la propiedad DomDocument del WebBrowser y convertirla a la clase HTMLDocument incluida en el ensamblado mshtml por lo que debes agregar a tu proyecto una referencia a ese ensamblado, con este objeto podemos usar la propiedad documentElement e innerHTML, en ella tenemos el código que buscamos.
para mayor claridad aquí esta el ejemplo:

   1:  string content = ((mshtml.HTMLDocument)browser.Document.DomDocument).documentElement.innerHTML;

Métodos de extensión

Los métodos de extensión son una forma muy sencilla y conveniente de agregar funcionalidad a código existente en .Net Framework se usan básicamente cuando necesitamos agregar funcionalidad a un código que no podemos cambiar, son muy usados en la librería de clases base, donde se utilizan por ejemplo para implementar Linq.
La forma de crear un método de extensión es crear una clase estática en la cual los métodos de extensión tienen como característica que el primer argumento de la función esta precedido por el modificador this y este parámetro es el que indica el tipo de datos que extiende el método.
Por ejemplo para extender el tipo string[]:

   1:  static class StringExtension {

   2:      public static void PrintAll(this string[] strings) {

   3:          foreach(string i in strings) {

   4:              Console.WriteLine(i);

   5:          }

   6:      }

   7:  }

Y podemos usar el método como si estuviera incluido en el tipo string[]:

   1:  static void Main(string[] args) {

   2:      string[] strings = new string[] { "hola", "mundo", "con", "extensiones"};

   3:      strings.PrintAll();

   4:      Console.ReadLine();

   5:  }

Cabe mencionar que no esta recomendado usar mucho los métodos de extensión, si es posible añadir los métodos en la clase que los necesita es mejor incluirlos directamente.

Usando XPath en .Net Framework

XPath es una tecnología que nos permite encontrar información en un documento XML, .Net Framework tiene integrada un API muy sencilla de usar que nos permite usar XPath en nuestras aplicaciones.
Aquí les muestro un ejemplo sencillo del uso de esta API.
Las clases principales son XPathDocument que nos permite cargar el documento a utilizar, XPathNavigator que nos permite realizar las consultas deseadas y XPathIterator que nos trae los resultados de la consulta.
También existe la interface IXPathNavigable que al ser implementada nos permite usar otro tipo de fuentes de datos que no sean XML.
En este ejemplo no explico detalles sobre XPath puesto que este es un blog de .Net y no de XML pero si quieres saber mas acerca de esta tecnología puedes visitar el tutorial de XPath en http://www.w3schools.com/XPath/default.asp.
Consideremos el siguiente xml:

   1:  <?xml version="1.0"?>

   2:  <Peliculas>

   3:    <Pelicula>

   4:      <Titulo>Mazinger</Titulo>

   5:      <Director>Jackie chan</Director>

   6:      <Estrenado>1975-03-19T00:00:00</Estrenado>

   7:      <Actores>

   8:        <Actor>

   9:          <Nombre>John Wayne</Nombre>

  10:          <Nacimiento>1915-10-23T00:00:00</Nacimiento>

  11:          <Roles>

  12:            <Rol>

  13:              <NombrePelicula>Mazinger</NombrePelicula>

  14:              <NombreRol>Estrella</NombreRol>

  15:            </Rol>

  16:          </Roles>

  17:        </Actor>

  18:      </Actores>

  19:    </Pelicula>

  20:    <Pelicula>

  21:      <Titulo>Terminator</Titulo>

  22:      <Director>James Cameron</Director>

  23:      <Estrenado>1985-02-14T00:00:00</Estrenado>

  24:      <Actores>

  25:        <Actor>

  26:          <Nombre>Arnold</Nombre>

  27:          <Nacimiento>1953-10-11T00:00:00</Nacimiento>

  28:          <Roles>

  29:            <Rol>

  30:              <NombrePelicula>Terminator</NombrePelicula>

  31:              <NombreRol>Protagonista</NombreRol>

  32:            </Rol>

  33:            <Rol>

  34:              <NombrePelicula>Terminator</NombrePelicula>

  35:              <NombreRol>Enemigo</NombreRol>

  36:            </Rol>

  37:          </Roles>

  38:        </Actor>

  39:        <Actor>

  40:          <Nombre>Linda Hamilton</Nombre>

  41:          <Nacimiento>1972-08-12T00:00:00</Nacimiento>

  42:          <Roles>

  43:            <Rol>

  44:              <NombrePelicula>Terminator</NombrePelicula>

  45:              <NombreRol>Protagonista</NombreRol>

  46:            </Rol>

  47:            <Rol>

  48:              <NombrePelicula>Terminator</NombrePelicula>

  49:              <NombreRol>Perseguida</NombreRol>

  50:            </Rol>

  51:          </Roles>

  52:        </Actor>

  53:      </Actores>

  54:    </Pelicula>

  55:  </Peliculas>

Para encontrar todos los actores usaríamos este código:

   1:  XPathDocument peliculas = new XPathDocument("peliculas.bak.xml");

   2:  XPathNavigator pelNav = peliculas.CreateNavigator();

   3:  XPathNodeIterator actoresIt = pelNav.Select("//Actor");

   4:  Console.WriteLine("Todos los actores");

   5:  while(actoresIt.MoveNext()) {

   6:      Console.WriteLine("Nombre: " + actoresIt.Current.SelectSingleNode("Nombre").Value);

   7:      Console.WriteLine("Fecha de nacimiento: " + actoresIt.Current.SelectSingleNode("Nacimiento").Value);

   8:  }

Cabe mencionar que el API es de solo lectura por lo que podemos consultar información pero no modificarla.

Usar o no DBLinq

La respuesta rápida: no lo uses.

DBLinq es un proyecto muy interesante nos permite accesar a diferentes tipos de bases de datos de la misma forma en accesamos a SQL Server con Linq a SQL Server de .Net Framework, tiene una herramienta (DBMetal.exe) que nos crea un conjunto de clases equivalente a las que se crean para Linq a SQL con Visual Studio o sqlmetal.exe.
Para mi lo mejor que tiene DBLinq es que solo cambiando la cadena de conexión y en ocasiones cambiando un poco el código generado por DBMetal.exe podemos cambiar de tipo de servidor (por ejemplo de SQL Server a MySql sin modificar el programa en lo más mínimo, pues la cadena de conexión se puede cambiar por ejemplo en el app.config o web.config, por lo que si escribes tu programa usando DBLinq tienes soporte instantaneo para todas las bases de datos que soporta este framework y las que soporte en el futuro.
Entonces por que recomiendo que no lo uses?
Aquí vienen las malas noticias, el proyecto tiene errores que lo hacen simplemente inutilizable, simplemente DBMetal.exe no puede manejar cualquier base de datos, basta que tengamos alguna asociación de tablas que no le guste al programa y nos mandara un error mientras que sqlmetal.exe puede manejar la misma base de datos sin problemas.
Aun así con un poco de trabajo se puede crear las clases necesarias y usar DBLinq en cualquier base de datos, sin embargo nos topamos con el siguiente problema: los querys regresan datos incorrectos.
Así es, lo corrobore con Linq a SQL, Linq a objetos y otros frameworks e indudablemente DBLinq regresa datos incorrectos, solo funciona para las bases de datos y querys mas triviales.

Más aun el proyecto a abril del 2011 parece abandonado y no ha habido cambios en el código durante más de un año.
La buena noticia es que el proyecto ahora se incluye como parte de Mono y los desarrolladores de Mono arreglan los errores que se reportan con mucha rapidez, yo pretendo trabajar un poco con ellos ya que en realidad el proyecto tiene un potencial muy grande y ya me gustaría estarlo usando en todos mis proyectos actuales.

En conclusión: De momento no cambies todavía a DBLinq pero mantén un ojo en el proyecto debido a su potencial.

Para aprender más sobre Linq visita:
Lista de artículos acerca de Linq