Fernando Berzal Galiano & Francisco Cortijo Bon inherit.xml control.xml indexers C# no permite, hablado con rigor, la sobrecarga del operador de acceso a tablas [ ]. Si permite, no obstante, definir lo que llama un indexador para una clase que permite la misma funcionalidad. Los indexadores permiten definir código a ejecutar cada vez que se acceda a un objeto del tipo del que son miembros usando la sintaxis propia de las tablas, ya sea para leer o escribir. Esto es especialmente útil para hacer más clara la sintaxis de acceso a elementos de objetos que puedan contener colecciones de elementos, pues permite tratarlos como si fuesen tablas normales. A diferencia de las tablas, los índices que se les pase entre corchetes no tiene porqué ser enteros, pudiéndose definir varios indexadores en un mismo tipo siempre y cuando cada uno tome un número o tipo de índices diferente. La sintaxis empleada para la definición de un indexador es similar a la de la definición de una propiedad. public class MiClase { ... public string this[int x] { get { // Obtener un elemento } set { // Fijar un elemento } } ... } ... MiClase MiObjeto = new MiClase(); El código que aparece en el bloque get se ejecuta cuando la expresión MiObjeto[x] aparece en la parte derecha de una expresión mientras que el código que aparece en el bloque set se ejecuta cuando MiObjeto[x] aparece en la parte izquierda de una expresión. Algunas consideraciones finales: Igual que las propiedades, pueden ser de sólo lectura, de sólo escritura o de lectura y escritura. El nombre dado a un indexador siempre ha de ser this. Lo que diferenciará a unos indexadores de otros será el número y tipo de sus índices. Maximo= " + this.MaxCoches; string str2 = " --> Real = " + this.NumCoches; return (str1 + "\n" + str2); } // El indexador devuelve un objeto Coche de acuerdo // a un índice numérico public Coche this[int pos] { // Devuelve un objeto del vector de coches get { if(pos < 0 || pos >= MaxCoches) throw new IndexOutOfRangeException("Fuera de rango"); else return (data.vectorCoches[pos]); } // Escribe en el vector set { this.data.vectorCoches[pos] = value;} } } // class Coches class IndexadorCochesApp { static void Main(string[] args) { // Crear una colección de coches Coches MisCoches = new Coches (); // Por defecto (10) Console.WriteLine ("***** Mis Coches *****"); Console.WriteLine ("Inicialmente: "); Console.WriteLine (MisCoches); // Añadir coches. Observar el acceso con [] ("set") MisCoches[0] = new Coche ("Opel", "Zafira", 200); MisCoches[1] = new Coche ("Citröen", "Xsara", 220); MisCoches[2] = new Coche ("Ford", "Focus", 190); MisCoches.NumCoches = 3; Console.WriteLine ("Despues de insertar 3 coches: "); Console.WriteLine (MisCoches); // Mostrar la colección Console.WriteLine (); for (int i=0; i image/out-Index1.gif interface Un interfaz define un contrato semántico que ha de respetar cualquier clase (o struct) que implemente el interfaz. La interfaz no contiene implementación alguna. La clase o struct que implementa el interfaz es la que tiene la funcionalidad especificada por el interfaz. Una interfaz puede verse como una forma especial de definir clases que sólo cuenten con miembros abstractos. Sin embargo, todo tipo que derive de una interfaz ha de dar una implementación de todos los miembros que hereda de esta, y no como ocurre con las clases abstractas donde es posible no darla si se define como abstracta también la clase hija. La especificación del interfaz puede incluir métodos, propiedades, indexadores y eventos, pero no campos, operadores, constructores o destructores. Aunque solo se permite la herencia simple de clases, como ocurre en Java, se permite y herencia múltiple de interfaces. Esto significa que es posible definir tipos que deriven de más de una interfaz. Los interfaces (como algo separado de la implementación) permiten la existencia del polimorfismo, al poder existir muchas clases o structs que implementen el interfaz. image/out-Inter1.gif Otro ejemplo: image/out-Inter3.gif El principal uso de las interfaces es indicar que una clase implementa ciertas características. Por ejemplo, el ciclo foreach trabaja internamente comprobando que la clase sobre la que se aplica implementa el interfaz IEnumerable y llamando a los métodos definidos en esa interfaz. La plataforma .NET no permite herencia múltiple de implementación, aunque sí se puede conseguir herencia múltiple de interfaces. Clases, structs e interfaces pueden heredar de múltiples interfaces (como en Java). image/out-Inter2.gif Si dos interfaces tienen un método con el mismo nombre, se especifica explícitamente el interfaz al que corresponde la llamada al método para eliminar ambigüedades interface IControl { void Delete(); } interface IListBox: IControl { void Delete(); } interface IComboBox: ITextBox, IListBox { void IControl.Delete(); void IListBox.Delete(); } delegate Un delegado es un tipo especial de clase que define la signatura de un método. Su función es similar a la de los punteros a funciones en lenguajes como C y C++ (C# no soporta punteros a funciones). Los delegados pueden pasarse a métodos y pueden usarse para llamar a los métodos de los que contienen referencias. Los delegados proporcionan polimorfismo para las llamadas a funciones: Para hacer más evidente el polimorfismo el método Main podría escribirse como: o bien así: Los delegados son muy útiles ya que permiten disponer de objetos cuyos métodos puedan ser modificados dinámicamente durante la ejecución de un programa. En general, son útiles en todos aquellos casos en que interese pasar métodos como parámetros de otros métodos. Los delegados son la base sobre la que se monta la gestión de eventos en la plataforma .NET. Un delegado es un tipo especial de clase cuyos objetos pueden almacenar referencias a uno o más métodos, de tal manera que a través del objeto sea posible solicitar la ejecución en cadena de todos ellos. Un delegado puede contener e invocar múltiples métodos. De esta forma se puede hacer multicasting de una forma sencilla y elegante. Para que un delegado pueda contener varios métodos, éstos no pueden devolver ningún valor (si lo intentasen devolver, se generaría una excepción en tiempo de ejecución). image/out-Del1.gif Cada delegado tiene una lista ordenada de métodos que se invocan secuencialmente (en el mismo orden en el que fueron añadidos al delegado). Los operadores += y -= se utilizan para añadir y eliminar métodos de la lista asociada a un delegado. Siempre se pueden utilizar interfaces en vez de delegados. Los interfaces son más versátiles, ya que pueden encapsular varios métodos y permiten herencia, si bien los delegados resultan más adecuados para implementar manejadores de eventos. Con los delegados se escribe menos código y se pueden implementar fácilmente múltiples manejadores de eventos en una única clase. Muchas aplicaciones actuales se programan en función de eventos. Cuando se produce algún hecho de interés para nuestra aplicación, éste se notifica mediante la generación de un evento, el cual será procesado por el manejador de eventos correspondiente (modelo "publish-subscribe"). Los eventos nos permiten enlazar código personalizado a componentes creados previamente (mecanismo de "callback"). El callback consiste en que un cliente notifica a un servidor que desea ser informado cuando alguna acción tenga lugar. C# usa los eventos de la misma manera que Visual Basic usa los mensajes. Las aplicaciones en Windows se programan utilizando eventos, pues los eventos resultan especialmente indicados para la implementación de interfaces interactivos. Cuando el usuario hace algo (pulsar una tecla, hacer click con el ratón, seleccionar un dato de una lista...), el programa reacciona en función de la acción del usuario. El uso de eventos, no obstante, no está limitado a la implementación de interfaces. También son útiles en el desarrollo de aplicaciones que deban realizar operaciones periódicamente o realizar operaciones de forma asíncrona (p.ej. llegada de un correo electrónico, terminación de una operación larga...). El lenguaje C# da soporte a los eventos mediante el uso de delegados. Al escribir nuestra aplicación, un evento no será más que un campo que almacena un delegado. Los usuarios de la clase podrán registrar delegados (mediante los operadores += y -=), pero no podrán invocar directamente al delegado. public delegate void EventHandler ( object sender, EventArgs e); public class Button { public event EventHandler Click; protected void OnClick (EventArgs e) { // This is called when button is clicked if (Click != null) Click(this, e); } } public class MyForm: Form { Button okButton; static void OkClicked(object sender, EventArgs e) { ShowMessage("You pressed the OK button"); } public MyForm() { okButton = new Button(...); okButton.Caption = "OK"; okButton.Click += new EventHandler(OkClicked); } }