Rozszerzanie istniejącej struktury w języku C# w celu dodania operatorów

Question

Chcę rozszerzyć wbudowaną strukturę .NET Color, aby dodać nowych operatorów, takich jak + lub -.
będę używał ich jak:

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

Czy to możliwe? jeśli tak, w jaki sposób?

Answer 1

Nie ma sposobu, aby to zrobić z wbudowanymi operatorami.

można napisać metodę rozszerzenia do rodzaju fałszywej nim jednak:

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

Spójrz na extension methods.

Answer 3

Struktury i klasy w języku C# mają wiele podobieństw, jednak jedną z wielu różnic jest to, że nie można podklasować struktury. Można użyć metody rozszerzającej do implementacji metody Add() lub Subtract(), ale nie można zapisać przeciążenia operatora w metodzie rozszerzenia.

Gdybym był tobą i naprawdę chciałem rozszerzyć funkcjonalność istniejącej struktury takiej jak ta, chciałbym zawrzeć strukturę we własnej klasie.

Answer 4

Powiedziałbym, że te już istnieją, czy mówisz o ich ponownym zdefiniowaniu? Są to operacje na alfa i RGB kolorów. Patrz poniżej:

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

Jak inni sugerują, można iść albo sposób rozszerzenie metod lub wzoru drogę Dekorator.

Należy jednak wziąć pod uwagę, że kolor ma wiele właściwości i metod, więc przekierowanie ich wszystkich z klasy dekoratora do zapakowanej struktury koloru będzie oznaczało napisanie wielu elementów. Jeśli pójdziesz tą drogą, jednak można rzeczywiście określić operatorów, a nawet niejawne konwersje z twojej klasy na kolor i na odwrót (tak, że można z nich korzystać więcej zamiennie), podobnie jak to:

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

przetestować :

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

Jeśli nie możesz czegoś rozszerzyć, możesz także utworzyć klasę opakowania lub strukturę. W wielu przypadkach kompozycja jest w rzeczywistości bardziej wydajna i elastyczna niż rozszerzenie.

Umożliwia wielokrotne dziedziczenie, można łatwo uaktualnić/zawinąć istniejący obiekt itp

Nie mówię, że jest to najlepsza odpowiedź na to pytanie, ale z pewnością coś warte rozważenia. :)