Peut pas convertir implicitement le type « X » « string » - quand et comment il décide qu'il « ne peut pas »?

Question

En ce moment je vais avoir avec Guids.

Je me souviens certainement que tout au long du code dans certains endroits, cela fonctionne la conversion implicite, dans d'autres, il ne fonctionne pas. Jusqu'à présent, je ne vois pas le motif.

Comment le compilateur décide quand il ne peut pas? Je veux dire, la méthode de type Guid.ToString() est présent, ne l'est pas appelée chaque fois que cette transformation est nécessaire?

Quelqu'un peut-il s'il vous plaît me dire dans quelles circonstances cette transformation se fait automatiquement et quand je dois appeler explicitement myInstance.ToString()?

Answer 1

En bref, quand il y a un opérateur de conversion implicite ou explicite défini:

class WithImplicit {
    public static implicit operator string(WithImplicit x) {
        return x.ToString();}
}
class WithExplicit {
    public static explicit operator string(WithExplicit x) {
        return x.ToString(); }
}
class WithNone { }

class Program {
    static void Main() {
        var imp = new WithImplicit();
        var exp = new WithExplicit();
        var none = new WithNone();
        string s1 = imp;
        string s2 = (string)exp;
        string s3 = none.ToString();
    } 
}

Answer 2

Non, il n'y a pas de conversion implicite de GUID à String, de sorte que cela ne fonctionne pas du tout partout dans le code.

Il ne fonctionne que lorsqu'il ya une conversion explicite, mais la conversion pourrait ne pas être très visible. Par exemple, lorsque vous concaténer des chaînes:

string id = "--" + guidValue + " : " + num;

Cela peut ressembler à une conversion implicite de GUID à String, mais ce n'est pas. Le code qui est généré ressemble vraiment à ceci:

string id = String.Concat(new object[] { "--", guidValue, " : ", num });

Toutes les opérandes sont coulés au type Object et placés dans un tableau. La méthode String.Concat appelle ensuite la méthode de ToString pour chaque élément du tableau pour obtenir la représentation de chaîne pour eux.

Answer 3

Le seul endroit où vous ne effectivement pas besoin d'appeler ToString () vous est lorsque les chaînes concaténer.

Guid g;
int i;
string s = "Hello "+g+' '+i;

Ensuite, il y a des situations où l'appel est fait par le .NET Framework, comme dans String.Format () .

Autre que cela, le compilateur ne convertir un type si elle est connue pour être compatible (par exemple la classe de base ou la mise en œuvre d'une interface ou via un opérateur de conversion explicitement code). Lorsque vous utilisez un casting et le compilateur sait que les types ne peuvent pas être compatibles (par exemple pas dans la même ligne d'héritage, et non des interfaces), il dira aussi qu'il ne peut pas le convertir. La même chose vaut pour les paramètres de type générique.