Question

首先让我首先说我理解访问说明符我只是没有看到在类中使用它们的意义。它对于限制范围的方法有意义，但对于类，为什么你想要一个私有类，是不是类的目的是能够重用它们？

在C＃中声明一个类时访问说明符的目的是什么？你什么时候使用它们？

由于

Answer 1

嗯，让我们说你想让一个课只能在她自己的集会中进行访问：

internal class Test

让我们说你有两个类，一个在另一个里面（嵌套类）：

protected internal class TestA
{
    private TestB _testB;

    private class TestB
    {
    }

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

TestB类只能在TestA内部的methods / properties / contructors中或在她自己内部访问。

同样适用于protected修饰符。

//注意

如果您没有指定访问修饰符，默认情况下它将是private，所以在我的示例中有以下行：

private TestB _testB;

等于

TestB _testB;

这同样适用于班级。

特殊修饰符

然后，有protected internal连接两个修饰符，因此您只能从同一个程序集中访问该类 OR ，即使它不是＆＃ 39;在同一个集会中。例如：

大会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 2

我将举一个内部课程的例子。想象一下，我有一些DLL。形成这个DLL我想只暴露一个名为A的类。但是，这个类A应该可以访问DLL中的其他类 - 因此我将在DLL内部创建所有其他类。因此，从DLL中你只能使用类A，而A仍然可以访问DLL中的其他类 - 但是，你不能。

Answer 3

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

对于更大的类，如果你公开了所有内容，你也会让代码用户更难以使用IntelliSense，这对于处理未知库来说非常方便。

Answer 4

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

用代码而不是理论来理解它会更容易。

我已在代码中添加了我的笔记，以获得更好的指导。

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 继承到 Assembly_1 的派生类。

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 5

-更新答案2019-

嗨，您可以通过下表找到辅助功能

了解C＃中类的Access说明符

5 个答案: