C# 编程/封装

封装是剥夺用户对类中用户不需要的信息的访问权限，并阻止用户以设计者未预期的方式操纵对象。

具有 公共保护级别 的类元素可供程序中任何位置的所有代码访问。这些方法和属性代表了允许外部用户对类进行的操作。

具有 私有保护级别 的方法、数据成员（和其他元素）表示类的内部状态（对于变量），以及不允许外部用户执行的操作。所有类和结构成员的私有保护级别是默认的。这意味着，如果您没有指定方法或变量的保护修饰符，编译器会将其视为 私有。

例如

public class Frog
{
    private int _height = 0;

    // Methods
    public void JumpLow() { Jump(1); }
    public void JumpHigh() { Jump(10); }

    void Jump(int height) { _height += height; }
}

在此示例中，Frog 类公开的公共方法是 JumpLow 和 JumpHigh。在内部，它们是使用私有 Jump 函数实现的，该函数可以跳到任何高度。此操作对外部用户不可见，因此他们无法让青蛙跳 100 米，只能跳 10 米或 1 米。私有方法 Jump 是通过更改私有数据成员 _height 的值来实现的，该成员也对外部用户不可见。一些私有数据成员通过 属性 可见。

保护级别

私有

私有成员只能在类本身内部访问。另一个类中的方法，即使是从具有私有成员的类派生的类，也无法访问这些成员。如果没有指定保护级别，类成员将默认设置为私有。

namespace PrivateSample
{
    public class Person
    {
        private string _name;

        // Methods
        public Person(string name)
        {
            // Private members can only be modified by the internal methods or constructors of class
            this._name = name; 
        }
    }

    public class Entry
    {
        static void Main(string[] args)
        {
            Person OnePerson = new Person("Samanta");
            //OnePerson._name = "Sam"; // This causes a error of access level
        }
    }
}

受保护的

受保护的成员可以由类本身和从该类派生的任何类访问。

namespace ProtectedSample
{
    public class Person
    {
        protected string _name;
    }
    /// <summary>
    /// When a class inherits from other class, it can access your protected and public members
    /// above your created members
    /// </summary>
    public class Warrior : Person
    {
        public void SetName(string name)
        {
            // Protected members can be accessed by internal methods or constructors of class
            // so, it can be accessed by inherit class too
            base._name = name;
        }
    }

    public class Entry
    {
        static void Main(string[] args)
        {
            Warrior OnePerson = new Warrior();
            OnePerson.SetName("Glades"); // OK
            // OnePerson._name = "Sam"; // This causes a error of access level too
            // protected members can not be accessed by external scopes
        }
    }
}

公共的

公共成员可以由任何类中的任何方法访问。

namespace PublicSample
{
    public class Person
    {
        public string Name;
    }

    public class Entry
    {
        static void Main(string[] args)
        {
            Person BeautifulPerson = new Person();
            BeautifulPerson.Name = "Debora"; // OK, public member can be accessed by other scopes
        }
    }
}

良好的编程实践是不将成员变量暴露给外部，除非必要。这对于只能通过 访问器 和 修改器方法 （getter 和 setter）访问的字段尤其如此。常量成员变量例外。

内部的

内部成员只能在同一个程序集中访问，在程序集外部不可见。如果顶级类的保护级别没有指定，它们将被视为内部的，并且只能在程序集中访问。

namespace InternalSample
{
    public class Person
    {
        internal string Name;
    }

    public class Entry
    {
        static void Main(string[] args)
        {
            Person BeautifulPerson = new Person();
            BeautifulPerson.Name = "Debora"; // OK, internal member can be accessed by other 
            // scopes in same assembly supposing that Person is in another assembly, by example a 
            // library, the name cannot be accessed. In another assembly source, this causes an error:
            // BeautifulPerson.Name = "Debora"; // Cannot access internal member
        }
    }
}

受保护的内部的

受保护的内部成员可以从从该类派生的任何类或同一个程序集中的任何类访问。因此，这意味着受保护的 或 内部。^[1]

这里，一个例子

namespace InternalSample
{
    public class Person
    {
        protected internal string Name;
    }

    public class Entry
    {
        static void Main(string[] args)
        {
            Person BeautifulPerson = new Person();
            BeautifulPerson.Name = "Debora"; // As above...
        }
    }
}

public class Book : InternalSample.Person
{
    static void Main(string[] args)
    {
        InternalSample.Person BeautifulPerson = new InternalSample.Person();
        string aName = BeautifulPerson.Name; // Can be accessed, as Book is derived from Person
    }
}