C#面试十问

1：C#中变量类型分为哪两种？它们的区别是什么？

• C#中的变量类型可以分为值类型和引用类型。

值类型可以存储其实际的值，如整数、浮点数、布尔值等。

引用类型存储的是对象的引用，而不是实际的值。

值类型和引用类型的主要区别在于它们在内存中存储和访问数据的方式。值类型存储在栈上，而引用类型的对象存储在堆上

2：Class和Struct的区别？

• struct 是值类型，而 class 是引用类型。这意味着在使用 struct 时，实际上是在使用它的副本，而在使用 class 时，实际上是在使用它的引用。
• struct 不能继承其他类型，而 class 可以继承其他类型。
• struct 默认有一个无参构造函数，但是 class 没有默认无参构造函数。
• struct 适用于小型、简单的数据类型，而 class 更适用于大型、复杂的数据类型。

3：C#中类的修饰符和类成员的修饰符有哪些？

在C#中，类的修饰符可以分为以下几种：

• public：表示类对外公开，可以从任何地方访问。
• internal：表示类只能在当前程序集内访问，不能跨程序集访问。
• protected：表示类只能在当前类和子类中访问。
• private：表示类只能在当前类内部访问。

类成员的修饰符包括：

1. public：表示成员对外公开，可以从任何地方访问。
2. internal：表示成员只能在当前程序集内访问，不能跨程序集访问。
3. protected：表示成员只能在当前类和子类中访问。
4. private：表示成员只能在当前类内部访问。
5. static：表示成员属于类型本身，而不是实例。可以通过类名直接访问，无需创建对象。
6. sealed：表示成员或类是密封的，不能被继承或重写。
7. abstract：表示成员或类是抽象的，只能在抽象类中定义，并且要求子类实现或重写该成员。
8. virtual：表示成员可以被子类重写，允许在子类中进行自定义实现。
9. override：表示成员在派生类中重写基类的实现。
10. readonly：表示成员只能在声明时或构造函数中初始化，并且不能再被修改
11. new:只能用于嵌套的类，表示对继承父类同名类型的隐藏.
12. const：表示该成员为常量，值在编译时确定并且不能再修改。

4：面向对象的三个特征（特点）是什么？

OOP

1. 封装（Encapsulation）：封装是将数据和操作数据的方法封装在一起，形成一个类。通过封装，我们可以隐藏实现的细节，只暴露出对外提供的接口。这样做的好处是提高了代码的可维护性和复用性，并且可以控制对数据的访问权限。
2. 继承（Inheritance）：继承是指一个类可以从另一个类中派生出来，并且继承了父类的属性和方法。通过继承，子类可以直接使用父类的功能，并且可以根据需要进行扩展或修改。继承可以提高代码的重用性、可扩展性和可维护性。
3. 多态（Polymorphism）：多态是指一个对象可以表现出多种形态。在面向对象编程中，多态可以通过继承和接口实现。多态性可以提高代码的灵活性和可扩展性。通过多态，可以在不改变原有代码的情况下，方便地增加新的功能。

这三个特征是面向对象编程的核心概念，它们使得代码更加灵活、可维护和可扩展。通过封装、继承和多态，能够更好地组织和管理代码，提高开发效率和代码质量。

5：面向对象和面向过程的区别？

C#面向对象编程（OOP）和面向过程编程（POP）是两种不同的编程范式，其主要区别在于以下几个方面：

1. 抽象程度：面向对象编程更加抽象和模块化，将程序组织成由对象组成的类层次结构。每个对象都有自己的属性和方法，并且可以通过消息传递进行交互。而面向过程编程更加注重步骤和流程，将程序组织成一系列的函数或过程。
2. 数据和行为的关联：面向对象编程将数据和操作数据的方法封装在一起形成对象，通过对象的方法来操作数据。而面向过程编程将数据和操作数据的函数分离开来，通过参数传递数据给函数进行操作。
3. 继承和多态：面向对象编程支持继承和多态，可以通过继承来扩展已有的类，并且可以通过多态来实现动态绑定。而面向过程编程没有继承和多态的概念，函数之间的调用是静态的。
4. 可重用性和可扩展性：面向对象编程通过封装、继承和多态实现了代码的重用性和可扩展性，可以通过继承和多态来扩展已有的类并且重写父类的方法。而面向过程编程较为复杂，需要在函数中手动管理数据和流程，代码的重用性和可扩展性较低。

总的来说，面向对象编程更加注重对问题进行抽象和建模，通过封装、继承和多态实现代码的重用性和可扩展性；而面向过程编程更加注重步骤和流程，将问题分解成一系列的函数或过程。选择使用哪种编程范式取决于具体的需求和问题的特点。

6：什么是装箱和拆箱？

• 装箱（Boxing）:将值类型（Value Type）转换为引用类型（Reference Type）。
• 拆箱（Unboxing）:将引用类型转换为值类型的过程。

装箱是指将值类型的数据封装为一个对象，在堆上创建一个引用类型的实例，并将值类型的值复制到该实例中。装箱操作会导致数据从栈上复制到堆上，增加了额外的开销。

拆箱是指将装箱后的对象重新还原为值类型数据。它是通过将堆上的对象拷贝到栈上来完成的，同时将其转换为相应的值类型。拆箱操作也会增加额外的开销。

装箱和拆箱常用于值类型和引用类型之间的转换，例如将值类型存储到集合类（如ArrayList）中，或者从集合类中获取值类型数据。在进行装箱和拆箱操作时，需要注意性能问题，因为装箱和拆箱操作会产生额外的开销和内存分配。

为了避免装箱和拆箱带来的性能损耗，可以使用泛型集合类（如List）或者适当地设计代码结构，以避免不必要的装箱和拆箱操作。

7：什么是IOC？

在C#中，IOC代表控制反转（Inversion of Control）。IOC是一种软件设计原则，它通过将对象的创建、依赖解析和管理交给容器来实现。传统的编程模式中，对象之间的依赖关系由对象自己负责创建和管理，而在IOC中，这种依赖关系的控制权被反转，交由容器来负责。

IOC的核心思想是将应用程序的控制权从具体的实现类中解耦出来，通过将对象的依赖关系外部化到配置文件或者代码中，实现了组件之间的松耦合。这样一来，可以很容易地替换、扩展或者重用组件，提高了代码的可维护性和可测试性。

在C#中，常见的IOC容器有多种选择，例如：

1. Unity：Unity是一个流行的开源IOC容器框架，它提供了依赖注入（Dependency Injection）的功能，并且支持构造函数注入、属性注入和方法注入等方式。
2. Autofac：Autofac是另一个常用的IOC容器框架，它提供了强大的依赖注入功能，支持构造函数注入、属性注入、方法注入和模块化配置等。
3. Ninject：Ninject是一个轻量级的IOC容器框架，它支持构造函数注入和属性注入，并且具有简单易用的语法。

8：什么是OOP？

OOP指的是面向对象编程（Object-Oriented Programming）。它是一种编程范式，通过将数据和操作封装到对象中来建模现实世界的概念和关系。

在C#中，OOP的基本概念包括以下几个方面：

1. 类（Class）：类是抽象数据类型的模板，用于描述对象的属性（字段）和行为（方法）。它定义了对象的结构和行为，并提供了创建对象的蓝图。
2. 对象（Object）：对象是类的实例，是内存中实际存在的数据。每个对象都有自己的状态（属性值）和行为（方法调用），并与其他对象进行交互。
3. 封装（Encapsulation）：封装是一种将数据和相关行为组合在一起的机制。通过将数据和方法封装到类中，可以隐藏内部实现细节，只暴露必要的接口给外部使用。
4. 继承（Inheritance）：继承是一种通过从现有类派生出新类的机制。派生类可以继承父类的属性和方法，同时还可以添加自己的特定功能。继承提供了代码重用和层次化组织的方式。
5. 多态（Polymorphism）：多态性允许不同类型的对象对同一个消息做出不同的响应。它使得可以使用通用的接口来操作不同类型的对象，提高了代码的灵活性和可扩展性。

通过使用OOP的概念和技术，可以将复杂的问题分解为更小的模块，并通过定义类和对象来组织和管理代码。这样可以提高代码的可读性、可维护性和可重用性，并使开发人员更加专注于问题的领域建模和业务逻辑的实现。

9：什么是AOP？

AOP指的是面向切面编程（Aspect-Oriented Programming）。它是一种编程范式，通过将横切关注点（Cross-Cutting Concerns）从主要业务逻辑中分离出来，以模块化的方式进行处理。

在C#中，AOP可以通过以下方式实现：

1. 切面（Aspect）：切面是横切关注点的具体实现。它包含了一系列的通用行为或功能，如日志记录、异常处理、事务管理等。每个切面都可以在不同的地方和时间点被应用到目标代码中。
2. 连接点（Join Point）：连接点是在执行过程中可以应用一个切面的特定位置。例如，方法的调用、属性的访问、异常抛出等都可以作为连接点。
3. 通知（Advice）：通知是切面在连接点执行前、执行后或出现异常时所执行的代码。它定义了切面在何时、何地和如何被应用到目标代码中。
4. 切入点（Pointcut）：切入点定义了哪些连接点将被应用一个或多个切面。通过指定切入点，可以选择性地将切面应用到目标代码中的特定位置。
5. 织入（Weaving）：织入是将切面应用到目标代码中的过程。它可以在编译时、运行时或加载时进行。织入可以通过静态代理、动态代理、IL重写等方式实现。

使用AOP的好处包括：

• 提高代码可读性和可维护性：将横切关注点与主要业务逻辑分离，使代码更加清晰和易于理解。
• 降低代码耦合度：通过切面的模块化方式处理通用行为，减少了代码间的直接依赖。
• 重用性：可以将相同的切面应用到不同的目标代码中，提高了代码的重用性。
• 可扩展性：通过添加新的切面，可以在不修改原始代码的情况下增加新的功能。

在C#中，可以使用第三方库如PostSharp来实现AOP。这些库提供了注解或配置的方式来定义切面和连接点，并在编译或运行时进行织入。

10：什么是DI？

DI指的是依赖注入（Dependency Injection）。它是一种设计模式，用于解耦组件之间的依赖关系，提高代码的可测试性、可维护性和可扩展性。

在C#中，依赖通常指一个对象需要依赖另一个对象才能完成某个功能。传统的方式是在使用对象之前，手动创建和管理其依赖的对象实例。而使用依赖注入，可以将对象的依赖关系委托给外部容器来管理。

依赖注入有三种主要的方式：

1. 构造函数注入（Constructor Injection）：通过构造函数将依赖对象作为参数传递进来，并在对象创建时进行注入。例如：

public class MyClass
{
    private readonly IDependency _dependency;
    
    public MyClass(IDependency dependency)
    {
        _dependency = dependency;
    }
}

​ 2.属性注入（Property Injection）：通过公共属性将依赖对象注入到目标对象中。例如：

public class MyClass
{
    public IDependency Dependency { get; set; }
}

3.方法注入（Method Injection）：通过方法参数将依赖对象注入到目标对象中。例如：

public class MyClass
{
    public void SetDependency(IDependency dependency)
    {
        // ...
    }
}

通过使用依赖注入，可以实现以下好处：

• 解耦依赖关系：将对象的创建和管理权交给外部容器，减少了对象之间的直接依赖。

• 提高代码可测试性：可以轻松地通过传递模拟的依赖对象来进行单元测试，而无需依赖真实对象。

• 简化代码维护：将依赖关系从代码中解耦出来，使得代码更加清晰、简洁和可维护。

• 支持可扩展性：通过配置不同的依赖对象实现，可以方便地更换或增加新的实现。

• 解耦依赖关系：将对象的创建和管理权交给外部容器，减少了对象之间的直接依赖。

• 提高代码可测试性：可以轻松地通过传递模拟的依赖对象来进行单元测试，而无需依赖真实对象。

• 简化代码维护：将依赖关系从代码中解耦出来，使得代码更加清晰、简洁和可维护。

• 支持可扩展性：通过配置不同的依赖对象实现，可以方便地更换或增加新的实现。

在C#中，可以使用第三方库如Autofac、Unity、Ninject等来实现依赖注入。这些库提供了容器和依赖解析器，用于管理对象的创建和注入。