el blog del isra

  string texto = "Cadena de texto";
  texto = texto.Delete(" de texto");
  // texto = "Cadena"

Retomando el ejemplo anterior, podemos crear una función Delete para el tipo string.

Primero les mostraré cómo crear un método estático, ya que de ahí nos basaremos para crear la extensión.

Como aclaración para los que no lo sepan, las funciones o métodos estáticos, en la programación orientada a objetos, son los que no dependen de un objeto, sino que pueden ser invocados directamente desde la clase. .NET ya incluye muchos de estos, como en éste ejemplo:

  string[] hm = new string[] { "hola", "mundo" };
  string hm2 = string.Join("-", hm);
  // hm2 = "hola-mundo"

Join, método estático de la clase String, une los datos de un arreglo de strings separados por lo indicado en el primer parámetro. Si no fuera un método estático, se tendría que hacer algo como hm.Join("-"), ya que debería ser invocado desde esa variable. Este último es el caso de los métodos de extensión, como veremos más adelante.

Ahora sí, comenzamos con nuestro método. Crearemos una clase independiente en la que introduciremos nuestro método de ejemplo:

C#

public class Extensiones
{
  public static string Delete(string value, string delete)
  {
    return value.Replace(delete, "");
  }
}

Sí, es algo sin chiste, pero se entiende u.u

VB.NET

Public Class Extensiones
  Public Shared Function Delete(value As String, delete As String) As String
    Return value.Replace(delete, "")
  End Function
End Class

En C#, la palabra static determina una función o variable estática. En VB.NET, se usa Shared.

Para implementar este método, haríamos esto:

  string texto = Extensiones.Delete("Hola mundo!", " mundo");

La variable texto tendrá el valor "Hola!", pues " mundo" se eliminará. No tuvimos que crear una instancia de Extensiones, pues Delete es estático.

Sigue siendo mucho rollo para lo que queremos hacer, por lo que el agregar la función Delete al tipo String será la mejor solución.

Para aplicar un método de extensión, no basta con hacer estática sólo la función, sino toda la clase. Éste será el primer paso. Aquí la diferencia entre los lenguajes es más marcada:

C#

public static class Extensiones
{

}

VB.NET

Module Extensiones

End Module

¡Éitale! ¿Qué pasó aquí? En C#, una clase puede ser definida como estática, pero en Visual Basic, no. Esto tiene que ver con la forma en que se programaba en VB6 y anteriores, que no sé bien cómo era, pero tiene características que se han mantenido. Para este lenguaje se crea un módulo, que tendrá nuestra función.

Nuestro método también será diferente en ambos casos, así que los pondré con su explicación por separado:

C#

public static class Extensiones
{
  public static string Delete(this string value, string delete)
  {
    return value.Replace(delete, "");
  }
}

La diferencia aquí fue el this en el primer parámetro del método. Esto indicará que el primer parámetro será el objeto de referencia, al que se aplicará el método. Se invocará de esta manera:

  string texto = "Hola mundo!";
  string texto2 = texto.Delete(" mundo");
  // texto2 = "Hola!"

¿Por qué sólo envío un parámetro al método Delete? Porque el parámetro que lleva la expresión this no es considerado como tal. Al entrar a Delete, value será texto, y delete será " mundo".

VB.NET

Imports System.Runtime.CompilerServices

Module Extensiones
  <Extension()> _
  Public Function Encriptar(ByVal value As String, ByVal delete As String) As String
    Return value.Replace(delete, "")
  End Function
End Module

Primera diferencia: Se debe agregar el atributo Extension a la función, el cual se encuentra en el espacio System.Runtime.CompilerServices (por eso importé la biblioteca, aunque también pude haber escrito la ruta en el atributo). Éste indicará que la función es un método de extensión.

Segunda: No necesita la palabra this, o mejor dicho, su equivalente en VB, Me, por lo mismo de haber indicado el atributo Extension.

Igual que en C#, el primer parámetro será el objeto que invoque al método:

  Dim texto As String = "Hola mundo!"
  Dim texto2 As String = texto.Delete(" mundo")
  ' texto2 = "Hola!"

Los métodos de extensión no tienen que devolver un valor, necesariamente. Ni el valor devuelto debe ser del mismo tipo del objeto de referencia.

C#

  // Método que muestra una ventana con el mensaje de la Exception
  public static void ShowErrorMessage(this Exception ex)
  {
    // Este método invoca al otro método de extensión, FullErrorMessage()
    MessageBox.Show(ex.FullErrorMessage(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
  }

  // Método que genera un string de la excepción y sus excepciones internas.
  // Si el objeto contiene otra excepción interna, se invoca a éste mismo método para dicha excepción.
  public static string FullErrorMessage(this Exception ex)
  {
    string msg = ex.Message;
    if (ex.InnerException != null)
      msg += "\n" + ex.InnerException.FullErrorMessage();
    return msg;
  }

VB.NET

  ' Método que muestra una ventana con el mensaje de la Exception
  Public Shared Sub ShowErrorMessage(ex As Exception)
    ' Este método invoca al otro método de extensión, FullErrorMessage()
    MessageBox.Show(ex.FullErrorMessage(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
  End Sub

  ' Método que genera un string de la excepción y sus excepciones internas.
  ' Si el objeto contiene otra excepción interna, se invoca a éste mismo método para dicha excepción.
  Public Static Function FullErrorMessage(ex As Exception)
    Dim msg As String = ex.Message
    If ex.InnerException IsNot Nothing Then _
      msg &= VbCrLf & ex.InnerException.FullErrorMessage()
    Return msg
  End If

Si usamos .NET 2 (Visual Studio 2005), hay que quitar la propiedad estática a la clase, quitar el this en los métodos e implementarlo como una función estática normal, como en el primer ejemplo.

EDITADO:

Se me había pasado algo (gracias, Aníbal). Un método de extensión afecta tanto a la clase que se le indica como a todas las clases que heredan de ésta. Por ejemplo, si estamos trabajando para un sitio Web, y creamos un método de extensión para WebControl, éste método se implementará en todas las instancias de TextBox, Button, GridView, Label, etc., pues todas se derivan de aquella. Si creamos el método para la clase Control, se implementará no sólo en los derivados de WebControl, sino también en otros como los HtmlControls (HtmlAnchor, HtmlButton, HtmlImage, HtmlGenericControl).

Si creamos un método de extensión para la clase object, se implementará en TODAS las clases y tipos de datos del lenguaje, ya sean instancias de controles, como los mencionados, o tipos int, string, char, bool, etc., e incluso enumeradores.