抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。

一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

public：所有对象都可以访问;

private：对象本身在对象内部可以访问;

protected：只有该类对象及其子类对象可以访问

internal：同一个程序集的对象可以访问;

protected internal：访问限于当前程序集或派生自包含类的类型。

Public 访问修饰符

Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。

下面的实例说明了这点：

实例

1. using System; 
2.  
3. namespace RectangleApplication 
4. { 
5.     class Rectangle 
6.     { 
7.         //成员变量 
8.         public double length; 
9.         public double width; 
10.  
11.         public double GetArea() 
12.         { 
13.             return length * width; 
14.         } 
15.         public void Display() 
16.         { 
17.             Console.WriteLine("长度： {0}", length); 
18.             Console.WriteLine("宽度： {0}", width); 
19.             Console.WriteLine("面积： {0}", GetArea()); 
20.         } 
21.     }// Rectangle 结束 
22.  
23.     class ExecuteRectangle 
24.     { 
25.         static void Main(string[] args) 
26.         { 
27.             Rectangle r = new Rectangle(); 
28.             r.length = 4.5; 
29.             r.width = 3.5; 
30.             r.Display(); 
31.             Console.ReadLine(); 
32.         } 
33.     } 
34. } 

当上面的代码被编译和执行时，它会产生下列结果：

1. 长度：4.5 
2. 宽度：3.5 
3. 面积：15.75 

在上面的实例中，成员变量 length 和 width 被声明为 public，所以它们可以被函数 Main() 使用 Rectangle 类的实例 r 访问。

成员函数 Display() 和 GetArea() 可以直接访问这些变量。

成员函数 Display() 也被声明为 public，所以它也能被 Main() 使用 Rectangle 类的实例 r 访问。

Private 访问修饰符

Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

下面的实例说明了这点：

实例

1. using System; 
2.  
3. namespace RectangleApplication 
4. { 
5.     class Rectangle 
6.     { 
7.         //成员变量 
8.         private double length; 
9.         private double width; 
10.  
11.         public void Acceptdetails() 
12.         { 
13.             Console.WriteLine("请输入长度："); 
14.             length = Convert.ToDouble(Console.ReadLine()); 
15.             Console.WriteLine("请输入宽度："); 
16.             width = Convert.ToDouble(Console.ReadLine()); 
17.         } 
18.         public double GetArea() 
19.         { 
20.             return length * width; 
21.         } 
22.         public void Display() 
23.         { 
24.             Console.WriteLine("长度： {0}", length); 
25.             Console.WriteLine("宽度： {0}", width); 
26.             Console.WriteLine("面积： {0}", GetArea()); 
27.         } 
28.     }//end class Rectangle     
29.     class ExecuteRectangle 
30.     { 
31.         static void Main(string[] args) 
32.         { 
33.             Rectangle r = new Rectangle(); 
34.             r.Acceptdetails(); 
35.             r.Display(); 
36.             Console.ReadLine(); 
37.         } 
38.     } 
39. } 

当上面的代码被编译和执行时，它会产生下列结果：

请输入长度：

4.4

请输入宽度：

3.3

长度：4.4

宽度：3.3

面积：14.52

在上面的实例中，成员变量 length 和 width 被声明为 private，所以它们不能被函数 Main() 访问。

成员函数 AcceptDetails() 和 Display() 可以访问这些变量。

由于成员函数 AcceptDetails() 和 Display() 被声明为 public，所以它们可以被 Main() 使用 Rectangle 类的实例 r 访问。

Protected 访问修饰符

Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。我们将在继承的章节详细讨论这个。更详细地讨论这个。

Internal 访问修饰符

Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。