blocks|key|1857746|text|事实恰恰相反。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1857747|32+(或64)位整数比int16快。通常，原生数据类型是最快的。|1857748|如果你想让你的数据结构尽可能的精简，Int16是很好的选择。这节省了空间，并可能提高性能。|1857749|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The opposite is true.

32 (or 64) bit integers are faster than int16. In general the native datatype is the fastest one.

Int16 are nice if you want to make your data-structures as lean as possible. This saves space and may improve performance.

blocks|key|2071669|text|Int16实际上可能效率较低，因为用于字存取的x86指令比用于双字存取的指令占用更多的空间。这将取决于JIT做什么。但不管怎样，当它在迭代中用作变量时，它几乎肯定不会更有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2071670|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|$]]

Int16 may actually be less efficient because the x86 instructions for word access take up more space than the instructions for dword access. It will depend on what the JIT does. But no matter what, it's almost certainly not more efficient when used as the variable in an iteration.

blocks|key|1857842|text|永远不要假设效率。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1857843|不同的编译器和不同的平台，效率不同，效率也会有所不同。除非您对此进行了实际测试，否则无法判断int16和int哪个更有效。|1857844|我只会坚持使用int，除非您遇到使用int16修复的已证实的性能问题。|1857845|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Never assume efficiency.

What is or isn't more efficient will vary from compiler to compiler and platform to platform. Unless you actually tested this, there is no way to tell whether int16 or int is more efficient.

I would just stick with ints unless you come across a proven performance problem that using int16 fixes.

blocks|key|2071745|text|我无法想象Int16和int相比会有什么显著的性能提升。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2071746|您在变量声明中保留了一些内容。|2071747|当规格发生变化时，无论你计算的是什么，现在都可以超过32767，并且你发现当你的应用程序开始抛出异常时，绝对不值得麻烦。|2071748|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I can't imagine there being any significant performance gain on Int16 vs. int.

You save some bits in the variable declaration.

And definitely not worth the hassle when the specs change and whatever you are counting can go above 32767 now and you discover that when your application starts throwing exceptions...

blocks|key|1857942|text|在现代硬件上，任何性能差异都将是如此微小，以至于无论出于何种意图和目的，它都不会产生任何差异。尝试编写几个测试工具，并运行它们几百次，取平均循环完成时间，您就会明白我的意思。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1857943|如果你的资源非常有限，从存储的角度来看，这可能是有意义的-嵌入式系统具有很小的堆栈，为慢速网络(例如GPRS等)设计的有线协议，等等。|1857944|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Any performance difference is going to be so tiny on modern hardware that for all intents and purposes it'll make no difference. Try writing a couple of test harnesses and run them both a few hundred times, take the average loop completion times, and you'll see what I mean.

It might make sense from a storage perspective if you have very limited resources - embedded systems with a tiny stack, wire protocols designed for slow networks (e.g. GPRS etc), and so on.

blocks|key|2071910|text|使用比Int32小的数据类型没有显著的性能提升，事实上，我在某处读到，由于内存分配的原因，使用Int32比使用Int16更快|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2071911|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|$]]

There is no significant performance gain in using a data type smaller than Int32, in fact, i read somewhere that using Int32 will be faster than Int16 because of memory allocation

blocks|key|2071966|text|这里的其他方法是正确的，如果您需要小于Int32+(对于32位代码)/Int64(对于64位代码)，如果您需要它来满足极端的存储需求，或者用于业务对象字段的另一个级别的强制(当然，在这种情况下，您仍然应该具有适当级别的验证)，那么它们是正确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2071967|一般来说，在出现性能问题之前，不要担心效率问题。在这种情况下，对其进行分析。如果在分析时使用两种方法进行猜测和检查对您的帮助还不够大，请检查IL代码。|2071968|不过这是个好问题。你正在学习更多关于编译器如何做它的事情的知识。如果你想学习更有效的编程，学习IL的基础知识和C#/VB编译器如何工作将是一个很好的主意。|2071969|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The others here are correct, only use less than Int32 (for 32-bit code)/Int64 (for 64-bit code) if you need it for extreme storage requirements, or for another level of enforcement on a business object field (you should still have propery level validation in this case, of course).
And in general, don't worry about efficiency until there is a performance problem. And in that case, profile it. And if guess &amp; checking with both ways while profiling doesn't help you enough, check the IL code.
Good question though. You're learning more about how the compiler does it's thing. If you want to learn to program more efficiently, learning the basics of IL and how the C#/VB compilers do their job would be a great idea.

I have a questionable coding practice. 

When I need to iterate through a small list of items whose count limit is under <code>32000</code>, I use <code>Int16</code> for my i variable type instead of <code>Integer</code>. I do this because I assume using the <code>Int16</code> is more efficient than a full blown <code>Integer</code>. 

Am I wrong? Is there no effective performance difference between using an <code>Int16</code> vs an <code>Integer</code>? Should I stop using <code>Int16</code> and just stick with <code>Integer</code> for all my counting/iteration needs?

.NET Integer vs Int16?

嵌入式系统

数据结构

编译器

我有一个可疑的编码实践。当我需要迭代计数限制在32000以下的一小部分项时，我会对i变量类型使用Int16，而不是Integer。我这样做是因为我认为使用Int16比使用成熟的Integer更有效。我说错了吗？使用Int16与使用Integer之间是否没有有效的性能差异？我是否应该停止使用Int16，只使用Intege...

问.NET整型vs Int16？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET整型vs Int16？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET整型vs Int16？
EN