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 🙂

Ya he comentado aquí varias veces cuánto me gusta la revista Spectrum del IEEE.

En el número de Diciembre viene un artículo que me ha llamado poderosamente la atención. Se trata de la historia de Richard Thurman (nada que ver con la maravillosa Uma), un programador de -ahora- 35 años que harto de su trabajo y aficionado a los juegos on-line se decidió a ganarse la vida haciendo trampas automatizadas en juegos on-line.

En concreto estuvo tres años ordeñando la pila de dinero que le podían ofrecer los aficionados a Everquest. Lo que hizo fue crear una DLL que le permitía tocar las posiciones de memoria apropiadas para hacer una interfaz de comunicación con el cliente de este juego. Luego con una aplicación escrita en VB.NET se comunicaba con el juego a través de esta interfaz y creó con mucho esfuerzo (50.000 líneas de código) un programa que jugaba de manera automática al juego, matando dragones, concinando pollos para venderlos, etc… Compró 30 ordenadores baratos y varias líneas de conexión a Internet para no llamar la atención y durante 3 años estuvo ganando dinero a expuertas (hasta, en determindos momentos, ¡2.400 dólares a la hora!). ¿Cómo es esto posible?

Lo que conseguía era oro digital que no tiene valor a priori en el mundo real. No obstante hay tante gente jugando a este tipo de juegos, estilo World of Warcraft, Halo 3, y similares, que pagan muchísimo dinero por conseguir objetos virtuales que necesitan para jugar, como oro digital, espadas, armaduras, etc… Incluso hay quien, como no puede dedicarle todo el tiempo que le gustaría, paga a gente para que jueguen por ellos.

Se estima que el mercado mundial de objetos virtuales para juegos on-line mueve al año entre 200 y 1.000 millones de dólares. Mucha pasta. A mi, que no soy aficionado a estas cosas y que jamás he jugado a un juego de este estilo, me parece absolutamente increible y es un mundo que desconozco pero que me está empezando a fascinar a raíz de este artículo.

Bueno, el caso es que el bueno de Richard ganaba muchos objetos virtuales (sobre todo oro) y luego los cambiaba por dinero real en las páginas de intermediarios de este mercado que abundan sobre todo en Asia, ganando tanto dinero que dejó su trabajo.

Este tipo de cosas no gustan a los jugadores de verdad y mucho menos a las empresas como Sony o EA Games que están detrás de los juegos, pero el caso es que el comportamiento de este hombre no constituye una ilegalidad, y ese es el problema precisamente. De hecho el artículo habla también de un enorme mercado laboral oculto en China de decenas de personas hacinadas en sórdidas y humeantes habitaciones que juegan durante horas y horas todos los días por un mísero sueldo para conseguir estos objetos y ganar dinero para esas empresas. Son las llamadas Gold Farms. ¿Qué es más inmoral lo de Richard o esto? ¿Y si la gente que juega en las Gold Farms, lo hace porque le gusta además de por el dinero aunque sea un ambiente enfermizo?

Es un tema totalmente apasionante y muetra muy bien cómo los mundos virtuales y el mundo real se entrecruzan mucho más de lo que nos pensamos. Merece mucho la pena leer el artículo por que cuenta muchas cosas interesantes sobre estos mundos y el mercado negro que hay detrás, y también menciona algunos detalles técnicos sobre cómo funcionaba el sistema de Richard.

Lee el artículo completo «How to Game Online Gaming»

No te pierdas tampoco el anexo del artículo dedicado a la prostitución on-line. Cuenta como muchas mujeres (y algunos hombres haciéndose pasar por mujeres) se dedican a prostituir a sus personajes virtuales en mundos como Second Life que tienen enormes prostíbulos virtuales con sus propios proxenetas, barras americanas, etc… Absolutamente impresionante.

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.