Extender una estructura existente en C# para agregar operadores

Question

Quiero extender .NET incorporado en la estructura Color para agregar nuevos operadores como + o -.
voy a utilizar como ellos:

Color c1 = Color.FromName("Red"); 
Color c2 = Color.FromName("Blue"); 
Color result = c2 - c1; 

¿Es posible? si es así, ¿cómo?

Answer 1

No hay forma de hacerlo con los operadores integrados.

Se puede escribir un método de extensión de tipo de fingir sin embargo:

public static class Extensions 
{ 
    public static Color Substract(this Color color, Color theOtherColor) 
    { 
     //perform magic here! 
     //be sure to return something or this won't compile 
    } 
} 

Color c1 = Color.FromName("Red"); 
Color c2 = Color.FromName("Blue"); 
Color result = c2.Subtract(c1); 

Answer 2

Mira extension methods.

Answer 3

Las estructuras y las clases en C# comparten muchas similitudes, sin embargo, una de varias diferencias es que no se puede crear una subclase de una estructura. Puede usar un método de extensión para implementar un método Add() o un método Subtract(), pero no puede escribir una sobrecarga del operador en un método de extensión.

Si yo fuera usted y realmente quisiera extender la funcionalidad de una estructura existente como esta, envolvería la estructura en mi propia clase.

Answer 4

Yo diría que estos ya existen, ¿estás hablando de redefinirlos? Estas son operaciones en el alfa y RGB de los colores. Sigue a continuación:

http://msdn.microsoft.com/en-us/library/system.windows.media.color.op_subtraction.aspx

http://msdn.microsoft.com/en-us/library/system.windows.media.color.op_addition.aspx

Answer 5

Como otros sugirieron, puede ir de cualquier manera el métodos de extensión o la forma Decorator.

Sin embargo, tenga en cuenta que Color tiene un buen número de propiedades y métodos, por lo que redirigirlos a todos desde la clase de decorador a su estructura de Color envuelta significará escribir muchos textos repetidos. Si ir por ese camino, sin embargo, puede de hecho definir operadores y conversiones incluso implícitas de su clase a color y al revés (para que pueda utilizarlos más intercambiable), así:

public class MyColor { 
    public System.Drawing.Color val; 

    public MyColor(System.Drawing.Color color) 
    { 
     this.val = color; 
    } 

    public static MyColor AliceBlue 
    { 
     get { 
      return new MyColor(System.Drawing.Color.AliceBlue); 
     } 
    } 

    public override string ToString() 
    { 
     return val.ToString(); 
    } 
    // .... and so on.... 

    // User-defined conversion from MyColor to Color 
    public static implicit operator System.Drawing.Color(MyColor c) 
    { 
     return c.val; 
    } 
    // User-defined conversion from Color to MyColor 
    public static implicit operator MyColor(System.Drawing.Color c) 
    { 
     return new MyColor(c); 
    } 
} 

para poner a prueba :

MyColor c = System.Drawing.Color.AliceBlue; // assigning a Color to a MyColor 
              // thanks to the implicit conversion 
Console.WriteLine(c.ToString()); // writes "Color [AliceBlue]" 

Answer 6

Si no puede extenderse algo, también puede crear una clase contenedora o estructura. En muchos casos, una composición es realmente más poderosa y flexible que una extensión.

Permite la herencia múltiple, se puede actualizar fácilmente/envolver un objeto existente, etc.

No estoy diciendo que es la mejor respuesta a esta pregunta, pero sin duda algo digno de consideración. :)