blocks|key|1895902|text|你试过使用DirectCast(b,+Int16)吗？CType与C#强制转换不同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1895903|Here的一篇文章比较了DirectCast和CType的性能，并更详细地讨论了何时应该使用这两种语言。|1895904|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/KB/vb/DirectcastVsCtype.aspx^0|5|K|0|C|A|N|5|0|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Have you tried using <code>DirectCast(b, Int16)</code>? CType is not the same as a C# cast.

<a href="http://www.codeproject.com/KB/vb/DirectcastVsCtype.aspx" rel="nofollow noreferrer">Here</a>'s an article comparing the performance of <code>DirectCast</code> and <code>CType</code>, as well as going into more detail to when either should be used.

blocks|key|1895935|text|首先:我对此的理解是CType(b，Int16)与(Int16)b不同，一个是类型(CType)的转换，另一个是类型转换。(+Int16)+b等于DirectCast(b，Int16)而不是CType(b，Int16)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1895936|两者之间的区别(如MSDN中所述)是，只要存在有效的转换，CType就会成功，然而，DirectCast要求对象的运行时类型相同，因此，您所做的只是在设计时告诉编译器此对象属于该类型，而不是告诉它转换为该类型。|1895937|请参阅：http://msdn.microsoft.com/en-us/library/7k6y2h6x(VS.71).aspx|offset|length|1895938|然而，潜在的问题是，您正在尝试将32位整数转换为16位整数，这是...我遗漏了我需要的词，也许有人可以在这里为我插入有损。从16位到32位的转换是允许的，因为它是无损的，从32位到16位的转换是不确定的。关于它在C#中工作的原因，你可以看看@Roman的答案--它与C#不检查溢出的事实有关。|1895939|&H7FFFFFFF+And+&HFFFF的结果值结果是UInt16.MaxValue+(+65535+)+UInt16运行在0到65535之间，你试图将它塞进Int16中，它运行在-32768到32767之间，正如你所看到的，这是不起作用的。此外，这个值可能适合UInt16的事实也是巧合的，将两个32位整数相加并试图将它们填入16位整数(短整型)将经常导致溢出，因此我认为这是一个固有的危险操作。|style|CODE|1895940|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/7k6y2h6x(VS.71).aspx^0|0|0|4|1O|0|0|0|0|L|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@$F|Y|G|Z|1|10]]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@$F|13|G|14|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

First up: My understanding of this is that CType(b, Int16) isn't the same as (Int16)b. One is a conversion of type (CType) and the other is a cast. (Int16)b equates to DirectCast(b, Int16) rather than CType(b, Int16).

The difference between the two (as noted on MSDN) is that CType succeeds so long as there is a valid conversion, however, DirectCast requires the run-time type of the object to be the same, and as such, all you're doing is telling the compiler at design time that this object is of that type rather than telling it to convert to that type.

See: <a href="http://msdn.microsoft.com/en-us/library/7k6y2h6x(VS.71).aspx" rel="nofollow noreferrer">http://msdn.microsoft.com/en-us/library/7k6y2h6x(VS.71).aspx</a>

The underlying problem though is that you're trying to convert a 32 bit integer into a 16 bit integer which is... [I'm missing the word I need, perhaps someone can insert it here for me] lossy. Converting from 16 bit to 32 bit is allowed because it's lossless, converting from 32 bit to 16 bit is undefined. For why it works in C# you can see @Roman's answer - it relates to the fact that C# doesn't check the overflow.

The resulting value of <code>&amp;H7FFFFFFF And &amp;HFFFF</code> results in UInt16.MaxValue (65535) UInt16 runs from 0 to 65535, you're trying to cram that into Int16 which runs from -32768 through to 32767 which as you can see isn't going to work. Also the fact that this value might fit into a UInt16 is coincidental, adding two 32 bit integers and trying to cram them into a 16 bit integer (short) would frequently cause an overflow and thus I would say this is an inherently dangerous operation.

blocks|key|595234|text|?CType(b,+Int16)
Constant+expression+not+representable+in+type+'Short'.

?b
65535

?directcast(b,+Int16)
Value+of+type+'Integer'+cannot+be+converted+to+'Short'.

?int16.TryParse(b.ToString(),+c)
False|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|595235|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>?CType(b, Int16)
Constant expression not representable in type 'Short'.

?b
65535

?directcast(b, Int16)
Value of type 'Integer' cannot be converted to 'Short'.

?int16.TryParse(b.ToString(), c)
False
</code></pre>

blocks|key|658343|text|From+MSDN|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|658344|对于抛出OverflowException的算术、强制转换或转换操作，该操作必须在已检查的上下文中发生。默认情况下，在Visual+Basic中检查算术运算和溢出；在C#中则不检查。如果操作发生在未经检查的上下文中，则通过丢弃不适合目标类型的任何高位来截断结果。|style|BOLD|658345|编辑:如果你打算将代码从C#移植到VB.NET，你可能会对differences+between+them感兴趣。还要比较并显式地将compiler+settings设置为与C#中的默认设置相同(需要时)。|658346|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.overflowexception.aspx|1|http://www.codeproject.com/KB/dotnet/vbnet_c__difference.aspx|2|http://msdn.microsoft.com/en-us/library/07bysfz2.aspx^0|0|9|0|0|1G|13|0|T|O|1|1U|H|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@$A|10|B|11|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|J|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]|T|$5|M|N|O|C|$P|U]]]]

<a href="http://msdn.microsoft.com/en-us/library/system.overflowexception.aspx" rel="noreferrer">From MSDN</a>:

For the arithmetic, casting, or conversion operation to throw an OverflowException, the operation must occur in a checked context. By default, arithmetic operations and overflows in Visual Basic are checked; in C#, they are not. If the operation occurs in an unchecked context, the result is truncated by discarding any high-order bits that do not fit into the destination type.

EDIT:
If you're going to port code from C# to VB.NET, you may be interested in <a href="http://www.codeproject.com/KB/dotnet/vbnet_c__difference.aspx" rel="noreferrer">differences between them</a>. Also compare and explicitly set <a href="http://msdn.microsoft.com/en-us/library/07bysfz2.aspx" rel="noreferrer">compiler settings</a> to be the same as default settings in C# (when needed).

blocks|key|1895974|text|你可以用一个结构来截断这种溢出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1895975|<StructLayout(LayoutKind.Explicit)>+_
Public+Structure+int3216
++++<FieldOffset(0)>+Public+i32+As+Int32
++++<FieldOffset(0)>+Public+i16high+As+Int16
++++<FieldOffset(2)>+Public+i16low+As+Int16
End+Structure|code-block|syntax|javascript|1895976|..。|1895977|++Dim+_i3216+As+int3216
++_i3216.i32+=+a+And+&HFFFF
++c+=+_i3216.i16low|1895978|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can truncate this kind of overflow with a structure.

<pre><code>&lt;StructLayout(LayoutKind.Explicit)&gt; _
Public Structure int3216
 &lt;FieldOffset(0)&gt; Public i32 As Int32
 &lt;FieldOffset(0)&gt; Public i16high As Int16
 &lt;FieldOffset(2)&gt; Public i16low As Int16
End Structure
</code></pre>

...

<pre><code> Dim _i3216 As int3216
 _i3216.i32 = a And &amp;HFFFF
 c = _i3216.i16low
</code></pre>

blocks|key|595332|text|http://www.cnblogs.com/liujq007/archive/2010/12/04/1896059.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|595333|摘要：|595334|对于无符号类型:只需执行And运算符，或2st方法。|595335|Dim+a+As+Byte+=+CByte(300+And+&HFF)|code-block|syntax|javascript|595336|对有符号类型:向左移位n位，然后向右移位n位，这是为了扩展有符号位。N=+(sizeof(type1)+-+sizeof(type2))+*8或VB:使用Len(新类型)而不是sizeof(类型)|595337|Dim+a+As+Short+=+CShort(34042+<<+16+>>+16)|595338|您可以在下面的链接中找到详细信息。|595339|entityMap|0|LINK|mutability|MUTABLE|url^0|0|1R|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|17|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|18|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|4]]]]

<a href="http://www.cnblogs.com/liujq007/archive/2010/12/04/1896059.html" rel="nofollow">http://www.cnblogs.com/liujq007/archive/2010/12/04/1896059.html</a>

Summary:

To unsigned type: just do And operator, or 2st method.

<pre><code>Dim a As Byte = CByte(300 And &amp;HFF)
</code></pre>

To signed type: left shift n bits, then right shift n bits, which is to expand the signed bit. n = (sizeof(type1) - sizeof(type2)) * 8 or VB:use Len(New type) instead of sizeof(type)

<pre><code>Dim a As Short = CShort(34042 &lt;&lt; 16 &gt;&gt; 16)
</code></pre>

You can find the details from the link below.

blocks|key|595315|text|我在寻找解决方案时遇到了这个问题，以便转换短消息并获得没有溢出错误的溢出结果。我在这里找到了一个解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|595316|http://bytes.com/topic/visual-basic-net/answers/732622-problems-typecasting-vb-net|offset|length|595317|大约在页面的一半是这样的：|595318|595319|老的，VB的“适当的”技巧，“侧步”到十六进制，然后再回来仍然有效！|blockquote|595320|595321|595322|Dim+unsigned+as+UInt16+=+40000
Dim+signed+as+Int16+=+CShort(Val("&H"+&+Hex(unsigned)))|code-block|syntax|javascript|595323|它看起来工作得相当流畅！|595324|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|2A|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|18|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1B|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|C]]]]

I came across this question when looking for a solution for converting a Short and getting the overflow result with out the overflow error. I found a solution here:

<a href="http://bytes.com/topic/visual-basic-net/answers/732622-problems-typecasting-vb-net" rel="nofollow">http://bytes.com/topic/visual-basic-net/answers/732622-problems-typecasting-vb-net</a>

about halfway down the page is this:

<blockquote>
 The old, VB "Proper" trick of "side-stepping" out to Hexadecimal and
 back again still works!
</blockquote>

<pre><code>Dim unsigned as UInt16 = 40000
Dim signed as Int16 = CShort(Val("&amp;H" &amp; Hex(unsigned)))
</code></pre>

it seems to work pretty slick!

The following code works fine in C#.

<pre><code> Int32 a, b;
 Int16 c;

 a = 0x7FFFFFFF;
 b = a &amp; 0xFFFF;
 c = (Int16)b;
</code></pre>

But this code crash with a OverflowException in <a href="http://en.wikipedia.org/wiki/Visual_Basic_.NET" rel="nofollow noreferrer">VB.NET</a>.

<pre><code> Dim a, b As Int32
 Dim c As Int16

 a = &amp;H7FFFFFFF
 b = a And &amp;HFFFF
 c = CType(b, Int16)
</code></pre>

Both code snippets seem the same to me. What is the difference and how can I get the C# code converted to VB.NET?

Difference between casting in C# and VB.NET

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

下面的代码在C#中运行良好。    Int32 a, b;    Int16 c;    a = 0x7FFFFFFF;    b = a & 0xFFFF;    c = (Int16)b;但这段代码在中使用OverflowException时会崩溃。    Dim a, b As Int32    Dim c As...

问C#和VB.NET中强制转换的区别
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#和VB.NET中强制转换的区别EN