Las lambdas como funciones anónimas

  delegado duplica = x => x * 2; 
  escribe duplica(2); // Escribe un 4

  Func<int, int> duplica = x => x * 2;
  int result = duplica(7); // result vale 14

  // Es método ejecuta la función indicada por
  // el parámetro operacion, enviándole el valor especificado, 
  // y retorna el resultado obtenido de la misma.
  public int calcula(int valor, Func<int, int> operacion)
  {
    return operacion(valor); // retorna el resultado de aplicar la 
                             // expresión indicada al valor.
  }

  // Usos posibles:
  int i = calcula(4, x => x / 2); // Le pasamos una referencia a la 
                                  // función que estamos definiendo sobre
                                  // la marcha. El resultado es que i=2.

  int j = calcula(4, duplica);    // Le pasamos la variable "duplica", 
                                  // que es una referencia a la lambda
                                  // definida anteriormente. J valdrá 8.

  bDuplica := { |n| n*2 }
  ? EVAL(bDuplica, 7)     // Muestra un 14

  // Nos suscribimos al evento MouseMove:
  this.MouseMove += new MouseEventHandler(this.Form1_MouseMove);
  [...]

  // Tratamiento del evento MouseMove:
  private void Form1_MouseMove(object sender, MouseEventArgs e)
  {
    this.Text = e.X + "," + e.Y;
  }

  this.MouseMove += delegate(object sender, MouseEventArgs args)
  {
    this.Text = args.X + "," + args.Y;
  };

  this.MouseMove += (sender, args) => {
                       this.Text = args.X + "," + args.Y;
                    };

Tipos de delegados de expresiones lambda

  Func<int, int> duplica = x => x * 2;

  public delegate TResult Func<T, TResult>(T arg);

  // En el área de declaraciones:
  public delegate int Duplicador(int arg);
  ...
  // En el código:
  Duplicador duplica = delegate(int k) { return k*2 };

  // Recibe un entero y retorna un booleano:
  Func<int, bool> esPar = x => x%2==0;     
  Console.WriteLine(esPar(2)); // Muestra "True"

  // Recibe dos enteros, retorna otro entero:
  Func<int, int, int> suma = (a,b) => a+b;
  Console.WriteLine(suma(2,3)); // Muestra "5"

  // No recibe nada, retorna un texto:
  Func<string> hora = () => "Son las "
                             + DateTime.Now.ToShortTimeString();
  Console.WriteLine(hora()); // Muestra "Son las 14:21:10"

  public delegate 
         TResult Func<T1, T2, T3, T4, T5, T6, TResult>
                 (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6);

  // Acción sin parámetros (no genérica):
  Action saluda = () => Console.WriteLine("hola");
  saluda();  // Muestra "hola";

  // Acción que recibe un string
  Action<string> apaga = motivo => { 
                                      log(motivo);
                                      shutdown();
                                   };
  apaga("mantenimiento"); // Apaga el sistema

  Func<int, int> duplica = (int a) => (int)(a * 2); // ¡Redundante!

  // Forma más cómoda:

  Func<int, int> duplica =  a => a * 2; // Ok!

Introducción a las lambda

"Una expresión lambda es una función anónima que puede contener expresiones e instrucciones y se puede utilizar para crear delegados o tipos de árboles de expresión"

"Una expresión lambda es una función sin nombre que calcula y devuelve un solo valor. Se pueden utilizar las expresiones lambda dondequiera que un tipo de delegado sea válido"

"Las Expresiones Lambda aportan una sintaxis más concisa y funcional para escribir métodos anónimos."
[...]
"La forma más sencilla para conceptualizar las expresiones lambda es pensar en ellas como formas de escribir métodos breves en una línea."

Forma de las expresiones lambda

Forma general: parámetros => expresión, donde:
- parámetros: lista de parámetros separados por comas
- "=>" : separador.
- expresión: implementación de las operaciones a realizar

num => num * 2     // Lambda con un parámetro que retorna
                   // el doble del valor que se le pasa.

(a, b) => a + b    // Lambda con dos parámetros que retorna
                   // la suma de ambos.

num => {                        // Lambda con cuerpo que recibe un 
   int x = new Random().Next(); // entero, y retorna la suma de éste
   return num+x;                // con un número aleatorio.
}  

() => DateTime.Now // Lambda que no recibe parámetros
                   // y retorna la fecha y hora del sistema.

msg => Console.WriteLine(msg); // Recibe un parámetro, realiza una
                               // acción y no retorna nada.

  (int a, int b) => (int)(a+b)

Aunque lamentablemente no me haya dado  demasiada prisa en hacerlo, tenía ganas de probar este producto. Si habéis utilizado alguna vez el interfaz de edición de Blogger, sabréis que no es precisamente una maravilla, y que a veces complica bastante la publicación de entradas en el blog, y máxime cuando se trata de contenidos con formatos especiales, como puede ser código fuente en cualquier lenguaje.

Live Writer es una fantástica aplicación de escritorio desarrollada por Microsoft en el contexto de su iniciativa Live, cuyo objetivo es facilitar la edición y publicación de entradas en blogs y, lo más curioso, compatible con los motores más difundidos del mercado: Blogger, WordPress, LiveSpaces, LiveJournal, TypePad, y un largo etcétera. Y cuando digo compatible, al menos con Blogger, me refiero a realmente compatible, una integración casi perfecta, que hace que la edición de entradas sea una gozada.

Durante la instalación, Writer nos solicita la introducción de los datos de acceso al blog: la dirección, el usuario y clave. Con esta información, y por supuesto previa confirmación por parte del usuario, crea automáticamente una entrada temporal en el blog que utiliza para tomarla como plantilla, eliminándola unos segundos después. De esta forma, cuando estamos escribiendo, podemos acceder a una previsualización del contenido insertada en sobre dicha plantilla, que nos dará una idea muy aproximada, prácticamente real, del resultado final que obtendremos una vez publiquemos la entrada.

El editor sobre el que escribimos es muy ligero, tiene las opciones justas para poder escribir y dar formato a los textos, siempre de forma visual (el famoso WYSIWYG). Aunque a primera vista puede parecer que se quedará corto, nada más lejos de la realidad; no he echado en falta prácticamente ninguna característica que realmente pudiera hacerme falta durante la escritura: formatos estándar (negritas-cursivas-tachados, subrayados), colores, tablas, alineados, listas, citas,… y siempre generando un código XHTML realmente limpio y muy bien estructurado, a diferencia de otros editores basados en web (como el de Blogger, por ejemplo).

Sólo en casos especiales (por ejemplo, la inclusión de una etiqueta <acronym> para mostrar ayuda sobre el significado de WYSIWYG, o la inclusión de código fuente marcado con <code> son los únicos casos en los que he tenido que salirme del editor visual y acceder a la vista de código fuente XHTML para introducir las etiquetas.

Otro aspecto muy importante es su extensibilidad. Existen un gran número de complementos que pueden instalarse sobre este software para dotarlo de nuevas capacidades no contempladas en el producto base. Por aunque la galería de complementos de Microsoft todavía está a cero no está muy transitada, es fácil encontrar muchos sitios web donde se ofrecen plugins de todo tipo. Por ejemplo, he encontrado uno que a priori puede resultar muy útil, Steve’s Dunn Code Formatter, que permite incluir fácilmente porciones de código formateadas como la siguiente:

try
{
    calculate(); // Hard work!
}
catch (Exception ex)
{
    Logger.Log(ex.Message);
    throw;
}

Pero lo que sin duda más ha llamado mi atención es la gran facilidad para insertar contenidos multimedia, como álbumes de fotos, vídeos, mapas interactivos, y especialmente imágenes, que es lo que más suelo utilizar en mis posts. En este último caso, es sorprendentemente útil la capacidad de Live Writer para abrir imágenes del equipo local o pegarlas directamente desde el portapapeles (por ejemplo capturas de pantalla), ajustarlas al tamaño indicado e incluso agregarle sobre la marcha efectos como sombreados o reflejos (podéis ver ejemplos más arriba). Por fin se acabó el retoque con aplicaciones externas, tener que subir la imagen al servidor, ver cómo queda, retocarla de nuevo, volver a subirla…

Por último, el hecho de tratarse de una herramienta off-line aporta mucha agilidad, y nos brinda la posibilidad de trabajar en modo desconectado, aunque a costa de perder algunas funcionalidades para las que obviamente es necesario disponer de conexión a internet, como la edición de posts ya publicados, almacenados en el blog, o el envío directo de las entradas. En estos casos, el sistema almacena toda la información en local, para que más adelante podamos enviar los cambios realizados.

Ni que decir tiene que este post está completamente escrito sobre Live Writer, e incluso las imágenes las he generado desde la propia herramienta.

En resumen: una maravilla, imprescindible.

Descarga: Microsoft Live Writer

Publicado en: www.variablenotfound.com.

• crear y lanzar una nueva excepción partiendo de la original
• relanzar la excepción original
• dejar que la excepción original siga su camino

  ...
  try
  {
    transmitir(datos);
  }
  catch (HostNotFoundException ex)
  {
    sendToAdmin(ex.Message); // Avisa al administrador 
    throw new TransmissionException("Host no encontrado", ex);
  }
  catch (TimeOutException ex)
  {
    increaseTimeOutValue(); // Ajusta el timeout para próximos envíos
    throw new TransmissionException("Fuera de tiempo", ex);
  }
  ...

  ...
  try
  {
    transmitir(datos);
  }
  catch (HostNotFoundException ex)
  {
    sendToAdmin(ex.Message); // Avisa al administrador 
    throw ex;
  }
  ...

  ...
  try
  {
    transmitir(datos);
  }
  catch (HostNotFoundException ex)
  {
    sendToAdmin(ex.Message); // Avisa al administrador 
    throw;// Eleva la excepción al siguiente nivel
  }
  ...

• Importación de espacios de nombres
• Definición de alias, tanto de espacios de nombres como de tipos.
• Adquisición y liberación de recursos

1. Importación de espacios de nombres

  using System;
  using System.Collections;...

2. Definición de alias

2.1. Alias de espacios de nombres

  using System;
  namespace Prueba
  {
    class Saludo
    {
      public static void Run()
      {
        Console.WriteLine("hola");
      }
    }
  }

  namespace OtroNS
  {
    class Prueba
    {
      public static void Main(string[] args)
      {
        Prueba.Saludo.Run();  // No compila
        Console.ReadLine();
      }
    }
  }

      ...
      public static void Main(string[] args)
      {
        global::Prueba.Saludo.Run();
        Console.ReadLine();
      }
      ...

  ...
  using MiAlias = Prueba;
  ...
      ....
      public static void Main(string[] args)
      {
        MiAlias::Prueba.Saludo.Run();
        Console.ReadLine();
      }
      ...

2.2. Alias a tipos

  using Strings = System.Collections.Specialized.StringCollection;
  using Con = System.Console;
  ...
  Strings s = new Strings(); // 's' es un StringCollection
  Con.WriteLine("hola");

3. Adquisición y liberación de recursos

  using (SqlConnection conn = new SqlConnection(connectionString)) 
  {
    hacerAlgoConLosDatos(conn);
  }
  // Al llegar aquí, la conexión está liberada. Seguro.
  // Además, la variable conn no es visible.

  SqlConnection conn = new SqlConnection(connectionString);
  try
  {
    hacerAlgoConLosDatos(conn);
  }
  finally
  {
    if (conn != null)
      ((IDisposable)conn).Dispose();
  }

  // Anidando usings
  using (SqlConnection conn1 = new SqlConnection(connstr1))
  {
    using (SqlConnection conn2 = new SqlConnection(connstr2))
    {
       // hacer algo con las dos bases de datos
    }
  }

  // Forma más compacta
  using (SqlConnection conn1 = new SqlConnection(connstr1),
                       conn2 = new SqlConnection(connstr2))
  {
       // hacer algo con las dos bases de datos
  }

• primero, la descarga de estas librerías será, para el cliente, probablemente más rápida que si las tiene que obtener desde tu servidor a través de internet. Se trata de infraestructura de red de Google, y eso implica unas garantías.


• segundo, y relacionada con la anterior, si se trata de un sitio web de alto tráfico, la concurrencia permitida seguramente será infinitamente mayor que la que puedas ofrecer en otro servidor.


• tercero, si el usuario ha visitado previamente otro sitio web que use también la misma librería, se beneficiará del cacheado local de la misma, puesto que su navegador no la descargaría de nuevo. Y en cualquier caso, se estarían aprovechando las optimizaciones de caché de Google.


• cuarto, no consumes ancho de banda de tu proveedor, aunque éste sea despreciable. Y con despreciable me refiero al ancho de banda, no al proveedor ;-)


• quinto, puedes utilizar las librerías desde webs alojadas en algún sitio donde no se pueda, o no sea sencillo, subir archivos de scripts, como la plataforma Blogger desde la que escribo.

• jQuery
• jQuery UI
• Prototype
• script_aculo_us
• MooTools
• Dojo
• SWFObject
• Yahoo! User Interface Library (YUI)

  <script 
    src="http://ajax.googleapis.com/ajax/libs/prototype/1.6.0.2/prototype.js">
  </script>