Comment écrire un opérateur de surcharge où les deux arguments sont interface

Question

J'utilise l'interface pour la plupart de mes trucs. Je ne peux pas trouver un moyen de créer un opérateur de surcharge + qui me permettrait de faire une addition sur des objets implémentant l'interface iPoint

Code

interface IPoint 
{ 
    double X { get; set; } 
    double Y { get; set; } 
} 
 

class Point : IPoint 
{ 
    double X { get; set; } 
    double Y { get; set; } 

    //How and where do I create this operator/extension ??? 
    public static IPoint operator + (IPoint a,IPoint b) 
    { 
    return Add(a,b); 
    } 

    public static IPoint Add(IPoint a,IPoint b) 
    { 
     return new Point { X = a.X + b.X, Y = a.Y + b.Y }; 
    } 
} 

    //Dumb use case : 
public class Test 
{ 
    IPoint _currentLocation; 

    public Test(IPoint initialLocation) 
    { 
    _currentLocation = intialLocation 
    } 
    public MoveOf(IPoint movement) 
    { 

     _currentLocation = _currentLocation + intialLocation; 
    //Much cleaner/user-friendly than _currentLocation = Point.Add(_currentLocation,intialLocation); 
    } 
} 

Answer 1

Vous n'avez pas. Imaginez si vous avez deux instances IPoint, a et b, les deux classes différentes (qui implémentent IPoint). Appelez maintenant "a + b". Quel opérateur + est appelé? Quel type de béton est retourné? Editer: Désolé, pour clarifier votre commentaire, "Pas en C# tel quel". J'ai un débat philipsophique sur la question de savoir si vous devriez être capable de le faire, car je pense que vous pouvez créer une confusion significative.

Answer 2

Je ne pense pas que vous pouvez faire ce que vous demandez, j'ai regardé dans le passé et à venir vide. Le problème est, même dans votre exemple d'utilisation .Add est que vous devez toujours convertir le paramètre movement en un Point Type pour avoir accès à cette méthode. Ceci, je crois est une limitation de C#, si je me trompe, je serais très heureux de le savoir.

Ce que je suggère est que si vous connaissez vous toujours va obtenir un Point Type dans MoveOf alors il serait prudent de toujours jeter à Point dans la méthode, si tel est le cas, alors vous devrait accepter Point comme paramètre.

La seule autre chose que je peux dire est que si vous créez un Point Type au départ et à passer que MoveOf, vous pouvez vérifier le type de movement à l'intérieur MoveOf avant la coulée elle. Le problème ici est bien sûr que vous devrez éventuellement faire cela pour tous les types qui héritent de IPoint et utilisent la méthode MoveOf.