UDP套接字sendto（）函数(UDP socket sendto() functions)

 
 
 using System.Text; 意味着我正在使用名为“System.Text”的单个命名空间，或者我正在使用“System”命名空间中嵌套的“Text”命名空间？ 
 
 
 后者。 您正在使用嵌套在“System”命名空间内的“Text”命名空间。 
 
 请注意，当你说 
 
namespace Foo.Bar.Blah
{
    class C 
    {
    ...
 
 这只是一种简短的写作方式 
 
namespace Foo
{
    namespace Bar 
    {
        namespace Blah
        {
            class C 
            {
            ...
 
 命名空间只有“简单”的名字。 
 
 
 
 我们应该为每个我们使用的命名空间都有一个明确的'using'指令吗？ 
 
 
 通常你会，是的。 有些情况下你可能不想这样做。 例如，如果您有两个名称空间都包含一个相同名称的类型，并且您想使用两个名称空间中的类型， 在这种情况下，使用两个名称空间可能会令人困惑。 另外，“使用”带来了扩展方法; 如果有不想绑定的扩展方法，请不要包含包含它们的名称空间。 
 
 
 
 如果“文本”嵌套在“系统”中，为什么只有“使用系统”包含所有的名称空间？ 
 
 
 我不明白这个问题的措辞。 我想也许你在问： 
 
 
 
 为什么using System; 不是让简单的名字Text解析为嵌套的命名空间？ 
 
 
 也就是说，为什么这不起作用： 
 
namespace Foo
{
    namespace Bar
    {
         class Blah {}
    }
}
 
 在另一个文件中： 
 
using Foo;
class Abc : Bar.Blah {}
 
 using Foo; 只包括直接在Foo中声明的类型 。 它没有引入直接在Foo中声明的命名空间 。 C＃的设计者认为把命名空间“纳入范围”是太混乱了; 通常人们使用指令将类型 “纳入范围”。 

 
 
Does using System.Text; mean that I'm using a single namespace named as "System.Text" or that I'm using the "Text" namespace nested inside "System" namespace?
 
 
The latter. You are using the "Text" namespace that is nested inside the "System" namespace.
 
Note that when you say
 
namespace Foo.Bar.Blah
{
    class C 
    {
    ...
 
That is just a short form way of writing
 
namespace Foo
{
    namespace Bar 
    {
        namespace Blah
        {
            class C 
            {
            ...
 
Namespaces only have "simple" names. 
 
 
 
should we have an explicit 'using' directive for every namespace we use?
 
 
Typically you do, yes. There are some situations in which you might want to not do so. For example, if you have two namespaces that both contain a type of the same name and you want to use types from both namespaces; in that case it might be too confusing to have a "using" of two namespaces. Also, "using" brings extension methods into play; if there are extension methods that you do not want to bind to, do not include the namespace that contains them.
 
 
 
if "Text" is nested inside "System" why only "using System" includes all the namespaces? 
 
 
I do not understand the question the way it is worded. I think maybe you are asking:
 
 
 
Why does using System; not make the simple name Text resolve to the nested namespace? 
 
 
That is, why does this not work:
 
namespace Foo
{
    namespace Bar
    {
         class Blah {}
    }
}
 
In a different file:
 
using Foo;
class Abc : Bar.Blah {}
 
The using Foo; only includes the types declared directly inside Foo. It does not bring in namespaces declared directly inside Foo. The designers of C# thought that it was too confusing to bring namespaces "into scope" like this; typically people use using directives to bring types "into scope".