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();
        }
    }
}

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

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

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

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

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

关于虚无的问题

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

图形概述(简要总结)

实际上，情况要比这复杂一些。 现在(从c# 7.2开始)，也有private protected，派生类是否在同一个程序集中也很重要。

因此，需要扩展概述:

请参阅有关此主题的c# -dotnet-docs。

因为静态类是密封的，所以它们不能被继承(除非是从Object继承)，所以关键字protected在静态类上是无效的。

对于默认情况，如果你在前面不放访问修饰符，请参见这里: c#类和成员(字段，方法等)的默认可见性?

Non-nested

enum                              public
non-nested classes / structs      internal
interfaces                        internal
delegates in namespace            internal
class/struct member(s)            private
delegates nested in class/struct  private

嵌套:

nested enum      public
nested interface public
nested class     private
nested struct    private

此外，还有seal -关键字，它使类不可继承。 同样，在VB中。NET，关键字有时是不同的，所以这里有一个小抄:

c#总共有6个访问修饰符:

private:使用此可访问性声明的成员可以在包含类型中可见，但对任何派生类型、同一程序集中的其他类型或包含程序集中之外的类型都不可见。也就是说，访问仅限于包含类型。

protected:使用此可访问性声明的成员可以在包含程序集中从包含类型派生的类型中可见，也可以在包含程序集中从包含类型派生的类型中可见。也就是说，只能访问包含类型的派生类型。

internal:使用此可访问性声明的成员可以在包含该成员的程序集内可见，它对包含该成员的程序集之外的任何程序集都不可见。也就是说，访问仅限于包含程序集。

internal protected:使用此可访问性声明的成员可以在包含程序集内部或外部从包含类型派生的类型中可见，它也对包含程序集内的任何类型可见。也就是说，访问仅限于包含程序集或派生类型。

public:使用此可访问性声明的成员可以在包含此成员的程序集或引用包含该成员的程序集的任何其他程序集中可见。也就是说，访问不受限制。

在c# 7.2中，增加了一个新的可访问性级别:

private protected:使用此可访问性声明的成员可以在包含程序集中从此包含类型派生的类型中可见。对于非从包含类型派生的任何类型或包含程序集外部的任何类型都不可见。也就是说，访问权限仅限于包含程序集中的派生类型。

源代码，包括新的私有受保护访问修饰符的示例代码

Private状态表示变量只能被同一类的对象访问。受保护状态将这种访问权限扩展到该类的后代。

“从上表中我们可以看到隐私和受保护之间的区别……我认为两者是一样的....那么这两个单独的命令有什么用呢?

查看MSDN链接了解更多信息