主页 / 问题 / 556790
Accepted
Lightness
Asked:2020-08-18 20:42:15 +0000 UTC2020-08-18 20:42:15 +0000 UTC

在命名空间内连接库

  • 772

我经常注意到库不是在之前namespace而是在内部连接的代码。我想知道他们为什么这样做，根本区别是什么？

常用连接方法：

using System;
using System.Linq;
using System.Collections.Generic;
namespace Domain 
{ 

}

内部连接方法namespace：

namespace Domain
{
    using System;
    using System.Linq;
    using System.Collections.Generic;
}
c#

2 个回答

  1. Best Answer

    将类似问题的答案翻译成英文

    确实有区别。
    假设有一个包含以下代码的File1.cs文件：

    // File1.cs
using System;
namespace Outer.Inner
{
    class Foo
    {
        static void Bar()
        {
            double d = Math.PI;
        }
    }
}

    现在假设有人添加了另一个文件 ( File2.cs )：

    // File2.cs
namespace Outer
{
    class Math
    {
    }
}

    编译器会在查找命名空间外部Outer之前先查找using，因此它会查找Outer.Math而不是System.Math. 不幸的是（或者幸运的是？），Outer.Math没有 member PI，因此编译器将开始对File1.csMath.PI发誓。

    如果将using名称空间定义放入其中，一切都会改变，如下所示：

    // File1b.cs
namespace Outer.Inner
{
    using System;
    class Foo
    {
        static void Bar()
        {
            double d = Math.PI;
        }
    }
}

    现在编译器将找到System，Outer并将使用System.Math，一切都会好起来的。

    一些人认为Math这对于自定义类来说是个坏名字，因为这样的类已经存在于System; 事实是只有这里有区别，这会影响代码的可维护性。

    还想知道如果Foo在命名空间Outer而不是Outer.Inner. 在这种情况下，添加Outer.Math到File2会破坏File1，无论using. 这意味着编译器在查找任何using.

    • 8

  2. 翻译，答案之一“using”语句应该在名称空间内部还是外部？

    首先，让我们注意命名空间是这样定义的：

    namespace MyCorp.TheProduct.SomeModule.Utilities
{
    ...
}

    等同于定义多个嵌套的命名空间：

    namespace MyCorp
{
    namespace TheProduct
    {
        namespace SomeModule
        {
            namespace Utilities
            {
                ...
            }
        }
    }
}

    如果您在空间外部包含一个程序集，那么它将在所有封闭空间内可见。查找特定类型的规则可以这样表达：首先，在最里面的“作用域”中寻找匹配项，如果那里没有找到，则向上一级查找，依此类推，直到找到匹配项. 如果在任何级别有多个匹配项，您将收到编译器警告。如果未找到，则抛出编译时错误。

    现在，让我们通过一个包含两个主要约定的具体示例来更清楚地了解这意味着什么。

    (1) 外用：

    using System;
using System.Collections.Generic;
using System.Linq;
//using MyCorp.TheProduct;  <-- uncommenting this would change nothing
using MyCorp.TheProduct.OtherModule;
using MyCorp.TheProduct.OtherModule.Integration;
using ThirdParty;

namespace MyCorp.TheProduct.SomeModule.Utilities
{
    class C
    {
        Ambiguous a;
    }
}

    在上述情况下，要找出 的类型Ambiguous，搜索按以下顺序进行：

    1. 内部嵌套类型C（包括继承的嵌套类型）
    2. 当前命名空间中的类型MyCorp.TheProduct.SomeModule.Utilities
    3. 命名空间类型MyCorp.TheProduct.SomeModule
    4. 输入MyCorp.TheProduct
    5. 输入MyCorp
    6. 全局命名空间中的类型
    7. 输入System, System.Collections.Generic, System.Linq,和MyCorp.TheProduct.OtherModule_MyCorp.TheProduct.OtherModule.IntegrationThirdParty

    其他约定：

    (2) 内部使用： 

    namespace MyCorp.TheProduct.SomeModule.Utilities
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using MyCorp.TheProduct;                           // MyCorp can be left out; this using is NOT redundant
    using MyCorp.TheProduct.OtherModule;               // MyCorp.TheProduct can be left out
    using MyCorp.TheProduct.OtherModule.Integration;   // MyCorp.TheProduct can be left out
    using ThirdParty;

    class C
    {
        Ambiguous a;
    }
}

    现在按类型搜索按Ambiguous以下顺序进行：

    1. 内部嵌套类型C（包括继承的嵌套类型）
    2. 当前命名空间中的类型MyCorp.TheProduct.SomeModule.Utilities
    3. 输入System, System.Collections.Generic, System.Linq, MyCorp.TheProduct,和MyCorp.TheProduct.OtherModule_ MyCorp.TheProduct.OtherModule.IntegrationThirdParty
    4. 命名空间类型MyCorp.TheProduct.SomeModule
    5. 输入MyCorp
    6. 全局命名空间中的类型

    （请注意，这MyCorp.TheProduct是“3.”的一部分，因此在“4.”和“5.”之间不需要。）

    最后的评论

    无论您将using它放在命名空间声明的内部还是外部，总有可能有人稍后将具有相同名称的新类型添加到具有更高优先级的空间之一。

    此外，如果嵌套命名空间与类型同名，这可能会导致问题。

    从一个地方移动到另一个地方总是很危险的using，因为搜索层次结构会发生变化并且可能会找到不同的类型。因此，选择一个惯例并坚持下去，这样您就不必搬家了using。

    Visual Studio默认情况下，模板using位于命名空间之外（例如，如果您在新文件中创建新类）。

    脱离命名空间的一个（微小）优势using是，您可以使用全局属性指令，例如 [assembly: ComVisible(false)]代替[assembly: System.Runtime.InteropServices.ComVisible(false)].

    • 6

相关问题