blocks|key|1582158|text|简而言之，当定义了隐式或显式转换运算符时：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582159|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();
++++}+
}|code-block|syntax|javascript|1582160|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In short, when there is an implicit or explicit conversion operator defined:

<pre><code>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();
 } 
}
</code></pre>

blocks|key|1582237|text|唯一不需要自己调用ToString()的地方是在连接字符串时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582238|Guid+g;
int+i;
string+s+=+"Hello+"%2Bg%2B'+'%2Bi;|code-block|syntax|javascript|1582239|在某些情况下，例如在String.Format()中，调用是由.NET框架发出的。|offset|length|1582240|除此之外，编译器只会在已知兼容的情况下转换类型(例如基类或实现接口，或通过显式编码的转换操作符)。当你使用强制转换，并且编译器知道类型不兼容时(例如，不在同一继承线上，也不在接口上)，编译器也会说它不能转换它。泛型类型参数也是如此。|1582241|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.string.format.aspx^0|0|0|A|F|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

The only place where you effectively don't need to call ToString() yourself is when concatenating strings.

<pre><code>Guid g;
int i;
string s = "Hello "+g+' '+i;
</code></pre>

Then there are some situations where the call is made by the .NET Framework, such as in <a href="http://msdn.microsoft.com/en-us/library/system.string.format.aspx" rel="nofollow noreferrer">String.Format()</a>.

Other than that, the compiler will only convert a type if it is known to be compatible (e.g. base class or implementing an interface or via an explicitly coded conversion operator). When you use a cast and the compiler knows that the types cannot be compatible (e.g. not in the same inheritance line, and not interfaces), it will also say that it cannot convert it. The same goes for generic type parameters.

blocks|key|1367219|text|不，没有从GUID到String的隐式转换，所以这在代码中的任何地方都不起作用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1367220|它只在有显式转换的情况下才有效，但转换可能不是很明显。例如，当您连接字符串时：|1367221|string+id+=+"--"+%2B+guidValue+%2B+"+:+"+%2B+num;|code-block|syntax|javascript|1367222|这看起来像是从GUID到String的隐式转换，但它不是。生成的代码实际上如下所示：|1367223|string+id+=+String.Concat(new+object[]+{+"--",+guidValue,+"+:+",+num+});|1367224|所有操作数都转换为Object类型，并放入数组中。然后，String.Concat方法为数组中的每一项调用ToString方法，以获取它们的字符串表示形式。|1367225|entityMap^0|5|4|A|6|0|0|0|7|4|C|6|0|0|9|6|S|D|1H|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|T|$]]

No, there is no implicit conversion from <code>GUID</code> to <code>String</code>, so that doesn't work anywhere at all in the code.

It only works where there is an explicit conversion, but the conversion might not be very visible. For example when you concatenate strings:

<pre><code>string id = "--" + guidValue + " : " + num;
</code></pre>

This may look like an implicit conversion from <code>GUID</code> to <code>String</code>, but it isn't. The code that is generated actually looks like this:

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

All operands are cast to the type <code>Object</code> and placed in an array. The <code>String.Concat</code> method then calls the <code>ToString</code> method for each item in the array to get the string representation for them.

Right now I'm having it with <code>Guid</code>s.

I certainly remember that throughout the code in some places this implicit conversion works, in others it does not. Until now I fail to see the pattern.

How the compiler decides when it cannot? I mean, the type method <code>Guid.ToString()</code> is present, isn't it called whenever this transformation is needed?

Can someone please tell me under what circumstances this transformation is done automatically and when I have to call <code>myInstance.ToString()</code> explicitly?

Cannot implicitly convert type 'X' to 'string' - when and how it decides that it "cannot"?

编译器

现在我正和Guids在一起。我当然记得，在整个代码中，这种隐式转换在某些地方起作用，而在另一些地方却不起作用。到目前为止，我还看不出其中的模式。编译器如何决定什么时候它不能呢？我的意思是，类型方法Guid.ToString()存在，它不是在需要这种转换时调用的吗？谁能告诉我这个转换是在什么情况下自动完成的，什么时候必须...

问无法隐式地将类型'X‘转换为'string’-何时以及如何决定“不能”？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问无法隐式地将类型'X‘转换为'string’-何时以及如何决定“不能”？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问无法隐式地将类型'X‘转换为'string’-何时以及如何决定“不能”？
EN