blocks|key|1135119|text|var根本不会降低性能。变量仍然是强类型|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1135120|隐式类型局部变量是强类型的，就像您自己声明了类型一样，但编译器决定类型。|blockquote|1135121|唯一的区别是，您不必手动拼写源代码中的类型。如果你指的是VB+6的Variant，那根本就没有关系。|1135122|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb383973.aspx^0|0|3|H|3|0|0|0|X|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

<code>var</code> does not degrade performance at all. The variable is still <a href="http://msdn.microsoft.com/en-us/library/bb383973.aspx">strongly typed</a>:

<blockquote>
 An implicitly typed local variable is strongly typed just as if you
 had declared the type yourself, but the compiler determines the type.
</blockquote>

The only difference is that you don't have to manually spell out the type in source code. There's no relation at all with VB 6's <code>Variant</code>, if that's what you are referring to.

blocks|key|1138227|text|它一点也不像Variant，也不降低性能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1138228|在.NET中，var是由编译器提供的一种速记机制；编译的代码是强类型的，就像您已经声明了正确的类型一样。|1138229|entityMap^0|6|7|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|$]]

It is not like <code>Variant</code> at all, and it does not degrade performance.

In .NET, var is provided by the compiler as a shorthand mechanism; the compiled code is just as strongly-typed as if you had declared the correct type.

blocks|key|2289634|text|什么？不，哇，你搞错了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2289635|C#的var与VB的Variant完全不同，那是C#中的dynamic+(或多或少)。|offset|length|style|CODE|2289636|var只是编译器在编译程序时填写的占位符，在运行时，实际类型被完全声明和使用，因此绝对不会造成性能损失。|2289637|//+this+won't+work
var+i=0;
i="a";+//+it+would+with+dynamic+though!|code-block|syntax|javascript|2289638|entityMap^0|0|3|3|A|7|S|7|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

What? No wow you got this all wrong.

C#'s <code>var</code> is nothing like VB's <code>Variant</code>, that's <code>dynamic</code> in C# (more or less).

<code>var</code> is just a placeholder for the compiler to fill in when it's compiling your program, at run time the actual type is fully declared and used, so there's absolutely no performance loss at all.

<pre><code>// this won't work
var i=0;
i="a"; // it would with dynamic though!
</code></pre>

blocks|key|1810982|text|var是有帮助的，有几个原因，它减少了代码的冗长性，并且允许更容易地重构，当一个方法的输出被分配给一个变量的类型发生变化时，如果它仍然满足不需要更改的使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810983|此外，在编译为IL时，性能也不会受到影响，因为无论哪种方式，它的结果都是一样的。|1810984|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|$]]

var is helpful for several reasons, it reduces verbosity of code as well as allowing for easier refactoring, when a type changes on the output of a method being assigned to a variable, if it still meets the usage no change is needed.

Also there are no performance hits as it gets compiled to IL where it ends up the same either way.

blocks|key|1811046|text|var不会降低性能，而且仍然是强类型的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1811047|由于LINQ能够返回'匿名类型‘，所以引入它是因为LINQ是必要的。|1811048|这是afaik引入该关键字的主要原因，因为您无法控制编译器生成的类型的名称。一个附加的值是，您可以使用它作为语法糖，在声明变量时不重复变量的类型：|1811049|var+=+new+List<MyComplexType<WithTypeParameter>>();|code-block|syntax|javascript|1811050|而不是：|1811051|List<MyComplexType<WithTypeParameter>>+x+=+new+List<MyComplexType<WithTypeParameter>>();|1811052|例如。|1811053|无论如何，var并不像Visual中的变体数据类型。当您将某个实例分配给使用var关键字声明(并初始化)的变量时，不能将另一种类型的实例分配给它。其次，如果不初始化变量，就不能声明“var”变量。|1811054|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb397696.aspx^0|0|3|0|B|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|H|3|I|5|6|7|1B|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1C|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1D|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1E|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1F|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1G|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

<code>var</code> does not degrade performance, and is still strongly typed.

It has been introduced because it was necessary for LINQ, since LINQ is able to return '<a href="http://msdn.microsoft.com/en-us/library/bb397696.aspx" rel="nofollow">anonymous types</a>'. 
That was afaik the primary reason to introduce this keyword, since you have no control over the name of the type that will be generated by the compiler.
An added value is, that you can use it as syntactic sugar to not duplicate the type of the variable when declaring one:

<pre><code>var = new List&lt;MyComplexType&lt;WithTypeParameter&gt;&gt;();
</code></pre>

instead of:

<pre><code>List&lt;MyComplexType&lt;WithTypeParameter&gt;&gt; x = new List&lt;MyComplexType&lt;WithTypeParameter&gt;&gt;();
</code></pre>

for example.

By all means, var is not something like the Variant datatype in Visual Basic. When you assign a certain instance to a variable that has been declared (and initialized) with the var keyword, you cannot assign an instance of another type to it.
Next to that, you cannot declare a 'var' variable without initializing it.

Type inference makes use of the <code>var</code> keyword. The compiler "infers" what the type of the variable is by what the variable is initialized to. 
e.g. var somenum=o;
becomes int somenum=0; 

Even though somenum is never declared as being an <code>int</code>, the compiler figures this out &amp; somenum is an <code>int</code> for as long as it is in scope. 

it is like <code>variant</code> type used in <code>visual basic</code>. using it in program, upto some extent it degrades performance &amp; <code>var</code> is not included in dot net framework before 3.5 . 

even it degrades performance &amp; dot net framework supports strong type checking ,why <code>var</code> is included in framework 3.5? 

is <code>var</code> violets strong type checking? if not how?

type inference var

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯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编辑器全新改版上线，欢迎大家体验!

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

社区新版编辑器体验调研

类型推断使用var关键字。编译器根据变量初始化的内容“推断”变量的类型。例如var somenum=o；变成int somenum=0；尽管 somenum 从未被声明为int，但编译器指出了这一点&只要它在作用域内，它就是一个int。它类似于在variant中使用的visual basic类型。在程序中使用它，在一定程度上降低了性能& var在3.5以前不包含在点网框架中。即使它降低了性能&点网

问类型推理变量
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问类型推理变量EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问类型推理变量
EN