20 个（高级开发人员）C# 面试问题及答案（2023）

各位 C# 大佬们，大家好！你们有能力征服这终极挑战吗？欢迎来到我们 C# 面试问答系列的最终章！

如果你已经做到了这一点，那么你已经是一位经验丰富的专家，随时准备展现你的技能。准备好挑战迄今为止最棘手的问题，在 C# 的世界里证明你的实力吧。

让我们开始吧，好吗？

您能在 C# 环境中描述即时编译 (JIT) 吗？

回答

即时 (JIT) 编译是 .NET 运行时使用的一种技术，通过在运行时将中间语言 (IL) 字节码编译为本机机器码来显著提升性能。JIT 编译器不会在执行前将整个代码预编译为本机代码，而是在运行时优化并仅编译所需的方法，从而大大减少加载时间和内存使用量。

C# 环境中 JIT 编译的主要优点是：

应用程序启动更快：由于只编译代码的必要部分，因此应用程序启动更快。
更好的内存使用：未使用的 IL 字节码永远不会转换为本机代码，从而降低内存使用率。
平台特定优化：专门为运行时平台生成本机代码，以实现更好的优化和性能。

C# 上下文中的 JIT 编译器遵循的过程包括三个阶段：

加载 IL 字节码：CLR 加载要执行的方法所需的 IL 字节码。
将 IL 字节码编译为本机代码：JIT 编译器将 IL 字节码编译为本机机器代码。
执行本机代码：执行生成的本机代码。

C# 中的普通类属性和计算类属性有什么区别？

回答

普通的类属性是一个简单的属性，它保存一个值，并包含一个 getter 和/或 setter 方法。这些属性可用于存储和检索对象的数据。setter 负责设置属性值，而 getter 负责返回属性值。

计算类属性（也称为已计算属性）是一种不存储任何数据，而是根据类中其他属性值计算其值的属性。计算属性只有一个 getter 方法（用于返回计算结果），没有 setter 方法。

正常属性：

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

计算属性：

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public string FullName
    {
        get
        {
            return $"{FirstName} {LastName}";
        }
    }
}

在此示例中，FullName是一个返回连接的名字和姓氏的计算属性。

如何在 C# 中实现自定义可等待类型？

回答

要在 C# 中实现自定义可等待类型，您需要遵循以下步骤：

创建一个代表可等待类型的类。
在类中实现INotifyCompletion接口，用于在操作完成时发出通知。
添加一个名为的方法GetAwaiter，该方法返回类本身的实例。
IsCompleted作为可等待模式的一部分，在类中实现该属性。
添加一个名为类的方法OnCompleted(Action continuation)，该方法将在操作完成时执行一项操作。
实现该GetResult方法，它将返回异步操作的结果。

以下是自定义可等待类型的示例：

public class CustomAwaitable : INotifyCompletion
{
    private bool _isCompleted;

    public CustomAwaitable GetAwaiter() => this;

    public bool IsCompleted => _isCompleted;

    public void OnCompleted(Action continuation)
    {
        Task.Delay(1000).ContinueWith(t =>
        {
            _isCompleted = true; 
            continuation?.Invoke();
        });
    }

    public int GetResult() => 42;
}

为什么要使用 System.Reflection 命名空间，它与 C# 有何关系？

回答

System.Reflection 是 .NET 中的一个命名空间，它提供了在运行时获取有关类、对象和程序集的类型信息（元数据）的功能。它允许开发人员以动态方式检查代码并与之交互，从而提供以下功能：

检查类型信息，例如属性、字段、事件和方法。
创建和操作对象实例。
调用方法并访问实例上的字段/属性。
发现并检查应用于类型和成员的属性。
加载并与程序集交互。

下面的示例演示了如何使用 System.Reflection 获取有关类的类型及其方法的信息：

using System;
using System.Reflection;

class Example
{
    static void Main()
    {
        Type myType = typeof(DemoClass);

        MethodInfo[] myMethods = myType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

        Console.WriteLine("The methods in the DemoClass are:");

        foreach (MethodInfo method in myMethods)
        {
            Console.WriteLine(method.Name);
        }
    }
}

class DemoClass
{
    public void Method1() { }
    public void Method2() { }
    public void Method3() { }
}

C# 中的表达式树是什么以及如何使用它们？

回答

C# 中的表达式树是一种数据结构，它以树状格式表示代码（具体来说，是表达式），其中每个节点都是一个对象，代表表达式的一部分。表达式树使开发人员能够在运行时以结构化的方式检查、操作或解释代码。它们允许对所表达的代码进行修改、编译和执行等操作。

表达式树主要应用于如下场景：

构建动态 LINQ 查询以进行数据操作。
针对性能关键代码路径的动态代码生成。
表达式树的序列化和反序列化。
分析 lambda 表达式的并行性或将其转换为另一种形式。

下面是为简单 lambda 表达式创建表达式树的示例：

using System;
using System.Linq.Expressions;

class Program
{
    static void Main()
    {
        Expression<Func<int, int, int>> addExpression = (a, b) => a + b;

        // Access the expression tree structure for examination or manipulation
        BinaryExpression body = (BinaryExpression)addExpression.Body;
        ParameterExpression left = (ParameterExpression)body.Left;
        ParameterExpression right = (ParameterExpression)body.Right;

        Console.WriteLine("Expression: {0} + {1}", left.Name, right.Name);

        // Compile the expression tree to a delegate to execute it
        Func<int, int, int> addFunc = addExpression.Compile();

        int result = addFunc(3, 5);
        Console.WriteLine("Result: {0}", result);
    }
}

C# 中“yield”关键字的实际用例是什么？

回答

C# 中的关键字yield用于迭代器方法中，用于创建有状态迭代器并动态返回值序列，而无需将整个序列存储在内存中。它IEnumerator<T>根据迭代器方法中的代码生成接口的自定义实现，并记住调用之间的当前执行状态MoveNext()。这种对迭代器的惰性求值可以提高内存使用率和性能，尤其适用于大型或无限序列。

该关键字的实际用例yield包括：

实现需要支持foreach迭代的自定义集合或序列。
生成无限的值序列或不应存储在内存中的序列。
处理大型数据集或逐步流数据而不消耗大量内存。

下面是一个示例，演示如何使用yield关键字生成无限偶数序列：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        foreach (int evenNumber in GenerateEvenNumbers())
        {
            if (evenNumber > 50)
            {
                break;
            }

            Console.WriteLine(evenNumber);
        }
    }

    public static IEnumerable<int> GenerateEvenNumbers()
    {
        int number = 0;

        while (true)
        {
            yield return number;
            number += 2;
        }
    }
}

解释 C# 中“volatile”关键字的作用。

回答

C# 中的关键字volatile应用于字段，表示它们可以被多个线程访问，并且由于 .NET 运行时或底层硬件执行的优化，字段的值可能会发生意外变化。

当字段被标记为时volatile，编译器和运行时不会重新排序或缓存其读写操作，从而确保始终读取最新值，并且写入操作对其他线程立即可见。这提供了一个内存屏障，强制执行原子读写操作，并防止因优化而产生意外的副作用。

该volatile关键字应该用在多个线程必须访问共享字段，并且需要适当的同步来保持数据一致性的场景中。

下面是一个演示变量用法的示例volatile：

using System;
using System.Threading;

class VolatileExample
{
    private static volatile bool _shouldTerminate = false;

    static void Main()
    {
        Thread workerThread = new Thread(Worker);
        workerThread.Start();

        Console.ReadLine();
        _shouldTerminate = true;

        workerThread.Join();
    }

    static void Worker()
    {
        int counter = 0;

        while (!_shouldTerminate)
        {
            counter++;
        }

        Console.WriteLine("Terminated after {0} iterations.", counter);
    }
}

在此示例中，该_shouldTerminate字段用于通知工作线程何时终止。将其标记为volatile可确保工作线程立即看到更新的值。

什么是弱引用？在 C# 中何时使用它们？

回答

在 C# 中，弱引用是指对对象的引用强度不足以阻止它们被垃圾回收。它们允许你只要对象在内存中存在，就能保持对该对象的引用，但不会阻止垃圾回收 (GC) 在内存压力增加时回收该对象。使用弱引用，只要对象仍在内存中，你就可以访问它，但不会阻止 GC 在必要时回收该对象。

当你需要持有对大型对象的引用以进行缓存，但又不想在内存压力增加时阻止该对象被垃圾回收时，弱引用就非常有用。这可以实现更高效的内存管理，尤其是在处理大型数据集或内存缓存时。

WeakReference要在 C# 中使用弱引用，您需要创建或类的实例WeakReference<T>。

下面是一个演示弱引用用法的示例：

using System;

class Program
{
    static void Main()
    {
        WeakReference<MyLargeObject> weakReference = new WeakReference<MyLargeObject>(new MyLargeObject());

        MyLargeObject largeObject;
        if (weakReference.TryGetTarget(out largeObject))
        {
            // The object is still in memory, so we can use it
            Console.WriteLine("Using the large object.");
        }
        else
        {
            // The object has been garbage collected, so we need to recreate it
            Console.WriteLine("The large object has been garbage collected.");
            largeObject = new MyLargeObject();
        }
    }
}

class MyLargeObject
{
    private byte[] _data = new byte[1000000]; // A large object consuming memory
}

在此示例中，如果 GC 决定回收MyLargeObject实例使用的内存，则weakReference.TryGetTarget调用将返回false。否则，largeObject仍可通过弱引用访问。

描述如何在 C# 中实现自定义属性。

回答

要在 C# 中实现自定义属性，请按照以下步骤操作：

创建一个从该类派生的类System.Attribute。
根据需要向类添加属性、字段或方法来存储元数据。
使用属性语法将属性应用于代码中的元素（例如类、方法或属性）。

以下是在 C# 中创建和使用自定义属性的示例：

using System;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class CustomAttribute : Attribute
{
    private string _description;

    public CustomAttribute(string description)
    {
        _description = description;
    }

    public string Description => _description;
}

[Custom("This is a custom attribute applied to the example class.")]
class ExampleClass
{
    [Custom("This is a custom attribute applied to the example method.")]
    public void ExampleMethod()
    {
        // ...
    }
}

在此示例中，我们创建了一个名为的自定义特性，CustomAttribute并附带一个description属性。我们将其应用于及其ExampleClass。ExampleMethod()特性AttributeUsage用于限制可应用自定义特性的目标。

解释使用 ArraySegment 在 C# 中实现内存高效数组处理的概念。

回答

C# 中的结构ArraySegment<T>体允许您使用现有数组的一部分来处理数组，从而提供了一种高效内存的处理方法。这在您需要处理大型数组的一部分并希望避免创建新子数组所导致的内存开销的情况下非常有用。

该ArraySegment<T>结构表示数组内连续的元素范围，并提供诸如Array、Offset和Count等属性来访问底层数组和段边界。

下面是一个示例，演示了如何使用ArraySegment<T>内存高效的数组处理：

using System;

class Program
{
    static void Main()
    {
        int[] largeArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        ArraySegment<int> segment = new ArraySegment<int>(largeArray, 2, 3);

        PrintArraySegment(segment);
    }

    static void PrintArraySegment(ArraySegment<int> segment)
    {
        int[] array = segment.Array;
        for (int i = segment.Offset; i < segment.Offset + segment.Count; i++)
        {
            Console.WriteLine(array[i]);
        }
    }
}

在此示例中，ArraySegment<int>创建了一个对象来表示的一部分largeArray。该PrintArraySegment方法处理数组段而不创建新的子数组，从而减少了内存开销。

什么是 Roslyn 编译器平台，它与 C# 有何关系？

回答

Roslyn 编译器平台是 Microsoft 为 C# 和 Visual Basic .NET (VB.NET) 语言开发的一组开源编译器、代码分析 API 和代码重构工具。Roslyn 公开了强大的代码分析和转换 API，使开发人员能够创建更高级的静态代码分析器、代码修复器和重构工具。

Roslyn 与 C# 的关系：

它提供了默认的 C# 编译器，将 C# 代码转换为 Microsoft 中间语言 (MSIL) 代码。
它为 Visual Studio 提供了现代 C# 语言服务实现。
它让开发人员可以利用代码分析和操作 API 来获得更深入的代码洞察和生成。
它支持现代 C# 版本的高级功能，如模式匹配、表达式体成员和异步等待构造。

解释鸭子类型的概念以及如何在 C# 中实现它。

回答

鸭子类型是一种编程概念，其中对象的类型由其行为（方法和属性）决定，而不是由其显式的类或继承层次结构决定。换句话说，鸭子类型基于这样的原则：“如果它看起来像鸭子，游起来像鸭子，叫起来也像鸭子，那么它很可能就是鸭子。”

dynamicC# 是一门静态类型语言，这意味着该语言不直接支持鸭子类型。但是，你可以在 C# 中使用关键字或反射来实现鸭子类型。

使用dynamic关键字：

public void MakeDuckSwim(dynamic duck)
{
    duck.Swim();
}

但需要注意的是，usingdynamic可能会带来性能开销，并且会损失一些编译时的安全性。如果对象上不存在该方法或属性，则会在运行时发生错误。

C# 中的 GetHashCode 和 Equals 方法有什么区别？

回答

GetHashCode和Equals方法是类的成员System.Object，该类是 C# 中所有对象的基类。它们用于比较对象是否相等，并用于不同的目的：

GetHashCode：此方法返回对象的整数（哈希码）表示形式。它主要用于基于哈希的集合（例如Dictionary、[HashSet](https://www.bytehide.com/blog/hashset-csharp/ "How To C# HashSet (Tutorial): From A to Z")等），以优化对象的查找和存储。实现此方法时，应确保被视为相等的对象具有相同的哈希码值。
Equals：此方法检查两个对象的内容是否相等。它使用它们的数据成员来判断是否相等。默认情况下，该Equals方法将比较对象引用，但可以重写它以根据实际对象内容提供自定义比较逻辑（例如比较属性）。

当您重写该Equals方法时，您还应该重写该GetHashCode方法以保持两个方法之间的一致性，确保被视为相等的对象具有相同的哈希码。

解释 C# 中非托管资源的概念以及如何管理它们。

回答

非托管资源是指不由 .NET 运行时直接控制的资源，例如文件句柄、网络连接、数据库连接和其他系统资源。由于 .NET 运行时的垃圾收集器不管理这些资源，因此开发人员必须显式处理此类资源，以避免资源泄漏或潜在的应用程序不稳定。

要正确管理非托管资源，您可以：

IDisposable在使用非托管资源的类中实现该接口。该IDisposable接口提供了Dispose清理非托管资源的方法。

public class FileWriter : IDisposable
{
    private FileStream fileStream;

    public FileWriter(string fileName)
    {
        fileStream = new FileStream(fileName, FileMode.Create);
    }

    public void Dispose()
    {
        if (fileStream != null)
        {
            fileStream.Dispose();
            fileStream = null;
        }
    }
}

使用该using语句确保Dispose当对象超出范围时自动调用该方法。

using (FileWriter writer = new FileWriter("file.txt"))
{
    // Do some operations
}

在这个例子中，Dispose当退出块时该方法将被自动调用using，确保正确清理非托管资源。

描述 C# 中的并行编程支持及其优势。

回答

System.ThreadingC# 中的并行编程支持由、System.Threading.Tasks和命名空间提供System.Collections.Concurrent。这些并行执行功能使开发人员能够编写利用现代多核和多处理器硬件的应用程序，以获得更好的性能和响应能力。

C# 中的关键并行编程功能：

任务并行库 (TPL)：提供用于并发执行任务的高级抽象，简化管理线程、同步和异常处理等并行工作。
并行 LINQ（PLINQ）：标准 LINQ 的并行执行版本，使开发人员能够轻松高效地并行化数据密集型查询操作。
并发集合：诸如ConcurrentDictionary、、ConcurrentQueue和ConcurrentBag之类的集合ConcurrentStack提供线程安全的数据结构来帮助管理并行应用程序中的共享状态。

C# 中并行编程的好处：

利用多核和多处理器系统提高性能。
通过同时执行耗时任务而不阻塞 UI 线程来提高响应速度。
通过 TPL 和 PLINQ 提供的高级抽象简化并行编程。
更好地利用系统资源，从而实现更高效、更具可扩展性的应用程序。

如何在 C# 中执行编译时代码生成，以及有什么好处？

回答

可以使用 C# 9.0 和 .NET 5 中引入的源生成器实现 C# 中的编译时代码生成。源生成器是在编译期间运行的组件，可以检查、分析和生成与原始代码一起编译的其他 C# 源代码。

源生成器是一个单独的程序集，包含一个或多个实现该ISourceGenerator接口的类。Visual Studio 和 .NET 构建系统将发现具有相应项目引用的源生成器，并在编译过程中运行它们。

编译时代码生成的好处：

改进的性能：编译时的代码生成减少了运行时开销。
减少代码：自动生成重复或样板代码可减少开发人员需要编写和维护的代码。
安全性：生成的代码在运行前经过验证和保护，防止运行时代码生成产生的安全漏洞。
可扩展性：源生成器支持创建高级库和框架，从而进一步增强和优化代码生成和操作。

C# 中的 stackalloc 是什么，什么时候应该使用它？

回答

在 C# 中，stackalloc是一个允许您在堆栈上分配内存块的关键字。

int* block = stackalloc int[100];

通常，在 C# 中使用数组时，它们是在堆上创建的。这会带来一定的开销，因为必须分配内存，并且在对象不再使用时进行垃圾回收。在处理大型数组或高性能代码时，这种影响有时可能非常显著。

该stackalloc关键字通过直接在堆栈上创建数组来绕过这个问题。这主要有 3 个含义：

性能：通常，在栈上分配内存比在堆上分配内存更快。无需担心垃圾回收，因为内存会在方法退出时自动回收。这使得它对于小型数组非常高效。
内存限制：与堆相比，栈的资源非常有限。具体大小取决于设置和其他因素，但通常在 1MB 左右。这使其stackalloc不适合较大的数组。
寿命：堆上分配的内存可以与应用程序的寿命一样长，而栈上分配的内存仅存在到当前方法结束。任何尝试使用超出此寿命的栈分配内存的行为都会导致问题。

典型的用例stackalloc是涉及相对较小的数组的高性能场景，例如图形或数学运算。请注意，使用不当很容易导致堆栈溢出，从而导致应用程序崩溃。

stackalloc如果满足以下情况，请考虑使用：

您有一个小数组（通常最多几百个元素）。
该数组对于您的方法来说是本地的，不需要返回或传递到其他地方。
垃圾收集的开销对您的用例的性能有重大影响。

下面是一个使用示例stackalloc：

unsafe 
{
    int* fib = stackalloc int[100];

    fib[0] = fib[1] = 1;

    for(int i=2; i<100; ++i)
    {
        fib[i] = fib[i - 1] + fib[i - 2];
    }

    Console.WriteLine(fib[60]); //Prints fibonacci number at position 60
}

请注意，stackalloc使用不安全的代码，因此必须使用 /unsafe 开关进行编译。

解释 Tuple 类及其在 C# 中的用例。

回答

C# 中的类[Tuple](https://www.bytehide.com/blog/tuple-csharp/ "Tuples in C#: Full Guide")表示固定大小、不可变的异构类型元素集合。它是System命名空间的一部分，并提供了一种简单的方法来分组对象，而无需定义自定义的特定于域的类。元组在需要从方法返回多个值，或者在不创建特定数据结构的情况下存储或传递数据的情况下非常有用。

使用Tuple的示例：

public Tuple<int, string> GetPersonInfo()
{
    int age = 30;
    string name = "John";
    return Tuple.Create(age, name);
}

var personInfo = GetPersonInfo();
Console.WriteLine($"Name: {personInfo.Item2}, Age: {personInfo.Item1}");

在 C# 7.0 中，通过引入ValueTuple ，元组得到了改进。 ValueTuple 是基于结构体（而不是基于类）的元组，允许命名元素并具有其他增强功能：

public (int Age, string Name) GetPersonInfo()
{
    int age = 30;
    string name = "John";
    return (age, name);
}

var personInfo = GetPersonInfo();
Console.WriteLine($"Name: {personInfo.Name}, Age: {personInfo.Age}");

C# 7.0 中的本地函数是什么，如何使用它们？

回答

C# 7.0 中引入了局部函数，它们是在另一个方法的作用域内定义的函数。局部函数允许你在需要辅助函数的方法内部声明辅助函数，从而使辅助函数保持私有，并避免类级命名空间的混乱。

本地函数具有如下优势：

更好地组织和封装功能。
访问包含方法的变量，允许它们轻松共享状态。
可访问性有限，因为本地函数在其包含的方法之外不可见。

局部函数示例：

public int CalculateSum(int[] numbers)
{
    // Local function
    int Add(int a, int b)
    {
        return a + b;
    }

    int sum = 0;
    foreach (int number in numbers)
    {
        sum = Add(sum, number);
}
    return sum;
}

在这个例子中，Add本地函数仅在方法内可见，并且可以访问包含方法的CalculateSum局部变量（例如）。sum

解释.NET 中的编组概念及其在 C# 中的应用。

回答

封送处理是将一个运行时环境的类型、对象和数据结构转换为另一个运行时环境的过程，尤其是在托管 (.NET) 代码和非托管（本机）代码之间的通信环境中。当需要与使用其他编程语言、操作系统或硬件和软件平台（例如，COM、Win32 API 或其他第三方库）开发的组件进行交互时，封送处理在 .NET 中被广泛使用。

在 C# 中，命名空间有助于System.Runtime.InteropServices编组，并提供所需的属性、方法和结构以：

定义内存中结构和联合的布局。
将托管类型映射到非托管类型。
指定非托管函数的调用约定。
分配和释放非托管内存。

在 C# 中使用编组的示例：

using System;
using System.Runtime.InteropServices;

class Program
{
    // Import Win32 MessageBox function
    [DllImport("user32.dll", CharSet = CharSet.Unicode)]  
    public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);

    static void Main()
    {
        MessageBox(IntPtr.Zero, "Hello, World!", "C# Message Box", 0);
    }
}

在此示例中，我们使用特性MessageBox从本机库导入该函数。这使托管 C# 代码能够调用非托管 Win32 MessageBox 函数。调用非托管函数时，封送处理过程将处理字符串值和其他必要数据类型的转换。user32.dllDllImport

恭喜您完成了我们 C# 面试问答系列中最具挑战性的一关！您已经克服了最棘手的问题，并最终取得了胜利。但别让您的旅程就此结束，我的编程行家！

保持联系并关注我们的内容，探索 C# 领域更多精彩的冒险。记住，学习永无止境。继续编码，不断成长，不断突破极限。

你的编程征程下一步该怎么走？选择权在你手中！

文章来源：https://dev.to/bytehide/20-senior-developer-c-interview-questions-and-answers-2023-3bjc