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的。

巴特西