了解 C# 中类的访问说明符

Question

首先让我先说我确实了解访问说明符，我只是不明白在类中使用它们的意义。在方法上限制其范围是有道理的，但在类上，你为什么想要一个私有类，类的目的不是能够重用它们吗？

在 C# 中声明类时访问说明符的目的是什么？您什么时候使用它们？

谢谢

Answer 1

- 更新答案 2019 -

您好，您可以通过下表找到可访问性

Answer 2

我创建了一个应用程序来理解访问说明符。

用代码代替理论会更容易理解。

我在代码中添加了我的注释，以获得更好的指导。

namespace ConsoleApplication1
{
    //A normal public class which contains all different types of access-modifier classes in the assembly named 'ConsoleApplication1'
    public class Base
    {
        public class PublicBase
        {
            public static void fn_PublicBase()
            {
                Console.WriteLine("fn_PublicBase");
            }
        }
        private class PrivateBase
        {
            public static void fn_PrivateBase()
            {
                Console.WriteLine("fn_PrivateBase");
            }
        }

        protected class ProtectedBase
        {
            public static void fn_ProtectedBase()
            {
                Console.WriteLine("fn_ProtectedBase");
            }
        }

        internal class InternalBase
        {
            public static void fn_InternalBase()
            {
                Console.WriteLine("fn_InternalBase");
            }
        }

        protected internal class ProInternalBase
        {
            public static void fn_ProInternalBase()
            {
                Console.WriteLine("fn_ProInternalBase");
            }
        }       

        //TIP 1:This class is inside the same class 'Base' so everything is accessible from above.Hurray!!
        class Base_Inside
        {
            public static void fn_Base_Inside()
            {
                //All methods are easily accessible.Does not consider a modified indeed.
                PublicBase.fn_PublicBase();
                PrivateBase.fn_PrivateBase();
                ProtectedBase.fn_ProtectedBase();
                InternalBase.fn_InternalBase();
                ProInternalBase.fn_ProInternalBase();
            }
        }
    }

    //Different class but inside the same assembly named 'ConsoleApplication1'
    public class Base_Sibling  : Base
    {        
        //TIP 2:This class is NOT in same class 'Base' but in the same assembly so  only protected is NOT accessible rest all are accessible.        
        public void fn_Base_Sibling()
        {
            PublicBase.fn_PublicBase();
            //PrivateBase.fn_PrivateBase();     //ERROR:Accesibility of 'protected'            
            ProtectedBase.fn_ProtectedBase();   //protected is accessible because Base_Sibling inherit class 'Base'. you can not access it via Base.ProtectedBase
            InternalBase.fn_InternalBase();
            ProInternalBase.fn_ProInternalBase();
        }
    }
}

现在了解内部、受保护的内部之间的区别， 我已经为以 Assembly_1 命名的项目添加了一个 解决方案。

我已将 ConsoleApplication1 的 Base 类继承到 Assembly_1 的 Derived 类。

namespace Assembly_1
{
    //TIP:if it does not inherit class 'ConsoleApplication1.Base' then we can not access any thing beacuse this is different assembly.
    //TIP:only INTERNAL is NOT accessible , rest all are accessible from first assembly if it inherits class 'Soul'
    public class Derived : ConsoleApplication1.Base
    {
        public class PublicDerived
        {
            public static void fn_PublicDerived()
            {
                PublicBase.fn_PublicBase();             //YES, becuase this is 'public'
              //PrivateBase.fn_PrivateBase();           //No, becuase this is 'private'
                ProtectedBase.fn_ProtectedBase();       //YES, becuase this is 'protected'
              //InternalBase.fn_InternalBase();         //No, becuase this is 'internal'
                ProInternalBase.fn_ProInternalBase();   //YES, becuase this is 'protected internal'
            }
        }
    }
}

Answer 3

好吧，假设您希望一个类只能在她自己的程序集中访问：

internal class Test

假设您有两个类，一个在另一个内部（嵌套类）：

protected internal class TestA
{
    private TestB _testB;

    private class TestB
    {
    }

    public TestA()
    {
        _testB = new TestB();
    }
}

TestB 类只能在 TestA 或她自己内部的方法/属性/构造函数内部访问。

这同样适用于protected 修饰符。

// 注意

如果你不指定访问修饰符，默认为private，所以在我的例子中如下行：

private TestB _testB;

等于

TestB _testB;

这同样适用于类。

特殊修饰符

然后，protected internal 连接了两个修饰符，因此您只能从由该类派生的类访问同一程序集中的该类或，即使它不在同一个组件。示例：

组件 1：

public class TestA : TestB
{
    public TestB GetBase()
    {
        return (TestB)this;
    }

    public int GetA1()
    {
        return this.a1;
    }
}
protected internal class TestB
{
    public int a1 = 0;
}

程序

TestA _testA = new TestA(); // OK
TestB _testB = new TestB(); // ERROR

int debugA = new TestA().a1 // ERROR
int debugB = new TestA().GetA1(); // OK

TestB testB_ = new TestA().GetBase(); // ERROR

来源

Link (Access Modifiers)

• Internal

类型或成员可以被同一程序集中的任何代码访问， 但不是来自另一个程序集。

• Private

类型或成员只能由同一类中的代码访问或 结构。

• Protected

类型或成员只能由同一类中的代码访问或 struct，或者在从该类派生的类中。

• Public

类型或成员可以被同一个中的任何其他代码访问 程序集或引用它的其他程序集。

Answer 4

使用访问说明符的最大好处是当其他人正在使用您的类时。通过明确指定对象中应该触摸和不应该触摸的内容，您可以保护对象的内部机制和完整性不被滥用或损坏。

对于更大的类，如果您将所有内容都公开，您的代码用户也会更难使用 IntelliSense，这在您处理未知库时非常方便。

Answer 5

我会给你一个内部类的例子。想象一下我有一些 DLL。形成这个 DLL，我只想公开一个名为 A 的类。然而，这个类A 应该可以访问 DLL 中的其他类 - 因此我会将 DLL 中的所有其他类设置为内部类。因此，从 DLL 中您只能使用类 A，而 A 仍然可以访问 DLL 中的其他类 - 但是您不能。