var 关键字而不使用“using someNamespace”

发布于 2024-08-31 21:12:48 字数 615 浏览 10 评论 0原文

即使您没有在顶部包含必要的 using 声明，Visual Studio/intellisense 如何知道如何处理声明为 var 的变量？

例如，我在不同的命名空间中定义了类 MyDomainObject 如果我不在文件中声明 using TheOtherNameSpace; ，以下代码将无法编译：

private void Foo()
{
   MyDomainObject myObj = new MyDomainObject(); 
   // Doesn't know what this class is
}

但是如果我使用 var

var myObj = new MyDomainObject();

这将编译，并且智能感知确切地知道我可以做什么与它。

那么，在没有 using 的情况下，它到底是如何知道类型是什么的呢？

（顺便说一句，如果它不需要 using 就知道，为什么我们还需要 using ？！）

原文

How does Visual Studio/intellisense know what to do with a variable declared as var even if you don't include the necessary using declaration at the top?

For example, I have class MyDomainObject defined in a different namespace
If I don't declare using TheOtherNameSpace; in the file the following code won't compile:

private void Foo()
{
   MyDomainObject myObj = new MyDomainObject(); 
   // Doesn't know what this class is
}

But if I use var

var myObj = new MyDomainObject();

This will compile, and intellisense knows exactly what I can with it.

So how the heck does it know what the type is without the using?

(And as an aside, if it knows without the using, why do we need usings at all?!)

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

一桥轻雨一伞开 2024-09-07 21:12:48

您使用构造函数的示例将不起作用，但稍微复杂一点的情况会起作用。例如，假设您有三种类型：

命名空间 N1 中的 class Foo
命名空间 N2 中的
class Bar 命名空间 N3 中的 class Baz

现在假设 Bar 有一个返回 Foo 实例的方法：

public static Foo GetFoo() { ... }

这里，Bar.cs 需要 N1 的 using 指令，除非它指定了完整的名称。

现在假设我们在 Baz 中有这样的代码：

using N2;
...
var foo = Bar.GetFoo();

它将编译，但

using N2;
...
Foo foo = Bar.GetFoo();

不会。原因是 using 指令的存在只是为了让编译器知道名称“Foo”的含义 - 它的完全限定名称是什么。在第一个代码段中，Bar.GetFoo() 被有效地声明为返回 N1.Foo，因此编译器没有问题。在第二个片段中，编译器首先看到“Foo”，但对 N1 一无所知，因此不知道如何查找它。

Your example with a constructor won't work, but a slightly more involved situation will. For example, suppose you have three types:

class Foo in namespace N1
class Bar in namespace N2
class Baz in namespace N3

Now suppose Bar has a method which returns an instance of Foo:

public static Foo GetFoo() { ... }

Here, Bar.cs would need a using directive for N1, unless it specified the name in full.

Now suppose that we have this code in Baz:

using N2;
...
var foo = Bar.GetFoo();

That will compile, but

using N2;
...
Foo foo = Bar.GetFoo();

won't. The reason is that using directives are only there so that the compiler knows what the name "Foo" means - what its fully qualified name is. In the first snippet, Bar.GetFoo() is effectively declared to return N1.Foo, so the compiler is fine. In the second snippet, the compiler first sees "Foo" and doesn't know anything about N1, so doesn't know how to look it up.

回复收藏 0 原文