blocks|key|5140267|text|如果源类型不能转换为目标类型，则前者将抛出异常。后者将导致sc2为空引用，但也不例外。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5140268|编辑|5140269|我最初的答案当然是最明显的区别，但作为Eric+Lippert+points+out，这并不是唯一的一个。其他差异包括：|offset|length|5140270|5140271|您不能使用'+as‘运算符转换为不接受’|unordered-list-item|5140272|‘作为值的类型，您不能使用'as’来转换对象，如将数字转换为不同的表示形式(例如，将浮点数转换为整数)。|5140273|5140274|最后，使用'as‘与cast操作符，您还会说“我不确定这是否会成功。”|5140275|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/ericlippert/archive/2009/10/08/what-s-the-difference-between-as-and-cast-operators.aspx^0|0|0|W|A|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$F|11|G|12|1|13]]|A|$]]|$1|H|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|K|7|16|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

The former will throw an exception if the source type can't be cast to the target type. The latter will result in sc2 being a null reference, but no exception.

[Edit]

My original answer is certainly the most pronounced difference, but as Eric Lippert <a href="http://blogs.msdn.com/ericlippert/archive/2009/10/08/what-s-the-difference-between-as-and-cast-operators.aspx" rel="noreferrer">points out</a>, it's not the only one. Other differences include:

<ul>
<li>You can't use the 'as' operator to cast to a type that doesn't accept 'null' as a value</li>
<li>You can't use 'as' to convert things, like numbers to a different representation (float to int, for example).</li>
</ul>

And finally, using 'as' vs. the cast operator, you're also saying "I'm not sure if this will succeed."

blocks|key|2885429|text|另请注意，只能将as关键字与引用类型或可为note的类型一起使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2885430|即：|2885431|double+d+=+5.34;
int+i+=+d+as+int;|code-block|syntax|javascript|2885432|将不会编译|2885433|double+d+=+5.34;
int+i+=+(int)d;|2885434|将进行编译。|2885435|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Also note that you can only use the as keyword with a reference type or a nullable type

ie:

<pre><code>double d = 5.34;
int i = d as int;
</code></pre>

will not compile

<pre><code>double d = 5.34;
int i = (int)d;
</code></pre>

will compile.

blocks|key|2885572|text|当类型转换失败时，使用"+as“进行类型转换当然要快得多，因为它避免了抛出异常的代价。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2885573|但当强制转换成功时，它并不会更快。http://www.codeproject.com/KB/cs/csharpcasts.aspx的图表具有误导性，因为它没有解释它测量的是什么。|offset|length|2885574|底线是：|2885575|2885576|如果您希望转换成功(即失败将是异常情况)，请使用转换。|unordered-list-item|2885577|如果您不知道转换是否会成功，请使用"as“运算符并测试结果是否为null。|2885578|2885579|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/KB/cs/csharpcasts.aspx^0|0|H|1D|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|K|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Typecasting using "as" is of course much faster when the cast fails, as it avoids the expense of throwing an exception.

But it is not faster when the cast succeeds. The graph at <a href="http://www.codeproject.com/KB/cs/csharpcasts.aspx" rel="noreferrer">http://www.codeproject.com/KB/cs/csharpcasts.aspx</a> is misleading because it doesn't explain what it's measuring.

The bottom line is:

<ul>
<li>If you expect the cast to succeed (i.e. a failure would be exceptional), use a cast.</li>
<li>If you don't know if it will succeed, use the "as" operator and test the result for null.</li>
</ul>

blocks|key|2885766|text|这两种方法之间的不同之处在于，第一个((SomeClass)obj)可能会导致调用type+converter。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2885767|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/yy580hbd(VS.80).aspx^0|15|E|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

A difference between the two approaches is that the the first ((SomeClass)obj) may cause a <a href="http://msdn.microsoft.com/en-us/library/yy580hbd(VS.80).aspx" rel="noreferrer">type converter</a> to be called.

blocks|key|700321|text|嗯，+'as‘运算符“帮助你用更低的来掩盖你的问题，因为当它被提供一个不兼容的实例时，它将返回null，也许你会把它传递给一个方法，然后再传递给另一个方法，以此类推，最后你会得到一个NullReferenceException，这会让你的调试变得更加困难。”|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|700322|不要滥用它。直接类型转换操作符在99%25的情况下更好。|700323|entityMap^0|2|G|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Well the 'as' operator "helps" you bury your problem way lower because when it is provided an incompatible instance it will return null, maybe you'll pass that to a method which will pass it to another and so on and finally you'll get a NullReferenceException which will make your debugging harder.

Don't abuse it. The direct cast operator is better in 99% of the cases.

blocks|key|2885478|text|这里有一个很好的方法来记住他们每个人遵循的过程，当我试图决定哪个更适合我的情况时使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2885479|DateTime+i+=+(DateTime)value;
//+is+like+doing
DateTime+i+=+value+is+DateTime+?+value+as+DateTime+:+throw+new+Exception(...);|code-block|syntax|javascript|2885480|下一步应该很容易猜到它是做什么的|2885481|DateTime+i+=+value+as+DateTime;|2885482|在第一种情况下，如果值不能转换，那么在第二种情况下，如果值不能转换，就会抛出异常，i被设置为null。|2885483|因此，在第一种情况下，如果第二次强制转换失败，则进行硬停止，然后进行软停止，稍后可能会遇到NullReferenceException。|2885484|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here is a good way to remember the process that each of them follow that I use when trying to decide which is better for my circumstance.

<pre><code>DateTime i = (DateTime)value;
// is like doing
DateTime i = value is DateTime ? value as DateTime : throw new Exception(...);
</code></pre>

and the next should be easy to guess what it does

<pre><code>DateTime i = value as DateTime;
</code></pre>

in the first case if the value cannot be cast than an exception is thrown in the second case if the value cannot be cast, i is set to null. 

So in the first case a hard stop is made if the cast fails in the second cast a soft stop is made and you might encounter a NullReferenceException later on.

blocks|key|2885535|text|要扩展Rytmis's+comment，不能对结构(值类型)使用as关键字，因为它们没有空值。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2885536|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2483/casting-newtype-vs-object-as-newtype#2487^0|3|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

To expand on <a href="https://stackoverflow.com/questions/2483/casting-newtype-vs-object-as-newtype#2487">Rytmis's comment</a>, you can't use the as keyword for structs (Value Types), as they have no null value.

blocks|key|700266|text|所有这些都适用于引用类型，值类型不能使用as关键字，因为它们不能为null。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|700267|//if+I+know+that+SomeObject+is+an+instance+of+SomeClass
SomeClass+sc+=+(SomeClass)+someObject;


//if+SomeObject+*might*+be+SomeClass
SomeClass+sc2+=+someObject+as+SomeClass;|code-block|syntax|javascript|700268|cast语法更快，但只有在成功时，失败的速度才会慢得多。|700269|最佳实践是在不知道类型的情况下使用as：|700270|//we+need+to+know+what+someObject+is
SomeClass+sc;
SomeOtherClass+soc;

//use+as+to+find+the+right+type
if(+(+sc+=+someObject+as+SomeClass+)+!=+null+)+
{
++++//do+something+with+sc
}
else+if+(+(+soc+=+someObject+as+SomeOtherClass+)+!=+null+)+
{
++++//do+something+with+soc
}|700271|但是，如果您绝对确定someObject是SomeClass的一个实例，那么就使用cast。|700272|在.Net+2或更高版本中，泛型意味着您很少需要引用类的非类型化实例，因此较少使用后者。|700273|entityMap^0|K|2|0|0|0|H|2|0|0|A|A|L|9|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1A|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

All of this applies to reference types, value types cannot use the <code>as</code> keyword as they cannot be null.

<pre><code>//if I know that SomeObject is an instance of SomeClass
SomeClass sc = (SomeClass) someObject;


//if SomeObject *might* be SomeClass
SomeClass sc2 = someObject as SomeClass;
</code></pre>

The cast syntax is quicker, but only when successful, it's much slower to fail.

Best practice is to use <code>as</code> when you don't know the type:

<pre><code>//we need to know what someObject is
SomeClass sc;
SomeOtherClass soc;

//use as to find the right type
if( ( sc = someObject as SomeClass ) != null ) 
{
 //do something with sc
}
else if ( ( soc = someObject as SomeOtherClass ) != null ) 
{
 //do something with soc
}
</code></pre>

However if you are absolutely sure that <code>someObject</code> is an instance of <code>SomeClass</code> then use cast.

In .Net 2 or above generics mean that you very rarely need to have an un-typed instance of a reference class, so the latter is less often used.

blocks|key|700194|text|对于那些有VB.NET经验的人来说，(类型)与DirectCast相同，而"as类型“与TryCast相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700195|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|$]]

For those of you with VB.NET experience, (type) is the same as DirectCast and "as type" is the same as TryCast.

blocks|key|2885220|text|如果强制转换尝试失败，则括号强制转换将引发异常。如果强制转换尝试失败，则"as“强制转换返回null。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2885221|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|$]]

The parenthetical cast throws an exception if the cast attempt fails. The "as" cast returns null if the cast attempt fails.

blocks|key|2885396|text|它们会抛出不同的异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2885397|()：NullReferenceException|2885398|as+:+InvalidCastException|2885399|这对调试很有帮助。|2885400|"as“关键字尝试强制转换对象，如果转换失败，则返回null。如果强制转换失败，()强制转换操作符将立即抛出异常。|2885401|仅当您期望在非异常情况下强制转换失败时，才使用C#+"as“关键字。如果您希望强制转换成功，并且没有准备好接收任何可能失败的对象，则应该使用()强制转换操作符，以便抛出适当且有用的异常。|2885402|有关代码示例和更多说明，请参阅：http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html|offset|length|2885403|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html^0|0|0|0|0|0|0|G|1R|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|13|8|@]|9|@$N|14|O|15|1|16]]|A|$]]|$1|P|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

They'll throw different exceptions.
() : NullReferenceException 
as : InvalidCastException 
Which could help for debugging.
The &quot;as&quot; keyword attempts to cast the object and if the cast fails, null is returned. The () cast operator will throw an exception immediately if the cast fails.
Only use the C# &quot;as&quot; keyword where you are expecting the cast to fail in a non-exceptional case. If you are counting on a cast to succeed and unprepared to receive any object that would fail, you should use the () cast operator so that an appropriate and helpful exception is thrown.
For code examples and a further explanation: <a href="http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html" rel="nofollow noreferrer">http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html</a>

blocks|key|700153|text|这就像是解析和TryParse之间的区别。当你预料到它可能会失败时，你可以使用TryParse，但当你确信它不会失败时，你就会使用解析。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700154|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|$]]

It's like the difference between Parse and TryParse. You use TryParse when you expect it might fail, but when you have strong assurance it won't fail you use Parse.

What is actually the difference between these two casts?
<pre><code>SomeClass sc = (SomeClass)SomeObject;
SomeClass sc2 = SomeObject as SomeClass;
</code></pre>
Normally, shouldn't they both be explicit casts to the specified type?

Casting: (NewType) vs. Object as NewType

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

这两种类型之间的区别到底是什么？SomeClass sc = (SomeClass)SomeObject;SomeClass sc2 = SomeObject as SomeClass;通常，它们不应该都显式转换为指定的类型吗？

问将：( NewType )与Object转换为NewType
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将：( NewType )与Object转换为NewTypeEN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将：( NewType )与Object转换为NewType
EN