C# 封装

2025 年 8 月 30 日 | 阅读 9 分钟

封装是一种将数据和方法封装到单个单元中的技术。它用于在类中创建数据成员和成员函数的组。这个封装的类包含用于读写数据的 getter 和 setter 属性。它包括一个使用访问修饰符限制直接访问数据的功能，这些修饰符提供受控访问。

在C# 编程中，封装实现了数据隐藏，这意味着它隐藏了类的内部细节，并通过公共方法公开了基本细节。它允许保留数据并提高数据安全性，这使得代码更易于维护和理解。

封装语法

它具有以下语法：

class Classname
{
    private dataType field_name;   // Private field

    public dataType Property_name   // Property (getter & setter)
    {
        get { return fieldName; }
        set { fieldName = value; }
    }
}

在这个语法中，

class Classname: 它表示类的名称。
private datatype field_name: 它表示包含数据类型和字段名称的私有字段。
public dataType Property_name: 它表示声明为公共的属性。
get: 它用于读取私有字段的值。
set: 它用于分配和修改私有字段的值。

C# 封装示例

让我们举一个例子来说明 C# 中的封装。

示例

using System;

namespace AccessSpecifiers  
{  
    class Employee  
    {  
        // Private fields (data hidden from outside)
        private string id;  
        private string name;  
        private string email;  

        // Public properties (controlled access)
        public string ID  
        {  
            get { return id; }  
            set { id = value; }  
        }  

        public string Name  
        {  
            get { return name; }  
            set { name = value; }  
        }  

        public string Email  
        {  
            get { return email; }  
            set { email = value; }  
        }  
    }  

    class Tpoint  
    {  
        static void Main(string[] args)  
        {  
            Employee emp = new Employee();  

            // Set values using properties
            emp.ID = "101";  
            emp.Name = "George";  
            emp.Email = "George@example.com";  

            // Get values using properties
            Console.WriteLine("ID = " + emp.ID);  
            Console.WriteLine("Name = " + emp.Name);  
            Console.WriteLine("Email = " + emp.Email);  
        }  
    }  
}

编译并运行

输出

ID = 101
Name = George
Email = George@example.com

说明

在这个例子中，我们创建了一个 Employee 类，通过将其数据成员（id、name、email）声明为私有来隐藏它们。之后，我们通过充当 getter 和 setter 的公共属性（ID、Name、Email）提供对这些字段的访问。它确保受控访问并保护内部数据，同时仍然允许从类外部进行安全的读/写操作。

为什么我们需要 C# 中的封装

有几种情况表明 C# 中需要封装。其中一些如下：

封装隐藏了内部细节并保护其免受未经授权的访问。
它通过属性中的验证提供数据控制。
它使代码更易于维护，因为内部修改不会影响外部代码。
它增强了可读性并使程序组织良好。

C# 封装中的访问修饰符

在 C# 编程中，访问修饰符指定了类成员（字段、方法、属性等）的访问方式和位置。访问修饰符是封装的重要组成部分，封装是面向对象编程 (OOP) 的四个基本构建块之一。C# 主要有五种访问修饰符：

在这里，我们将逐一讨论这些访问修饰符。

1) Public 访问修饰符

Public 修饰符是 C# 中最常访问的访问说明符。它可以从任何地方访问，从类内部和外部。任何其他代码都可以访问同一程序集或引用它的另一个程序集中的类型或成员。

C# Public 访问修饰符示例

让我们举一个例子来说明 C# 封装中的公共访问修饰符。

示例

using System;
namespace CarExample
{
    class Car
    {
        public string Model;  

        public void ShowModel()
        {
            Console.WriteLine("Car Model: " + Model);
        }
    }
    class Tpoint
    {
        static void Main()
        {
            Car car = new Car();
            car.Model = "Porsche";   
            car.ShowModel();
        }
    }
}

编译并运行

输出

Car Model: Porsche

说明

在这个例子中，我们创建了一个 Car 类。之后，我们将 Model 字段声明为公共的，可以直接从 Car 类外部访问和修改。最后，我们使用 ShowModel() 方法显示在主函数中定义的汽车模型。

2) Private 访问修饰符

Private 访问说明符将其可访问性限制在声明它们的类或结构中。它们不能在类外部访问，并且是限制性最高的访问级别。

C# 中 Private 访问修饰符示例

让我们举一个例子来说明 C# 中的 private 访问修饰符。

示例

using System;
class BankAccount
{
    private double balance;  
    public void Deposit(double amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }
    public void Withdraw(double amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
        }
        else
        {
            Console.WriteLine("Invalid withdraw amount!");
        }
    }
    public double GetBalance()
    {
        return balance;
    }
}
class Program
{
    static void Main()
    {
        BankAccount account = new BankAccount();
        account.Deposit(5000); 
        Console.WriteLine("Balance: " + account.GetBalance());
        account.Withdraw(1000); 
        Console.WriteLine("Balance after withdrawal: " + account.GetBalance());
    }
}

编译并运行

输出

Balance: 5000
Balance after withdrawal: 4000

说明

在此示例中，我们使用带有私有 balance 字段的 BankAccount 类以防止直接访问。公共方法允许存款、取款和检索余额。在 Main 方法中，创建了一个帐户实例，存入和取出资金，并显示余额。

3) Protected 访问修饰符

Protected 访问说明符的成员可以在同一类中以及由派生类访问。它使子类能够访问其基类的成员变量和成员函数。它通常用于实现具有受控访问的继承。

C# 中 Protected 访问修饰符示例

让我们举一个例子来说明 C# 中的 protected 访问修饰符。

示例

using System;
namespace ProtectedExample
{
    class Person
    {
        protected string name;
        public void SetName(string n)
        {
            name = n;
        }
    }
    class Student : Person
    {
        public void ShowName()
        {
            Console.WriteLine("Student Name: " + name); 
        }
    }
    class Program
    {
        static void Main()
        {
            Student s = new Student();
            s.SetName("Michael");
            s.ShowName();
        }
    }
}

编译并运行

输出

Student Name: Michael

说明

在此示例中，我们演示了继承和封装。我们创建了一个 Person 类，其中包含一个受保护的 name 字段，该字段不能直接访问，但可以在派生类 Student 中使用。之后，SetName 方法为 name 赋值，ShowName 显示它。在 Main 方法中，Student 实例设置并显示 name。

4) Internal 访问修饰符

Internal 访问修饰符提供在声明它们的程序中访问，并在同一程序集级别访问，但不能从另一个程序集访问。

C# 中 Internal 访问修饰符示例

让我们举一个例子来说明 C# 中的 internal 访问修饰符。

示例

using System;
namespace Internal
{
    internal class Calculator
    {
        internal int Add(int a, int b)
        {
            return a + b;
        }
        internal int Multiply(int a, int b)
        {
            return a * b;
        }
    }
    class Program
    {
        static void Main()
        {
            Calculator calc = new Calculator();
            Console.WriteLine("Sum: " + calc.Add(6, 27));        
            Console.WriteLine("Product: " + calc.Multiply(4, 17));
        }
    }
}

编译并运行

输出

Sum: 33
Product: 68

说明

在此示例中，我们创建了一个带有加法和乘法方法的 internal 类 Calculator。由于该类是 internal 的，因此它仅在同一程序集内可见。在 Main 方法中，实例化一个 Calculator 对象并用于打印加法和乘法结果。

5) Protected Internal 访问修饰符

在 C# 编程中，protected internal 访问修饰符是 protected 和 internal 访问修饰符的组合。protected internal 访问修饰符成员可以在同一程序集内和派生类中访问，即使这些派生类位于不同的程序集中。

C# 中 Protected Internal 访问修饰符示例

让我们举一个例子来说明 C# 中的 protected internal 访问修饰符。

示例

using System;
namespace ProtectedInternal
{
    class Employee
    {
        protected internal string Name;
        protected internal int Salary;
        public void SetDetails(string name, int salary)
        {
            Name = name;
            Salary = salary;
        }
    }
    class Manager : Employee
    {
        public void ShowDetails()
        {
            Console.WriteLine("Manager Name: " + Name);
            Console.WriteLine("Manager Salary: " + Salary);
        }
    }
    class Program
    {
        static void Main()
        {
            Manager mgr = new Manager();
            mgr.Name = "Jhonson";
            mgr.Salary = 80000;
            mgr.ShowDetails();
            Employee emp = new Employee();
            emp.SetDetails("David", 50000);
            Console.WriteLine("Employee Name: " + emp.Name);
            Console.WriteLine("Employee Salary: " + emp.Salary);
        }
    }
}

编译并运行

输出

Manager Name: Jhonson
Manager Salary: 80000
Employee Name: David
Employee Salary: 50000

说明

在此示例中，我们创建了一个 Employee 类并在其中声明了两个成员。之后，Name 和 Salary 成员可以在派生类 (Manager) 中访问，并且可以直接从 Program 类访问，因为它们位于同一程序集中。

访问说明符比较表

下表显示了 C# 中这些说明符之间的比较。

说明符	同类	派生类（同一程序集）	其他类（同一程序集）	其他程序集
公共	是的	是的	是的	是的
私有	是的	不能	不能	不能
Protected	是的	是的	不能	不能
内存	是的	是的	是的	不能
Protected Internal	是的	是的	是的	是（仅限派生）
Private Protected	是的	是（仅限同一程序集）	不能	不能

通过属性进行 C# 封装

在 C# 中，属性是使用封装的首选方法。我们可以将字段定义为私有，并通过 get 和 set 属性提供受控访问，而不是直接公开字段。

使用属性进行 C# 封装示例

让我们举一个例子来说明使用 C# 属性的封装。

示例

using System;
class Employee
{
    private string name;
    private int age;
    public string Name
    {
        get { return name; }
        set
        {
            if (!string.IsNullOrEmpty(value))
                name = value;
            else
                Console.WriteLine("Invalid Name!");
        }
    }
    public int Age
    {
        get { return age; }
        set
        {
            if (value > 0 && value <= 60)
                age = value;
            else
                Console.WriteLine("Invalid Age! Must be between 1 and 60.");
        }
    }
}
class Tpoint
{
    static void Main()
    {
        Employee emp = new Employee();
        emp.Name = "Jackson";
        emp.Age = 42;
        Console.WriteLine("Name of the Employee : " + emp.Name);
        Console.WriteLine("Age of the Employee : " + emp.Age);
        emp.Name = "";     
        emp.Age = 87;     
    }
}

编译并运行

输出

Name of the Employee : Jackson
Age of the Employee : 42
Invalid Name!
Invalid Age! Must be between 1 and 60.

说明

在此示例中，我们演示了通过将 name 和 age 作为字段的私有成员进行封装，并通过公共属性 Name 和 Age 揭示它们。这些属性使用 get 返回值，并使用 set 在赋值前验证有效输入。在 Main() 函数中，使用属性提供值，接受并打印有效输入，而无效输入则打印错误消息。

C# 中封装的优点

C# 中封装的几个优点如下：

它通过限制直接操作并通过属性或方法仅公开必要数据来安全地存储内部对象信息。
它防止未经授权的使用并以安全的方式维护内部数据。
我们可以更改类的内部结构，而不会影响程序的其他部分。
代码易于编写和更改，因为内部更改不会干扰使用该类的外部代码。
封装的类是密封的；因此，它们可以在不同的项目中使用。

C# 中封装的缺点

C# 中封装的几个缺点如下：

如果我们为每个字段添加 getter 和 setter，它可能会使代码变长并使其难以阅读。
方法/属性数据访问可能比直接字段访问效率略低。
设计不佳的封装会降低其好处。

C# 封装常见问题

1) C# 中的封装是什么？

在 C# 编程中，封装是将数据（字段）和操作（方法）分组到单个单元（类）中的过程。它还涉及阻止直接访问类成员以维护数据完整性。

2) 为什么封装在 C# 中很重要？

它通过隐藏内部状态并强制所有交互都通过对象的方法来进行，从而保护了对象的完整性。它阻止未经授权的使用和滥用，从而提供受控的访问和更改。

3) 在 C# 中没有属性可以封装吗？

可以，使用私有字段和 getter 和 setter 方法。但现在推荐使用属性（get 和 set）。

4) 封装与抽象有何不同？

封装： 它隐藏了存储/修改数据的内部实现细节（侧重于数据保护）。

抽象： 它隐藏了方法实现细节，只公开所需行为（侧重于功能）。

5) 我们最常使用哪个访问修饰符进行封装？

在 C# 编程中，最常用于封装的访问修饰符是 private 访问修饰符，因为它通过限制对字段的直接访问来确保数据隐藏。根据所需的公开级别，可以使用其他访问修饰符。

下一主题C# 字符串

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

.Net Framework

C# 教程

C# 控制语句

C# 函数

C# 数组

C# Object 类

C# 属性

C# 继承

C# 多态

C# 抽象

C# 命名空间

C# 字符串

C# 异常处理

C# 文件 IO

C# 集合

C# 泛型

C# 委托

C# 反射

匿名函数

C# 多线程

C# 同步

C# 高级主题

C# 2.0

C# 3.0

C# 4.0

C# 5.0

C# 6.0

C# 7.0

C# 7.1

C# 程序

C# 面试问题

C# 杂项

ASP.NET 教程

ADO.NET 教程

C# Web 服务

C# 字符串函数

C# 新特性

C# 封装

封装语法

C# 封装示例

示例

为什么我们需要 C# 中的封装

C# 封装中的访问修饰符

1) Public 访问修饰符

示例

2) Private 访问修饰符

示例

3) Protected 访问修饰符

示例

4) Internal 访问修饰符

示例

5) Protected Internal 访问修饰符

示例

访问说明符比较表

通过属性进行 C# 封装

使用属性进行 C# 封装示例

示例

C# 中封装的优点

C# 中封装的缺点

C# 封装常见问题