Estendere una struttura esistente in C# per aggiungere operatori

Question

Desidero estendere la struttura integrata di .NET per aggiungere nuovi operatori come + o -.
Userò come loro:

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

E 'possibile? se sì, come?

Answer 1

Non c'è modo di farlo con gli operatori integrati.

si potrebbe scrivere un metodo di estensione per tipo di esso falso però:

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

Guarda extension methods.

Answer 3

Le strutture e le classi in C# condividono molte somiglianze, tuttavia una delle diverse differenze è che non è possibile creare una sottoclasse di una struttura. È possibile utilizzare un metodo di estensione per implementare un metodo Add() o Subtract(), ma non è possibile scrivere un overload di operatore in un metodo di estensione.

Se fossi in te e volessi davvero estendere la funzionalità di una struttura esistente come questa, vorrei avvolgere la struttura nella mia classe.

Answer 4

Direi che questi esistono già, stai parlando di ridefinirli? Queste sono operazioni sull'alpha e RGB dei colori. Vedere qui sotto:

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

Come altri hanno suggerito, si può andare sia il modo in cui i metodi di estensione o il modo modello Decorator.

Tuttavia, considera che Color ha un discreto numero di proprietà e metodi, quindi ridirigli tutti dalla classe decoratore alla struttura Color avvolta significherà scrivere un numero elevato di piastre. Se seguire questa strada, tuttavia, è possibile infatti definire gli operatori e le conversioni anche implicite dalla classe al colore e viceversa (in modo da poterli utilizzare più intercambiabile), in questo modo:

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); 
    } 
} 

per testare :

Answer 6

Se non è possibile estendere qualcosa, è anche possibile creare una classe wrapper o una struttura. In molti casi una composizione è in realtà più potente e flessibile di un'estensione.

Esso permette l'ereditarietà multipla, è possibile aggiornare facilmente/avvolgere un oggetto esistente ecc

Non sto dicendo che è la migliore risposta a questa domanda, ma sicuramente qualcosa da prendere in considerazione. :)