Por otro lado está el BarÇa. Los regates del Madrid son de 20 metros, los del BarÇa son de 20 centímetros. El BarÇa ataca como una manada de lobos, acorralan por ambas bandas a su presa, su resistencia y trabajo en equipo la hace finalmente desfallecer, muchas veces sus goles se intuyen minutos antes. El Madrid ataca como un guepardo, se desplaza por el campo en modo de bajo consumo para apretar el kers en el momento justo, gastan todas las reservas de energía en 6 segundos, no se les ve venir. Te preguntas que ha pasado, estás jugando mejor que ellos, es injusto, absurdo. Y es que los dos son grandes depredadores, pero no tienen nada que ver. El BarÇa basa todo su juego en el pressing de una manada de lobos como mecanismo de inmediata recuperación de la pelota para ponerla al servicio de las mejores botas del mundo. Disputar la posesión del balón al BarÇa es imposible. Pero es evidente que últimamente algo ha cambiado en el BarÇa y Pep lleva un tiempo viéndolo. Han perdido a sus dos defensas más rápidos, Puyol y Abidal, bueno para las cualidades del felino. Eso ha supuesto trastocar un poco el esquema de juego y el rendimiento ha caído y la defensa se ha vuelto un poco más insegura, pero el Madrid no va a cambiar y el BarÇa va a tener la posesión del balón en la zona de 3/4 del campo, justo dónde los lobos son más peligrosos, justo dónde al felino parece no importarle.

No tengo claro que el partido del próximo sábado en liga sea el menos importante de los cuatro que a fecha de hoy se presupone que va a haber. Es el más psicológico de todos. Es el primer zarpazo. Pep nunca ha sido un tipo tranquilo (creo que ha sido el jugador del BarÇa que más rojas ha visto en toda la historia), hasta ahora eso tampoco se ha notado apenas, durante los dos últimos años todo ha ido de perlas, pero ahora se juega toda la temporada contra el Madrid y yo últimamente lo veo desquiciado, con lo listo y provocador que es Mourinho… mala mezcla, esa puerta hay que mantenerla cerrada Pep. El BarÇa se alimentó de las provocaciones de Mourinho y Cristiano para el 5-0 de la primera vuelta, me temo que esa puerta Mourinho ya la ha cerrado también, en Bilbao ya no compadeció en rueda de prensa y veremos a ver lo que hace esta semana. ¿Qué va a pasar? Yo me mojo y digo que el partido de liga lo gana el Madrid y la copa la gana el BarÇa (muy a mi pesar), pero bueno, si acierto, os prometo que si finalmente se cruzan en semifinales de Champions, volveré a hacer un pronóstico y si no, pues también, con un par . Mientras tanto, disfrutemos todos de una borrachera de goles, espero que la haya y que sea una fiesta de fútbol para todos, una fiesta bien llevada y que todos sepamos aprovecharnos de un acontecimiento sin precedentes para disfrutar como niños.

• Proporciona implementación de la interfaz IComponent, permitiendo ser situado en el diseñador de visual studio.
• Gestiona excepciones en el hilo de trabajo, lo cual quiere decir que no es necesario incluir bloques try/catch en el hilo de trabajo.
• Permite actualizar windows forms y controles WPF.

Vemos un ejemplo de su uso. He procurado comentar al máximo el código, explicando cada detalle que pueda resultar de interés:

using System;
using System.ComponentModel;
using System.Threading;

class Program
{
    static BackgroundWorker bw;

    static void Main()
    {
        // Creamos una instancia de la clase BackgroundWorker
        // con el objetivo de configurarla a nuestro gusto
        // para posteriormente arrancar la operación asíncrona.
        bw = new BackgroundWorker();

        // Queremos estar informados del estado de la operación.
        // Esto nos habilita para poder llamar a bw.ReportProgress().
        bw.WorkerReportsProgress = true;

        // Queremos tener la posibilidad de cancelar el proceso.
        // Esto nos habilita para poder llamar a bw.CancelAsync().
        bw.WorkerSupportsCancellation = true;

        // Suscripción a eventos.

        // DoWork es el hilo en donde se va a realizar la operación.
        bw.DoWork += bw_DoWork;

        // Este evento es el que tenemos que aprovechar para ser informados
        // del estado de la operación.
        bw.ProgressChanged += bw_ProgressChanged;

        // Este evento es el que se va a disparar cuando la tarea haya finalizado.
        // Aquí es donde vamos a poder recoger los resultados de la operación.
        bw.RunWorkerCompleted += bw_RunWorkerCompleted;

        // Una vez que ya hemos configurado el backgroundWorker como hemos querido
        // este método sirve para poner en marcha la operación
        // que potencialmente puede llevar un tiempo más o menos grande en realizarse.
        bw.RunWorkerAsync("¡Hola, hilo de trabajo!");

        // Ten en cuenta que después de la anterior llamada,
        // el hilo principal de la aplicación sigue con lo suyo.
        Console.WriteLine("Presiona ENTER dentro de los próximos 5 segundos para cancelar.");

        // Esto nos va a servir para que la aplicación no termine.
        Console.ReadLine();

        if (bw.IsBusy)  // Si estamos metidos de lleno en el bw_DoWork...
            bw.CancelAsync();   // pues le vamos a dar a cancelar.

        // Pulsamos cualquier tecla para finalizar.
        Console.ReadLine();
    }

    ///
    ///
    ///
    /// <param name="sender" />
    /// <param name="e" />
    ///
    /// DoWork se dispara en un hilo diferente al hilo principal de la aplicación.
    /// Desde aqui no podemos hacer referencia a ningún control de la aplicación.
    /// No es necesario que aquí coloquemos bloques try/catch.
    /// Si ocurre una excepción, bw_DoWork finalizará repentinamente
    /// disparándose inmediatamente bw_RunWorkerCompleted
    /// en donde tenemos la manera de saber que es lo que ha ocurrido.
    ///
    static void bw_DoWork(object sender, DoWorkEventArgs e)
    {
        // Cuando hemos llamado a bw.RunWorkerAsync()
        // hemos pasado información al hilo de trabajo.
        // Eso suele ser usado para suministrar al hilo de trabajo
        // información necesaria para que él sea capaz de hacer su tarea.
        string desdeHiloPrincipal = e.Argument.ToString();

        for (int i = 0; i <= 100; i += 20)
        {
            // Cada vez que iteramos,
            // comprobamos si nos han mandado salirnos.
            if (bw.CancellationPending)
            {
                // Si es así, informamos...
                e.Cancel = true;
                // y nos salimos.
                return;
            }

            // Informamos desde aquí acerca del progreso de la operación.
            bw.ReportProgress(i);

            // Aunque estemos en otro hilo diferente,
            // si no ponemos este Sleep aquí,
            // podríamos poner de rodillas al microprocesador,
            // la aplicación podría no responder,
            // obtendríamos justo lo que queremos evitar.
            // Lo que tu pares aquí, es tiempo que concedes al micro
            // para atender al hilo principal de la aplicación.
            Thread.Sleep(1000);
        }
        // Esto se pasa al evento RunWorkerCompleted.
        // Digamos que es el resultado final de la operación.
        // Result es un object, podemos pasar cualquier cosa.
        e.Result = 123;
    }

    ///
    /// bw_ProgressChanged se dispara tras la llamada a bw.ReportProgress(i)
    /// que hemos puesto en bw_DoWork.
    ///
    /// <param name="sender" />
    /// <param name="e" />
    ///
    /// bw_ProgressChanged se dispara en el hilo principal de la aplicación.
    /// Por eso podemos hacer desde él referencia a los controles de nuestra aplicación.
    /// Normalmente suele ser utilizado para actualizar barras de progreso.
    ///
    static void bw_ProgressChanged(object sender,
                                   ProgressChangedEventArgs e)
    {
        Console.WriteLine("Completado " + e.ProgressPercentage + "%");
    }

    ///
    /// Varios pueden ser los motivos por los cuales el proceso terminó.
    /// Desde bw_RunWorkerCompleted tenemos la manera de saber la razón
    /// y actuar en consecuencia.
    /// bw_RunWorkerCompleted también se ejecuta en el hilo principal de
    /// la aplicación, luego desde él también podemos hacer refenrencia
    /// a los controles de nuestra aplicación.
    ///
    /// <param name="sender" />
    /// <param name="e" />
    ///
    /// Puede ser que la operación haya sido cancelada por nosotros mismos.
    /// En ese caso, e.Cancelled = True.
    /// Puede ser que en bw_DoWork haya saltado una excepción.
    /// En ese caso, e.Error != null
    /// O puede ser que la operación haya finalizado sin más.
    ///
    static void bw_RunWorkerCompleted(object sender,
                                      RunWorkerCompletedEventArgs e)
    {
        if (e.Cancelled)
            Console.WriteLine("Tu cancelaste la operación!");
        else if (e.Error != null)
            Console.WriteLine("Excepción en el hilo de trabajo: " +
                              e.Error.ToString());
        else
            // Desde el método DoWork
            Console.WriteLine("Completado - " + e.Result);
    }
}

Subclasing

BackgroundWorker no se trata de una clase sellada, posee un método virtual OnDoWork que sugiere un modo de uso diferente al que acabamos de ver y es que podemos agregar capacidades asíncronas a cualquier clase que hayamos definido haciendo que herede de la clase BackgroundWorker y reemplazando su método OnDoWork. En este caso, la configuración queda encapsulada dentro de nuestra clase y un cliente solo tendría que suscribirse a los eventos ProgressChanged y RunWorkerCompleted. Veamos un ejemplo. Este sería el código fuente de la clase:

using System.ComponentModel;
using System.Threading;

namespace BackgroundWorker
{
    class MiClase : System.ComponentModel.BackgroundWorker
    {
        public MiClase()
        {
            this.WorkerReportsProgress = true;
            this.WorkerSupportsCancellation = true;
        }

        public MiClase(int unDato,
                       string otroDato) : this()
        {

        }

        protected override void OnDoWork(DoWorkEventArgs e)
        {
            // Cuando hemos llamado a bw.RunWorkerAsync()
            // hemos pasado información al hilo de trabajo.
            // Eso suele ser usado para suministrar al hilo de trabajo
            // información necesaria para que él sea capaz de hacer su tarea.
            string desdeHiloPrincipal = e.Argument.ToString();

            for (int i = 0; i <= 100; i += 20)
            {
                // Cada vez que iteramos,
                // comprobamos si nos han mandado salirnos.
                if (this.CancellationPending)
                {
                    // Si es así, informamos...
                    e.Cancel = true;
                    // y nos salimos.
                    return;
                }

                // Informamos desde aquí acerca del progreso de la operación.
                this.ReportProgress(i);

                // Aunque estemos en otro hilo diferente,
                // si no ponemos este Sleep aquí,
                // podríamos poner de rodillas al microprocesador,
                // la aplicación podría no responder,
                // obtendríamos justo lo que queremos evitar.
                // Lo que tu pares aquí, es tiempo que concedes al micro
                // para atender al hilo principal de la aplicación.
                Thread.Sleep(1000);
            }
            // Esto se pasa al evento RunWorkerCompleted.
            // Digamos que es el resultado final de la operación.
            // Result es un object, podemos pasar cualquier cosa.
            e.Result = 123;
        }
    }
}

Y éste sería el código fuente del cliente que hace uso de nuestra nueva clase:

using BackgroundWorker;
using System;
using System.ComponentModel;

class Program
{
    static MiClase miClase;

    static void Main()
    {
        // Configuramos nuestra clase a través del constructor.
        miClase = new MiClase(1, "Cualquier cosa");
        miClase.ProgressChanged += new ProgressChangedEventHandler(miClase_ProgressChanged);
        miClase.RunWorkerCompleted += new RunWorkerCompletedEventHandler(miClase_RunWorkerCompleted);
        miClase.RunWorkerAsync("¡Hola, hilo de trabajo!");

        Console.WriteLine("Presiona ENTER dentro de los próximos 5 segundos para cancelar.");

        Console.ReadLine();

        if (miClase.IsBusy)
            miClase.CancelAsync();

        Console.ReadLine();
    }

    static void miClase_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        Console.WriteLine("Completado " + e.ProgressPercentage + "%");
    }

    static void miClase_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        if (e.Cancelled)
            Console.WriteLine("Tu cancelaste la operación!");
        else if (e.Error != null)
            Console.WriteLine("Excepción en el hilo de trabajo: " +
                              e.Error.ToString());
        else
            // Desde el método DoWork
            Console.WriteLine("Completado - " + e.Result);
    }
}

Bueno, es otra forma de hacer lo mismo. Este uso que acabamos de ver hace que el patrón asíncrono basado en eventos quede obsoleto.

La clase principal contiene una referencia a un objeto que implementa IClaseDependiente y así poder llamar al método HacerAlgo de un objeto. ClaseDependiente1, ClaseDependiente2 y ClaseDependiente3 implementan esa interfaz. Un código cliente entonces creará la apropiada dependencia y le dirá a la clase principal que lo use (via la interfaz). Es fácil de entender si vemos el código fuente:

using System;

namespace InyeccionDependencias
{
    class Program
    {
        static void Main(string[] args)
        {
            IClaseDependiente dependencia = ObtenerDependencia();

            ClasePrincipal clasePrincipal = new ClasePrincipal();

            // Aquí es donde inyectamos la dependencia
            clasePrincipal.ClaseDependiente = dependencia;

            clasePrincipal.HacerAlgo();

            Console.ReadLine();
        }

        /// <summary>
        /// Aqui es donde obtenemos la dependencia correspondiente
        /// a lo que ponga en el fichero de configuración de la aplicación.
        /// </summary>
        /// <returns></returns>
        static IClaseDependiente ObtenerDependencia()
        {
            string claseACrear = Properties.Settings.Default.NombreClase;
            Type tipo = System.Type.GetType(claseACrear);
            IClaseDependiente dependencia = (IClaseDependiente)Activator.CreateInstance(tipo);
            return dependencia;
        }
    }

    public interface IClaseDependiente
    {
        void HacerAlgo();
    }

    public class ClaseDependiente1 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 1");
        }
    }

    public class ClaseDependiente2 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 2");
        }
    }

    public class ClaseDependiente3 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 3");
        }
    }

    /// <summary>
    /// La clase principal no tiene conocimiento alguno acerca de las clases secundarias,
    /// solamente de su funcionalidad, a través de la interfaz.
    /// </summary>
    public class ClasePrincipal
    {
        IClaseDependiente claseDependiente;

        public IClaseDependiente ClaseDependiente
        {
            get
            {
                return claseDependiente;
            }
            set
            {
                claseDependiente = value;
            }
        }

        public void HacerAlgo()
        {
            claseDependiente.HacerAlgo();
        }
    }
}

El fichero App.Config sería como sigue:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
            <section name="InyeccionDependencias.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
        </sectionGroup>
    </configSections>
    <applicationSettings>
        <InyeccionDependencias.Properties.Settings>
            <setting name="NombreClase" serializeAs="String">
                <value>InyeccionDependencias.ClaseDependiente2</value>
            </setting>
        </InyeccionDependencias.Properties.Settings>
    </applicationSettings>
</configuration>

Para entender como funciona esto, tan solo hay que ir cambiando el nombre de la clase que queramos inyectar en el archivo de configuración de la aplicación entre las tres clases disponibles (ClaseDependiente1, ClaseDependiente2 y ClaseDependiente3) y ver cómo se comporta el código paso a paso.

Tipos de inyección de dependencias

1. Setter injection: El ejemplo que hemos visto se corresponde con este tipo, es decir, hemos dado a la clase principal su dependencia mendiante el set de una propiedad.
2. Constructor injection: inyectar a la clase principal su dependencia en su constructor.
3. Interface injection: La clase principal implementará otra interfaz que se definirá a través de la cual inyectaremos la dependencia.

A continuación os dejo el código fuente de lo que sería una constructor injection y de una interface injection:

Constructor injection:

using System;

namespace InyeccionDependencias
{
    class Program
    {
        static void Main(string[] args)
        {
            IClaseDependiente dependencia = ObtenerDependencia();

            // Inyectamos la dependencia en el constructor
            ClasePrincipal clasePrincipal = new ClasePrincipal(dependencia);

            clasePrincipal.HacerAlgo();

            Console.ReadLine();
        }

        /// <summary>
        /// Aqui es donde obtenemos la dependencia correspondiente
        /// a lo que ponga en el fichero de configuración de la aplicación.
        /// </summary>
        /// <returns></returns>
        static IClaseDependiente ObtenerDependencia()
        {
            string claseACrear = Properties.Settings.Default.NombreClase;
            Type tipo = System.Type.GetType(claseACrear);
            IClaseDependiente dependencia = (IClaseDependiente)Activator.CreateInstance(tipo);
            return dependencia;
        }
    }

    public interface IClaseDependiente
    {
        void HacerAlgo();
    }

    public class ClaseDependiente1 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 1");
        }
    }

    public class ClaseDependiente2 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 2");
        }
    }

    public class ClaseDependiente3 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 3");
        }
    }

    /// <summary>
    /// La clase principal no tiene conocimiento alguno acerca de las clases secundarias,
    /// solamente de su funcionalidad, a través de la interfaz.
    /// </summary>
    public class ClasePrincipal
    {
        IClaseDependiente claseDependiente;

        public ClasePrincipal(IClaseDependiente claseDependiente)
        {
            this.claseDependiente = claseDependiente;
        }

        public void HacerAlgo()
        {
            claseDependiente.HacerAlgo();
        }
    }
}

Interface injection:

using System;

namespace InyeccionDependencias
{
    class Program
    {
        static void Main(string[] args)
        {
            IClaseDependiente dependencia = ObtenerDependencia();

            // Inyectamos la dependencia en el constructor
            ClasePrincipal clasePrincipal = new ClasePrincipal();
            ((IInyectarDependencia)clasePrincipal).InyectarDependencia(dependencia);

            clasePrincipal.HacerAlgo();

            Console.ReadLine();
        }

        /// <summary>
        /// Aqui es donde obtenemos la dependencia correspondiente
        /// a lo que ponga en el fichero de configuración de la aplicación.
        /// </summary>
        /// <returns></returns>
        static IClaseDependiente ObtenerDependencia()
        {
            string claseACrear = Properties.Settings.Default.NombreClase;
            Type tipo = System.Type.GetType(claseACrear);
            IClaseDependiente dependencia = (IClaseDependiente)Activator.CreateInstance(tipo);
            return dependencia;
        }
    }

    public interface IClaseDependiente
    {
        void HacerAlgo();
    }

    public class ClaseDependiente1 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 1");
        }
    }

    public class ClaseDependiente2 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 2");
        }
    }

    public class ClaseDependiente3 : IClaseDependiente
    {
        public void HacerAlgo()
        {
            Console.WriteLine("Hacer algo desde la clase dependiente 3");
        }
    }

    /// <summary>
    /// La clase principal no tiene conocimiento alguno acerca de las clases secundarias,
    /// solamente de su funcionalidad, a través de la interfaz.
    /// </summary>
    public class ClasePrincipal : IInyectarDependencia
    {
        IClaseDependiente claseDependiente;

        public void HacerAlgo()
        {
            claseDependiente.HacerAlgo();
        }

        public void InyectarDependencia(IClaseDependiente claseDependiente)
        {
            this.claseDependiente = claseDependiente;
        }
    }

    public interface IInyectarDependencia
    {
        void InyectarDependencia(IClaseDependiente claseDependiente);
    }
}

using System;

namespace InversionControl
{
    class Program
    {
        static void Main(string[] args)
        {
            // EnteroExtraño define un método de ordenación personalizado
            // en donde los enteros negativos son mayores que los positivos.
            EnteroExtraño[] ary = new EnteroExtraño[7];
            ary[0] = new EnteroExtraño(-1);
            ary[1] = new EnteroExtraño(1);
            ary[2] = new EnteroExtraño(2);
            ary[3] = new EnteroExtraño(-2);
            ary[4] = new EnteroExtraño(-3);
            ary[5] = new EnteroExtraño(3);
            ary[6] = new EnteroExtraño(0);

            // Array.Sort llama repetidamente al método CompareTo en EnteroExtraño
            // Aquí es donde se produce la inversión de control.
            Array.Sort(ary);

            foreach (EnteroExtraño i in ary)
                Console.WriteLine(i.ToString());

            Console.ReadLine();
        }
    }

    class EnteroExtraño : IComparable
    {
        private int valor;

        internal EnteroExtraño(int valor)
        {
            this.valor = valor;
        }

        #region IComparable Members
        /// <summary>
        /// Ordena enteros de una forma extraña.
        /// Cualquier entero negativo es mayor que un entero positivo.
        /// De lo contrario, ordena con normalidad.
        /// Esto significa que el -1 es el número más grande posible.
        /// </summary>
        public int CompareTo(object obj)
        {
            int otroValor = ((EnteroExtraño)obj).valor;
            if (valor == otroValor)
                return 0;
            else if (valor < 0 && otroValor >= 0)
                return 1;
            else if (otroValor < 0 && valor >= 0)
                return -1;
            else
                return valor.CompareTo(otroValor);
        }
        #endregion

        public override string ToString()
        {
            return valor.ToString();
        }
    }
}

Si implementamos la interfaz IComparable en una clase, escribimos código en el método CompareTo(). Este método define cuando un objeto de la clase que lo contiene es mayor que otro. Entonces, cuando llamamos al método Array.Sort(…) sobre un array de objetos de esa clase, es el framework el que se encarga de llamar a nuestra rutina de ordenación de los objetos, acorde a nuestra definición. Nosotros no tenemos el control de cuando se realizan las llamadas, podemos pensar en todo esto como la inversión de control (IoC).

El Common Language Runtime (CLR)

El CLR provee un contexto común dentro del cual todos los componentes .NET se ejecutan, independientemente del lenguaje con el que han sido escritos. El CLR maneja cualquier aspecto del código en tiempo de ejecución, (gestión de la memoria, entorno seguro de ejecución, acceso a los servicios del sistema operativo subyacente…). O sea, que lo que hace el CLR es gestionar la ejecución de las aplicaciones diseñadas para la plataforma .NET. Por eso, al código de estas aplicaciones se le suele llamar código gestionado o manejado y al código no escrito para ser ejecutado directamente en la plataforma .NET se le suele llamar código no gestionado o no manejado.

Microsoft Intermediate Languaje (MSIL)

Compilar código manejado es un proceso que comprende dos fases_

1. Todos los compiladores que generan código para la plataforma .NET no generan código máquina para CPUs x86 ni para ningún otro tipo de CPU concreta, sino que generan código escrito en el lenguaje intermedio conocido como Microsoft Intermediate Language (MSIL). MSIL es el único código que es capaz de interpretar el CLR, y por tanto cuando se dice que un compilador genera código para la plataforma .NET lo que se está diciendo es que genera MSIL definido por Microsoft.
2. Ya que las CPUs no pueden ejecutar directamente MSIL, antes de ejecutarlo habrá que convertirlo al código nativo de la CPU sobre la que se vaya a ejecutar. De esto se encarga un componente del CLR conocido como compilador JIT (Just-In-Time) o jitter que va convirtiendo dinámicamente el código MSIL a ejecutar en código nativo. La actuación de un jitter durante la ejecución de una aplicación gestionada puede dar la sensación de hacer que ésta se ejecute más lentamente debido a que ha de invertirse tiempo en las compilaciones dinámicas. Esto es cierto, pero en .NET, cada código no es interpretado cada vez que se ejecuta sino que sólo es compilado la primera vez que se llama al método al que pertenece. El hecho de que la compilación se realice dinámicamente permite que el jitter tenga acceso a mucha información sobre la máquina en que se ejecutará la aplicación, con lo que puede optimizar el código para ella generado.

Metadatos

Cuando un cliente usa un servidor ¿Cómo sabe que tipos contiene, el espacio de nombres en el que está contenido cada tipo, el nombre de cada tipo, su visibilidad, su clase base, que interfaces soporta, sus métodos, el prototipo de cada método y cosas así? La solución que .NET da a este problema se llama metadatos. Los metadatos son un conjunto de datos organizados de forma estándar en tablas, generados por el compilador de alto nivel directamente desde los archivos fuente e incrustándolos en el archivo físico que contiene el MSIL.

El significado de los metadatos es similar al de otras tecnologías previas a la plataforma .NET como lo son los ficheros IDL (interface definition languaje). Sin embargo, los metadatos tienen ventajas:

• Contienen más información.
• Siempre se almacenan incrustados en el módulo al que describen, haciendo imposible la separación entre ambos.
• Es posible consultar los metadatos de cualquier módulo a través de las clases del espacio de nombres System.Reflection. Por ejemplo, IntelliSense usa Reflection.

En otra entrada ya haremos un resumen de lo que son los ensamblados y los archivos manifiestos y con eso ya tendremos los fundamentos para seguir hablando de los principios de la programación orientada a componentes.

En la programación orientada a componentes, la unidad fundamental de reutilización es la interfaz, para usar un componente, el cliente lo único que necesita conocer es la definición de la interfaz y ser capaz de tener acceso al componente binario que implementa esa interfaz. Veamos un ejemplo:

Todo lo que el cliente tiene que hacer es instanciar una clase que soporte la interfaz y asignar el objeto a una variable de la interfaz:

IMiInterfaz objeto;  
objeto = new MiClase();   
objeto.Metodo1();

Si cambia la implementación en MiClase, el cliente no tiene porqué enterarse. Además, en el ejemplo, esto también es posible:

IMiInterfaz objeto;
objeto = new MiOtraClase();
objeto.Metodo1();

De esta manera tenemos acceso a la interpretación que MiOtraClase de para la interfaz. En el ejemplo, IMiInterfaz sería como la interfaz USB, en dónde cada ratón (MiClase, MiOtraClase), cumplen con ella (la implementan), pudiendo tener cada objeto ratón sus peculiaridades de diseño (color, tamaño etc, eso ya depende de cómo definas cada una de las clases). Sin embargo, .NET también te deja hacer esto:

MiClase objeto;
objeto = new MiClase();
objeto.Metodo1();

en donde se está accediendo directamente a la clase que provee el servicio, en vez de hacerlo a través de la interfaz. O sea, que .NET no te obliga a cumplir con este principio a la hora de programar, siendo así accesible también a todos aquellos programadores que no están acostumbrados a usar los conceptos abstractos de la programación orientada a interfaces, pero que sepáis que los desarrolladores .NET disciplinados siempre deberían forzar la separación en sus desarrollos para obtener los beneficios de la programación orientada a componentes.

• La clase que implementa cierta lógica.
• La entidad física que contiene a la clase (dll).
• La lógica asociada para hacer uso de la clase (información de tipos, política de seguridad, información de versiones…).

Digamos que la programación orientada a objetos se focaliza en las relaciones que hay entre las clases combinadas dentro de un gran ejecutable binario, mientras que la programación orientada a componentes se centra en módulos intercambiables que trabajan de forma independiente y de los cuales no es necesario saber nada acerca de sus implementación interna. La diferencia entre ambas técnicas es la manera que tienen ellas de ver a la aplicación final. En la programación orientada a objetos, el resultado es un código binario monolítico, todas las clases se localizan en él, mientras que la programación orientada a componentes se puede imaginar como las piezas del lego, un cambio en la implementación de una de las piezas está disponible inmediatamente para todo cliente que la use, sin necesidad de recompilar.

En la programación orientada a objetos, las aplicaciones son modeladas con jerarquías de clases complicadas, pero esa es una forma pobre de alcanzar la reutilización de código. Para derivar de una clase base y extenderla, tienes que estar muy familiarizado con los detalles de implementación de la clase base, para estar seguro de cómo va a afectar a los clientes los cambios que tú hagas. Es lo que se conoce con el nombre de reutilización de caja blanca. La programación orientada a componentes, lo que predica es la llamada reutilización de caja negra, es decir, permite usar un componente existente sin necesidad de conocer los detalles internos de su implementación. Esto se logra a través de las interfaces. En vez de diseñar complejas jerarquías de clases, se diseñan interfaces usadas como contratos entre componentes, clientes y servidores. O sea, que hay que tender ha diseñar jerarquías de clases simples y centrarse en la programación orientada a interfaces.

Una aplicación orientada a componentes es más fácil de extender (cumplir con nuevos requisitos a través de nuevos componentes sin tocar los ya existentes), reduce los costes de mantenimiento de las aplicaciones y normalmente sus desarrollos suelen ser más cortos en términos de tiempo.

Los principios más importantes de la programación orientada a componentes son:

1. La separación de la interfaz de la implementación.
2. La compatibilidad binaria.
3. La independencia del lenguaje.
4. La transparencia en la localización.
5. La gestión de la concurrencia.
6. El control de versiones.
7. La seguridad basada en componentes.

.NET te habilita para cumplir con cada uno de estos principios, pero no obliga. En próximas entradas iré explicando cosas de cada uno de ellos.

Se dice que ellos asustan y que nosotros ya no, cosa que me agrada bastante escuchar. Tienen un balance de 13 goles a favor y 2 en contra. De los 13 goles, 4 se los han hecho a la Inglaterra de Capello y otros 4 a Argentina. En principio son datos que por si mismos asustan un poco, pero que hay que analizar fríamente. Yo lo he hecho y he llegado a una conclusión, a una especie de clave para poder ganarlos: España tiene que poner todo de su parte para conseguir que el partido se juegue. ¿Qué quiero decir? Alemania iba ganando 1-2 a Inglaterra (desde un previo 0-2 si mal no recuerdo) cuando un tiro lejano de Lampard creo recordar, botó dentro de la portería casi medio metro y el gol no fue concedido. Hubiera significado el 2-2. En ese instante, otro partido diferente se jugó, fue todo irreal. El partido contra Argentina lo empezaron ganando en el minuto 3. Por tanto, son enfrentamientos que no han existido, porque todo cambia. Eso es a lo que me refiero con que España tiene que ocuparse de que eso no pase, luego hay otras variables, por supuesto. Eso por un lado. Por otro lado, la nueva Alemania, para ciertas cosas, sigue siendo la Alemania de siempre. Cuando empieza un mundial, siempre hay 3 cosas seguras: Que va a haber un equipo revelación, que por lo menos un equipo va a ser la decepción y que Alemania va a llegar lejos. Y es que la tendencia a definir bien los objetivos y la perseverancia para alcanzarlos son características muy marcadas en la mentalidad de los equipos alemanes.

Por lo tanto, si mezclamos estas reflexiones con el recuerdo del partido que se jugó en la final de la pasada Eurocopa, uno sospecha, aunque muchos insistan en que no tiene absolutamente nada que ver aquél evento con éste, como van a empezar el partido los alemanes. Los primeros 30 minutos, si nada ocurre (un penalti, una cantada de alguien…), si el 0-0 permanece, me los espero de una tensión y una intensidad alemana muy fuerte, igual que en la final de hace dos años. Eso ya dice cómo tenemos que salir de concentrados. Van a intentar que no haya partido, pegando ellos primero una o dos veces. Este dato parece cobrar especial interés en este mundial ya que, en 60 enfrentamientos ha habido 3 remontadas, un dato escandaloso, aún más importante cuando todos hemos visto la contra que tiene el equipo alemán. Un equipo en desventaja en el marcador siempre tiende a abrirse un poco más para intentar el empate, arriesgando, eso es lo que aprovechan ellos para aumentar la ventaja en el marcador. La última vez que nos echaron de un mundial fue Francia, que a la contra nos metió el 3-1 (Zidane).

También hay que esperar que nos hayan estudiado mucho y hayan detectado debilidades en el equipo español, que las tiene. Yo lo he meditado y he encontrado una que me preocupa especialmente. Me preocupa el juego aéreo, dónde además ellos son fuertes. En el partido contra Paraguay, a los paraguayos se les anuló un gol legal en una jugada aérea. Hubiera sido el 1-0 que nunca fue, o sea, que ese es otro ejemplo de partido irreal, igual de irreal que el gol de Villa a Portugal, en fuera de juego, lo digo porque parece que nos molesta reconocerlo, otro ejemplo más de partido fantasma. No solo eso, también hubo un centro desde la banda al que el delantero paraguayo no llegó a rematar de cabeza por medio metro. El penalti que paró Casillas vino en una jugada aérea. Alemania no se va a comer mucho la cabeza para atacarnos, en cuanto puedan, Phillip Lahm, Podolski o quien sea, centrarán al 9, esa figura en periodo de extinción, y es que ellos juegan con el clásico 9, Klose.

Podolski ha hecho una mala temporada en el Colonia y Klose en el Bayern no juega, pero es que esta gente cuando se pone la camiseta de su país se transforma. Todos los jugadores de la selección alemana juegan en la bundesliga, en la cual, este año se ha jugado con el balón del mundial. Ese es otro punto que me preocupa, el balón. Todos hablamos del mano a mano que Casillas ganó al paraguayo, pero lo que no puedo entender es que nadie diga que esa circunstancia fue generada por una incapacidad de Casillas de blocar un balón con el pecho. En otras competiciones suele blocarlo sin más historias. No es la primera vez que vemos algo así. Con un tiro de Ronaldo pasó lo mismo, Casillas se pasó 5 segundos resoplando. He visto uno de los goles de Forlán a Ghana, de falta directa, a mi me parece que el balón hace unos giros muy extraños. Ellos lo habrán visto y seguro que van a insistir con los tiros a puerta, hay que estar muy atentos y llegar antes que ellos al rechace.

No todo son pegas, ellos también tienen defectos. Quique Sánchez Flores comentó en uno de los partidos de la selección alemana que la pareja de centrales Mertesacker y Friedrich no le habían transmitido mucha seguridad. Además, los 5 equipos que han jugado contra España, con leves diferencias entre ellos, han jugado igual. Se cierran atrás y buscan una jugada aislada. Tú eres bueno, atácame, ven tú, que eres muy bueno y gáname. Los 5 han salido mal parados, otra razón más para que Alemania salga como creo que van a salir. No creo que ellos con su juego nos hagan sentir tan incómodos jugando como nos hemos sentido ya. Así que creo que si hay partido, quizás España juegue el mejor partido del mundial. Si ellos hacen lo que digo, jugarán con la defensa unos metros más adelantada que nuestros anteriores rivales, eso crea más espacios para las características de Torres y Villa y aumenta las posibilidades de los fuera de juego dudosos, me está dando la impresión en este mundial que se está aplicando mayoritariamente la regla que dice que ante la duda no se pita fuera de juego.

Ese escenario puede beneficiar a un delantero con las características de Torres. Torres es un delantero muy peligroso cuando tiene metros por delante y los centrales alemanes son sobrios, rígidos, Torres tiene una zancada muy peligrosa, contra Chile lo vimos, el primer gol de Villa viene precedido de un desmarque muy largo de Torres, dónde ya le había ganado la posición al defensa. Hay un debate acerca de si Torres debe jugar o no, en el instante en el que estoy escribiendo esta entrada todavía no se sabe si Torres va a ser titular o no. Ahora he de decir que no soy un especial defensor de Torres aunque me ha parecido bien que haya estado saliendo de titular, porque la calidad la tiene, mucha, y aunque todos sabemos que no atraviesa su mejor momento, si es cierto que de alguien como él siempre se espera que en cualquier momento aparezca. Para mi, Torres debería jugar contra Alemania de titular, es más, por el tipo de enfrentamientos que ha tenido España, hubiera entendido más que se hubiera quedado en el banquillo ya en beneficio de algún bajito y no contra Alemania, pero bueno, Del Bosque es sabio, les ve entrenar todos los días y él es el que sabe, nadie mejor que él para saber si debe ser titular o no.

Ellos son previsibles, son así, analizan, identifican los puntos débiles y los atacan con insistencia, así que se puede resumir lo siguiente:

• Previsible arranque Alemán en tromba, importancia de pegar primero.
• Se prevé insistencia alemana en el juego aéreo y en los disparos lejanos (extraños del balón).
• Ataques alemanes muy verticales (recuerdan a los de chile), contras muy peligrosas.
• Juego más abierto que el de los pasados rivales, defensa alemana unos metros más adelantada, sacar beneficio de la velocidad de nuestras puntas en los desmarques, los fueras de juego dudosos no suelen ser señalados.

Como siempre, que la suerte nos acompañe, no podemos decir a día de hoy que no esté siendo así.

Ya escribí algo de este tema en una entrada anterior a esta, antes de que empezara el mundial incluso. El resumen que se puede hacer de aquella entrada es:

• tenemos poca memoria.
• no te rías.

A los españoles nos gusta mucho el fútbol y típicamente siempre hemos tenido una de las mejores ligas del mundo y en ocasiones la mejor. Eso, a nivel de selección, hace que nuestra percepción de la situación que ocupa España a nivel de selección esté casi siempre alejada de la realidad, y es que cuando nos dicen que tenemos que enfrentarnos con equipos como por ejemplo Chile en esta ocasión, sentimos algo así como “¿Chile? ojito si, pero ¿Cómo no vamos a ganar?”, más aún cuando España tiene la generación de jugadores que tiene y cuando viene de triunfar en la anterior Eurocopa, sus jugadores juegan en los principales clubes de Europa, están acostumbrados a la presión, a la alta competición, en fin…

Bueno, antes de meterme a analizar a la selección chilena me gustaría hablar de las estadísticas. Para mí, las estadísticas son meramente eso, estadísticas, indicadores que te ayudan a reflexionar acerca de lo que ha pasado, ayudan a diagnosticar la situación. Ellas, en sí mismas, no constituyen un objetivo, es decir, el objetivo no es tener un 70% de posesión del balón, aunque eso sea bueno, aunque sea nuestro estilo de juego. No constituye un objetivo tirar a puerta 25 veces y que 18 de las 25 hayan ido entre los tres palos, ni centrar 15 veces al área en la última media hora de partido. El objetivo es ganar. Si, si es posible, con nuestra señal de identidad, pero el objetivo debe ser ganar. Las estadísticas de un partido de fútbol, como los resultados de un análisis de sangre, si no se interpretan bien, te pueden conducir a equivocaciones y a autoengaños. Por ejemplo, yo no soy médico, pero mis entendederas me hacen imaginar que puedo tener todos los ratios de un análisis de sangre perfectos y sin embargo avecinarse un problema grave. Quizás lleve 30 años fumando y bebiendo y eso haga que la elasticidad de mis arterias esté en peligro, de tal forma que muy  probablemente pudiera ocurrir algo que no quiero decir, aunque no tenga colesterol ni triglicéridos, no es lo normal, una mala vida suele suele ir acompañado de malos coeficientes, pero yo no me puedo escudar en buenos ratios para seguir bebiendo o fumando. ¿la elasticidad de las arterias me la dice un coeficiente concreto? A lo mejor no. Por tanto, el objetivo para mí no debería ser dar unos buenos niveles, sino llevar una vida sana, cuidar mi alimentación, hacer deporte… O sea, que no es un razonamiento del tipo “…cómo me dan todos los ratios bien, estoy perfecto, nada me va a pasar…” Nadie en su sano juicio diría algo así. O con un coche. Tu puedes llevar el coche al taller de la marca siempre en fechas y romper la distribución con 56.000 km ¿no?  es decir, ocurren cosas, no todo está bajo control. Pues con esto de las estadísticas de los partidos de fútbol ocurre lo mismo, está bien, pero no te aseguran nada para el próximo partido, lo digo porque veo un poco de obsesión con los datos en los medios de comunicación.

Como la risa creo que ya se nos ha cortado a todos un poco, otra cosa en la que quiero hacer hincapié es en la falta de memoria. A los ejemplos que puse en la entrada anterior, me gustaría añadir un par de ellos más. Todos hemos visto en Telecinco de comentarista a Guillermo Amor. ¿Por qué no le preguntan que fue lo que pasó en la Eurocopa de Inglaterra en 1996? España jugó su tercer partido contra Rumanía (si, si, Rumanía, la que te suena como Chile cuando te dicen que hay que ganarla) y el empate no le valía a España para clasificar (¿A que te suena?). Pues bien, era el minuto 84 de partido cuando Amor logró el 2-1 para España de cabeza. Si, minuto 84. Si lo quieres recordar, aquí tienes el gol. ¿Tenía España mal equipo o buen equipo? Otro ejemplo. El 21 de Junio del año 2000, hace ahora exactamente 10 años, España se jugaba el pase en su tercer partido de la Eurocopa contra Yugoslavia. Curiosamente, había perdido 1-0 el primer partido contra Noruega (pedazo de selección, ¿te suena eso de algo?). A la selección Española solo le valía la victoria para pasar a cuartos de final. Alfonso metió el gol de la victoria en el minuto 94. Minuto 94 tío. Todo el mundo recuerda eso, si lo quieres volver a recordar, pulsa aquí. ¿Tenía España mal equipo o buen equipo?

Conclusiones que saco yo, dos:

• Siempre creemos que tenemos buen equipo.
• Si Chile nos pasa por encima, me parecería injusto que te sintieras desgraciado, no recuerdas que a veces has ganado.

¿De acuerdo? Bueno, pues ahora vamos con Chile. Chile es la típica selección que si no pasa a octavos me daría mucha pena. Amo ese tipo de propuestas tan valientes, tan alejadas de la especulación. Chile es un equipo muy agresivo, es un equipo valiente. Yo no sé si habéis visto al Madrid de Pellegrini (chileno también, fíjate tú la casualidad) este año. Lillo dijo este mismo año que el Madrid juega a golearte, mientras que el Barça te golea mientras juega. Y es que para mí, el partido del viernes entre ambas selecciones es un auténtico Madrid-Barça en cuanto a estilos se refiere. Os sonarán esas típicas jugadas de ataque del Madrid de Pellegrini endiabladas, cuando el interior toca de cuchara el balón en vertical hacia el delantero, casi sin mirar, sin pensar, el cual ya está corriendo en trayectoria incisiva, sin apenas tiempo a darse cuenta. Bien, pues un estilo parecido es el que tiene Chile. Chile te puede jugar con tres centrales y tres delanteros y el tiempo que pasa el balón en los pies de sus centrocampistas es mínimo, Chile no elabora, echan mano de pases largos a los interiores, los cuales se abren mucho a banda y siempre cerca del área para encarar sin piedad. Su selección es la que tiene la estatura media más bajita de todo el mundial, pero ojo, que no te confunda ese parámetro del análisis. Cuelgan balones desde la banda sin parar y si reculas como Mertesacker contra Serbia, puede haber un Jovanovic Chileno que haga lo mismo en el área pequeña. Sus puntas son muy rápidas, son buenas técnicamente y su movilidad es incansable, no dan respiro, todo eso hace que sean muy difíciles de defender. Además, repito, son valientes, no dudan en encarar, les da igual que se la quiten, el entrenador es igual de valiente que los jugadores y les concedió licencia para arriesgar así. Tiran muchos desmarques en paralelo a la línea del área, rozando el límite del fuera de juego. Otro desmarque tipo que repiten mucho es la de estar los interiores completamente abiertos en banda, pegados a la línea y el centrocampista aproximarse a la línea de banda desde el círculo central y buscar la espalda del lateral en un pase en profundidad, corriendo el interior hacia adentro. Ya te digo, son un auténtico coñazo de equipo. No te equivoques con su defensa, ya te digo que acumulan hombres atrás, son difíciles de atacar. Ellos apuestan y juegan así. Por tanto, para mí, el viernes van a salir al ataque descaradamente. Es un equipo consistente, es decir, llevan tiempo jugando así con Marcelo Bielsa. Tienen jugadas ensayadas a balón parado y, aunque parezca de infantiles lo que voy a decir, si se les hace falta, no dudan en levantarse rápidamente y tocar el balón hacia delante, juegan a la sorpresa con cualquier cosa, hay que ponerse en medio del balón y abortar ese tipo de despistes, aunque parezca obvio lo que he dicho.

Como todos los equipos, también adolece de defectos. Les cuesta marcar gol, pero mucho ojito, eso es solo lo que dicen sus estadísticas del mundial, pueden no estar señalando la realidad y es que la realidad dice que son buenos técnicamente, no te fíes de ese parámetro del análisis de la sangre chilena, pueden tener un partido en el que metan casi todas las ocasiones, a nosotros nos está pasando lo mismo, sin embargo todos confiamos en que eso deje de ser así, pues ellos igual, creo que este enfrentamiento puede terminar en una borrachera de goles entre los dos, yo creo que va a ser un intercambio de golpes tremendo, el que menos falle ganará, yo creo que va a ser un partido para las delanteras y no para las defensas. Chile tiene todas las papeletas para poder llevarse por delante a cualquiera, no tenemos que dejar que sea contra nosotros, no paguemos los platos rotos. Otra pega que tienen en su contra es un par de ausencias por tarjeta de dos hombres importantes para ellos, creo que uno es un tal Carmona que, digamos, es el Xabi Alonso del equipo, el que distribuye a toda prisa, por lo tanto ahí hemos ganado algo, hablan de un tal Estrada para sustituirlo, ya veremos a ver. También presionan mucho la salida del balón del equipo contrario, por lo tanto, tienen  un estilo de juego muy exigente en cuanto a estado físico se refiere y ya se sabe lo que suele pasar cuando se llega a la mitad de la segunda parte jugando así, el cansancio se apodera de ti y te hace cometer más fallos, yo creo que si España es capaz de imponer su personalidad en el juego y controlar el partido de forma que haya tablas en el marcador en el minuto 20 de la segunda parte, creo que tenemos nosotros más posibilidades de acertar de cara al gol que ellos, por las razones que estoy dando.

Conclusión: pues que Del Bosque tiene trabajo en pensar cómo va a neutralizar eso. Se requiere máxima concentración en defensa y ahora me alegro de que nuestro equipo juegue con dos pivotes, los dos defienden mucho y van a tener que esforzarse en echar una mano atrás, más que nunca. Se necesita alta tensión atrás y templanza a la hora de rematar para aprovechar más de lo que se ha hecho. No podemos dejar que la flacidez nos invada, he visto síntomas. Para mí, la mejor manera de defenderlos es presionar su salida de balón, no dejar que llegue el balón a la zona dónde ellos quieren jugarlo, donde se sienten cómodos. No sé que pensar. Creo que algo sorprendente va a pasar. Dicen que los sismólogos son incapaces hoy en día de predecir terremotos, tan solo de medir en tiempo real, obtener gráficas e interpretarlas, pero ya hemos visto lo que son los datos. Por ahora, el mecanismo más preciso que existe en la predicción de terremotos es el de los perros aullando y animales huyendo. Estoy nervioso, cuando pienso en fútbol y en España, llevo unos días escuchando a unos perros aullando en mi interior ¿se avecina un terremoto? ¿volverá a ser en Chile de nuevo el terremoto o esta vez cruzará el océano? Esperemos que España no sea destruida y salga reforzada de este enfrentamiento. ¡Qué Del Bosque nos conduzca a la final!

Se suele decir que la selección española juega como el Barça. De acuerdo, de hecho, muchos de los jugadores son de ese club. ¿y? ¿se quiere decir algo con eso? Pues que el Barça es el equipo que ahora mismo hace el mejor fútbol del mundo y la selección española también y que por consiguiente tenemos gran parte de las papeletas para ganar el mundial. O sea, una regla de tres en todo su esplendor. A mi me parece que las reglas de tres no funcionan en el fútbol, lo deberíamos de saber ya todos, pero, parece que no… Vamos, de tantas veces que uno escucha eso, no sé yo ni cómo es que se juega el mundial, que le den el título directamente a España y se acabó, bueno, mejor no, que jueguen, que como lo hacen tan bien, pues nos van a entretener a todos un montón, hasta los demás nos aplaudirán, total, todos recordamos la última Eurocopa, hacía tiempo que alguien no la ganaba con tanta autoridad, al menos esa sensación nos dejó a todos ¿no?

Bueno, pues aquí estoy yo para decir que si, pero que no. Me explico. Nos acordamos de lo que nos da la gana. ¿Queréis que hablemos del Barça? pues mirad, vamos a hablar primero del Barça y después de la selección Española. Hay unos cuantos equipos por ahí que tienen bastante claro cómo jugarle al Barça. Pero eso no es de ahora, no lo digo por la eliminatoria de Champions de este año con el Inter. También lo digo por la del año anterior. No me refiero al gol de Iniesta en el último suspiro, porque si fuera por eso, me parece totalmente justo que en aquella ocasión el gato al agua se lo llevara el Barça, por la simple razón de que el Barça la metió cuando tuvo ocasión de hacerlo y Didier Drogba, que tuvo varias, las falló, aunque luego quería pegar al árbitro. A lo que vamos, en aquella eliminatoria, el control lo tuvo en todo momento el Chelsea, en los dos partidos, pero nosotros preferimos pensar que no. ¿Por qué? pues porque el Barça juega bonito, al ataque, y el Chelsea se defiende y no hace otra cosa y no hay derecho y patatín patatán. Fíjate bien que he dicho “tener el control”, no he dicho merecer ganar. Ahora hablamos de eso, pero pongamos más ejemplos, que no sea el del Inter, que ese se lo sabe todo el mundo, todos hemos visto cómo eliminaron al Barça este año. Este año, el Málaga ha estado a punto de descender a 2ª división. En el Nou Camp, el Barça le ganó al Málaga 2-1 en los últimos minutos.

Métele un gol a la Francia de principios de década. Aquello era impresionante. Yo recuerdo que provocaba en mi la misma admiración aquello, que la que me provoca ahora el Barça o España (para eso te tiene que gustar mucho el fútbol). Era espectacular, no estoy hablando de Zidane, estoy hablando de que caían los partidos y era casi imposible generar ocasiones de gol. A mi me daba la risa. Pero eso no es que yo meta 9 atrás, salgo a la contra y ya está. Si no ¿Por qué no lo haces tú? Yo puedo admitir que te guste más un estilo de fútbol que el otro, a mi también, pero es igual de difícil, estoy hablando de que es muy difícil hacerlo a la perfección, porque si no, no aguantas 90 minutos, 180 minutos, o 7 partidos de un mundial. Aquella Francia ganó un mundial, una Eurocopa, nos echó de otro mundial cuando nos reíamos de ellos antes del partido porque eran muy viejos y llegaron a la final de ese mundial el día que Zidane se retiró del fútbol profesional de forma oficial, así que, casualidades con ese tipo de equipos, no las hay, al menos yo no lo veo así. O sea, que no hay por qué despreciarlo, diciendo que así cualquiera. Oye, perdona, pero no, cualquiera no. Hay más ejemplos:

• Cuando el Madrid fue de víctima al Nou Camp con Fabio Capello de entrenador creo (venían de Munich de ser eliminados de la champions por un error de Roberto Carlos, no sé si estoy mezclando fechas), el Barça empató al Madrid 3-3 en los últimos minutos con una gran actuación de Messi (3 goles).
• El Real Madrid de Juande Ramos, claramente inferior al Barça, aguantó el 0-0 en el Nou Camp hasta el minuto 82, en el que un súper acabado Michel Salgado hizo un penalti que se podría haber evitado.
• Hemos hablado de la última eliminatoria Chelsea Barça, pero ya nadie parece recordar que hubo otra igual un año anterior en la que el Barça cayó eliminado (con Frank Rijkard de entrenador creo recordar).

No es tan fácil. Pongo todo el rato ejemplos con el Barça, porque es el equipo que todo el mundo pone como modelo. Además, aunque no viene a cuento, aprovecho para decir, dado que estoy haciendo una exposición de las razones por las que creo que tenemos poca memoria, que llevamos todo este año y parte del anterior diciendo que el Barça es lo que es hoy en día por la cantera, porque a todos los niveles el club siempre juega con la misma filosofía y que llevan 20 años haciendo las cosas así. ¿A que jugaba el Barça de Van Gaal? ¿acaso era un Barça de blanco y negro o es un Barça de esta misma década? Ya nadie se acuerda de los famosos meses de noviembre, en los que había rachas de 5 derrotas seguidas. ¿Dónde estaba la cantera? ¿No llevan 20 años así? Entonces ¿No perdió el Barça 5-1 un partido en la Rosaleda en el 2003 creo que fue? ¿Son Bogarde, Riziguer, cocú, Iovani, Thuram y muchos más, jugadores de la cantera del Barça? El día del pasillo del Barça al Madrid, en el que el Barça perdió 4-1 (creo), en vez de fijarnos en esa tontería de pasillos o no pasillos ¿Por qué nadie le preguntó a Xavi Hdez. cuantos títulos llevaba ganados con el Barça hasta ese día? ¿Alguien puede tomarse la molestia de buscar el dato y decírnoslo? ¿Estoy hablando de un Barça de la época del nodo? Eso fue en mayo del 2008, hace 2 años justos.

Bien, podríamos seguir, pero hemos dicho que vamos a hablar de España, que para ella es esta entrada, aunque no lo parezca de momento. Pero seguimos poniendo ejemplos:

• España le ganó a Suecia en el último minuto, con un gol que se inventó Villa (estoy hablando de la última Eurocopa).
• Con Grecia empezamos perdiendo y luego hubo remontada (Grecia se fue a la calle en la 1ª ronda, fíjate tú).
• A Italia, esa cuadrilla de viejos (cometimos con ellos el mismo error que con Francia, que nos pierde la boca…), no la ganamos. ¡No la ganamos tío! Fue todo en los penaltis.
• A Alemania la ganamos 1-0 en la final. 1-0 tío, no te vayas tú a creer otra cosa.
• EE.UU nos eliminó hace un año en el mismo escenario en el que este año va a ser el mundial (¿A que te recuerda el fútbol de EE.UU?).
• A Argentina, en España, en el último amistoso, la ganamos 2-1, en los últimos instantes del partido, y de penalti, que creo que metió Xabi Alonso.
• ¿Por qué no te pones el video del partido que jugó España en el mundial de Alemania, nada más y nada menos que con la todo poderosa Túnez? ¿Alguien me puede decir que fue lo que ocurrió? ¿Fue fácil ganar o se te quedó cara de tonto?
• Todos nos acordamos de la injusticia cometida contra España en el mundial de Corea/Japón 2002. ¿Alguien se acuerda de lo que pasó en octavos? ¿Te lo digo yo? Es que nos gusta mucho hablar de justicia. Irlanda (fíjate tú la pedazo de selección) tuvo contra las cuerdas a una España noqueada durante toda la prórroga y todo se decidió a los penaltis. Pasamos de milagro. Ponte el video majo…

Pero no. Nosotros solo nos acordamos de que en Francia ganamos con autoridad este invierno y de que a Rusia le metimos 3-0 creo que fue (que venía el equipo de Hidink de eliminar a Holanda) y como España es muy buena, como el Barça lo es también, pues ya está. Y digo yo ¿Pero de qué vamos?

¿Cual es mi opinión? pues que en fútbol, como en la vida misma, casi cualquier cosa es posible y que una cosa es la sensación y otra muy diferente es ganar. En fútbol, como en la vida misma, no es posible saber que es lo que va a pasar y en fútbol, como en la vida misma, tú puedes ser sobre el papel mucho más virtuoso que nadie, pero la determinación, el trabajo y la definición clara de objetivos, puede hacer que mucha gente te pueda ganar y si a nosotros esas virtudes nos parecen muy poco para ganar (suele ser muy habitual en España, total, aquí tenemos mucho talento, no me explico cómo es que vamos en el vagón de cola en todo), a lo mejor es muy poco el fútbol que hemos visto, muy poca la memoria que tenemos, o muy poco lo que sabemos de la vida. Cómo España tenga su mundial, la verdad, va a ser difícil que no lo gane, pero Cesc, Torres, Xabi, Iniesta… son jugadores que están tocados, cualquiera que haya jugado al fútbol, aunque sea con los amigos, sabe que un jugador que no esté bien físicamente, no parece ni el mismo jugador. ¿Lo has tenido en cuenta?

Así que no despreciemos a nadie, que ya lo hemos hecho otras veces (antes lo he explicado), curiosamente con selecciones que han demostrado mucho más que nosotros históricamente, así que mucho ojito si nos tenemos que enfrentar con selecciones del estilo de Inglaterra, Argentina, Italia o EE.UU, que es el estilo de juego que peor nos viene (los ejemplos del Chelsea con el BarÇa lo demuestran, ya que somos tan aficionados a las similitudes entre ambos equipos), es decir, me da mucho menos miedo, fíjate tú que tipo de opinión tengo, o al menos creo que España puede jugar muchísimo mejor contra equipos como Brasil, Holanda, Turquía, Portugal, etc.

En cualquier caso, miremos ahora hacia delante, que es lo que nos toca, vamos a por el mundial, que es nuestra obligación pensar en positivo, que razones para ello tenemos y a ver que pasa, pero eso sí, no te rías hombre, ni te creas mejor que nadie, por que si no, los champiñones se te van a atragantar: “¡Camarero!     ¡una de champiñones!      ¡champiñones!      ¡champiñones!      oe     oe     oe…”