Impossibile convertire implicitamente il tipo 'X' a 'stringa' - quando e come si decide che “non può”?

Question

In questo momento sto avendo con Guids.

Certamente ricordo che tutto il codice in alcuni luoghi funziona questa conversione implicita, in altri non è così. Fino ad ora non riesco a vedere il modello.

Come il compilatore decide quando essa non si può? Cioè, il metodo di tipo Guid.ToString() è presente, non è chiamata ogni volta che è necessario questa trasformazione è?

Qualcuno può dirmi in quali circostanze questa trasformazione avviene automaticamente e quando devo chiamare myInstance.ToString() esplicitamente?

Answer 1

In breve, quando v'è una implicita o esplicita operatore di conversione definito:

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

No, non v'è alcuna conversione implicita da GUID a String, in modo che non funziona ovunque a tutti nel codice.

Funziona solo in presenza di una conversione esplicita, ma la conversione potrebbe non essere molto visibile. Per esempio, quando si concatenare le stringhe:

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

Questo può sembrare una conversione implicita da GUID a String, ma non lo è. Il codice che viene generato in realtà assomiglia a questo:

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

Tutti gli operandi sono espressi al tipo Object e collocati in una matrice. Il metodo String.Concat poi chiama il metodo ToString per ogni elemento dell'array per ottenere la rappresentazione di stringa per loro.

Answer 3

L'unico posto dove si effettivamente non è necessario chiamare ToString () te è quando la concatenazione delle stringhe.

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

Poi ci sono alcuni casi in cui la chiamata viene effettuata da .NET Framework, come in String.Format () .

Oltre a questo, il compilatore convertire solo un tipo, se è noto che sia compatibile (ad esempio classe base o implementazione di un'interfaccia o tramite un operatore di conversione esplicitamente codificata). Quando si utilizza un cast e il compilatore sa che i tipi non possono essere compatibili (ad esempio, non è nella stessa linea di successione, e non interfacce), sarà anche dire che non è possibile convertirlo. Lo stesso vale per i parametri di tipo generico.