C#面试十问 | 嘻哈∠※

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

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

2：Class和Struct的区别？

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

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

C#面试十问-LMLPHP

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

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

类成员的修饰符包括：

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

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

OOP

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

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

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

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

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

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

6：什么是装箱和拆箱？

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

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

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

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

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

7：什么是IOC？

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

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

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

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

8：什么是OOP？

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

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

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

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

9：什么是AOP？

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

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

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

使用AOP的好处包括：

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

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

10：什么是DI？

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

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

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

构造函数注入（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等来实现依赖注入。这些库提供了容器和依赖解析器，用于管理对象的创建和注入。