.NET 6 中的 20 个新 API

12/13/2021 01:30:56 | China Standard Time

这篇文章将会列出一些 .NET 6 中新增的一些很棒的 API，以及一些旧 API 发生的变化，希望你可以用到。文中列出的并不完整，如果你想了解到更多的信息可以去 Github 或者 Microsoft Docs。

![](https://corehome.oss-accelerate.aliyuncs.com/blogs/773ae845-d83f-45ec-a30a-6e312f04af7c.jpg)

## DateOnly 和 TimeOnly

.NET 6 中引入的两种新类型，表示时间或日期的部分内容。

```csharp
// public DateOnly(int year, int month, int day)
// public DateOnly(int year, int month, int day, Calendar calendar)
DateOnly dateOnly = new(2021, 9, 25);
Console.WriteLine(dateOnly);
// Output: 25-Sep-21

// public TimeOnly(int hour, int minute)
// public TimeOnly(int hour, int minute, int second)
// public TimeOnly(int hour, int minute, int second, int millisecond)
// public TimeOnly(long ticks)
TimeOnly timeOnly = new(19, 0, 0);
Console.WriteLine(timeOnly);
// Output: 19:00 PM

DateOnly dateOnlyFromDate = DateOnly.FromDateTime(DateTime.Now);
Console.WriteLine(dateOnlyFromDate);
// Output: 23-Sep-21

TimeOnly timeOnlyFromDate = TimeOnly.FromDateTime(DateTime.Now);
Console.WriteLine(timeOnlyFromDate);
// Output: 21:03 PM
```

## Parallel.ForEachAsync

异步 ForEach

```csharp
var userHandlers = new[]
{
	"users/okyrylchuk",
	"users/jaredpar",
	"users/davidfowl"
};

using HttpClient client = new()
{
	BaseAddress = new Uri("https://api.github.com"),
};
client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("DotNet", "6"));

ParallelOptions options = new()
{
	MaxDegreeOfParallelism = 3
};

await Parallel.ForEachAsync(userHandlers, options, async (uri, token) =>
{
	var user = await client.GetFromJsonAsync<GitHubUser>(uri, token);
	Console.WriteLine($"Name: {user.Name}\nBio: {user.Bio}\n");
});

public class GitHubUser
{
	public string Name { get; set; }
	public string Bio { get; set; }
}

// Output:
// Name: David Fowler
// Bio: Partner Software Architect at Microsoft on the ASP.NET team, Creator of SignalR
// 
// Name: Oleg Kyrylchuk
// Bio: Software developer | Dotnet | C# | Azure
// 
// Name: Jared Parsons
// Bio: Developer on the C# compiler
```

## ArgumentNullException.ThrowIfNull()

检查空引用异常

```csharp
ExampleMethod(null);

void ExampleMethod(object param)
{
	ArgumentNullException.ThrowIfNull(param);
	// Do something
}
```

## PriorityQueue

.NET 6 中的新数据结构，优先级队列。

```csharp
PriorityQueue<string, int> priorityQueue = new();

priorityQueue.Enqueue("Second", 2);
priorityQueue.Enqueue("Fourth", 4);
priorityQueue.Enqueue("Third 1", 3);
priorityQueue.Enqueue("Third 2", 3);
priorityQueue.Enqueue("First", 1);

while (priorityQueue.Count > 0)
{
	string item = priorityQueue.Dequeue();
	Console.WriteLine(item);
}

// Output:
// First
// Second
// Third 2
// Third 1
// Fourth
```

## 新的读写文件 API

.NET 6 引入了一个新的低级 API，用于在没有 `FileStream` 的情况下读取和写入文件。
`RandomAccess` 提供了基于偏移量 API 以线程安全的方式读写入文件。

```csharp
using SafeFileHandle handle = File.OpenHandle("file.txt", access: FileAccess.ReadWrite);

// Write to file
byte[] strBytes = Encoding.UTF8.GetBytes("Hello world");
ReadOnlyMemory<byte> buffer1 = new(strBytes);
await RandomAccess.WriteAsync(handle, buffer1, 0);

// Get file length
long length = RandomAccess.GetLength(handle);

// Read from file
Memory<byte> buffer2 = new(new byte[length]);
await RandomAccess.ReadAsync(handle, buffer2, 0);
string content = Encoding.UTF8.GetString(buffer2.ToArray());
Console.WriteLine(content); // Hello world
```

## 周期计时器

异步的周期性计时器。允许异步等待计时器滴答。可以使用 `WaitForNextTickAsync` 等待计时器的下一个刻度或计时器停止。

```csharp
// One constructor: public PeriodicTimer(TimeSpan period)
using PeriodicTimer timer = new(TimeSpan.FromSeconds(1));

while (await timer.WaitForNextTickAsync())
{
	Console.WriteLine(DateTime.UtcNow);
}

// Output:
// 13 - Oct - 21 19:58:05 PM
// 13 - Oct - 21 19:58:06 PM
// 13 - Oct - 21 19:58:07 PM
// 13 - Oct - 21 19:58:08 PM
// 13 - Oct - 21 19:58:09 PM
// 13 - Oct - 21 19:58:10 PM
// 13 - Oct - 21 19:58:11 PM
// 13 - Oct - 21 19:58:12 PM
// ...
```

## Metrics

.NET 6 实现了 OpenTelemetry Metrics API 规范。你可以使用 Meter 类来创建仪表对象。

- Counter
- Histogram
- ObservableCounter
- ObservableGauge

```csharp
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Create Meter
var meter = new Meter("MetricsApp", "v1.0");
// Create counter
Counter<int> counter = meter.CreateCounter<int>("Requests");

app.Use((context, next) =>
{
	// Record the value of measurement
	counter.Add(1);
	return next(context);
});

app.MapGet("/", () => "Hello World");
StartMeterListener();
app.Run();

// Create and start Meter Listener
void StartMeterListener()
{
	var listener = new MeterListener();
	listener.InstrumentPublished = (instrument, meterListener) =>
	{
		if (instrument.Name == "Requests" && instrument.Meter.Name == "MetricsApp")
		{
			// Start listening to a specific measurement recording
			meterListener.EnableMeasurementEvents(instrument, null);
		}
	};

	listener.SetMeasurementEventCallback<int>((instrument, measurement, tags, state) =>
	{
		Console.WriteLine($"Instrument {instrument.Name} has recorded the measurement: {measurement}");
	});

	listener.Start();
}
```

## 通过反射获取可空信息

- ParameterInfo
- FieldInfo
- PropertyInfo
- EventInfo

```csharp
var example = new Example();
var nullabilityInfoContext = new NullabilityInfoContext();
foreach (var propertyInfo in example.GetType().GetProperties())
{
	var nullabilityInfo = nullabilityInfoContext.Create(propertyInfo);
	Console.WriteLine($"{propertyInfo.Name} property is {nullabilityInfo.WriteState}");
}

// Output:
// Name property is Nullable
// Value property is NotNull

class Example
{
	public string? Name { get; set; }
	public string Value { get; set; }
}
```

## 通过反射获取嵌套的可空性信息

你可以获取到嵌套的可空信息，例如数组为非 null，元素可以为 null。

```csharp
Type exampleType = typeof(Example);
PropertyInfo notNullableArrayPI = exampleType.GetProperty(nameof(Example.NotNullableArray));
PropertyInfo nullableArrayPI = exampleType.GetProperty(nameof(Example.NullableArray));

NullabilityInfoContext nullabilityInfoContext = new();

NullabilityInfo notNullableArrayNI = nullabilityInfoContext.Create(notNullableArrayPI);
Console.WriteLine(notNullableArrayNI.ReadState);              // NotNull
Console.WriteLine(notNullableArrayNI.ElementType.ReadState);  // Nullable

NullabilityInfo nullableArrayNI = nullabilityInfoContext.Create(nullableArrayPI);
Console.WriteLine(nullableArrayNI.ReadState);                // Nullable
Console.WriteLine(nullableArrayNI.ElementType.ReadState);    // Nullable

class Example
{
	public string?[] NotNullableArray { get; set; }
	public string?[]? NullableArray { get; set; }
}
```

## 进程路径和 ID

你可以更方便的获取进程路径和进程ID

```csharp
int processId = Environment.ProcessId
string path = Environment.ProcessPath;

Console.WriteLine(processId);
Console.WriteLine(path);
```

## 新的配置帮助程序

在 .NET 6 中添加了新的配置帮助程序 `GetRequiredSection`。如果缺少所需的配置，则会引发异常。

```csharp
WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
WebApplication app = builder.Build();

MySettings mySettings = new();

// Throws InvalidOperationException if a required section of configuration is missing
app.Configuration.GetRequiredSection("MySettings").Bind(mySettings);
app.Run();

class MySettings
{
	public string? SettingValue { get; set; }
}
```

## CSPNG

你可以更轻松的生成加密随机数列。它适用与：

- 密钥生成
- 某些签名方案

```csharp
// Fills an array of 300 bytes with a cryptographically strong random sequence of values.
// GetBytes(byte[] data);
// GetBytes(byte[] data, int offset, int count)
// GetBytes(int count)
// GetBytes(Span<byte> data)
byte[] bytes = RandomNumberGenerator.GetBytes(300);
```

## 本机内存 API

.NET 6 引入了一个新的 API 来分配本机内存。新的 `NativeMemory` 类型具有用于分配和释放内存的方法。

```csharp
unsafe
{
	byte* buffer = (byte*)NativeMemory.Alloc(100);

	NativeMemory.Free(buffer);

	/* This class contains methods that are mainly used to manage native memory.
	public static class NativeMemory
	{
		public unsafe static void* AlignedAlloc(nuint byteCount, nuint alignment);
		public unsafe static void AlignedFree(void* ptr);
		public unsafe static void* AlignedRealloc(void* ptr, nuint byteCount, nuint alignment);
		public unsafe static void* Alloc(nuint byteCount);
		public unsafe static void* Alloc(nuint elementCount, nuint elementSize);
		public unsafe static void* AllocZeroed(nuint byteCount);
		public unsafe static void* AllocZeroed(nuint elementCount, nuint elementSize);
		public unsafe static void Free(void* ptr);
		public unsafe static void* Realloc(void* ptr, nuint byteCount);
	}*/
}
```

## 幂运算

- `IsPow2` 可以返回指定的值是否为 2 的幂。
- `RoundUpToPowerOf2` 将指定值舍去为 2 的幂。

```csharp
// IsPow2 evaluates whether the specified Int32 value is a power of two.
Console.WriteLine(BitOperations.IsPow2(128));            // True

// RoundUpToPowerOf2 rounds the specified T:System.UInt32 value up to a power of two.
Console.WriteLine(BitOperations.RoundUpToPowerOf2(200)); // 256
```

## 异步等待任务

您可以更轻松的等待异步任务执行。当任务超时后会引发超时异常。

> 注意：这是一个不可取消的操作

```csharp
Task operationTask = DoSomethingLongAsync();

await operationTask.WaitAsync(TimeSpan.FromSeconds(5));

async Task DoSomethingLongAsync()
{
	Console.WriteLine("DoSomethingLongAsync started.");
	await Task.Delay(TimeSpan.FromSeconds(10));
	Console.WriteLine("DoSomethingLongAsync ended.");
}

// Output:
// DoSomethingLongAsync started.
// Unhandled exception.System.TimeoutException: The operation has timed out.
```

## 新的数学 API

```csharp
// New methods SinCos, ReciprocalEstimate and ReciprocalSqrtEstimate
// Simultaneously computes Sin and Cos
(double sin, double cos) = Math.SinCos(1.57);
Console.WriteLine($"Sin = {sin}\nCos = {cos}");

// Computes an approximate of 1 / x
double recEst = Math.ReciprocalEstimate(5);
Console.WriteLine($"Reciprocal estimate = {recEst}");

// Computes an approximate of 1 / Sqrt(x)
double recSqrtEst = Math.ReciprocalSqrtEstimate(5);
Console.WriteLine($"Reciprocal sqrt estimate = {recSqrtEst}");

// New overloads
// Min, Max, Abs, Clamp and Sign supports nint and nuint
(nint a, nint b) = (5, 10);
nint min = Math.Min(a, b);
nint max = Math.Max(a, b);
nint abs = Math.Abs(a);
nint clamp = Math.Clamp(abs, min, max);
nint sign = Math.Sign(a);
Console.WriteLine($"Min = {min}\nMax = {max}\nAbs = {abs}");
Console.WriteLine($"Clamp = {clamp}\nSign = {sign}");

// DivRem variants return a tuple
(int quotient, int remainder) = Math.DivRem(2, 7);
Console.WriteLine($"Quotient = {quotient}\nRemainder = {remainder}");

// Output:
// Sin = 0.9999996829318346
// Cos = 0.0007963267107331026
// Reciprocal estimate = 0.2
// Reciprocal sqrt estimate = 0.4472135954999579
// Min = 5
// Max = 10
// Abs = 5
// Clamp = 5
// Sign = 1
// Quotient = 0
// Remainder = 2
```

## CollectionsMarshal.GetValueRefOrNullRef

获取对结构体的引用，用于高性能场景。

```csharp
Dictionary<int, MyStruct> dictionary = new()
{
	{ 1, new MyStruct { Count = 100 } }
};

int key = 1;
ref MyStruct value = ref CollectionsMarshal.GetValueRefOrNullRef(dictionary, key);
// Returns Unsafe.NullRef<TValue>() if it doesn't exist; check using Unsafe.IsNullRef(ref value)
if (!Unsafe.IsNullRef(ref value))
{
	Console.WriteLine(value.Count); // Output: 100

	// Mutate in-place
	value.Count++;
	Console.WriteLine(value.Count); // Output: 101
}

struct MyStruct
{
	public int Count { get; set; }
}
```

## 配置主机选项

IHostBuilder上的新配置主机选项API。它使应用程序设置更简单。

```csharp
public class Program
{
	public static void Main(string[] args)
	{
		CreateHostBuilder(args).Build().Run();
	}

	public static IHostBuilder CreateHostBuilder(string[] args) =>
		Host.CreateDefaultBuilder(args)
			.ConfigureHostOptions(o =>
			{
				o.ShutdownTimeout = TimeSpan.FromMinutes(10);
			});
}
```

## 创建异步作用域

.NET 6 引入了一种新的CreateAsyncScope方法，用于创建AsyncServiceScope。现有的CreateScope方法会在释放IAsyncDisposable服务时引发异常。CreateAsyncScope提供了一个简单的解决方案。

```csharp
await using var provider = new ServiceCollection()
		.AddScoped<Example>()
		.BuildServiceProvider();

await using (var scope = provider.CreateAsyncScope())
{
	var example = scope.ServiceProvider.GetRequiredService<Example>();
}

class Example : IAsyncDisposable
{
	public ValueTask DisposeAsync() => default;
}
```

## 简化加密操作

- AES
- RSA
- ...

```csharp
static byte[] Decrypt(byte[] key, byte[] iv, byte[] ciphertext)
{
	using (Aes aes = Aes.Create())
	{
		aes.Key = key;
		return aes.DecryptCbc(ciphertext, iv, PaddingMode.PKCS7);
	}
}
```

01/26/2022 16:43:05

TOP