C# 12 中的新增功能

太原椰千语 發表於 2023-10-8 10:35:00

<p><img src="https://img2023.cnblogs.com/blog/3089082/202310/3089082-20231008103311850-1546236360.jpg"></p>
<p>新的 C# 12 功能在预览版中已经引入. 您可以使用最新的 Visual Studio 预览版或最新的 .NET 8 预览版 SDK 来尝试这些功能。以下是一些新引入的功能:</p>
<ul>
<li><strong>主构造函数</strong></li>
<li><strong>集合表达式</strong></li>
<li><strong>默认 Lambda 参数</strong></li>
<li><strong>任何类型的别名</strong></li>
<li><strong>内联数组</strong></li>
<li><strong>拦截器</strong></li>
<li><strong>使用nameof访问实例成员</strong></li>
</ul>
<h2 id="主构造函数">主构造函数</h2>
<p>现在可以在任何 class 和 struct 中创建主构造函数。主构造函数不再局限于 record 类型。主构造函数参数都在类的整个主体的范围内。为了确保显式分配所有主构造函数参数，所有显式声明的构造函数都必须使用 this() 语法调用主构造函数。将主构造函数添加到 class 可防止编译器声明隐式无参数构造函数。在 struct 中，隐式无参数构造函数初始化所有字段，包括 0 位模式的主构造函数参数。</p>
<p>编译器仅在 record 类型（record class 或 record struct 类型）中为主构造函数参数生成公共属性。对于主构造函数参数，非记录类和结构可能并不总是需要此行为。</p>
<p>主构造函数的参数位于声明类型的整个主体中。它们可以初始化属性或字段。它们可用作方法或局部函数中的变量。它们可以传递给基本构造函数。</p>
<p>主构造函数指示这些参数对于类型的任何实例是必需的。任何显式编写的构造函数都必须使用 this(...) 初始化表达式语法来调用主构造函数。这可确保主构造函数参数绝对由所有构造函数分配。对于任何 class 类型（包括 record class 类型），当主构造函数存在时，不会发出隐式无参数构造函数。对于任何 struct 类型（包括 record struct 类型），始终发出隐式无参数构造函数，并始终将所有字段（包括主构造函数参数）初始化为 0 位模式。如果编写显式无参数构造函数，则必须调用主构造函数。在这种情况下，可以为主构造函数参数指定不同的值。</p>
<p>下面看下主构造函数的应用场景</p>
<h3 id="初始化属性">初始化属性</h3>
<p>以下代码初始化从主构造函数参数计算的两个只读属性：</p>
<pre><code class="language-csharp">public readonly struct Distance(double dx, double dy)
{
public readonly double Magnitude = Math.Sqrt(dx * dx + dy * dy);
public readonly double Direction = Math.Atan2(dy, dx);
}
</code></pre>
<p>前面的代码演示了用于初始化计算的只读属性的主构造函数。 Direction 和 Magnitude 的字段初始值设定项使用主构造函数参数。主构造函数参数不会在结构中的其他任何位置使用。前面的结构就像编写了以下代码一样：</p>
<pre><code class="language-csharp">public readonly struct Distance
{
public readonly double Magnitude { get; }

public readonly double Direction { get; }

public Distance(double dx, double dy)
{
   Magnitude = Math.Sqrt(dx * dx + dy * dy);
   Direction = Math.Atan2(dy, dx);
}
}
</code></pre>
<p>当需要参数来初始化字段或属性时，利用新功能可以更轻松地使用字段初始值设定项。</p>
<h3 id="创建可变状态">创建可变状态</h3>
<p>前面的示例使用主构造函数参数来初始化只读属性。如果属性不是只读的，你还可以使用主构造函数。考虑下列代码：</p>
<pre><code class="language-csharp">public struct Distance(double dx, double dy)
{
public readonly double Magnitude => Math.Sqrt(dx * dx + dy * dy);
public readonly double Direction => Math.Atan2(dy, dx);

public void Translate(double deltaX, double deltaY)
{
   dx += deltaX;
   dy += deltaY;
}

public Distance() : this(0,0) { }
}
</code></pre>
<p>在前面的示例中，Translate 方法了更改 dx 和 dy 组件。这就需要在访问时计算 Magnitude 和 Direction 属性。 => 运算符指定一个以表达式为主体的 get 访问器，而 = 运算符指定一个初始值设定项。此版本将无参数构造函数添加到结构。无参数构造函数必须调用主构造函数，以便初始化所有主构造函数参数。</p>
<h3 id="依赖关系注入">依赖关系注入</h3>
<p>主构造函数的另一个常见用途是指定依赖项注入的参数。下面的代码创建了一个简单的控制器，使用时需要有一个服务接口：</p>
<pre><code class="language-csharp">public interface IService
{
Distance GetDistance();
}

public class ExampleController(IService service) : ControllerBase
{

public ActionResult<Distance> Get()
{
   return service.GetDistance();
}
}
</code></pre>
<p>主构造函数清楚地指明了类中所需的参数。使用主构造函数参数就像使用类中的任何其他变量一样。</p>
<h3 id="初始化基类">初始化基类</h3>
<p>可以从派生类的主构造函数调用基类的主构造函数。这是编写必须调用基类中主构造函数的派生类的最简单方法。例如，假设有一个类的层次结构，将不同的帐户类型表示为一个银行。基类类似于以下代码：</p>
<pre><code class="language-csharp">public class BankAccount(string accountID, string owner)
{
public string AccountID { get; } = accountID;
public string Owner { get; } = owner;

public override string ToString() => $"Account ID: {AccountID}, Owner: {Owner}";
}
</code></pre>
<p>一个派生类将呈现一个支票帐户：</p>
<pre><code class="language-csharp">public class CheckAccount(string accountID, string owner, decimal overdraftLimit = 0) : BankAccount(accountID, owner)
{
public decimal CurrentBalance { get; private set; } = 0;

public void Deposit(decimal amount)
{
   if (amount < 0)
   {
         throw new ArgumentOutOfRangeException(nameof(amount), "Deposit amount must be positive");
   }
   CurrentBalance += amount;
}

public void Withdrawal(decimal amount)
{
   if (amount < 0)
   {
         throw new ArgumentOutOfRangeException(nameof(amount), "Withdrawal amount must be positive");
   }
   if (CurrentBalance - amount < -overdraftLimit)
   {
         throw new InvalidOperationException("Insufficient funds for withdrawal");
   }
   CurrentBalance -= amount;
}

public override string ToString() => $"Account ID: {AccountID}, Owner: {Owner}, Balance: {CurrentBalance}";
}
</code></pre>
<h3 id="总结">总结</h3>
<p>通过合理有效地利用主构造函数，我们可以创造出更灵活、更强大、更可控的代码构造。</p>
<h2 id="集合表达式">集合表达式</h2>
<p>集合表达式引入了新的语法来创建常见的集合值。可以使用展开运算符 .. 将其他集合内联到这些值中。</p>
<p>以下示例演示了集合表达式的使用：</p>
<pre><code class="language-csharp">// Create an array:
int[] a = ;

// Create a span
Span<int> b= ['a', 'b', 'c', 'd', 'e', 'f', 'h', 'i'];

// Create a 2 D array:
int[][] twoD = [, , ];

// create a 2 D array from variables:
int[] row0 = ;
int[] row1 = ;
int[] row2 = ;
int[][] twoDFromVariables = ;

</code></pre>
<h3 id="总结-1">总结</h3>
<p>集合表达式使得代码更简洁，操作更便捷。</p>
<h2 id="默认-lambda-参数">默认 Lambda 参数</h2>
<p>现在可以为 Lambda 表达式的参数定义默认值。语法和规则与将参数的默认值添加到任何方法或本地函数相同。</p>
<pre><code class="language-csharp">Func<int, string, bool> isTooLong = (int x, string s = "") => s.Length > x;
</code></pre>
<h3 id="总结-2">总结</h3>
<p>默认 Lambda 参数，弥补了Lambda不能设置默认参数的缺陷。</p>
<h2 id="任何类型的别名">任何类型的别名</h2>
<p>可以使用 using 别名指令创建任何类型的别名，而不仅仅是命名类型。这意味着可以为元组类型、数组类型、指针类型或其他不安全类型创建语义别名。</p>
<pre><code class="language-csharp">using Point = (int x, int y);
</code></pre>
<h3 id="总结-3">总结</h3>
<p>它提供了一个简短的，由开发者提供的名称，可以用来替代那些完整的结构形式。</p>
<h2 id="内联数组inline-arrays">内联数组（Inline Arrays）</h2>
<p>运行时团队和其他库作者使用内联数组来提高应用的性能。内联数组使开发人员能够创建固定大小的 struct 类型数组。具有内联缓冲区的结构应提供类似于不安全的固定大小缓冲区的性能特征。你可能不会声明自己的内联数组，但当它们从运行时 API 作为 System.Span<t> 或 System.ReadOnlySpan<t> 对象公开时，你将透明地使用这些数组。</t></t></p>
<p>内联数组的声明类似于以下 struct：</p>
<pre><code class="language-csharp">
public struct Buffer
{
private int _element0;
}
</code></pre>
<p>它们的用法与任何其他数组类似：</p>
<pre><code class="language-csharp">var buffer = new Buffer();
for (int i = 0; i < 10; i++)
{
buffer = i;
}

foreach (var i in buffer)
{
Console.WriteLine(i);
}
</code></pre>
<p>区别在于编译器可以利用有关内联数组的已知信息。你可能会像使用任何其他数组一样使用内联数组。</p>
<h3 id="总结-4">总结</h3>
<p>内联数组对性能提高帮助很大。</p>
<h2 id="拦截器interceptors">拦截器（Interceptors）</h2>
<p>警告：本次发布的预览版引入了一项叫做interceptors（拦截器）的新功能。这项新功能主要用于一些高级场景，尤其是将会带来更好的AOT编译能力。作为.NET 8的实验性功能，在未来的版本中有可能被修改甚至删除，因此，它不应该在生产环境中使用。</p>
<p>拦截器是一种方法，该方法可以在编译时以声明方式将对可拦截方法的调用替换为对其自身的调用。通过让拦截器声明所拦截调用的源位置，可以进行这种替换。此过程可以向编译中（例如在源生成器中）添加新代码，从而提供更改现有代码语义的有限能力。</p>
<p>在源生成器中使用拦截器修改现有编译的代码，而非向其中添加代码。源生成器将对可拦截方法的调用替换为对拦截器方法的调用。</p>
<h3 id="总结-5">总结</h3>
<p>拦截器很强大，进一步了解可以参考下面连接：<br>
https://github.com/dotnet/roslyn/blob/main/docs/features/interceptors.md</p>
<h2 id="使用nameof访问实例成员">使用nameof访问实例成员</h2>
<p>曾经为了访问实例成员，你频繁地编写nameof感到非常恼火吗？好消息是，C# 12 Preview 3为你带来解决方案。让我们一起看看这个神奇的功能是如何工作的：<br>
记得以前，当尝试使用nameof关键字去访问一个实例字段时，你必须有一个对象的实例，对吧？<br>
现在，告别这些限制吧！有了C# 12 Preview 3，我们只需要类就可以做到这一点。<br>
给出一个实际的例子，让我们看看这个独特的特性在这段代码中是如何发挥作用的：</p>
<pre><code class="language-csharp">internal class NameOf
{
public string S { get; } = "";
public static int StaticField;
public string NameOfLength { get; } = nameof(S.Length);
public static void NameOfExamples()
{
   Console.WriteLine(nameof(S.Length));    // 使用`nameof`访问实例成员
   Console.WriteLine(nameof(StaticField.MinValue));// 使用`nameof`访问静态字段
}

public int StringLength(string s)
{ return s.Length; }
}
</code></pre>
<p>你看到nameof如何处理S.Length 和 StaticField.MinValue了吗？这是C# 12 Preview 3的新特性！你不需要一个实例就可以获取S.Length的名称。你也可以用nameof获取StaticField.MinValue。<br>
简单来说，想象你有一个叫做"NameOf"的玩具盒。以前，你必须爬进盒子里才能找到你最喜欢的玩具。<br>
但现在呢？你只需要告诉你的魔术盒你想要什么（比如，你想要的玩具魔方的长度，或者芭蕾舞泰迪熊的最小数量），它就会给你，都不用进去！</p>
<h3 id="总结-6">总结</h3>
<p>nameof的增强，让代码更少，逻辑更简单。</p>
<p>参考文档：<br>
https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-12</p>
<p>原文地址：https://blog.baibaomen.com/c-12-%e4%b8%ad%e7%9a%84%e6%96%b0%e5%a2%9e%e5%8a%9f%e8%83%bd/</p><br><br>
来源：https://www.cnblogs.com/baibaomen-org/p/17748318.html

頁: [1]

琼殿技术论坛's Archiver

C# 12 中的新增功能