El blog del burgués

14 febrero 2011

Inversión de Control (IoC)

Filed under: C#,CAB,SCSF — elburgues @ 8:20 PM

Normalmente, para reutilizar código fuente de alguien, se debe llamar a una librería. Es lo que estamos haciendo cuando usamos .NET framework. Por ejemplo, cuando llamas a Console.WriteLine(“bla bla…”), estás usando código fuente que ha escrito alguien, tu haces la llamada, por lo tanto, tu tienes el control. Sin embargo, hay veces que es .Net framework el que reutiliza código fuente escrito por ti. Por ejemplo, cuando escribes un algoritmo de ordenación de números enteros usando la interfaz IComparable. En ese caso la dirección del control está invertida, alguien está llamando a tu código en vez de ser tu el que llama al código de alguien. Eso es la inversión de control (IoC). Veamoslo con el ejemplo que hemos descrito:

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).

Anuncios

Dejar un comentario »

Aún no hay comentarios.

RSS feed for comments on this post.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

Crea un blog o un sitio web gratuitos con WordPress.com.

A %d blogueros les gusta esto: