La fonction opérateur + avec deux conversions implicites ne fonctionne pas

Question

J'essaie de transférer certaines parties de ginac (www.ginac.de) vers C#. Mais je rencontrais ceci:

class Program { 

static void Main(string[] args) { 

     symbol s = new symbol();   
     numeric n = new numeric(); 

     ex e = s + n; // "Operator + doesn't work for symbol, numeric" 
    } 
} 

class ex { 
    //this should be already be sufficient: 
    public static implicit operator ex(basic b) { 
     return new ex(); 
    } 
    //but those doesn't work as well: 
    public static implicit operator ex(numeric b) { 
     return new ex(); 
    } 
    public static implicit operator ex(symbol b) { 
     return new ex(); 
    } 

    public static ex operator +(ex lh, ex rh) { 
     return new ex(); 
    } 
} 
class basic {  
} 
class symbol : basic { 
} 
class numeric : basic { 
} 

L'ordre doit être: implicitement jeté symbolisation> Basic-> ex, puis numeric> Basic-> ex puis utilisez l'opérateur ex + (ex, ex) fonction.

Dans quel ordre la recherche de fonctions de moulage implicites et de fonctions d'opérateur est-elle effectuée? Y a-t-il un moyen de contourner cela?

Answer 1

Lance le premier opérande sur "ex". Le premier opérande de l'opérateur + ne sera pas implicitement casté. Vous devez utiliser une distribution explicite.

L'opérateur + détermine réellement son type à partir du premier opérande, qui est le symbole dans votre cas. Lorsque le premier opérande est un ex, alors ex + ex va tenter la distribution implicite du second opérande.

Answer 2

Le problème est avec le operator + Selon MSDN, le compilateur génère une erreur si aucun des paramètres de la méthode operator + n'est de type classe dans lequel la méthode est écrite. Link to documentation.

class iii { //this is extracted from the link above.. this is not complete code. 
public static int operator +(int aa, int bb) ... // Error CS0563 
// Use the following line instead: 
public static int operator +(int aa, iii bb) ... // Okay. 
} 

Ce code fonctionnera parce que vous convertissez au moins un des paramètres à ex Type:

class basic { } 
class symbol : basic { } 
class numeric : basic { } 

class ex { 
    public static implicit operator ex(basic b) { 
     return new ex(); 
    } 

    public static implicit operator basic(ex e) { 
     return new basic(); 
    } 

    public static ex operator + (basic lh, ex rh) { 
     return new ex(); 
    } 
} 

class Program { 
    static void Main(string[] args) { 
     symbol s = new symbol(); 
     numeric n = new numeric(); 

     // ex e0 = s + n; //error! 
     ex e1 = (ex)s + n; //works 
     ex e2 = s + (ex)n; //works 
     ex e3 = (ex)s + (ex)n; //works 
    } 
}