20 道 C# 面试题（针对新生）2023

向右看齐 2023-10-12 22:33 18阅读 0赞

嘿，C\# 爱好者们！那么您已经掌握了基础知识，现在您渴望解决一些更具挑战性的面试问题，是吗？也许您是一个新人，希望在第一次面试中给人留下深刻的印象，或者只是想积累您的 C\# 专业知识。你猜怎么了？你来对地方了，我的朋友！

在本文中，我们将深入研究 20 个非常适合新手的 C\# 面试问题；比基础知识高出一个档次但仍然完全可行的。在这些问题中，您会发现各种各样的问题来测试您的逻辑思维、代码分析技能和那些非常重要的编程概念。

准备好让面试官大吃一惊了吗？

来吧！

C\# 中的命名空间是什么？  
回答  
C\# 中的命名空间是一种对相关类型进行分组并改进代码组织的方法。它用于避免可能具有相同标识符的不同类或类型之间的命名冲突。命名空间作为层次结构工作，您可以在其中嵌套命名空间，并且它们可以跨越多个文件甚至库。

例如：

namespace Company.Project
    {
        
        class MyClass
        {
        
            // Class implementation
        }
    }

在此示例中，该类MyClass是在Company.Project命名空间内声明的。

C\# 中“using”指令的用途是什么？  
回答  
usingC\# 中的指令有两个主要目的：

命名空间导入：using允许您导入命名空间，以便您可以使用该命名空间中定义的类型和成员，而无需指定其完全限定名称。它使您的代码更具可读性并降低代码复杂性。例如：

using System;
    
        class Program
        {
        
            static void Main()
            {
        
                // Without the 'using' directive, you would need to write: System.Console.WriteLine("Hello, World!");
                Console.WriteLine("Hello, World!");
            }
        }

资源管理：该using语句用于帮助您管理实现 IDisposable 接口的资源，例如文件流、网络连接或数据库连接。该using语句确保Dispose()在退出代码块时在资源上调用该方法，从而正确释放资源。例如：

using System.IO;
    
        class Program
        {
        
            static void Main()
            {
        
                using (StreamReader reader = new StreamReader("file.txt"))
                {
        
                    // Code to read from the file
                } // At this point, the Dispose() method of the StreamReader is automatically called, releasing resources.
            }
        }

C\# 中的引用类型是什么？  
回答  
C\# 中的引用类型是存储对存储数据的内存位置的引用的类型，而不是实际数据本身。当您从类创建对象或使用数组、委托、接口或 .NET Framework 中的大多数内置数据结构时，您正在使用引用类型。与值类型不同，引用类型在堆上分配，并且垃圾收集器管理它们的内存。

参考类型的关键方面：

当您将引用类型作为方法参数传递或将其分配给另一个变量时，这两个变量将引用相同的内存位置。因此，一个变量的修改将影响另一个变量。  
引用类型可以有一个null值，这意味着它们不引用任何内存位置或对象。

class Person
    {
        
        public string Name {
         get; set; }
    }
    
    Person person1 = new Person {
         Name = "John" };
    Person person2 = person1; // Both person1 and person2 reference the same object in memory
    person2.Name = "Jane"; // Changing person2.Name also updates person1.Name, as they both refer to the same object

如何在 C\# 中声明方法？  
回答  
C\# 中的方法是执行特定任务的代码块，可以根据需要多次调用。要声明方法，您需要在类中指定其访问级别、返回类型、方法名称和参数列表（如果适用）。这是一个例子：

public class Calculator
    {
        
        public int Add(int a, int b)
        {
        
            int sum = a + b;
            return sum;
        }
    }

Add在此示例中，我们声明一个使用 public 访问修饰符命名的方法、一个 int 返回类型和两个 int 类型的参数。该方法计算两个数字的总和并返回结果。

C\# 中可用的基本访问修饰符有哪些？  
回答  
C\# 中的访问修饰符控制类成员（方法、属性、字段等）和类本身的可见性和可访问性。C\# 中可用的基本访问修饰符有：

public：具有访问修饰符的成员和类public可以从同一程序集或引用它的另一个程序集中的任何代码访问。  
private：声明为的成员private只能在同一个类中访问。它们对其他类不可见，即使在同一程序集中也是如此。private默认情况下，如果未指定访问修饰符，则为类成员。  
protected：使用protected访问修饰符声明的成员可以在同一类中以及派生类中访问。它们对于同一程序集中的其他非派生类不可见。  
内部：具有internal访问修饰符的成员和类可以在同一程序集中的任何位置访问，但对其他程序集不可见。  
protected inside：使用protected internal访问修饰符声明的成员可以在同一程序集中访问，也可以由另一个程序集中的派生类访问。

public class MyClass
    {
        
        public int PublicMember;
        private int PrivateMember;
        protected int ProtectedMember;
        internal int InternalMember;
        protected internal int ProtectedInternalMember;
    }

C\# 中的构造函数是什么？  
回答  
构造函数是类中的一种特殊方法，在创建该类的对象时调用该方法。构造函数与类具有相同的名称，并且没有显式的返回类型。构造函数可以重载，这意味着一个类中可以有多个具有不同参数列表的构造函数。

构造函数用于：

初始化对象的状态（设置属性、字段等的默认值）。  
分配资源，例如内存或网络连接。  
验证输入参数或确保对象处于一致状态。  
例子：

public class Person
    {
        
        public string Name {
         get; set; }
        public int Age {
         get; set; }
    
        // Default constructor
        public Person()
        {
        
            Name = "Unknown";
            Age = 0;
        }
    
        // Parameterized constructor
        public Person(string name, int age)
        {
        
            Name = name;
            Age = age;
        }
    }
    
    // Usage:
    Person person1 = new Person(); // Calls the default constructor
    Person person2 = new Person("John", 25); // Calls the parameterized constructor

C\# 中的索引器是什么？  
回答  
C\# 中的索引器是类成员，允许您使用索引表示法访问对象的元素，类似于访问数组或集合中的元素的方式。索引器提供了一种更直观的方式来与类中存储的元素进行交互，特别是当它包含集合或数组时。

要定义索引器，您需要使用关键字this、要访问的元素的类型，并实现get和set访问器来访问和修改底层元素。

下面是一个简单的自定义集合类的索引器实现示例：

public class MyCollection
    {
        
        private int[] items = new int[10];
    
        public int this[int index]
        {
        
            get
            {
        
                return items[index];
            }
            set
            {
        
                items[index] = value;
            }
        }
    }
    
    // Usage:
    MyCollection collection = new MyCollection();
    collection[0] = 42; // Uses the indexer's set accessor
    int firstItem = collection[0]; // Uses the indexer's get accessor

如何在 C\# 中创建自定义异常处理？  
回答  
要在 C\# 中创建自定义异常处理，您可以创建一个继承自内置System.Exception类或其派生类之一的自定义异常类。当内置异常类不涵盖应用程序中的特定错误情况时，自定义异常非常有用。

以下是自定义异常类的示例：

public class CustomException : Exception
    {
        
        public CustomException() : base()
        {
        
        }
    
        public CustomException(string message) : base(message)
        {
        
        }
    
        public CustomException(string message, Exception innerException) : base(message, innerException)
        {
        
        }
    }

CustomException现在您可以在代码中抛出并捕获：

try
    {
        
        // Some code that might throw a CustomException
        throw new CustomException("This is a custom exception");
    }
    catch (CustomException ex)
    {
        
        Console.WriteLine("Caught a CustomException: " + ex.Message);
    }

如何防止 C\# 中的类继承？  
回答  
为了防止 C\# 中的类继承，可以sealed在声明类时使用关键字。一个sealed类不能被任何其他类继承，尝试从密封类继承会导致编译时错误。

public sealed class NonInheritableClass
    {
        
        // Class implementation
    }
    
    // This will result in a compile-time error:
    public class MyClass : NonInheritableClass
    {
        
    }

C\# 中“const”和“readonly”有什么区别？  
回答  
const和readonly都在 C\# 中用于创建赋值后无法更改的变量，但它们有一些区别：

const:  
只能应用于字段，不能应用于属性。  
必须在声明时赋值。  
分配的值必须是可以在编译时解析的常量表达式。  
const字段是隐式静态的，您不能使用实例成员来初始化它们。

public class Constants
    {
        
        public const double Pi = 3.14159;
    }
    readonly:

可应用于字段和属性。  
可以在声明时或构造函数内赋值。  
分配的值可以是常量表达式或在运行时解析的非常量表达式。  
readonly字段可以是静态成员或实例成员，具体取决于您的需要。

public class ReadOnlyFields
    {
        
        public readonly int InstanceField;
        public static readonly int StaticField;
    
        public ReadOnlyFields(int instanceValue, int staticValue)
        {
        
            InstanceField = instanceValue;
            StaticField = staticValue;
        }
    }

差异总结：

const是编译时常量，其值不能依赖于运行时条件。readonly是运行时常量，其值可以在运行时确定。  
const字段是隐式静态的，而readonly字段可以是静态成员或实例成员。  
C\# 中的垃圾回收是什么？  
回答  
C\# 中的垃圾收集 (GC) 是 .NET Framework 提供的自动内存管理系统。它负责释放应用程序不再使用的内存。垃圾收集器跟踪堆上分配的对象，确定哪些对象不再可访问，并回收相应的内存空间。

垃圾收集的主要好处是：

通过减少手动内存管理的样板代码，提高了开发人员的工作效率。  
防止内存泄漏，因为未使用的内存会自动回收。  
防止某些编程错误，例如悬空指针或双重释放问题。  
C\# 的垃圾收集是不确定的，这意味着您无法准确预测垃圾收集器何时运行。它使用分代方法，将对象分为几代，以减少垃圾收集所花费的时间和资源。垃圾收集器通常会在可用内存变低或系统空闲时运行。

虽然垃圾收集可以带来好处，但在处理大量消耗资源的对象（例如文件处理程序或数据库连接）时仍应小心。处理此类资源管理的类应实现该IDisposable接口以允许确定性的资源释放。

描述 C\# 中的面向对象编程 (OOP)。说出主要的 OOP 概念。  
回答  
面向对象编程 (OOP) 是一种编程范例，它将概念表示为具有属性（字段或属性）和行为（方法）的对象。OOP 的目标是通过强调关注点分离并遵守 OOP 原则来生成可重用、可维护和模块化的代码。

C\# 是一种面向对象的编程语言，它完全支持 OOP 概念。C\# 中的主要 OOP 概念是：

封装：将数据（属性）和对数据进行操作的方法（函数）捆绑到单个单元（类）中的过程。封装有助于保护对象的内部状态并控制对其属性的访问。  
继承base：一个类从另一个类（ class）继承属性、方法和行为的能力，以实现代码重用并表示相关对象的层次结构。在C\#中，一个类只能继承一个类，但可以实现多个接口。  
多态性：多态性是单个接口表示不同类型的能力或方法基于派生类型具有多个实现的能力。在C\#中，多态性可以通过重载（在同一类型中使用相同的方法名和不同的参数）和覆盖（在派生类中重新定义基类方法）来实现。  
抽象：抽象是通过关注复杂的现实世界对象和概念的基本特征来简化它们的过程。在 C\# 中，可以通过使用抽象类和接口来定义一组相关类型必须实现的公共属性和方法来实现抽象。  
如何在 C\# 中创建泛型类或方法？  
回答  
C\# 中的泛型类或方法是可以使用任何类型而无需在运行时进行显式类型转换或类型检查的类或方法。泛型类型提高了代码的可重用性、灵活性和类型安全性。

要在 C\# 中创建泛型类或方法，需要使用尖括号来定义类型参数。这是泛型类和泛型方法的示例：

// A generic class example
    public class GenericList<T>
    {
        
        // Class implementation using the generic type parameter T
    }
    
    // A generic method example
    public static T Max<T>(T value1, T value2) where T : IComparable<T>
    {
        
        return value1.CompareTo(value2) > 0 ? value1 : value2;
    }

在此示例中，T是泛型类GenericList和泛型方法的类型参数Max(T, T)。该方法还使用约束 ( where T : IComparable) 来确保类型参数T实现IComparable接口。

C\# 中的抽象类和接口有什么区别？  
回答  
C\#中抽象类和接口都用于定义抽象实体，但它们有一些区别：

抽象类：

可以同时具有抽象和非抽象（实现）方法。  
可以有字段（变量）、属性和事件。  
支持构造函数和析构函数。  
可以具有成员的访问修饰符（公共、受保护、内部等）。  
支持继承；一个类只能继承一个抽象类。  
可以对某些方法或属性有完整的实现，但不能直接实例化。  
接口：

只能有方法、属性和事件签名（无实现）。  
不能有字段或构造函数。  
任何成员（方法、属性、事件）都不能具有访问修饰符（所有成员都是隐式公共的）。  
支持多重继承；一个类可以实现多个接口。  
不能有任何实施细节，只有成员的签名。  
总之，抽象类提供了可以在多个派生类之间共享的基本实现，而接口定义了任何实现类都必须遵守的契约。当您想要提供一些默认行为时，请使用抽象类；当您需要多重继承或想要严格定义通用功能契约时，请使用接口。

C\# 中“out”和“ref”参数有什么区别？  
回答  
outC\# 中的和参数都ref用于通过引用传递参数，允许方法在方法外部修改所传递变量的值。然而，两者之间存在一些差异：

参考：

作为参数传递的变量ref必须在传递给方法之前进行初始化。  
调用的方法不必为ref参数分配值，因为它已经有一个值。例子：

public void Swap(ref int a, ref int b)
      {
        
          int temp = a;
          a = b;
          b = temp;
      }
    
      int x = 1, y = 2;
      Swap(ref x, ref y); // x = 2, y = 1 after the method call

输出：

作为参数传递的变量out在传递给方法之前不需要进行初始化。  
out调用的方法必须在方法返回之前 为参数赋值。例子：

public void Divide(int a, int b, out int quotient, out int remainder)
      {
        
          quotient = a / b;
          remainder = a % b;
      }
    
      int q, r;
      Divide(10, 3, out q, out r); // q = 3, r = 1 after the method call

总之，ref当您希望被调用的方法修改已初始化的变量时，请使用参数；out当您希望被调用的方法提供不依赖于传递变量的初始值的值时，请使用参数。

描述 C\# 中委托的概念。  
回答  
C\# 中的委托是一种引用类型，表示具有特定签名的方法。委托允许您将方法视为对象并将它们作为参数传递、从方法返回它们或将它们存储为属性。委托提供了一种创建函数指针或回调的方法，使得开发更灵活和可扩展的应用程序成为可能。

在设计事件驱动系统时，委托特别有用，其中组件必须对其他组件事件或信号做出反应，而无需紧密耦合。以下是委托声明、实例化和调用的示例：

// Declare a delegate type with a specific signature
    public delegate void MyDelegate(string message);
    
    // A method that matches the delegate signature
    public static void Greet(string message)
    {
        
        Console.WriteLine("Hello, " + message);
    }
    
    // Create an instance of the delegate, assigning the method to it
    MyDelegate greetDelegate = new MyDelegate(Greet);
    
    // Invoke the delegate
    greetDelegate("World");

C\# 还支持通用委托、多播委托以及内置委托Func<T, TResult>和Action委托（在 .NET Framework 3.5 中引入），以提高灵活性和可用性。

“”、“Equals”和“ReferenceEquals”方法之间有什么区别？  
回答  
在 C\# 中，“”、“Equals”和“ReferenceEquals”用于比较对象或值是否相等，但也有一些区别：

== 运算符：“”运算符比较两个对象或值是否相等。对于值类型，它检查值是否相等。对于引用类型，它检查对象引用是否相等，这意味着它们指向内存中的同一个对象。对于自定义引用类型，可以通过重载“”运算符来覆盖此行为。

int a = 10;
       int b = 10;
       Console.WriteLine(a == b); // True, because the values are equal
    
       string s1 = "hello";
       string s2 = new String("hello".ToCharArray());

Console.WriteLine(s1 == s2); // False, because the object references are different  
Equals：“Equals”方法通过检查两个对象的值而不是它们的引用来比较两个对象是否相等。引用类型的“Equals”的默认实现会检查引用相等性，但可以在自定义类中覆盖它以提供基于值的比较。

string s1 = "hello";
       string s2 = new String("hello".ToCharArray());
       Console.WriteLine(s1.Equals(s2)); // True, because the values are equal

ReferenceEquals：“ReferenceEquals”方法检查两个对象引用是否相等，这意味着它们指向内存中的同一对象。它不比较值。此方法无法被覆盖，并且在需要执行严格的引用比较时非常有用。

string s1 = "hello";
       string s2 = new String("hello".ToCharArray());
       Console.WriteLine(ReferenceEquals(s1, s2)); // False, because the object references are different

总之，使用“==”运算符进行简单的值比较和引用比较，在需要对引用类型执行基于值的比较时使用“Equals”，在需要专门比较对象引用时使用“ReferenceEquals”。

解释 C\# 中依赖注入的概念。  
回答  
依赖注入 (DI) 是 C\# 和其他面向对象语言中使用的一种设计模式，有助于分离对象依赖项的创建和管理，从而提高应用程序的模块化、可维护性和可测试性。

在 C\# 上下文中，依赖项注入是一种技术，其中对象从外部源接收其依赖项（它所依赖的对象、服务或值），而不是直接创建、管理或查找这些依赖项。依赖注入可以使用构造函数注入、属性注入或方法注入来实现：

构造函数注入：依赖关系通过对象的构造函数传递给对象。这是最常见和推荐的依赖项注入方法，因为它强制使用所有必需的依赖项创建对象并处于有效状态。

public class UserService
       {
        
           private readonly ILogger _logger;
    
           public UserService(ILogger logger)
           {
        
               _logger = logger;
           }
    
           public void DoSomething()
           {
        
               _logger.Log("User Service is doing something.");
           }
       }

属性注入：依赖项是通过对象的公共属性或设置器设置的。当依赖项是可选的或可以在对象生命周期内更改时，使用此技术。

public class UserService
       {
        
           public ILogger Logger {
         get; set; }
    
           public void DoSomething()
           {
        
               Logger?.Log("User Service is doing something.");
           }
       }

方法注入：依赖项通过方法传递给对象。当对象仅需要一个方法而不是对象的整个生命周期的特定依赖项时，此技术适用。

public class UserService
       {
        
           public void DoSomething(ILogger logger)
           {
        
               logger.Log("User Service is doing something.");
           }
       }

在 C\# 中，流行的依赖注入框架（例如 Autofac、Unity 或内置的 .NET Core 依赖注入）可用于管理和解决对象依赖关系。

C\#如何支持多重继承？  
回答  
C\# 不直接支持类的多重继承。C\# 中的类只能从一个基类继承。然而，C\# 允许通过接口进行多重继承，因为一个类可以实现多个接口。

当一个类实现多个接口时，它本质上继承了每个接口的行为，并且每个接口可以被视为该类必须遵守的契约。这种多重继承方法提供了灵活性，同时避免了多重类继承可能产生的复杂性和歧义性。

例子：

public interface IEngine
    {
        
        void StartEngine();
    }
    
    public interface IDriver
    {
        
        void Drive();
    }
    
    public class Car : IEngine, IDriver
    {
        
        public void StartEngine()
        {
        
            Console.WriteLine("Car engine started.");
        }
    
        public void Drive()
        {
        
            Console.WriteLine("Car is being driven.");
        }
    }
    
    // Usage:
    Car car = new Car();
    car.StartEngine();
    car.Drive();

在此示例中，Car实现IEngine和IDriver接口以提供多个类似继承的功能。

C\# 中的方法重载是什么？  
回答  
方法重载是 C\# 中的一项功能，它允许一个类具有多个名称相同但参数列表不同的方法。根据提供的参数在编译时调用正确的方法。方法重载是实现编译时多态性的一种方法。方法的返回类型不考虑重载。方法签名，即方法名和参数列表必须是唯一的。

这是一个例子：

public class Calculator
    {
        
        public int Add(int x, int y)
        {
        
            return x + y;
        }
    
        public double Add(double x, double y)
        {
        
            return x + y;
        }
    
        public int Add(int x, int y, int z)
        {
        
            return x + y + z;
        }
    }

在上面的示例中，我们Add使用不同的参数列表重载了该方法。

就是这样，伙计们！这 20 个针对 C\# 新手的问题只是一个开始。

请继续关注我，因为我将分享更多针对所有技能水平（从新手到经验丰富的专业人士）的 C\# 面试问题。

不要忘记关注，这样您就可以随时了解情况。让我们一起来C\#吧！