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访问修饰的作用。

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.说说什么是原始字符串。

{
     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有什么改进？

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; }
}

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

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);

// 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";

// 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;

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

public sealed class SomeAttribute<T> : Attribute
{
}

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

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));
       }
   })
});

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