Un delegate es un objeto que hace referencia a uno o más métodos, previamente declarados en nuestra aplicación. Todos aquellos métodos que sean incluidos en él, tienen la particularidad de ser idénticos en cuanto al retorno y los parámetros que recibe. ¿Con todo esto qué quiero decir? ¿Cuál es el objetivo? La magia está en que, si nosotros creamos un delegate con una serie de métodos asociados, al llamar al mismo lanzará un método detrás de otro pasándole a cada uno de ellos el valor(es) con el que invocamos al delegate. Veamos un ejemplo:

delegate void Delegado(string cadena);

Si mi delegado es como el anterior, todos los métodos que contenga no deberán de retornar nada y necesitan como parámetro un string.
Esa sería la forma de declarar un delegado. Para continuar con el ejemplo, voy a crear dos métodos que cumplan las características del delegado (Esto es muy importante porque, de no ser así, lanzará una excepción).

public void Saludo(string cadena)
{
    lblResult.Text += "Hola " + cadena;
}

public void Despedida(string cadena)
{
   lblResult.Text += " Adios " + cadena;
}

La forma de asignar un método sería la siguiente:

protected void btnDelegado_Click(object sender, EventArgs e)
{
    Delegado delegando = Saludo;
    delegando += Despedida;
    delegando(txtCadena.Text);
}

Para asignar el método Saludo, simplemente utilizo el símbolo = y, para añadir el método Despedida +=
Si quisiéramos eliminar en algún momento del delegado uno de los métodos, únicamente tendríamos que utilizar -= nombre_del_Metodo

¡Saludos!

Una de las nuevas funcionalidades de C# 3.0 fue la posibilidad de ampliar los métodos de una clase ya existente. Con ello, conseguimos aprovechar al máximo las clases ya predeterminadas, añadiéndole alguna funcionalidad que nos es requerida para nuestra aplicación. De no ser así, deberíamos tener estos métodos en clases distintas y perderíamos esa unificación.

He recuperado un pequeño ejemplo de msdn, donde añadimos un nuevo método a la clase String con el que podemos contar las palabras de una cadena.

Para ello, he creado un proyecto web con un texbox y un botón. Añado un proyecto de tipo librería para almacenar mi clase “Extensions” dónde especifico el nuevo método que agregaré a esta clase. De esta manera puedo utilizar mis extensiones en cualquier otro proyecto que lo necesite.

using System;

namespace Extensions
{
    public static class Extensions
    {
        public static int ContarPalabras(this String str)
        {
            return str.Split(new[] {' ', '.', '?'}, StringSplitOptions.RemoveEmptyEntries).Length;
        }
    }
}

Como podemos ver, creamos un método con el nombre que queremos que aparezca dentro de nuestra clase. Como parámetros (aquí está la clave) le indicamos que este método (this) pertenece a la clase String.
El contenido del mismo es exactamente igual que cualquier otro método. En este caso, lo único que hacemos es crearnos un array, a raíz de un split realizado a la cadena que está instanciada en nuestra clase String, y retornamos el tamaño de ese array, omitiendo los blancos.
Importamos la librería a nuestro proyecto web y, si nos creamos un String y comprobamos la lista de posibilidades nos aparecería lo siguiente:

Para comprobar esta funcionalidad, defino un evento click para mi botón y recojo la cadena introducida por el usuario para comprobar su tamaño.

using System;
using Extensions;

namespace ExtensionMethod
{
    public partial class Default : System.Web.UI.Page
    {
       protected void btnContar_Click(object sender, EventArgs e)
        {
            string cad = txtCadena.Text;
            lblResult.Text = string.Format("La cadena tiene {0} palabra(s)", cad.ContarPalabras());
        }
    }
}

¡Saludos!

Una de las nuevas características preparadas para C# 4.0 son los parámetros opcionales, ya conocidos por Visual Basic .NET. El objetivo será declarar nuestros métodos, constructores e indexadores con unos valores por defecto en el caso de no indicarlos en la llamada. 

using System;

namespace ParametrosOpcionales
{
    class Program
    {
        static void Main()
        {
            DatosPersonales("Gisela");
            DatosPersonales("Gisela", "Perez");
            DatosPersonales("Gisela", "Perez", 10);

            Console.ReadLine();

        }

        static void DatosPersonales(string nombre, string apellido = "Torres", int edad = 20)
        {
            Console.WriteLine("Nombre:{0} Apellido:{1} Edad:{2}", nombre, apellido, edad);
        }
    }
}

Podemos realizar distintas llamadas indicando únicamente el obligatorio, el obligatorio y uno de los opcionales o todos ellos. Visto así, podemos preguntarnos cuál sería la manera de llamar a nuestro método pasándole como argumentos el primer parámetro y el último, sin querer saber nada del segundo. ¿Esto es posible? Afortunamente si y aquí es donde entran en juego los argumentos nombrados, pensados para casos como este. 

DatosPersonales(nombre: "Jose");

DatosPersonales(nombre: "Pedro", apellido: "Leal");

DatosPersonales(edad: 40, apellido: "Rodriguez", nombre: "Laura");

Si utilizamos este tipo de llamada, incluso es posible alterar el orden de los parámetros. 

Podemos llegar a pensar en la posibilidad de olvidarnos de la sobrecarga en algunos casos, sobre todo por el ahorro de código que esto supone. También es cierto que podemos necesitar que la sobrecarga y los parámetros opcionales convivan.

using System;
namespace ParametrosOpcionales
{

    class Program
    {
        static void Main()
        {
            ejemplo("Hola");

            Console.ReadLine();
        }

        static void ejemplo(object saludo)
        {
            Console.WriteLine("Object: {0}", saludo);
        }

        static void ejemplo(string saludo, string nombre = "Gisela")
        {
            Console.WriteLine("{0} {1}", saludo, nombre);
        }

        static void ejemplo(string saludo)
        {
            Console.WriteLine("Simplemente {0}", saludo);

        }
    }
}

En este ejemplo, existen tres tipos de sobrecarga. Si nosotros únicamente pasamos como argumento un string (“Hola”) debemos tener claro cual de los tres métodos será el candidato. Hay que tener en cuenta lo siguiente:

- Siempre se eligirá en primer lugar aquel método que no necesite convertir el dato que le estamos pasando a otro tipo.

- Tendrá preferencia aquel método que no necesite omitir sus parámetros opcionales.

Así pues, si arrancamos este ejemplo comprobaremos que la sobrecarga elegida será la tercera por ser el arguménto del mismo tipo y por no contenter parámetros opcionales que no se están teniendo en cuenta en nuestra llamada.

¡Saludos!