Sobrecarga de operadores en

Acerca de Sobrecarga de operadores

Los principales operadores aritméticos y de comparación se pueden adaptar para que los usen tus propias clases y structs. Esto se conoce como sobrecarga de operadores.

Este artículo es un análisis exhaustivo de la sintaxis, así como de qué operadores se pueden sobrecargar y cuáles no.

La mayoría de los operadores tienen la forma:

static <return type> operaator <operator symbols>(<parameters>);

Los operadores de conversión tienen la forma:

static (explicit|implicit) operator <cast-to-type>(<cast-from-type> <parameter name>);

Los operadores se comportan igual que los métodos estáticos.

• Un símbolo de operador ocupa el lugar del identificador de un método, y tiene parámetros y un tipo devuelto. Las reglas de tipos para los parámetros y el tipo devuelto siguen tu intuición, y puedes confiar en que el compilador te dé indicaciones detalladas.
• En las operaciones binarias, el primer parámetro recibe el argumento de la izquierda de la operación.
• Los operadores tienen una signatura formada por dos parámetros (en el caso de las operaciones binarias) y un tipo devuelto, o por un solo parámetro y un tipo devuelto en el caso de los operadores unarios.
• En los operadores binarios, uno de los tipos de los parámetros debe ser el de la clase que los declara.
• En el caso de las conversiones de tipos, el parámetro o el tipo devuelto debe ser el tipo de la clase que las declara.
• En los operadores de incremento y decremento, el parámetro y el tipo devuelto deben ser los de la clase que los declara.

Ejemplos de sintaxis:

struct Point
{
    decimal x;
    decimal y;

    public static bool operator ==(Point pt, Point ptOther)
    {
        return pt.x == ptOther.x && pt.y == ptOther.y;
    }

    public static bool operator !=(Point pt, Point ptOther)
    {
        return !(pt == ptOther);
    }

    public static Point operator *(Point pt, decimal scale)
    {
        var ptNew = new Point();
        ptNew.x = pt.x * scale;
        ptNew.y = pt.y * scale;
        return ptNew;
    }

    public static implicit operator Point((decimal x, decimal y) xy)
    {
        var pt = new Point();
        pt.x = xy.x;
        pt.y = xy.y;
        return pt;
    }

    public static explicit operator (decimal x, decimal y)(Point pt)
    {
        return (pt.x, pt.y);
    }
}

A menudo resulta productivo implementar un método Equals() y llamarlo desde el operador ==. De forma similar, para las comparaciones puedes implementar la interfaz IComparable. En ambos casos, matas dos pájaros de un tiro y algo más.

Ten en cuenta que no puedes crear operadores a partir de símbolos que no formen parte del conjunto estándar de operadores. Solo puedes usar símbolos existentes para aquellas operaciones en las que la documentación especifique que se pueden sobrecargar. Los operadores que se pueden sobrecargar están listados aquí.

Ten en cuenta que el orden de los parámetros es importante cuando difieren en tipo. En el código de ejemplo anterior, pt * 10m es una expresión válida, mientras que 10m * pt no compilará.

Referencia

Esta documentación sobre la sobrecarga de operadores detalla la sintaxis.