Johnvey Hwang ha realizado ingeniería inversa de la API que Google utiliza en GMail y ha creado una biblioteca de clases en C# que permiten comunicarse directamente con el servicio desde cualquier aplicación, sin necesidad de usar el navegador.

GMail, el famoso servicio de correo de Google, utiliza un motor de interfaz de usuario basado en HTML Dinámico que consigue comunicación vía JavaScript con el servidor, sin necesidad de recargar la propia página varias veces. Lo cierto es que es una "virguería" (si me permitís la expresión) y la sensación de agilidad que imprime a la interfaz está muy bien.

La comunicación con el servidor no se realiza con XML sino con un formato propio (DataPack) que contiene únicamente matrices JavaScript que se procesan en el cliente por el motor de interfaz de usuario, siempre desde la misma página. La idea es muy interesante y ya se aplicaba por otros clientes de correo web como Oddpost (recientemente comprado por Yahoo para competir con GMail).

En fin, con esta API se pueden gestionar de manera muy sencilla múltiples cuentas de GMail, con todas las características del servicio para crear, recibir y gestionar mensajes, contactos, etc... De hecho es muy sencillo crear clientes de correo electrónico para la Web o el escritorio que usen GMail por debajo a través de esta API.

Se puede descargar desde la página de Johnvey Hwang. Desde mi punto de vista tiene muchas aplicaciones. Por ejemplo, se puede usar una cuenta de GMail para enviar y recibir notificaciones en ciertos programas, sin necesidad de instalar componentes de gestión de correo en los clientes y a través del puerto 80 (HTTP), es decir, sin problemas con cortafuegos.

La .NET Compact Framework (DNCF) es estupenda y permite crear aplicaciones .NET para dispositivos móviles (Pocket PC y SmartPhone) con casi las mismas técnicas y objetos que se utilizan en el desarrollo de aplicaciones de escritorio comunes. Sin embargo la DNCF no nos ofrece todo lo que proporciona su hermana mayor, la propia plataforma .NET.

Una carencia importante es la ausencia del método GetChanges en la clase DataSet. Este método se utiliza en ADO.NET para obtener una copia del DataSet original que sólo contiene los elementos que han cambiado desde la última llamada a AcceptChanges(). Esto resulta de mucha utilidad a la hora de sincronizar cambios en el servidor sobre todo si transmitimos el DataSet a través de un servicio Web. Gracias a este método sólo enviamos los datos necesarios y no el DataSet completo.

Por desgracia la calse DataSet de la DNCF no soporta el método GetChanges por lo que, o enviamos todos los datos y los seleccionamos en el servidor, o nos trabajamos nosotros mismos un método alternativo para hacerlo.

Yo, obviamente, he optado por el segundo método y a continuación expongo la función que he creado para obtener un DataSet que contiene únicamente los cambios sufridos por el que se le pasa como parámetro:

public DataSet GetChanges(DataSet ds)
  {
   //Si no tiene cambios, se devuelve una referencia nula
   if(!ds.HasChanges()) return null;

   //Se crea un nuevo DataSet
   DataSet dsCambios = new DataSet();

   //En cada tabla del DataSet original
   foreach(DataTable tabla in ds.Tables)
   {
    //Se clona la definición de la tabla en el nuevo DataSet
    dsCambios.Tables.Add(tabla.Clone());
    
    // se recorren los registros para comprobar si hay cambios
    foreach (DataRow fila in tabla.Rows)
    {
     if (fila.RowState == DataRowState.Added ||
      fila.RowState == DataRowState.Deleted ||
      fila.RowState == DataRowState.Modified)
     {
      dsCambios.Tables[tabla.TableName].ImportRow(fila);
     }
    }
   }
   //Se devuelve el nuevo DataSet con los cambios
   return dsCambios;
  }

Como se puede observar, lo que hago es recorrer las tablas del DataSet original clonándolas en otro nuevo y comprobando cada una de las filas en busca de cambios (fila añadida, borrada o modificada), y en caso de haberlos importándola con el mismo estado al DataSet que contiene los cambios.

Con DataSets de muchos registros puede ser un método lento pero ahorrará mucho tráfico al enviar los cambios al servidor, aumentando el rendimiento de las aplicaciones.

Es bastante fácil crear una versión sobrecargada de este método que devuelva sólo un tipo determinado de cambios, al igual que hace el método GetChanges original. Se deja como ejercicio al lector ;-)

Seguimos con algunos consejos referentes a controles Web DataGrid.

Para poner una fila de un DataGrid en modo edición o para seleccionarla, normalmente añadimos un botón en la primera o la última columna que, al pulsarlo, hace un PostBack al sevidor y muestra los controles de edición o cambia la fila seleccionada (normalmente ésta aparece resaltada).
Podemos facilitarle mucho la vida a los usuarios si permitimos que la acción selección o la edición se obtenga pulsando en cualquier parte de una fila, y no sólo en el botón de edición.

¿Cómo se consigue esto?

Imaginemos que nuestro DataGrid tiene un botón de tipo LinkButton (o CommandButton) en la primera fila, que es el encargado de lanzar la edición o la selección de la fila. Podemos ocultarlo si queremos. Lo que tenemos que conseguir es que, cuando el usuario pulse en cualquier lugar de la fila, se envíe al servidor exactamente la misma información que si se hubiese pulsado sobre el botón, es decir, debemos simular el PostBack del botón concreto en cada fila. Aunque esto se puede intentar hacer "a pelo" es decir, viendo qué parámetros le pasa el botón a las funciones de JavaScript es mucho más sencillo que sea la propia página ASP.NET la que nos devuelva esta información. Para ello el objeto Page proporciona los métodos GetPostBackClientEvent y GetPostBackClientHyperlink.

Éstos devuelven la cadena JavaScript que utiliza un control a la hora de lanzar su PostBack al servidor. La diferencia es que el segundo le añade la cadena "javascript:" delante al código.

Teniendo en cuenta esto la solución es sencilla utilizando el evento ItemDataBound del control DataGrid:

private void DataGrid1_ItemDataBound(object sender, System.Web.UI.WebControls.DataGridItemEventArgs e)
{
      if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
   {
      //Aquí podríamos usar cualquier otra técnica para obtener una referencia al botón, como por ejemplo 'FindControl'
      LinkButton boton = (LinkButton)e.Item.Cells[0].Controls[0];
      e.Item.Attributes["onclick"] =
      Page.GetPostBackClientHyperlink(boton, "");
   }
}

Como se puede observar lo único que hacemos es asignar un atributo "onclick" a la fila del DataGrid, es decir, al elemento HTML 'TR' correspondiente que se genera, lo que hace que cuando se pulse en cualquier elemento que ése contenga se lanzará el PostBack, que es lo que buscábamos.
Al método GetPostBackClientHyperlink se le pasa una referencia al control cuyo código de PostBack queremos obtener, y una cadena con el parámetro adicional que debe pasar dicho método al servidor. Esto puede ser útil si, por ejemplo, queremos pasar directamente desde cada fila un identificador de la base de datos por ejemplo (aunque para eso hay métodos nativos más eficientes como los DataKey).

Creo que es un truco bastante interesante.

Esta semana seguimos con los trucos y consejos de los DataGrid de ASP.NET...

Para que una columna enlazada no aparezca tal y como está en la base de datos sino que se le aplique de manera automática un formato, es preciso utilizar la propiedad DataFormatString de las columnas. Ésta se puede aplicar directamente en el código HTML o, si usamos la interfaz gráfica del diseñador de DataGrids, usando el campo Formato.

El valor de esta propiedad sigue las mismas reglas que se usan en la plataforma para el formato de cadenas, y dependerá del tipo de dato almacenado en el campo de la base de datos.

Por ejemplo, si hemos enlazado un campo que contiene fechas y queremos que aparezca con formato largo, esto es, por ejemplo, "25 de Octubre de 2004", sólo tendríamos que asignar a la propiedad el valor "{0:D}". Si en lugar de una 'd' mayúscula la ponemos minúscula el formato de la fecha sería el corto.

Si la cantidad a mostrar es un precio y queremos que aparezca en el formato de moneda definido para la aplicación basta con asignar el valor "{0:C}" a la propiedad de formato.

Sin embargo, si lo que almacena la base de datos son Euros, por ejemplo, y queremos que independientemente del formato de moneda predefinido la cantidad aparezca con separadores de miles, dos decimales y el símbolo del euro al final sólo habría que escribir: "{0:N2} €".

Consulta la documentación de .NET para ver las diferentes posibilidades de formato.

Hace un par de días comenté el efecto de ejecución doble de ItemCreated que se podía dar al enlazar ciertos DataGrids en una página Web. Una forma posible e evitarlo (entre otras muchas) sería redefinir el evento LoadViewState de la página para marcar con un indicador booleano cuándo se está ejecutando, una cosa así:

private boolean RestaurandoViewState = false;

protected override void LoadViewState(object savedState)
{
     this.RestaurandoViewState = true;
     base.LoadViewState(savedState);
     this.RestaurandoViewState = false;
}

De este modo durante el evento ItemCreated sólo tenemos que comprobar si se está restaurando el ViewState o no, ejecutando el código sólo en caso de que no.

Sólo un par de detallitos simples que a veces pueden resultar útiles.

1.- Normalmente los controles DataGrid de ASP.NET (u otros similares enlazados) los generas usando el diálogo especial que tiene Visual Studio. En éste defines las columnas que va a llevar y las características de éstas. Si por ejemplo defines una columna plantilla que, de entrada, no está enlazada con ningún campo de un origen de datos, Visual Studio utiliza comillas dobles para asignar los valores propiedades.
Si luego retocamos la plantilla manualmente e incluimos código en ella lo más probable es que obtengamos un error. Ello se debe a que, al tener comillas en el exterior como delimitadores, en cuanto incluyamos también comillas dentro de la expresión (para una cadena, por ejemplo) el intérpreto de tiempo de ejecución identifica mal los límites del atributo, produciendo un error.
Solución: cambia los delimitadores externos del atributo a comillas simples ('). El intérprete las usa correctamente y se acabó el problema. Una tontería pero útil para principiantes.

2.- Muchas veces se incluye texto sacado de una base de datos dentro de la columna de un DataGrid. Si este es algo largo y hay muchas columnas normalmente se comprime para dejar sitio a las demás, quedando feo y destacando poco. Podemos impedir que ocurra esto en una columna de plantilla usando el atributo ItemStyle-Wrap, haciendo que el texto ocupe todo el espacio que necesite, por ejemplo:

<asp:TemplateColumn HeaderText="Mi encabezado" ItemStyle-Wrap=False>

Pues sí. Esta situación es algo que despista bastante si no se tiene controlado (y uno se da cuenta, claro).

En los DataGrid de WebForms en ASP.NET el evento ItemCreated se puede ejecutar dos veces a partir de la primera carga de la página. Esto se debe a que cuando hacemos un PostBack a la página (es decir, pulsamos un botón o hacemos algo que genera un evento en el servidor) los contenidos de la rejilla de datos se regeneran a partir del ViewState de la página y por lo tanto se lanza el evento para cada fila. Si además volvemos a enlazar la rejilla para responder a una ordenación o paginación, ésta se vuelve a generar y por lo tanto se lanza de nuevo el evento ItemCreated.

Si usamos el evento ItemDataBound esto no ocurre ya que los contenidos la primera vez se regeneran desde el ViewState y por lo tanto no hay enlace de datos. En este caso el evento sólo se lanza una vez: al realizar el verdadero enlace.

Conclusión: si usas el evento ItemCreated ten en cuenta que, dependiendo de cómo se genere la página, éste se puede notificar dos veces durante un Postback. Para evitarlo sustitúyelo por el evento ItemDataBound o bien escribe código en el evento que verifique la situación para evitar que se degrade el rendimiento por una acción innecesaria en cada fila. Por ejemplo, como el evento ItemDataBound se produce sólo una vez y además antes del segundo evento ItemCreated (de haberlo) se uede usar un indicador que marque que ya se ha pasado por ItemDataBound y que por lo tanto estamos en el ItemCreated correcto (en el segundo, no en el del ViewState).

---

NOTA: Añado esta nota aclaratoria porque alguna gente me ha comentado que no le quedaba claro... Veamos, este efecto sólo se produce si el DataGrid contiene elementos que se almacenan en el ViewState de la página y que, por consiguiente, se envían de nuevo al servidor durante el Postback. Es durante la regeneración de controles a partir del PostBack cuando se produce el efecto comentado, en otro caso no.

A ver, esta es peliaguda...

La situación es la siguiente: colocas un DataGrid en un formulario Web (o peor aún, lo copias y lo pegas desde otro formulario) y luego escribes con todo el cariño manejadores de eventos para, por ejemplo, ordenar columnas, paginar o responder a botones de acción (evento ItemCommand) confiando en que todo irá perfectamente. Después de un buen rato de crear columnas, botones y código lo vas a probar y... ¡nada! parece que no está cogiendo los manejadores de los eventos y por lo tanto no hace ni caso a ciertas acciones.

Te puedes desesperar tratando de ponerlo a funcionar. No hay manera. ¿A qué se debe esto?

Bueno pues la solución es sencilla aunque a ver quien es el listo que la intuye a la primera.

Seguro que realizas el enlace del DataGrid dentro del evento Load de la página ¿verdad?. Tu código será similar al siguiente:

private void Page_Load(object sender, System.EventArgs e)
{
    //algunas comprobaciones, conexiones, etc...
   Datagrid.DataBind();
}

De acuerdo. Todo parece correcto. Al fin y al cabo lo único que haces es enlazar el control a los datos cuando carga la página... ¡Mal!. Lo que ocurre es que cuando pulsas un botón o una columna y la página envía de nuevo datos al servidor (hace un PostBack, en jerga .NET) se ejecuta el evento Load de nuevo y se vuelve a enlazar el DataGrid. Debido a ello, los elementos se regeneran y por lo tanto se hace caso omiso de los eventos que existían en elementos anteriores. Nada menos.

La solución: muy sencilla. Haz así:

private void Page_Load(object sender, System.EventArgs e)
{
   if (!Page.IsPostback)
   {
       //algunas comprobaciones, conexiones, etc...
      Datagrid.DataBind();
   }
}

Solucionado. Ahora sólo se enlazará al cargar la página. Esto no te ocurrirá si enlazas el DataGrid en otro lugar del código pero sí durante la carga de la página.

Parece una tontería pero te aseguro que puedes pasarte horas rompiéndote la cabeza para averiguarlo si no te lo cuentan antes.

De nada ;-)

Cuando estamos escasos de ancho de banda para una aplicación Web puede resultar beneficioso comprimir las peticiones que se hagan al servidor, de forma que los archivos estáticos (imágenes, HTML...) y las páginas se envíen a los usuarios ocupando mucho menos tamaño.

En realidad en el caso de las imágenes no se ahorra demasiado ya que éstas son comprimidas por su propia naturaleza (todos los formatos de Internet, GIF, JPEG y PNG, incorporan ya compresión). Sin embargo si nos referimos a las páginas ASP y ASPX la compresión puede ayudar bastante puesto que al estar constituidas fundamentalmente por texto el grado de compresión que se alcanza es muy grande. Muchas páginas conocidas, como por ejemplo Google, utilizan la compresión de archivos para devolver sus resultados a los navegadores que soportan compresión (lo indican en las cabeceras que envían al servidor).

Para habilitar la compresión de respuestas en IIS 5.0 o superior sólo hay que ajustar dos claves de la metabase. Los pasos a seguir son muy sencillos:

1.- Detenga el servidor IIS (manualmente con el comando Net Stop w3svc)
2.- Desde la línea de comandos vaya a la carpeta adminScripts ubicada normalmente en c:\InetPub y escriba las dos órdenes siguientes (primero una y luego la otra):

CSCRIPT.EXE ADSUTIL.VBS SET W3Svc/Filters/Compression/GZIP/HcScriptFileExtensions "asp" "dll" "exe" "aspx"
CSCRIPT.EXE ADSUTIL.VBS SET W3Svc/Filters/Compression/DEFLATE/HcScriptFileExtensions "asp" "dll" "exe" "aspx"

3.- Reinicie el servidor Web (manualmente o con Net Start w3svc)

A partir de ahora las peticiones a archivos ASP o ASPX se procesarán y se comprimirán antes de enviarlas al usuario si su navegador lo soporta.

De todos modos hay que tener en cuenta una consideración de rendimiento importante, y es que la compresión se realiza en memoria para todas y cada una de las páginas cuando se solicitan. En el caso de archivos estáticos (como .HTM) la compresión se realiza una vez y se almacena en un directorio temporal para reutilizarla. Esto no se puede hacer para páginas dinámicas puesto que éstas, a priori, devuelven un resultado distinto cada vez que se solicitan. Por ello la compresión añade una carga adicional al servidor que debemos tener en cuenta sobre todo en el caso de servidores que reciben muchas visitas. Esto es como casi todo en la vida: tiene ventajas a costa de ciertos inconvenientes. Si nuestra prioridad es ahorrar ancho de banda porque andamos sobrados de procesador no habrá ningún problema. Si también tenemos el servidor muy cargado mejor buscar una opción alternativa, por ejemplo: comprar más ancho de banda ;-)

Hoy he leído este truco de Enrico Sabbadin en la página de .NET2TheMax y me ha parecido muy interesante...

Se trata de ejecutar una aplicación (o parte de ella) dentro de un dominio restringido de forma que se ejecute con bajos privilegios de seguridad (lo que se suele llamar un patio de juegos o sandbox). Esto puede ser interesante en diversas situaciones.

La técnica consiste, grosso modo, en crear un nuevo dominio de aplicaicón (AppDomain) y asignarle una política de seguridad que se carga desde un archivo en disco. Posteriormente se carga el ensamblado a ejecutar con bajo privilegio mediante una llamada a ExecuteAssembly. Interesante....

Para validar una dirección IP (del estilo xxx.xxx.xxx.xxx) introducida por un usuario disponemos de multitud de opciones: desde analizar la cadena separándola por los puntos hasta utilizar expresiones regulares. Sin embargo en .NET hay una forma muy fácil de conseguir lo mismo sin complicarnos la vida y es utilizar la clase IPAddress del espacio de nombres System.Net. Ésta posee un método Parse que aunque su objetivo es obtener una instancia de la clase a partir de una cadena que represente una IP, si bien la podemos utilizar indirectamente para simplemente validar este tipo de cadenas. De este modo una función que nos permite validar una IP contenida en una cadena de texto podría tener el siguiente aspecto:

 private static bool ValidaIP(string sIP)
 {
  try
  {
   IPAddress ip = IPAddress.Parse(sIP);
  }
  catch
  {
   return false;
  }
  return true;
 }

Ésta devuelve un booleano indicando si la IP es válida. Así de sencillo y sin necesidad de implementar análisis de cadenas o escribir una expresión regular.

Microsoft ha presentado su nuevo programa de apoyo a los desarrolladores de software españoles, con el fin de reafirmar su compromiso con la tecnología .NET. El plan destinará durante los próximos 10 meses 2 millones de euros para ofrecer a esta comunidad de forma gratuita la formación necesaria para conocer los últimos avances en la tecnología .NET de Microsoft, haciendo especial hincapié en su utilización en proyectos reales.

La comunidad española de desarrolladores en tecnologías de Microsoft es una de las más activas del mundo y abarca a más de 30.000 profesionales del sector que participan de forma asidua en las actividades que ofrece la compañía. Éstas se desarrollan en el sitio Web MSDN, que cuenta con información para desarrolladores y recibe un millón de visitas mensuales; en una gira de eventos y talleres que se llevan a cabo en diversas ciudades españolas y que atrae cada año a 6.000 asistentes. Asimismo, Microsoft organiza en Internet conferencias online, seminarios, chats o grupos de noticias que se convierten cada vez en una alternativa más utilizada por los desarrolladores en su formación.

Al igual que años anteriores, tanto yo como otros de los habitantes de este Blog de GolemProject (Jorge Serrano, Iván González, Leo Dolinski, Salvador Ramos, Miguel Egea, David Salgado...) estamos colaborando activamente con Microsoft en el desarrollo de esta iniciativa, participando en el desarrollo de la aplicación y ofreciendo formación conjunta en diversas ciudades españolas.

La iniciativa presentada, denominada Desarrolla con MSDN, se divide en cuatro módulos que cubren las últimas tecnologías de desarrollo de aplicaciones: .NET y Servicios Web; Aplicaciones Web; Clientes inteligentes y Microsoft Visual Studio 2005 y Microsoft SQL Server 2005. Estos módulos serán impartidos durante el año en forma de seminarios por 24 ciudades españolas, sesiones online a través de Internet y descarga de material didáctico desde la Web de Microsoft para desarrolladores, MSDN.

Una novedad importante es la incorporación de un proyecto práctico a modo de ejemplo que se desarrollará durante el año y que utilizará los conceptos más importantes aprendidos en cada módulo. Con esta aplicación, que se denomina MSDN Video, se mostrará en directo a través de Internet cómo utilizar las últimas tecnologías para crear una aplicación en la vida real, en este caso la gestión de una franquicia de tiendas de venta y alquiler de películas de video.

Los desarrolladores tendrán también la opción de descargar el código de la aplicación y estudiar a través de un manual en el que se incluye el uso práctico de la tecnología. Además se ofrecerá ayuda individualizada para la resolución de dudas de los participantes a través de foros en Internet, e-mail y chats en directo.

Al finalizar el año, Microsoft publicará todas las aportaciones enviadas y un jurado independiente elegirá el módulo más interesante. El autor del módulo premiado obtendrá el reconocimiento de Microsoft y la posibilidad de aprender con los propios autores de la tecnología asistiendo, con todos los gastos pagados, a la conferencia para desarrolladores más importante que organiza Microsoft y que tiene lugar en Estados Unidos, la Professional Developer Conference (PDC).

Esta estupenda utilidad en-línea de Alex Lowe puede resultar muy útil a muchos programadores. Se trata de un traductor que convierte de forma automática código escrito en C# a código VB.NET. No hace falta instalar nada para usarlo, sólo hay que conectarse a Internet, pegar el código en C# en un área de texto y pulsar un botón. ¡Ya está!.

Como bien pone el autor en su página, la traducción no es perfecta. Eso sí, el resultado es muy bueno. Yo lo he probado traduciendo código bastante largo y complejo en C#. Aunque el resultado en VB no compilaba a la primera, no se trataba de nada que no se pudiera arreglar con un buen Option Strict Off y cuatro ajustes manuales.

Sólo traduce código C# puro (no admite etiquetas HTML por el medio si copiamos de una aplicación Web).

Dan Wahlin ha escrito una interfaz para poder usar la herramienta a través de un servicio Web. En la propia página hay un enlace a esta información.

Puedes encontrarlo en la Web de ASPAlliance.

En muchos programas se suelen dar a los usuarios una serie de opciones para que escoja. Por ejemplo un tipo de búsqueda a realizar, un rango de posibles valores para parametrizar algún comportamiento, etc...

Lo más habitual es que estas opciones se "mapeen" después a elementos de una enumeración en el código de la capa de negocio. De esta forma si definimos una enumeración similar a esta:

public enum EstadoCivil
{
  Casado,
  Soltero,
  Divorciado,
  Viudo,
  Religioso,
}

lo más común será que en la interfaz de usuario exista un modo de seleccionar algún valor equivalente, por ejemplo a través de una lista desplegable o un conjunto de botones de radio.

Es bastante común generar los elementos de la interfaz manualmente, añadiendo opciones a una lista Web, por ejemplo, con código similar a este:

lista.Items.Add(new ListItem("Casado", "0");
lista.Items.Add(new ListItem("Soltero", "1");
etc...

Sin embargo sería muy útil poder añadir automáticamente los valores de una enumeración cualquiera sin preocuparse por saber cuántas son o cuál es su nombre. Gracias al poder de la reflexión en .NET esto es algo muy sencillo de conseguir.

Por ejemplo, la siguiente función toma como argumentos una referencia a un control de lista cualquiera de .NET (ListBox, CheckBoxList, DropDownList, etc...) y un valor enumerado cualquiera y rellena el control con tantas opciones como tenga disponibles dicha enumeración:

private void Enlaza(ListControl lst, Enum e)
{
 string[] valores = Enum.GetNames(e.GetType());
 foreach (string valor in valores)
  lst.Items.Add(valor);
}

Toda la clave está en el método GetNames del tipo Enum, que devuelve una matriz con los nombres de cada elemento de la enumeración indicada. Así, para rellenar una lista sólo hay que escribir, por ejemplo:

Enlaza(miListBox, EstadoCivil.Casado);

o sea, se le pasa una referencia al control de lista y un miembro cualquiera de la enumeración.
Fácil ¿verdad?

La anterior función es muy sencilla pero puede dar algunos problemas. Por ejemplo, si al definir la enumeración se han declarado algunos miembros con valores específicos y diferentes a los valores por defecto, entonces el orden en la lista no coincidirá con el valor de cada miembro (0, 1, 2...). Se puede arreglar, pero complica algo la función. El código definitivo es el siguiente:

private void Enlaza(ListControl lst, Enum e)
{
   Type tipo = Enum.GetUnderlyingType(e.GetType());
   string[] nombres = Enum.GetNames(e.GetType());
   Array valores = Enum.GetValues(e.GetType());
   for(int i=0; i<nombres.Length;i++)
     lst.Items.Add(new ListItem(nombres[i], Convert.ChangeType(valores.GetValue(i), tipo).ToString() ) );
}

Con esto ya queda totalmente definido. Se convierte cada uno de los valores a su tipo subyacente (para obtener su valor numérico, no su nombre) y luego se convierte en una cadena para añadirlo al ListItem. Lo bueno de este código es que, aunque un poco más complicado permite trabajar de forma genérica con cualquier enumeración, sin importar su tipo o la cantidad de elementos que tenga.

Se puede retocar la función para que, si se desea, se añada opcionalmente un elemento extra al principio o al final para permitir que el usuario escoja otra opción (por ejemplo, "Otro", "Ninguno", "[Cualquiera]"... dependiendo del contexto).