Siguiendo con esta serie vamos a ver el tercer método para conseguir detectar conectividad. Este es un poco rebuscado, y para ser franco no se me ocurrió a mi ni tampoco recuerdo ahora mismo en dónde lo aprendí o quién me lo contó :-( Pero bueno, ahí va...

Este pasa por comprobar si hay resolución DNS, y parte de la base (deduzco) de que el equipo local no es un servidor DNS, claro. Entonces lo que se hace es comprobar si se puede hacer la resolución de la IP del equipo actual, ya que si hay conectividad se puede consultar el servidor DNS. El código sería el siguiente:

    public static bool IsConnected3
    { 
        get
        { 
            try
            {  
                string hostName = Dns.GetHostName(); 
                IPHostEntry curHost = Dns.GetHostByName(hostName); 
                return curHost.AddressList[0].ToString() != IPAddress.Loopback.ToString(); 
            } 
            catch
            { 
                return false; 
            }
        }
    } 

Es decir, se obtiene el nombre del equipo actual y luego se averigua mediante una consulta DNS cuál es la IP que le corresponde. Si esa IP no es la del bucle local (127.0.0.1) entonces es que se ha resuelto bien y por lo tanto hay conectividad (contra el servidor DNS al menos).

Para mi es tal vez la más "por los pelos" de todas... ¿Qué opinas tú?

En mi post anterior sobre este tema hablé de un primer método de detección basado en la APi de Windows. Hoy me toca hablar de otro similar, si bien usando una API completamente diferente. Los restantes métodos que veremos no necesitan ya el uso de la API.

En esta ocasión usaremos la API del servicio de notificación de eventos del sistema, o sea, la System Event Notification Service (SENS) API. En concreto haremos uso de la función IsNetworkAlive, que se define así:

[DllImport("sensapi.dll")]
private static extern bool IsNetworkAlive(ref uint flags);

Este método devuelve verdadero o falso en función de si hay o no conexión a la red. ¡Ojo!, a la red, no necesariamente a Internet, pero en muchas ocasiones lo que querremos es eso (si trabajamos sólo en una red local).

Así, podemos definir nuestra propiedad IsConnected con esta función así:

public static bool IsConnected2
{
    get
    {
        uint flags = 0;
        return IsNetworkAlive(ref flags);
    }
}

Lo interesante de esta función es que el parámetro que toma es un indicador por referencia que devuelve un valor que nos permite averiguar si la conexión actual es a través de una tarjeta de red o mediante un acceso telefónico remoto, para lo cual se definen estas dos constantes:

private const int NETWORK_ALIVE_LAN = 0x00000001; 
private const int NETWORK_ALIVE_WAN = 0x00000002; 

Se puede comparar (comparación binaria) el valor devuelto en este parámetro con estos valores y saber si estamos conectados a una red local, a través de RAS o ambas cosas.

Según indican en la documentación de MSDN esta función es más lenta que la anterior, pero tiene la ventaja de que permite distinguir estos dos casos y además detecta las conexiones RAS de inmediato.

En breve más :-)

Hola holita vecinitos:

Es posible que, ante la inminente aparición en el mercado español de Visual Studio 2008, si estás pensando en obtener una certificación te encuentres en un mar de dudas respecto a qué es mejor hacer, cómo va a afectar la nueva versión de la plataforma en las certificaciones, y muchas otras cuestiones por el estilo.

Con el comienzo del año muchos han sido los alumnos de campusMVP que nos han llamado o escrito preguntándonos cosas como estas, pero no había apenas información pública al respecto por parte de Microsoft. Por fin, el pasado jueves por la tarde tuvimos la oportunidad de participar en una conferencia con los responsables de estas certificaciones en Redmond. Al día siguiente yo mismo ofrecí en Madrid una explicación sobre todas estas novedades, la cual se grabó en directo y desde campusMVP la hemos puesto a disposición de todos en Internet.

En este (creo que) completo vídeo explico el estado actual de las certificaciones para desarrolladores y cómo afectará la aparición de nuevas certificaciones para Visual Studio 2008 a medio plazo. Comento cuáles van a ser exactamente esas certificaciones, cuándo estarán disponibles, y qué es lo mejor que podemos hacer según sea nuestro caso particular. también desarrollo un poco qué pasa con las certificaciones antiguas MCAD/MCSD y cómo hacer la transición a las nuevas.

Me parece especialmente interesante resaltar que el examen de fundamentos 70-536 permanece igual y nos va a servir para obtener las nuevas certificaciones.

Si tienes interésen certificarte ahora o más adelante re recomiendo que veas este vídeo, con información que no te va a ofrecer nadie más.

Puedes verlo a pantalla completa o reducido, y saltar directamente a la parte que te interese utilizando la tabla de contenidos.

Aprovecho la ocasión para recordarte que el próximo viernes empezamos una nueva convocatoria de nuestros cursos de certificación.

Si haces ahora las certificaciones podrás aprovechar la oportunidad Second Shot, con la que  si suspendieses podrías presentarte gratis a un segundo examen. Es muy interesante y dejará de estar disponible en breve, por lo que no deberías dejarlo pasar.

También comienzan ese día los dos nuevos cursos de formación continuada sobre AJAX y sobre Creación de Controles Web.

No pierdas la oportunidad de aprender lo último en tecnología desde tu casa o puesto de trabajo y con la oportunidad de preguntarle dudas a los mejores.

¡Nos vemos!

Últimamente he estado trabajando bastante con la nueva API de Sincronización de Microsoft (Microsoft Sync Framework) que ahora mismo se encuentra en CTP (Community Technology Review), es decir, todavía no es la versión definitiva (pero casi). Esta plataforma te permite crear aplicaciones capaces de trabajar conectadas o desconectadas, y además sincronizar bases de datos, carpetas locales y remotas o información RSS se convierte en un trabajo sencillo. La API es bastante extensa y no voy a hablar de ella aquí (pronto leereis un artículo mío sobre el tema en DotNetMania). En lo que me quiero centrar es en el hecho de que, para trabajar desconectado, primero hay que saber qué realmente lo estamos ¿no?

De hecho en la API no hay referencia alguna a esto, y muchos de los que la usen se preguntarán "vale, ya sé trabajar en local cuando no hayconexión y sé cómo sincronizarla con una remota (o con la de cualquier otro equipo en redes P2P también soportadas por la API) cuando recupere la conexión, pero ¿Cómo diantres sé si tengo o no conexión?"

Bueno, hay varias formas de conseguirlo. Al menos se me ocurren cinco por lo menos. Así que lo que voy a hacer es comentar hoy el primero de los métodos y en los próximos post contaré los restantes. Chico, tengo poco tiempo, qué quieres :-(

En el últipo post, además, colgaré un ejemplo completo para descarga ¿OK?

El primero usa la API de Internet de Windows (WinInet) y en concreto la función InternetGetConnectedState. Asegúrate de incluir el spacio de nombres de ineroperatividad:

using System.Runtime.InteropServices;

La definición de esta función de la API de Windows es:

[DllImport("wininet.dll")]
private static extern bool InternetGetConnectedState(ref uint flags, uint dwReserved);

Así que podemos definir una propiedad de nuestra clase de utilidades para comprobar la conectividad así:

    public static bool IsConnected
    {
        get
        {
                uint flags = 0;
                return InternetGetConnectedState(ref flags,0);
        }
    } 

Con ello sabremos si alguna de las tarjetas de red de nuestro equipo están conectadas a Internet o no.

Además esta función nos permite saber a través de unas constantes que se pueden comparar con el resultado devuelto en "flags", cómo estamos conectados a Internet:

    private const int INTERNET_CONNECTION_CONFIGURED = 0x40; //Conexión a Internet configurada, pero no tiene porqué estar activa
    private const int INTERNET_CONNECTION_LAN = 0x02; //Se usa la red local para salir a Internet
    private const int INTERNET_CONNECTION_MODEM = 0x01; //se usa un módem
    private const int INTERNET_CONNECTION_PROXY = 0x04; //Se sale a través de un proxy

Así que incluso podemos obtener información extra interesante.

En cuanto pueda meto el resto de métodos que se me ocurren y preparo un ejemplo de código :-)

En mi post anterior sobre novedades de C# 3.0 hablé sobre los tipos anónimos. En el ejemplo de código use una palabra clave nueva, 'var', cuyo significado dejé para hoy. Algún lector asiduo se adelantó ademas preguntando algo sobre cómo se determinaban los tipos de las propiedades de las clases anónimas así definidas.

La nueva palabra clave 'var' sirve para declarar variables locales sin indicar su tipo. Así podemos escribir, por ejemplo:

var i = 1;
var nombre = "JM";
var personajillo = new PersonaHumana("Perico", "De los palotes", 42)

Es muy parecido a la sintaxis de JavaScript, pero con una importante diferencia: el hecho de que no indiquemos el tipo no quiere decir que no lo tengan, ya que C# sigue siendo un lenguaje fuertemente tipado. Lo hace var no es declarar una variable sin tipo, sino que declara la variable con el tipo adecuado para contener el dato indicado, siendo dicho tipo deducido a partir del valor.

Así en el código anterior 'i' será un entero, 'nombre' será una cadena y 'personajillo' será una referencia a un objeto de la clase indicada.

En JavaScript y otros lenguajes sin tipado fuerte puedes cambiar alegremente el tipo de dato almacenado por una variables, pasando de contener un entero a una cadena, por ejemplo. En C#, gracias a los dioses, no es así.

Esta característica se ha introducido para dar soporte a los tipos anónimos que expliqué en el anterio post, y por lo tanto como expliqué allí, realmente para dar soporte a LINQ.

Por mi parte recomendaría no usarlos en situaciones normales porque el código queda menos claro y pueden dar lugar a confusiones, si bien no tengo otras razone de peso como por ejemplo que bajen el rendimiento o algo así. De hecho es lo miso que declarar el tipo de verdad, pero desde mi punto de vista dejas más cabos sueltos que si lo haces explícito.

Hola a todos:

Este mes tenemos varias novedades en campusMVP, como seguramente ya muchos habréis visto en el boletín, pero las reflejo aquí también...

La primera es que hemos lanzado nueva convocatoria de nuestros cursos de certificación. Comienzan el día 1 de febrero. Disponemos del curso 70-536 de fundamentos, la base para todas las certificaciones de desarrollo (tanto en C# como en VB), el 70-528 de desarrollo Web, el 70-540 de aplicaciones móviles y el 70-431 de SQL Server. También como no, el exitoso 70-290 de Windows Server 2003.

Más información sobre los cursos de certificación.

La otra novedad es la disponibilidad de dos nuevos cursos on-line que estamos seguros de que van a gustar ya que son resultado directo de vuestras peticiones:

· Desarrollo de aplicaciones Web mejoradas con AJAX. Podrás crear aplicaciones Web  con características avanzadas similares a las de escritorio: arrastrar y soltar, regiones desplegables, tareas asíncronas, interfaz rápida y sin parpadeos, animaciones, etc... Abarca las versiones 2005 y 2008 de Visual Studio.

· Creación de controles Web profesionales para ASP.NET: En este curso se enseña todo lo que necesitas saber para crear controles complejos con ASP.NET, tanto para uso interno como para su comercialización, abarcando desde los temas más básicos a los avanzados.

Indispensables para todo desarrollador Web :-)

¡Comienza el año aprendiendo y matriculate con nosotros!

Siguiendo con las serie de post sobre C# 3.0 y sus novedades hoy le toca el turno a los tipos anónimos.

Los tipos anónimos nos permiten definir clases de un solo uso dinámicamente, lo cual tiene una importancia vital en el manejo de resultados de consultas LINQ. De hecho, si no me equivoco, se añadieron al lenguaje precisamente para ello.

Una clase anónima se define con la palabra clave new, igual que una clase normal, pero no se le da nombre (de ahí lo de anónima) y se crea sobre la marcha a partir de los datos que se le pasen al constructor. Por ejemplo:

var nuevoMVP = new { Nombre = "José Manuel Alarcón", Especialidad = "ASP.NET", PrimerAño = 2004 };

Ahora ya podemos usar la variable 'nuevoMVP' como si hubiésemos instanciado una clase definida en el código de manera normal, por ejemplo:

Console.Write(nuevoMVP.Nombre);

Esto permite manejar datos "sintetizados" dinámicamente como resultados de consultas LINQ que contengan campos arbitrarios obtenidos desde la fuente de datos subyacente.

Como puedes suponer, realmente no son anónimos. Si usas reflexión (o directamente desemsamblas un código que los use) verás que el compilador genera internamente una clase con un nombre "raro" (como en el caso de las propiedades automáticas), lo que pasa que para el uso que hacemos es completamente irrelevante.

Otro detalle es que, en realidad, se denominan tipos anónimos inmutables. Ello se debe a que no se pueden modificar sus valores (las propiedades creadas son de solo lectura). Como vemos su uso es muy específico y relacionado con lo que comentaba de LINQ.

Por cierto, ¿te has fijado en la forma tan "extraña" de definir la variable que contiene la referencia al tipo anónimo? ¿Qué es eso de 'var'?

Pues es otra de las novedades importantes de C# 3.0 y además una de las más polémicas. Lo explicaré en el próximo post.

Estos días he estado trabajando unas cuantas horas de mi (poco) tiempo libre en una idea que tuve ya hace bastante tiempo. Se puede resumir con sólo una frase: crear una pequeña biblioteca JavaScript que, añadida a tu página Web (PHP, ASP, ASP.NET...) la dotará automáticamente de funcionalidad AJAX, sin que tengas que escribir ni una sola línea de código.

Pensé que iba a resultarme mucho más dificil, pero lo cierto es que ha sido bastante fácil de conseguir.

Ahora ya la puedo presentar para que el que quiera se descargue el resultado: AJAXInterceptor 0.5 Beta.

Sólo con añadir este pequeño módulo JavaScript al final de tus páginas consigues que los envíos de tus formularios se intercepten (de ahí el nombre), y en lugar de enviarse la petición al servidor de la manera normal, se hacen de manera asíncrona y en un modo suave estilo AJAX.

Dado que es una biblioteca de lado de cliente funcionará con cualquier tecnología de servidor: ASP.NET, PHP, JSP, Classic ASP... e incluso con archivos locales HTM. No obstante sólo lo he probado con aplicaciones ASP.NET y ASP 3.0 (por favor, mándame un correo si lo pruebas con otra tecnología de servidor),

He incluido extensibilidad en el módulo de modo que puedes añadir fácilmente tus propios indicadores de progreso personalizados (he incluido varios) y mostrar mensajes de error de la forma que prefieras (por defecto muestra una ventana de alerta para los errores).

La biblioteca funciona interceptando el envío de los formularios. Soporte tanto formularios enviados automáticamente (con botones de envío o la tecla 'enter'), y envíos de formularios hechos mediante código llamando al método submit(). Respeta además los posibles manejadores del evento onsubmit que hayas creado, por lo que puedes hacer la validación de formularios de la manera habitual (he buscado que sea lo más transparente posible).

Resumen de características:

• AJAXificación de aplicaciones Web sin escribir código
• Soporte de cualquier tecnología Web incluyendo ASP.NET, JSP, PHP, ASP 3.0...
• En ASP.NET soporte cualquier tipo de postback: directos y por código.
• Funciona en cualquier navegador moderno que soporte AJAX.
• Soporte el envío cruzado de formularios, es decir, puedes enviar la información a otras páginas diferentes dentro del mismo dominio. Si todas las páginas de tu sitio tienen AJAXInterceptor incluido (por ejemplo porque lo metes en una Master Page o en una plantilla) puedes tener todo el sitio AJAXificado.
• Respeta tus manejadores de evento de onsubmit.
• Soporta la historia del navegador de forma que tus usuarios pueden pulsar el botón "Atras" en el navegador y volver a la página anterior aunque la actual haya sido cargada con AJAX.
• He incluido dos versiones del módulo:
    - AJAXInterceptor.js: comentado por completo. Útil para depurar apliaciones.
    - AJAXINterceptor_r.js: versión reducida de tamaño. Se descarga más rápido ya que sólo ocupa 2.6 kB. Es mejor usar esto en aplicaciones en producción.
• Muestra y oculta automáticamente indicadores de progreso personalizados.
• Soporta la cancelación de las peticiones.
• Soporta la visualización personalizada de mensajes de error.
• Soporta cualquier formulario que haya en una página (si hay varios).

Obviamente no es un sustituto de una API potente como ASP.NET AJAX de Microsoft, PHPLiveX o AJAX.NET, pero te permitirá añadir soporte AJAX a tus aplicaciones en unos segundos y sin escribir código. ¡Dale una oportunidad y pruébalo!

En el ZIP encontrarás el módulo, un ejemplo de uso con ASP.NET y un PDF con la documentación de ayuda.

Me gustaría mucho que me escribieses en caso de que lo llegues a usar en alguna aplicación real o si lo mejoras con nuevas características. Usa el enlace "Contacto" que hay en el lateral de esta página para enviarme un e-mail.

Descargar: AJAXInterceptor 0.5 Beta (834 KB) ¡Freeware!

Actualización: Hoy (16/1/2008) he añadido el proyecto a CodePlex: http://www.codeplex.com/AJAXInterceptor. A partir de ahora las modificaciones y añadidos (de haberlos) irán apareciendo allí.

These last days I've been working a few hours of my spare time on a idea I had long time ago. It can be summed up in just one sentence: to write a small JavaScript library that added to your Web page (PHP, ASP, ASP.NET...) will enable it to be AJAX-enabled without you needing to write a single line of code.

I thought that it would be more difficult, but the fact is that it's been quite easy to achieve.

Now I can present it for you to freely download the result: AJAXInterceptor 0.5 Beta.

Just by adding this small JavaScript module to the end of your web pages, you get your form's submissions intercepted and, instead of sending request to the server in the usual way, they are done asynchronously and in an AJAX-style smooth way.

As long as it is a client-side library it will work with any server technology: ASP.NET, PHP, JSP, Classic ASP... and even with local HTM files. However I've only tested it against ASP.NET and ASP 3.0 applications (please, drop me a line if you test it with other server technologies).

I've included extensibility so that you can add easily your own progress indicators (several included) and show error messages the way you prefer (by default it shows an alert).

The library works by intercepting the submission of forms. It supports automatically submited forms (with submit buttons or the 'enter' key), and form submissions doing by code calling the submit() method. It respects the possible onsubmit event handlers you may have, so you can make your form validation as usual.

Features summary

• No-code AJAXification of web apps
• Supports any server technology, including ASP.NET, JSP, PHP, ASP 3.0...
• In ASP.NET it supports all kinds of postbacks: direct and by code.
• Works in any modern browser that supports AJAX.
• Supports cross-posting of forms, that is, you can send the information to any web page in the same domain. If all your web pages have AJAXInterceptor included (for example, you include it in your master page or template) you can hace
• Respects your custom onsumit event handlers.
• Supports browser history so that your users can hit the previous button and get the last rendered page.
• Two versions of the module:
    - AJAXInterceptor.js: full commented one. Useful for debugging purposes.
    - AJAXINterceptor_r.js: reduced-size version. It downloads faster as it only is  2.6 kB in size. It's better to use this on production apps.
• Automatically show/hide custom progress indicators.
• Support for cancelling operations.
• Support for custom message displaying.
• Supports any form in your page

Obviously this is not substitute at all of full-fledged APIs like Microsoft's ASP.NET AJAX, PHPLiveX or AJAX.NET, but will let you add AJAX support to your apps in a few seconds and without writing any code. Just give it a try!

In the ZIP you will find teh module, a working sample with ASP.NET and a PDF with the help documentation.

I will be very glad if you drop me a line in case you use AJAXInterceptor in any real-world application or if you enhance it with new features. Just use the 'contact' link in the left side of this page to send me an email.

Download: AJAXInterceptor 0.5 Beta (834 KB) ¡Freeware!

Update: Today (1/16/2008) I've added the project to CodePlex: http://www.codeplex.com/AJAXInterceptor. Next releases and additions (if any) will be added there.

Tengo intención de repasar estos días brevemente algunas novedades que trae la versión 3.0 del lenguaje C#, que viene con .NET 3.5 y con Visual studio 2008. Hay un poco de todo: cosas sencillas y complejas pero todas interesantes. Las intercalaré con algunos otros posts normales que se me vayan ocurriendo.

Hoy, como primer post sobre el tema, voy a describir algo muy sencillo pero de gran utilidad: las implementación automática de propiedades.

Generalmente cuando definimos una propiedad de C# debemos declarar una variable privada para contener los valores, así como sus métodos set y get para asignarla y recuperarla. Si no necesitamos añadir lógica y la propiedad sólo es un envoltorio deuncampo privado (algo super-común) avabamos repitiendo todo el tiempo multitud de código como este:

private string _nombre;

public string Nombre
{
  get
    {
      return _nombre;
    }
  set
    {
      _nombre = value;
    }
}

Un verdadero "peñazo" para hacer todo el tiempo lo mismo. Vale que en el ditor de Visual Studio tenemos la macro "prop" que nos ayuda a escribirlo pero ¿para qué hacerlo si es evidente cómo va todo el tiempo?

Eso debieron de pensar los diseñadores del lenguaje por que le han añadido una capacidad nueva para declarar propiedades como la anterior de manera rápida. Así para definir una propiedad idéntica a la anterior sin esfuerzo basta con escribir lo siguiente:

public string Nombre { get; set;}

¡Listo!. El compilador generará todo lo demás por nosotros escogiendo un nombre aleatorio para la variable privada (bastante feo por cierto) y dejando más claro y mucho más conciso nuestro código.

Hola a todos:

Ya he vuelto de mis pequeñas vacaciones navideñas en la nieve y, como casi siempre, me he traido un regalito... Lo cierto es que estos días de vuelta estoy muy falto de tiempo y no puedo preparar ningún artículo en condiciones, así que trato de compensarlo así, jeje. Así que ahí os lo dejo. Dentro de unos días espero estar más liberado y publicar algunas cosas interesantes para todos.

El regalito en cuestión es una colección de manejadores de vista previa para Windows Vista. Una característica muy chula de la nueva interfaz de Vista es la "vista" previa de archivos (en fin...). Aunque Vista trae manejadores para los formatos más básicos le faltan muchos. Por ejemplo, no trae uno para documentos PDF (con lo fácil que es de hacer usando el control ActiveX de Acrobat Reader), si bien Adobe en la última versión del Reader (la 8.1) ya lo ha incluido.

Otros manejadores que no incluye son vistas previas para archivos de código, como .aspx (páginas ASPX), .cs (código C#), etc... El bueno de Tatham Oddie ha creado unos manejadores que nos permitirán ver directamente desde el explorador de Windows el contenido de muchos de estos archivos, ahorrándonos tiempo:

Así, basta con ponernos encima para poder ver su contenido sin abrir Visual Studio u otro editor de código.

Con estos visores podremos ver los siguientes tipos de archivos:

• ASP.NET (.aspx)
• Batch files (.bat)
• C# (.cs)
• Cascading Style Sheets (.css)
• JavaScript (.js)
• Patch files (.diff)
• Ruby (.rb, .rhtml, .rjs)
• SQL (.sql)

Por desgracia (o más bien por falta de tiempo me imagino) no ha incluido visores para algunos otros tipos de archivo útiles (por ejemplo .vb o .config), pero están bastante bien y se lo agradecemos mucho.

No te olvides de activar el panel de vista previa en tus carpetas de código así:

Estos visores funcionarían también en teoría con la vista previa de Outlook 2007 pero no tienen utilidad puesto que los archivos de código no te los deja enviar ni abrir, así que...

¡Qué los disfrutes!