Le compilateur C# effectuera-t-il plusieurs conversions implicites pour passer d'un type à un autre?

Question

Disons que vous avez vous-même une classe comme les suivantes:

public sealed class StringToInt { 
    private string _myString; 
    private StringToInt(string value) 
    { 
     _myString = value; 
    } public static implicit operator int(StringToInt obj) 
    { 
     return Convert.ToInt32(obj._myString); 
    } 
    public static implicit operator string(StringToInt obj) 
    { 
     return obj._myString; 
    } 
    public static implicit operator StringToInt(string obj) 
    { 
     return new StringToInt(obj); 
    } 
    public static implicit operator StringToInt(int obj) 
    { 
     return new StringToInt(obj.ToString()); 
    } 
} 

Est-ce que vous alors en mesure d'écrire du code comme le suivant:

MyClass.SomeMethodThatOnlyTakesAnInt(aString); 

sans lui indiquant qu'il n'y a pas de conversion implicite de chaîne à int?

[Oui, je pourrais tester moi-même, mais je pensais que je le mettrais là-bas et voir ce que tous les gourous ont à dire]

Answer 1

Je suis à peu près certain que ce n'est pas possible sous C# 3.0. Les sections de the reference qui couvrent les conversions sont 6,4. A savoir, 6.4.4 "Conversions implicites définies par l'utilisateur".

Il ne parle que de conversions de S-> T (et non S> T-> U) qui couvre les cas tels que:

StringToInt _t = "foo"; 
int t = _t; 

et

int t = (StringToInt)"foo"; 

Si les deux ces cas impliquent seulement S-> T (deux fois).

Je suis assez sûr que ce n'est pas possible dans C# 3.0. Autoriser S-> T-> U nécessiterait beaucoup plus de travail à effectuer par le type de correspondance, au moins suivant l'algorithme spécifié.

Answer 2

Typos dans votre extrait:

public StringToInt(string value) 
{ 
    _myString = value; 
} 
public static implicit operator int(StringToInt obj) 
{ 
    return Convert.ToInt32(obj._myString); 
} 
public static implicit operator string(StringToInt obj) 
{ 
    return obj._myString; 
} 

Si aString est de type StringToInt, votre utilisation devrait fonctionner.

Answer 3

Cela ne semble pas fonctionner. Il nécessite au moins une distribution explicite. Eh bien ...

Answer 4

Aucun C# n'appelle plus d'une conversion implicite définie par l'utilisateur. À partir de la section Spécification C# 6.4.3:

L'évaluation d'une conversion définie par l'utilisateur n'implique jamais plus d'un opérateur de conversion défini ou défini par l'utilisateur. En d'autres termes, une conversion du type S au type T n'effectuera jamais une conversion définie par l'utilisateur de S à X, puis exécutera une conversion définie par l'utilisateur de X à T.