重新发布这个答案的精彩图表。

以下是维恩图中的所有访问修饰语，从更有限制的到更混杂的: 私人: private protected: c# 7.2新增 内部: 保护: 保护内部: 公众:

Hmm.

参见这里:访问修饰符。

简而言之:

Public使方法或类型从其他类型/类中完全可见。

Private只允许包含私有方法/变量的类型访问私有方法/变量(注意，嵌套类也可以访问包含类的私有方法/变量)。

Protected与private类似，只是派生类也可以访问Protected方法。

“Nothing”是VB。NET等价于null。虽然如果你提到的“nothing”意味着“没有访问修饰符”，那么这要视情况而定，尽管一个非常粗略的经验法则(当然在c#中)是，如果你没有显式地指定访问修饰符，方法/变量声明通常会受到尽可能多的限制。 即。

public class MyClass
{
    string s = "";
}

实际上等同于:

public class MyClass
{
    private string s = "";
}

当没有显式指定访问修饰符时，链接的MSDN文章将提供完整的描述。

Public -如果你能看到类，那么你也能看到方法

Private -如果你是类的一部分，那么你可以看到这个方法，否则就不能。

Protected -与Private相同，加上所有后代也可以看到该方法。

静态(类)——还记得“类”和“对象”之间的区别吗?忘掉这些吧。“static”也是如此。类是自身的唯一实例。

静态(方法)——无论何时使用这个方法，它都有一个独立于它所属类的实际实例的参考框架。

关于虚无的问题

默认情况下，命名空间类型是内部的 默认情况下，包括嵌套类型在内的任何类型成员都是私有的

using System;

namespace ClassLibrary1
{
    public class SameAssemblyBaseClass
    {
        public string publicVariable = "public";
        protected string protectedVariable = "protected";
        protected internal string protected_InternalVariable = "protected internal";
        internal string internalVariable = "internal";
        private string privateVariable = "private";
        public void test()
        {
            // OK
            Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(publicVariable);

            // OK
            Console.WriteLine(protectedVariable);

            // OK
            Console.WriteLine(internalVariable);

            // OK
            Console.WriteLine(protected_InternalVariable);
        }
    }

    public class SameAssemblyDerivedClass : SameAssemblyBaseClass
    {
        public void test()
        {
            SameAssemblyDerivedClass p = new SameAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }

    public class SameAssemblyDifferentClass
    {
        public SameAssemblyDifferentClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // NOT OK
            // Console.WriteLine(privateVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            //Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }
}

 using System;
        using ClassLibrary1;
        namespace ConsoleApplication4

{
    class DifferentAssemblyClass
    {
        public DifferentAssemblyClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            // Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protectedVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protected_InternalVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protected_InternalVariable);
        }
    }

    class DifferentAssemblyDerivedClass : SameAssemblyBaseClass
    {
        static void Main(string[] args)
        {
            DifferentAssemblyDerivedClass p = new DifferentAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            //Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);

            SameAssemblyDerivedClass dd = new SameAssemblyDerivedClass();
            dd.test();
        }
    }
}

嗯…

静态意味着您可以在没有类实例的情况下访问该函数。

您可以直接从类定义中访问。