1 .NET Core笔试题

1.说说显示实现接口和隐式实现接口的区别。

2.说说file访问修饰的作用。

3.说说什么是原始字符串。

4.C#10 中struct有什么改进？

5.说说C#10中Lambda表达式的新特点。

6.说说对于泛型特性的理解。

7.说说在ASP.NET Core7中，依赖注入中的方法注入需要注意什么？

8.说说ASP.NET Core7 限流中间件。

9.说说Record关键字的用法

10.说说 Minimal API的特点，和普通API有什么区别？

---

.bold { font-weight: bold }

1.说说显示实现接口和隐式实现接口的区别。

隐式接口实现： 如果类或者结构要实现的是单个接口，可以使用隐式实现。

显式接口实现： 如果类或者结构继承了多个接口，那么接口中相同名称成员就要显式实现。显示实现是

通过使用接口的完全限定名来实现接口成员的。

使用显式接口成员执行体通常有两个目的：

1、显式接口成员执行体不能通过类的实例进行访问，这就 可以从公有接口中把接口的实现部分单

独分离开。如果一个类只在内部使用该接口，而类的使用者不会直接使用到该接口，这种显式接口成员

执行体就可以起到作用。

2、 显式接口成员执行体避免了接口成员之间因为同名而发生混淆。如果一个类希望对名称和返回类型

相同的接口成员采用不同的实现方式，这就必须要使用到显式接口成员执行体。 如果没有显式接口成员

执行体，那么对于名称和返回类型不同的接口成员，类也无法进行实现。

ex:

//约定接口
interface ISkill
{
　　void Flying();
}

//隐式实现ISkill接口
public class Bird: ISkill
{
　　public void Flying()
    {
    }
}

//第一种调用方式
Bird bird = new Bird();
bird.Flying();

//第二种调用方式
 ISkill secondBrid = new Bird();
 secondBrid.Flying();

//用类和接口都可以调用Flying方法

//约定两个接口
interface InterfaceA
    {
        void Say();
    }
interface InterfaceB
    {
        void Say();
    }
//继承
class Person:InterfaceA, InterfaceB
    {
        void InterfaceA.Say()
        {
            Console.WriteLine("helloA");
        }

        void InterfaceB.Say()
        {
            Console.WriteLine("helloB");
        }
    }

//访问形式
class Program
{
        static void Main(string[] args)
        {
            InterfaceA p = new Person();
            p.Say();

            InterfaceB p2 = new Person();
            p2.Say();
        }
}

// 显示实现只能通过对应的接口访问对应的接口内的方法。用实现类去访问时访问不到的。

---

2.说说file访问修饰的作用。

.NET7到来时，C#11中添加了file访问修饰符。就是文件的意思，file是只能用来定义类型的访问修饰
符，不能定义类型中的类成员，即使嵌套类也不可以。file是用来定义使用范围最小的类型访问修饰符，
只限于在当前文件中，其他类型的成员内访问。

file基本的使用场景是，当需要一个类型时，但又不想这个类型的使用范围延伸到外部，所以就在当
前.cs文件定义一个file访问修饰符的类型，仅限于当前文件中的类型成员内部封装并访问。

ex:

public class Product {
    public string ? Name {
        get;
        set;
    }
    public decimal PurchasePrice {
        get;
        set;
    }
    public void PrintSalesProduct() {
        var salesPrice = new SalesPrice {
            RetailPrice = PurchasePrice * 1.5 m, WholesalePrice = PurchasePrice * 1.2 m
        };
        Console.WriteLine($ "Name:{Name},{salesPrice}");
    }
}
file record SalesPrice {
    public decimal RetailPrice {
        get;
        set;
    }
    public decimal WholesalePrice {
        get;
        set;
    }
}

---

3.说说什么是原始字符串。

C# 11 引入了原始字符串特性，允许用户利用原始字符串在代码中插入大量的无需转移的文本，方便开发者在代码中以字符串的方式塞入代码文本等。

原始字符串需要被至少三个 " 包裹，例如 """ 和 """"" 等等，前后的引号数量要相等。

另外，原始字符串的缩进由后面引号的位置来确定

例如：

此时 str 是：带有换行符的字符串

{
     string str = """
               hello
               world
               """;
     Console.WriteLine(str);
}

此时 str 是：带有换行符,且第二行有空格的字符串

{
   var str = """"
           hello
               world
           """";
   Console.WriteLine(str);
}

可以直接定义JSON格式

{
   //可以直接定义JSON格式
   var json = """"
               {
                   "a": 1,
                   "b": {
                           "c": "hello",
                           "d": "world"
                         },
                   "c": [1, 2, 3, 4, 5]
               }
               """";
   Console.WriteLine(json);
   object obj= Newtonsoft.Json.JsonConvert.DeserializeObject<object>(json);
   Hashtable tb = Newtonsoft.Json.JsonConvert.DeserializeObject<Hashtable>
(json);
}

可以直接定义JSON格式

{
   int age= 37;
   string? jsonResult= $$"""
                 {
                   "Id":123,
                   "Name":"Richard",
                   "Age":"{{age}}"
                 }
                 """;
}

---

4. C#10 中struct有什么改进？

主要在于支持了无参数构造函数的改进，在C# 10之前，约束了不能有无参数的构造函数，现在在C#10
方法了这一约束；

public struct Teaach
{
   public Teaach(string firstName, string lastName)
   {
       this.FirstName = firstName;
       this.LastName = lastName;
   }
   public string FirstName { get; set; }
   public string LastName { get; set; }
}

---

5.说说C#10中Lambda表达式的新特点

在之前的版本中我们是需要显式声明委托类型，如上述被注释的代码，在 C# 10 就可以直接使用 var
来声明由编译器去推断委托的类型

// Func<int> func = () => 1;
var func = () => 1;
// Func<string> func2 = ()=>"Hello";
var func2 = () => "Hello";

我们可以在指定输入参数类型的时候，可以设置 ref / out / int 来表示一个值类型的引用传递，示例如

下

var refFunc = (ref int x) => { x++; };
var outFunc = (out int x) => { x = -1; };
var inFunc = (in int x) => { };
var num = 1;
refFunc(ref num);
Console.WriteLine(num);
outFunc(out num);
Console.WriteLine(num);

C# 10 的委托可以指定返回类型，如下：

// return type
var lambdaWithReturnValue0 = int? () => null;
// return type and input type
var lambdaWithReturnValue1 = int? (string s)
   => string.IsNullOrEmpty(s) ? 1 : null;
// Func<bool, object>
var choose = object (bool b) => b ? 1 : "two";

对于能够推断出类型的方法，我们也可以使用 var 来声明委托，示例如下

// Action<string> func3 = LocalMethod;
var func3 = LocalMethod;
void LocalMethod(string a)
{
   Console.WriteLine(a);
}
var checkFunc = string.IsNullOrEmpty;
var read = Console.Read;
Action<string> write = Console.Write;

现在我们可以在 Lambda 表达式中指定 Attribute

var parse3 =[Description("Lambda attribute")](string s) => int.Parse(s);
var choose3 =[Description("Lambda attribute1")]object (bool b) => b ? 1 : "two";

---

6.说说对于泛型特性的理解。

泛型：不确定的类型，声明时不确定类型，调用时确定类型。可以支持一个类、方法、委托、接口等 类
支持不同类型的需求；那么对于泛型的支持；

C# 10 推广了特性，使得特性可以用泛型，如下例：

public sealed class SomeAttribute<T> : Attribute
{
}

在使用的时候：

[SomeAttribute<int>]
class A { }
[SomeAttribute<string>]
class B { }

---

7.说说在ASP.NET Core7中，依赖注入中的方法注入需要注意什么？

在MinimalAPI 或者是控制器中的方法中，如果需要支持注入，因为注入的对象和方法的参数是写在一起
的。会出现系统无法识别这里写的参数究竟是要注入，还是调用方传入的参数。那么如果明确那个参数
是要通过注入（也就是说通过IOC容器来创建），就需要给这个参数标记一个特性【FromServices】,指
定当前这个参数是来自于IOC容器，也就是注入进来的。

---

8.说说ASP.NET Core7 限流中间件。

实操如下：

安装.NET 7.0 SDK

通过nuget包安装Microsoft.AspNetCore.RateLimiting

创建.NET7网站应用，注册中间件

可以根据不同资源不同限制并发数，/api前缀的资源租约数2，等待队列长度为2，其他默认租约数1，队列长度1。

app.UseRateLimiter(new RateLimiterOptions()
{
   // 触发限流的响应码
   DefaultRejectionStatusCode = 500,
   OnRejected = async (ctx, rateLimitLease) =>
   {
       // 触发限流回调处理
   },
   Limiter = PartitionedRateLimiter.Create<HttpContext, string>(resource =>
   {
       if (resource.Request.Path.StartsWithSegments("/api"))
       {
           return RateLimitPartition.CreateConcurrencyLimiter("WebApiLimiter", _ => new ConcurrencyLimiterOptions(2,QueueProcessingOrder.NewestFirst, 2));
       }
       else
       {
           return RateLimitPartition.CreateConcurrencyLimiter("DefaultLimiter",
               _ => new ConcurrencyLimiterOptions(1, QueueProcessingOrder.NewestFirst, 1));
       }
   })
});

---

9. 说说Record关键字的用法

可以用来简单声明一个类：

record People
{
   public string Name { get; init; }
   public int Age { get; init; }
}
上面是声明一个类
下面的声明也是声明一个类，和上面的一样；不需要使用大括号来执行属性；
record People2(string Name, int Age);

这里的示例，用 record 声明了两个 实体，第二个 实体 声明的时候使用了简化的写法，record

People2(string Name, int Age); 这样的声明意味着，构造方法有两个参数，分别是 string Name 和 int

Age，并对应着两个属性，属性的声明方式和 People 一样 public string Name { get; init; } 都是一个

get 一个 init，对于 record 支持一个 with 表达式，来修改某几个属性的值，这对于有很多属性都相同的

场景来说是及其方便的；

---

10.说说 Minimal API的特点，和普通API有什么区别？

Minimal API翻译过来：极简Api或者最小Api，从名字上就可以理解。 Minimal API意在去掉过多的流
程。相比于普通的Webapi,在HttpContext的处理流程中，减少了处理的步骤，没有MVC的流程，在中间
件的位置处理了请求；减少了处理的步骤，减少了计算机的资源消耗，提高性能。当然在功能的支持上
也有部分是少于普通 的.NET Core WebApi的。