blocks|key|994237|text|当它确实是一种int类型时，进行强制转换；当它不是int类型，但您希望它成为一种类型时，则进行转换。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|994238|例如，当您知道o是一个整数时使用int+i+=+(int)o;|994239|int+i+=+Convert.ToInt32("123")因为"123“不是整数，所以它是整数的字符串表示。|994240|entityMap^0|7|3|P|3|0|G|F|0|0|U|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

Cast when it's really a type of <code>int</code>, Convert when it's not an <code>int</code> but you want it to become one.

For example <code>int i = (int)o;</code> when you know o is an int

<code>int i = Convert.ToInt32("123")</code> because "123" is not an int, it's a string representation of an int.

blocks|key|994507|text|还有一个不同之处。"Convert“总是溢出检查，而"cast”可能是，这取决于您的设置和使用的"checked“或"unchecked”关键字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994508|更明确地说。考虑下面的代码：|994509|int+source+=+260;
byte+destination+=+(byte)source;|code-block|syntax|javascript|994510|则destination将为4而不会出现警告。|994511|但是：|994512|int+source+=+260;
byte+destination+=+Convert.ToByte(source);|994513|会给你一个例外。|994514|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

There is another difference.
"Convert" is always overflow-checked, while "cast" maybe, depending on your Settings and the "checked" or "unchecked" keyword used. 

To be more explicit. 
Consider the code:

<pre><code>int source = 260;
byte destination = (byte)source;
</code></pre>

Then destination will be 4 without a warning. 

But:

<pre><code>int source = 260;
byte destination = Convert.ToByte(source);
</code></pre>

will give you a exception.

blocks|key|1208483|text|并非所有类型都支持像这样的转换|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208484|int+i+=+0;
decimal+d+=+(decimal)i;|code-block|syntax|javascript|1208485|因为它是实现explicit+operator所必需的。但.NET也提供了IConvertible+interface，因此实现该接口的任何类型都可以转换为大多数框架内置类型。最后，Convert类帮助操作类型实现了IConvertible接口。|offset|length|1208486|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/xhbhezf4(VS.71).aspx)|1|http://msdn.microsoft.com/en-us/library/system.iconvertible.aspx^0|0|0|6|H|0|11|M|1|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]|$I|10|J|11|1|12]]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

Not all types supports conversion like 

<pre><code>int i = 0;
decimal d = (decimal)i;
</code></pre>

because it is needed to implement <a href="http://msdn.microsoft.com/en-us/library/xhbhezf4(VS.71).aspx" rel="nofollow noreferrer">explicit operator</a>. But .NET also provide <a href="http://msdn.microsoft.com/en-us/library/system.iconvertible.aspx" rel="nofollow noreferrer">IConvertible interface</a>, so any type implements that interface may be converted to most framework built-in types. And finally, Convert class helps to operate with types implements IConvertible interface.

blocks|key|1208387|text|强制转换只是告诉编译器这个对象实际上是一个不同类型的实现，并且现在像对待新实现一样对待它。然而，转换人说这不是从你试图转换的东西继承的，但有一种固定的方法可以这样做。例如，假设我们要将"16“转换为int。"16“是一个字符串，不会以任何方式继承自int。但是，很明显，"+16“可以变成int16。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208388|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A cast just tells the compiler that this object is actually an implementation of a different type and to treat it like the new implementation now. Whereas a convert says that this doesn't inherit from what you're trying to convert to, but there is a set way to so it. For example, say we're turning "16" into an int. "16" is a string, and does not inherit from int in any way. But, it is obvious that "16" could be turned into the int 16.

blocks|key|994291|text|加上我的2c+--看起来概念上的区别可能是有用的。并不是说我是专家。：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994292|类型转换正在改变代表性类型。因此，"32“和32L和32.0f之间的相互转换似乎是合理的。c#不会自动支持"32“，但大多数动态语言会。所以我将使用(长)“32”或(字符串)32L。当我能做到的时候。我还有另一个规则--强制转换应该是可往返的。|994293|转换不一定是可往返的，可以简单地创建一个全新的对象。|994294|灰色区域例如是字符串"32xx“。可以这样说，当你转换它时，它变成了32L+(这个数字被解析到不能被解析)。Perl使用了这个。但这违反了我的往返要求。32.5f到32L也是如此。几乎所有的语言，包括非常静态类型的语言，都允许这样做，而且它也不符合可往返的规则。它是灰色的，因为如果您允许强制转换"32“，那么在编译时您不知道它是否可能是"32xxx”。|994295|另一个可以做的区别是只对"IsA“使用强制转换，而不对"makeLookLikeA”使用强制转换。因此，如果您知道一个字符串来自数据库，但实际上是非官方模式中的一个int，那么可以随意使用强制转换(尽管在这种情况下，c#希望您使用Convert+)。对于一个浮点数也是如此。但不适用于仅使用强制转换截断浮点数的情况。这一区别也解释了DownCasting和UpCasting+--对象始终是'IsA'，但类型可能已被泛化为列表。|994296|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Throwing in my 2c -- it seems that a conceptual distinction might be useful. Not that I'm an expert.. :

Casting is changing the representative type. So "32" and 32L and 32.0f seem reasonable to cast between each other. c# will not support the "32" automatically, but most dynamic languages will. So I'll use the (long)"32" or (String)32L. When I can. I also have another rule -- Casting should be round trippable.

Converting doesn't have to be round trippable, and can simply create a totally new object.

The Grey area is for example the string "32xx". A case can be made that when you cast it, it becomes 32L (the number was parsed until it couldn't be). Perl used this. But then this violates my round trip requirement. The same goes for 32.5f to 32L. Almost all languages including very statically typed ones allow this, and it too fails the round trippable rule. It is grey in that if you allow "32" to be cast, then at compile time you don't know if it might be "32xxx".

Another distinction that can be made is to just use casting for "IsA" and not for "makeLookLikeA". So if you know a string comes from a database but is actually an int in the unofficial schema, feel free to use a cast (although in this case c# wants you to use Convert anyway). The same would go for a float. But not for when you are just using the cast to truncate the float. This distinction also accounts for DownCasting and UpCasting -- the object was always 'IsA', but the type might have been generalized for a list.

blocks|key|994181|text|例如，对于可以接受字符串的Convert.ToInt32，有很多重载。当尝试将字符串转换为int类型时，将抛出编译错误。关键是它们有不同的用途。当你不确定你要转换的对象是什么类型时，Convert特别有用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|994182|entityMap^0|D|F|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

There are a lot of overloads for <code>Convert.ToInt32</code> that can take for example a string. While trying to cast a string to an int will throw a compile error. The point being is they're for different uses. Convert is especially useful when you're not sure what type the object you're casting from is.

blocks|key|1208896|text|您应该使用Convert.ToInt32而不是强制转换还有一个原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208897|例如：|1208898|float+a+=+1.3f;
float+b+=+0.02f;
int+c+=+(int)(a+/+b);
int+d+=+Convert.ToInt32(a+/+b);`|code-block|syntax|javascript|1208899|结果是c=+64和d=+65|1208900|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

There is one more reason you should use Convert.ToInt32 instead of a cast.

For example:

<pre><code>float a = 1.3f;
float b = 0.02f;
int c = (int)(a / b);
int d = Convert.ToInt32(a / b);`
</code></pre>

The result is c = 64 and d = 65

blocks|key|1208948|text|string+number+=+"123abc"；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208949|int+num；|1208950|Int32.TryParse(number，out+num)；//本次调用无异常抛出|1208951|Convert.ToInt32(number)；//本次调用抛出异常|1208952|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

string number = "123abc";

int num;

Int32.TryParse(number, out num); // no exception thrown at this call

Convert.ToInt32(number); // exception IS thrown at this call

I am curious to know what the difference is between a cast to say an <code>int</code> compared to using <code>Convert.ToInt32()</code>. Is there some sort of performance gain with using one?
Also which situations should each be used for? Currently I'm more inclined to use <code>Convert</code> but I don't have a reason to go either way. In my mind I see them both accomplishing the same goal.

When to use a Cast or Convert

数据库

编译器

Perl

我很好奇，与使用Convert.ToInt32()相比，使用强制转换来表示int有什么不同。使用它会带来性能上的提升吗？另外，每种情况都应该用于哪些情况？目前我更倾向于使用Convert，但我没有理由选择任何一种方式。在我的脑海中，我看到他们都在完成同样的目标。

问何时使用强制转换或转换
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时使用强制转换或转换EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时使用强制转换或转换
EN