Autor: aruiz

Hola!

Cuando desarrollamos una aplicación ASP.NET, nos podemos encontrar con la necesidad de depurar código JavaScript para ver si lo hemos implementado correctamente. Con Visual Studio 2003 (y con 2005 también) podemos hacerlo de una forma muy sencilla. En este artículo veremos cómo podemos hacerlo.

Para depurar código JavaScript se
puede utilizar el Visual Studio .NET 2003. Antes hay que hacer un par de pasos
previos:

1. Ir al escritorio, botón derecho sobre el icono de
   Internet Explorer, seleccionar Propiedades (esto es lo mismo que en una ventana
   del IE ir a Herramientas -> Opciones de Internet).
2. Seleccionar la pestaña Opciones Avanzadas.
3. En el árbol que aparece, bajo el apartado Examinar,
   deseleccionar los checks «Deshabilitar la depuración de secuencias de comandos
   (Internet Explorer)» y «Deshabilitar la depuración de secuencias de comandos
   (otros)».

Con esto tenemos configurado el IE para que cuando se
produzca un error en Javascript nos pregunte si queremos depurar.

El siguiente paso es abrir el IE, y abrir el Visual
Studio 2003. En el menú Herramientas, seleccionar la opción
«Procesos de depuración…» (Ctrl+Alt+P)» y en la
lista de procesos que aparece, debemos buscar el proceso IEXPLORE.EXE. Si
tenemos varios IE abiertos, examinad la columna que indica el título de la
ventana (es la tercera, se llama Título).

Seleccionad el proceso a depurar haciendo doble
click, y os aparecerá una ventana en la que se puede elegir qué queremos
depurar. Aseguraos de que la útlima opción está marcada («Script»), y para
cerrar la ventana del tipo de depuración, pulsad en Aceptar.

El proceso seleccionado se añadirá a la lista
inferior de la ventana de la lista de procesos. Podemos cerrar esta ventana
pulsando el primer botón de la derecha (Cerrar).

Cuando depuramos el IE, podemos ver una lista de los
documentos html que tiene cargados en ese momento y ver el código HTML y
JavaScript de los mismos si abrimos la ventana «Documentos en ejecución». Para
ello, vamos al menú Depurar, seleccionamos la opción Ventanas, y entre la lista
de las ventanas a mostrar seleccionamos «Documentos en ejecución». Normalmente
aparecerá en la parte de la derecha, donde está el Explorador de Soluciones. Si
hacemos doble click en cualquiera de los documentos HTML que tenga cargados,
podremos introducir puntos de ruptura (Breakpoints), y cuando se alcancen,
podremos depurar.

Otra opción es la de hacer saltar al depurador cuando
nosotros deseemos, sin poner un punto de ruptura explícitamente. Esto se
consigue escribiendo «debugger;» (sin las comillas) en nuestro código
JavaScript. Cuando a ejecución llegue a esa línea, si estamos depurando el IE,
saltará automáticamente al depurador. Ojo, aseguraos de que las llamadas al
depurador no estén en la versión final, ya que lo que hace esto es producir una
excepción que el depurador entiende. Los usuarios finales verán un mensaje de
error en la pantalla si dejamos la línea «debugger;».

Por cierto, esta misma técnica la podemos utilizar para depurar páginas ASP (ojo, ASP del antiguo, no ASP.NET). En este caso, el proceso que tenemos que depurar es inetinfo.exe si la aplicación se está ejecutando con protección de aplicación (App. Isolation) Bajo (se ejecuta en el mismo proceso del IIS). Si usamos otra protección de aplicación, el proceso a depurar será un dllhost.exe, que podremos identificar por la columna Tipo de la lista de procesos (deberá tener un tipo «Script»).

Pues esto es todo por hoy. Saludos!

Pablo Álvarez me ha marcado. Con premeditación y alevosía. Y la verdad es que ya quedan pocos a los que marcar… 😉

Así que ahora se supone que tengo que contar cinco cosas sobre mí que la mayoría de la gente desconozca (al menos la gente del plano digital, claro está). Pueeees, ¡vamos allá!

1. Soy zurdo. Pero zurdo, zurdo. Hago casi todo con la izquierda, y la derecha es más bien la mano tonta. Excepto para el fútbol, que tengo dos piernas derechas (desde la perspectiva de un zurdo, claro).
2. De pequeño jugaba al balonmano en mi colegio. Era un campeón calentando banquillo, porque como tenía el culo más bien grande, podía calentar dos sitios de una sola vez. Eso y el hecho de ser zurdo hacían que fuese un activo muy cotizado para un equipo de balonmano que perdía casi todos los partidos. 😛
3. Empecé en esto de la informática hace mucho, mucho tiempo en una galaxia… esteeee, no, en Valladolid. Mis padres compraron un Amstrad CPC 464 (sí, de los de cassette, con 64kb de RAM) y, aunque al principio lo usaba únicamente para jugar, poco después, intrigado por lo que hacían mis hermanos, aprendí a programar en BASIC, haciendo un pequeño juego de marcianos 1 contra 1, redefiniendo caracteres (SYMBOL…). Esto sería más o menos cuando tenía 9 años o así.
4. Durante un buen tiempo fui cantante de un grupo de rock. Como no sabía tocar ningún instrumento, me pusieron ahí, a hacer bulto. Y dimos unos cuantos conciertos en Valladolid. (Tengo pruebas!!!! aquí, aquí y aquí). Poco después de empezar, aprendí a tocar la guitarra (malamente). Ficheros ogg: éste, éste, éste, éste y éste.
5. También estuve un par de años haciendo un programa de radio en una emisora local de Valladolid, en la que teníamos que pagar para poder hacerlo (3.000 pelas al mes), el programa era semanal, de una hora de duración. Cachondeo, música, y crítica a la música de usar y tirar. Se llamaba Boogie, y era en Onda Verde.

Y para continuar la cadena… Marco a Emilio Calvo, a Bruno González, a Diego García Morate, a José Luis Ramos, y a The ZMan (Andy), que muchos de ellos tienen su blog algo olvidadete… 😉

Saludos!
 

Hola!

Hoy voy a hacer un artículo sobre sincronización de hilos. He visto alguna que otra vez una forma poco correcta de hacer que un hilo padre espere a que su hijo haya terminado (como quedarse en un bucle con un Sleep y comprobar periódicamente si el hilo hijo está vivo), así que voy a explicar una forma muy sencilla de coordinar los hilos.

Como ejemplo podemos usar un servicio de Windows, ya que en estos servicios, la creación de un hilo suele ser casi imprescindible, porque lo normal es que cuando el servicio arranca nosotros generalmente querremos que el servicio se quede activo, pero debemos salir del método OnStart del servicio tan pronto como sea posible para evitar un Timeout en el arranque.

Además, sería interesante que cuando paramos el servicio, en el método OnStop del servicio, el hilo principal espere a que el hilo hijo termine aquello que esté haciendo en ese momento, para no cortar alguna operación que se pueda estar realizando cuando se quiere parar el servicio.

Para conseguir esto, en nuestra clase del servicio podemos declarar un miembro que contenga un WaitHandle en el que almacenaremos si nuestro hilo hijo ha terminado su ejecución. Este WaitHandle es el que usará el hilo padre para esperar al hilo hijo.

Una breve descripción de lo que haremos en el servicio será lo siguiente:

• Al arrancar el servicio, crearemos un hilo nuevo en el ThreadPool, usando el método QueueUserWorkItem, al que le pasaremos el WaitHandle que hemos definido en la clase. Como WaitHandle es una clase abstracta, podemos usar (por ejemplo) un AutoResetEvent.
• Al parar el servicio, esperaremos a que el hilo hijo que creamos al arrancar el servicio termine su ejecución. Para ello usaremos el método estático WaitAll de la clase WaitHandle, pasándole como argumento el objeto estático de tipo WaitHandle que usamos al arrancar el servicio.
• En el método que ejecuta el hilo hijo debemos:
• Recibir el objeto WaitHandle (AutoResetEvent) que nos pasa el hilo que nos ha creado, y almacenarlo.
• Agrupar la ejecución del servidor en un bloque try { … } finally { … } (se puede-debe poner un catch), y en el finally deberemos notificar que hemos terminado la ejecución, llamando al método Set del objeto AutoResetEvent que hemos recibido, así nos aseguramos de que notificaremos que hemos terminado la ejecución del hilo hijo al hilo padre.

Bueno, pues ésta es la idea básicamente.

Saludos! 

Hola!

Lo primero, feliz año nuevo a todos. (un poco tarde, ¿verdad?)

Hoy voy a tratar un tema un tanto puñetero, que no debería darse nunca en un mundo ideal en el que todo el mundo escribiese código manejado y no hubiese que utilizar componentes COM antiguos hechos con Visual Basic 6 (o cualquier otra tecnología que sea COM y utilice el modelo STA).

¿Por qué los servicios web .NET no se llevan bien con Visual Basic 6? Pues por una razón bastante sencilla. Supongamos que tenemos el escenario propuesto, es decir, un servicio web .NET que utiliza una dll programada con Visual Basic 6. Supongamos también que este servicio se utiliza muy a menudo, de manera que tenemos varias llamadas concurrentes.

Visual Basic 6 utiliza siempre un modelo STA para la generación de sus componentes, y no se puede bajo ningún concepto generar componentes que usen un modelo MTA en Visual Basic 6. Esto quiere decir que cada vez que se realizamos una petición vía COM a un componente desarrollado con Visual Basic 6, esta llamada se ejecutará siempre en el mismo hilo de ejecución. Si se llama varias veces de forma concurrente a dicho objeto, COM encolará las peticiones, ya que un único hilo sólo puede procesar una petición cada vez.

Sin embargo, los servicios web .NET siempre utilizan un modelo MTA (al igual que las páginas aspx en .NET, salvo que utilicemos el atributo AspCompat). Esto quiere decir que para cada petición que realicemos a nuestro servicio, se creará un hilo diferente que llevará a cabo dicha petición. Esto lo podemos comprobar utilizando el siguiente servicio de prueba:

using System;

using System.Web;

using System.Web.Services;

using System.Threading;

[WebService(Namespace = "http://tempuri.org/")]

public class ServicioPrueba : System.Web.Services.WebService

{

    [WebMethod]

    public string Prueba()

    {

        return Thread.CurrentThread.ApartmentState.ToString();

    }

}

Ahora pongamos ambos modelos en correspondencia: El WebService usa MTA, y el componente usa STA. En el siguiente diagrama (obtenido del artículo de Jeff Prosise «Running ASMX Web Services on STA Threads«) podemos ver cómo se procesan las llamadas a nuestro componente COM:

Si estuviésemos utilizando una página web, podríamos aplicar el atributo AspCompat a la directiva @Page de nuestra página web, consiguiendo que nuestra página se ejecute en un modelo STA. Sin embargo, dicho atributo NO existe para la directiva de los WebServices: @WebService.

¿Qué podemos hacer entonces? En su artículo, Jeff nos propone la siguiente solución: Crear un httpHandler, que herede de System.Web.UI.Page, y que se encargue de procesar las llamadas a los WebServices. El hecho de heredar de Page nos permitirá aprovechar toda la infraestructura creada para soportar el comportamiento que controla el atributo AspCompat (es decir, que tenemos implementado y accesible lo necesario para poder ejecutar nuestro código bajo el modelo STA).

El siguiente diagrama mostraría cómo se procesan las llamadas utilizando el httpHandler propuesto en el artículo:

Tened en cuenta que esto hay que configurarlo en el web.config para que a la hora de procesar nuestros servicios se utilice el httpHandler. En el artículo lo configura para que este httpHandler se haga cargo de todos los servicios web, y normalmente eso no es lo que necesitamos, así que cuidadín, y a configurarlo correctamente. Por ejemplo, podríamos agrupar los WebServices que deben ejecutarse bajo STA en una ruta concreta, y colocar en esa ruta el fichero web.config que define el httpHandler.

Bueno, pues aquí lo voy a dejar por hoy. Saludos! 

Hola!

Este artículo de phobeo me ha parecido una idea genial. Pequeños problemas para hacernos escurrir el coco e intentar hacerlo de la mejor manera posible 🙂

Así que, como indico en el título, voy a recoger el guante, pero poco a poco. Es decir, voy a exponer mi solución al segundo problema: Cómo darle la vuelta a los bits de un byte.

He decidido implementarlo usando recursividad. La idea es que el reverso es igual al reverso de la segunda mitad colocado en la primera mitad más el reverso de la primera mitad colocado en la segunda mitad. (Qué enrevesado suenaaaaa dicho con palabras… [:(] )

Bueno, un código vale más que mil palabras:

#include "stdafx.h"

#include "conio.h"

#define BYTE unsigned char

BYTE reverseChar(BYTE input, BYTE first, BYTE last);
BYTE reverse(BYTE input);

int _tmain(int argc, _TCHAR* argv[])
{
    BYTE input;
    BYTE resultado;
    int num = 0;
    int lookUp[255];

    for(int i=0; i<256; i++)
    {
        lookUp[ i ] = -1;
    }

    while(num != -1)
    {
        printf("Introduzca un numero entre 0 y 255 (-1 para terminar): ");
        scanf("%d", &num);

        if((num > -1) && (num < 256))
        {
            if(lookUp[num] == -1)
            {
                input = (BYTE) num;
                resultado = reverse(input);
                lookUp[input] = resultado;
            }
            else
            {
                resultado = (BYTE) lookUp[num];
            }

            printf("El byte dado la vuelta es: %d.n", resultado);
        }
    }

    return 0;
}

BYTE reverse(BYTE input)
{
    return reverseChar(input, 0, 7);
}

BYTE reverseChar(BYTE input, BYTE first, BYTE last)
{
    BYTE mask = 0x01;
    BYTE result = 0;
    BYTE delta;
    BYTE half1, half2;

    if(first == last - 1)
    {
        result = ((input & (mask << last)) >> 1) | ((input & (mask << first)) << 1);
    }
    else
    {
        delta = (last - first + 1) >> 1;
        
        half1 = reverseChar(input, first + delta, last);
        half2 = reverseChar(input, first, first + delta - 1);

        result = (half1 >> delta) | (half2 << delta);
    }

    return result;
}

Bueno, pues nada más por hoy. Dejo el código fuente en un ficherico zip adjunto.

Hace ya unos cuantos años, antes de venir a Madrid, empecé a trabajar en Valladolid gracias a un buen amigo. En esa empresa tuve suerte de conocer a un «mega-crack» de la programación. Ése sí que era un Chuck Norris de la programación (como diría Pablo).

La persona en cuestión era Ciriaco García de Celis. Puede que el nombre no os suene a los más jóvenes, pero os puedo decir que él creó el programa 2M (un residente de MS-DOS gratuito que permitía formatear discos de 3 1/2 a 1.88Mb, y discos de 5 1/4 a 1.4Mb), entre otras muchas cosas. También diseñó un sistema de protección de aplicaciones basado en software que sólo se le puede ocurrir a alguien que conoce muy bien el hardware a bajo nivel, resistente al formateo de la máquina, por decir alguna otra perlita.

Pues bién, él fue el autor de un libro llamado «El Universo Digital», que tuve la suerte de comprarme en edición impresa. Hoy en día está disponible en internet, con una introducción que no aparece en el libro en papel. Ese libro era uno de los dos que podíamos llevar al examen de «Periféricos», una asignatura optativa muy interesante que se da en I. T. Sistemas, en el que aprendías a usar el hardware a bajo nivel – con C (qué jodío que era el puerto serie, oye). El otro era la Mega Biblia del PC de aquella época, el «PC Interno» (de Data Becker).

Con este pequeño recuerdo quería hacerle un breve homenaje, ya que, probablemente sin que él lo sepa, aprendí un montón de cosas de él.

Hola!

Otro MicroArtículo. Esta vez vamos a ver cómo manipular los colores de una imagen utilizando la clase ColorMatrix. En concreto, el ejemplo que voy a mostrar es cómo pintar imágenes semitransparentes utilizando esta clase.

La clase ColorMatrix representa una matriz de transformación de colores. Los colores se representan mediante un vector (B,G,R,A,w) en su forma homogénea, en la que w siempre es igual a 1. (El resto del mundo lo representa como A,R,G,B,w). Por lo tanto, para transformar un color en otro, lo podemos multiplicar por una matriz 5×5.

Esta matriz contiene una serie de coeficientes que definen la transformación propiamente dicha. Si utilizamos la matriz identidad (una en la que todos los valores son 0 salvo la diagonal, cuyos valores son 1), modificando el valor que representa la opacidad – el canal alpha, o A en el vector) podremos dibujar una imagen semitransparente:

float[][] matrix = new float[][] { //B     G     R     A        w

                      new float[] {1.0f, 0.0f, 0.0f, 0.0f,     0.0f},  // B

                      new float[] {0.0f, 1.0f, 0.0f, 0.0f,     0.0f},  // G

                      new float[] {0.0f, 0.0f, 1.0f, 0.0f,     0.0f},  // R

                      new float[] {0.0f, 0.0f, 0.0f, opacidad, 0.0f},  // A

                      new float[] {0.0f, 0.0f, 0.0f, 0.0f,     1.0f}   // w

                                   };

En el caso en el que queramos aplicar una transformación a los colores, como puede ser por ejemplo el paso a escala de grises, donde el tono de gris viene dado por lo siguiente:

R' = G' = B' = 0.3 * R + 0.59 * G + 0.11 * B

A = 1

La matriz de transformación será la siguiente:

float[][] matrix = new float[][] { // B      G      R     A     w

                      new float[] {0.11f, 0.11f, 0.11f, 0.0f, 0.0f},  // B

                      new float[] {0.59f, 0.59f, 0.59f, 0.0f, 0.0f},  // G

                      new float[] { 0.3f,  0.3f,  0.3f, 0.0f, 0.0f},  // R

                      new float[] { 0.0f,  0.0f,  0.0f, 1.0f, 0.0f},  // A

                      new float[] { 0.0f,  0.0f,  0.0f, 0.0f, 1.0f}   // w

                                 };

Bueno… Pues nada más por hoy. Tenéis en el código adjunto un control que hace estas dos transformaciones, para que jugar un poco con ellas. Una aclaración: En el formulario del proyecto de prueba he puesto el color de fondo del control a Rojo, para que se vea más claramente que se está pintando semitransparente, ok? No es que esté dejando el canal rojo a 1 😉

Iba a contestar en un comentario a este post del blog de Juan Fco. Berrocal en el que se comenta cómo limpiar los textboxes de un formulario de una manera sencilla, pero voy a aprovechar para hacer un microartículo (pero micro micro) 😉

Aquí presento lo que me parece una versión un poco más depurada del tema que se trata en el post de forma implícita (manipulación de varios controles de una sola vez). Y debajo explico por qué lo hago así.

private void btnLimpiar_Click(object sender, EventArgs e)

{

  limpiarTextBoxes(this);

  // Y opcionalmente...

  this.textBox1.Focus();

}

private void limpiarTextBoxes(Control parent)

{

   TextBox t;

   //Limpiar de manera rapida

   foreach (Control c in parent.Controls)

   {

       t = c as TextBox;

       if (t != null)

       {

           t.Clear();

       }

       if (c.Controls.Count > 0)

       {

           limpiarTextBoxes(c);

       }

   }

}

La única diferencia es que en el bucle foreach de la rutina que limpia el texto del TextBox, se hace un casting del Control a TextBox usando la palabra reservada «as» de C#. Esto lo que hace es que si el control es un TextBox (o un derivado de él) obtiene una referencia de tipo TextBox, y si no, devuelve null. Lo bueno es que obtenemos una referencia tipada con la clase que queremos manipular.

Creo que es más claro hacer esto como ejemplo, porque si quisieras llamar a un método o usar una propiedad que sólo implementa la clase TextBox (por ejemplo la propiedad CharacterCasing) y no lo implementa la clase Control, utilizando este código sí que es posible, y con el anterior no…

Hala, pues ya está. ¿A que ha sido realmente micro?

Saludos!

EDITADO: He cambiado el código según la sugerencia de Alejandro Mezcua, para limpiar el TextBox utilizando el método Clear, en vez de Text = «». El motivo lo podéis ver en los comentarios 😉
 

Lo primero, disculparme por no haber publicado nada últimamente. Entre el acueducto y que tengo una situación complicada entre mis manos actualmente… No he podido sacar el tiempo necesario para leer ni escribir mucho 🙁 

Leo en The Code Project un par de artículos escritos por Eric Woodruff bastante interesantes sobre SandCastle.

El primero de ellos presenta una herramienta GUI para generar los ficheros de ayuda. El aspecto de esta herramienta es muy familiar, se nota que está claramente basado en nDoc. 😉

Sandcastle Help File Builder

El segundo artículo comenta cómo se puede personalizar la herramienta BuildAssembler para añadir características que puedas necesitar y que no proporcione directamente la herramienta, implementando componentes de generación (Build Components).

Creating Custom Build Components for Sandcastle

Hola!

Quería comentaros que existe una web dedicada a los juegos que se desarrollaron en España durante la época en la que el Spectrum era el ordenador personal más vendido. Esta web, Computer Emuzone, tiene un foro muy activo, y tiene su propio equipo de desarrollo formado por gente entusiasta que dedica horas de su tiempo a desarrollar nuevos juegos para máquinas de 8 bits (Spectrum, Amstrad CPC, MSX) así como Remakes.

Además… Soy miembro del equipo de programación [:$]

Os dejo aquí alguna muestra de lo que se está desarrollando…

Remake del juego de Made In Spain «Sir Fred» (completado)

El Remake del juego de Dinamic «El Capitán Sevilla» (en desarrollo)

Juegos de CEZ GS

Alucino con lo que se puede meter en menos de 48Kb… 😉