Official announcement. Net 7 preview 5

Click on the blue words above

Pay attention to our

（ Reading time of this article ：12 minute )

Today we released .NET 7 preview 5..NET 7 This preview of includes improvements to general math , It's convenient API author , Make it easier , A new ML.NET Text classification API, Add the most advanced in-depth learning technology , For natural language processing , Various improvements to the source code generator and for RegexGenerator The new Roslyn Analyzers and fixers , And in CodeGen、 Observability 、JSON serialize / Several performance improvements in deserialization and using streams .

You can download for Windows、macOS and Linux Of .NET 7 Preview 5. 

• Setup and binaries

• Container image

• Linux software package

• Release notes

• Known problem

• GitHub Problem tracker

.NET 7 preview 5 Passed Visual Studio 17.3 preview 2 To test . If you want to .NET 7 And Visual Studio Series of products , We recommend that you use the preview channel version . If you are using macOS, We suggest using the latest Visual Studio 2022 for Mac preview . Now? , Let's look at some of the latest updates in this release .

• General mathematics ：

  https://devblogs.microsoft.com/dotnet/dotnet-7-generic-math/?ocid=AID3042760

• .NET 7 Preview 5：

  https://dotnet.microsoft.com/download/dotnet/7.0?ocid=AID3042760

• Setup and binaries ：

  https://dotnet.microsoft.com/download/dotnet/7.0?ocid=AID3042760

• Container image ：

  https://mcr.microsoft.com/catalog?search=dotnet/

• Linux software package ：

  https://github.com/dotnet/core/blob/master/release-notes/7.0/

• Release notes ：

  https://github.com/dotnet/core/tree/master/release-notes/7.0

• Known problem ：

  https://github.com/dotnet/core/blob/main/release-notes/7.0/known-issues.md

• GitHub Problem tracker ：

  https://github.com/dotnet/core/issues

• Preview channel version ：

  https://visualstudio.com/preview

• Visual Studio 2022 for Mac preview ：

  https://visualstudio.microsoft.com/vs/mac/preview/

Observability  

The goal of observability is to help you better understand the state of an application as its size and technical complexity increase . 

▌ Open and efficient ActivityEvent and ActivityLink Tag enumerator methods

#68056

The exposed methods can be used to enumerate in performance critical scenarios Tag object , Without any additional allocation and fast project access .

var tags = new List<KeyValuePair<string, object?>>()
{
    new KeyValuePair<string, object?>("tag1", "value1"),
    new KeyValuePair<string, object?>("tag2", "value2"),
};


ActivityLink link = new ActivityLink(default, new ActivityTagsCollection(tags));


foreach (ref readonly KeyValuePair<string, object?> tag in link.EnumerateTagObjects())
{
    // Consume the link tags without any extra allocations or value copying.
}            


ActivityEvent e = new ActivityEvent("SomeEvent", tags: new ActivityTagsCollection(tags));


foreach (ref readonly KeyValuePair<string, object?> tag in e.EnumerateTagObjects())
{
    // Consume the event's tags without any extra allocations or value copying.
}

• Observability ：

  https://devblogs.microsoft.com/dotnet/opentelemetry-net-reaches-v1-0/?ocid=AID3042760

• #68056：

  https://github.com/dotnet/runtime/issues/68056

System.Text.Json

polymorphism  

#63747

System.Text.Json Serialization and deserialization of polymorphic type hierarchies using attribute annotations are now supported ：

[JsonDerivedType(typeof(Derived))]
public class Base
{
    public int X { get; set; }
}


public class Derived : Base
{
    public int Y { get; set; }
}

This configuration is Base Enable polymorphic serialization , Especially when the runtime type is Derived when ：

Base value = new Derived();
JsonSerializer.Serialize<Base>(value); // { "X" : 0, "Y" : 0 }

Please note that , This does not enable polymorphic deserialization , Because the payload will act as Base Back and forth ：

Base value = JsonSerializer.Deserialize<Base>(@"{ ""X"" : 0, ""Y"" : 0 }");
value is Derived; // false

▌ Use a type discriminator

To enable polymorphic deserialization , The user needs to specify a type discriminator for the derived class ：

[JsonDerivedType(typeof(Base), typeDiscriminator: "base")]
[JsonDerivedType(typeof(Derived), typeDiscriminator: "derived")]
public class Base
{
    public int X { get; set; }
}


public class Derived : Base
{
    public int Y { get; set; }
}

Will now issue JSON And type discriminator metadata ：

Base value = new Derived();
JsonSerializer.Serialize<Base>(value); // { "$type" : "derived", "X" : 0, "Y" : 0 }

Can be used for polymorphic deserialization of values ：

Base value = JsonSerializer.Deserialize<Base>(@"{ ""$type"" : ""derived"", ""X"" : 0, ""Y"" : 0 }");
value is Derived; // true

The type discriminator identifier can also be an integer , So the following form is valid ：

[JsonDerivedType(typeof(Derived1), 0)]
[JsonDerivedType(typeof(Derived2), 1)]
[JsonDerivedType(typeof(Derived3), 2)]
public class Base { }


JsonSerializer.Serialize<Base>(new Derived2()); // { "$type" : 1, ... }

• #63747：

  https://github.com/dotnet/runtime/issues/63747

▌Utf8JsonReader.CopyString

#54410

Until today, ,Utf8JsonReader.GetString() The user has been using the decoded JSON The only way to string . This will always assign a new string , This may not be appropriate for some performance sensitive applications . Newly included CopyString Method allows you to set an escaped UTF-8 or UTF-16 The string is copied to the user owned buffer ：

int valueLength = reader.HasReadOnlySequence ? checked((int)ValueSequence.Length) : ValueSpan.Length;
char[] buffer = ArrayPool<char>.Shared.Rent(valueLength);
int charsRead = reader.CopyString(buffer);
ReadOnlySpan<char> source = buffer.Slice(0, charsRead);


ParseUnescapedString(source); // handle the unescaped JSON string
ArrayPool<char>.Shared.Return(buffer);

Or if you deal with UTF-8 preferable ：

ReadOnlySpan<byte> source = stackalloc byte[0];
if (!reader.HasReadOnlySequence && !reader.ValueIsEscaped)
{
    source = reader.ValueSpan; // No need to copy to an intermediate buffer if value is span without escape sequences
}
else
{
    int valueLength = reader.HasReadOnlySequence ? checked((int)ValueSequence.Length) : ValueSpan.Length;
    Span<byte> buffer = valueLength <= 256 ? stackalloc byte[256] : new byte[valueLength];
    int bytesRead = reader.CopyString(buffer);
    source = buffer.Slice(0, bytesRead);
}


ParseUnescapedBytes(source);

• #54410：

  https://github.com/dotnet/runtime/issues/54410

• Utf8JsonReader.GetString()：

  https://docs.microsoft.com/dotnet/api/system.text.json.utf8jsonreader.getstring?view=net-6.0?ocid=AID3042760

▌ Source generation improvements

Added right IAsyncEnumerable<T> (#59268)、JsonDocument(#59954) and DateOnly/TimeOnly(#53539) Type source code generation support . 

for example ：

[JsonSerializable(typeof(typeof(MyPoco))]
public class MyContext : JsonSerializerContext {}


public class MyPoco
{
    // Use of IAsyncEnumerable that previously resulted 
    // in JsonSerializer.Serialize() throwing NotSupportedException 
    public IAsyncEnumerable<int> Data { get; set; } 
}


// It now works and no longer throws NotSupportedException
JsonSerializer.Serialize(new MyPoco { Data = ... }, MyContext.MyPoco);

• #59268:

  https://github.com/dotnet/runtime/issues/59268

• #59954:

  https://github.com/dotnet/runtime/issues/59954

• #53539：

  https://github.com/dotnet/runtime/issues/53539

System.IO.Stream

ReadExactly and ReadAtLeast 

#16598

Use Stream.Read() One of the most common mistakes is Read() The returned data may be larger than Stream There is less data available in , And the data is less than the incoming buffer . Even for programmers who are aware of this , Every time they want to start from Stream It is annoying to write the same loop when reading from .

To solve this situation , We are System.IO.Stream New methods have been added to the base class ：

namespace System.IO;


public partial class Stream
{
    public void ReadExactly(Span<byte> buffer);
    public void ReadExactly(byte[] buffer, int offset, int count);


    public ValueTask ReadExactlyAsync(Memory<byte> buffer, CancellationToken cancellationToken = default);
    public ValueTask ReadExactlyAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken = default);


    public int ReadAtLeast(Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true);
    public ValueTask<int> ReadAtLeastAsync(Memory<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default);
}

new ReadExactly Method to ensure that the number of bytes requested is read accurately . If the stream ends before reading the requested bytes , Throw out EndOfStreamException.

using FileStream f = File.Open("readme.md");
byte[] buffer = new byte[100];


f.ReadExactly(buffer); // guaranteed to read 100 bytes from the file

new ReadAtLeast Method will read at least the requested number of bytes . If more data is available , It can read more data , Until the size of the buffer . If the stream ends before reading the requested bytes , Will trigger EndOfStreamException（ In advanced cases , When you want ReadAtLest But you also want to handle the end of flow scenario yourself , You can choose not to throw an exception ）.

using FileStream f = File.Open("readme.md");
byte[] buffer = new byte[100];


int bytesRead = f.ReadAtLeast(buffer, 10);
// 10 <= bytesRead <= 100

• #16598：

  https://github.com/dotnet/runtime/issues/16598

RegexGenerator The new Roslyn Analyzers and fixers  

#69872 

stay .NET 7 Regular expression improvement in ,Stephen Toub Describes the new RegexGenerator Source generator , It allows you to statically generate regular expressions at compile time , For better performance . Take advantage of this , First you must find a place in your code where you can use it , Then make changes to each code . It sounds like Roslyn The analyzer and fixer work perfectly , So we are Preview 5 Added a .

▌ Analyzer

The new parser is included in .NET 7 in , Search can be converted to use RegexGenerator Source generator Regex purpose . The analyzer will detect Regex The use of constructors , And if the following conditions are met Regex Use of static methods ：

The supplied parameter has a known value at compile time . The output of the source code generator depends on these values , So you must know them at compile time .

They are oriented to .NET 7 Part of the application . The new parser is included in .NET 7 In the target package , Only face .NET 7 Your application is qualified to use this analyzer .

LangVersion（ Learn more about ） higher than 10. At present, the regular expression source generator needs to LangVersion Set to preview .

Here is Visual Studio New profiler running in ：

• #69872：

  https://github.com/dotnet/runtime/pull/69872

• .NET 7 Regular expression improvement in ,Stephen Toub Describes the new RegexGenerator Source generator ：

  https://devblogs.microsoft.com/dotnet/regular-expression-improvements-in-dotnet-7/#source-generation?ocid=AID3042760

• Learn more about ：

  https://docs.microsoft.com/dotnet/csharp/language-reference/configure-language-version?ocid=AID3042760

▌ Code fixer

Code fixes are also included in .NET 7 in , It does two things . First , It is recommended to use RegexGenerator Source generator methods , And gives you the option to override the default name . It then replaces the original code with a call to the new method .

Here are Visual Studio New code fixes running in ：

General mathematics  

stay .NET 6 in , We previewed a project called Generic Math The function of , It allows the .NET Developers take advantage of static... In common code API, Including operators . This function will directly make it possible to simplify the code base API The author benefits . Other developers will benefit indirectly , Because they use API Will begin to support more types , Instead of requiring explicit support for every numeric type . 

stay .NET 7 in , We improved the implementation and responded to feedback from the community . About changes and availability API For more information , See our general math specific bulletin .

• Generic Math：

  https://devblogs.microsoft.com/dotnet/preview-features-in-net-6-generic-math/?ocid=AID3042760

• General math specific bulletin ：

  https://devblogs.microsoft.com/dotnet/dotnet-7-generic-math/?ocid=AID3042760

System.Reflection Performance improvements when invoking members  

#67917 

When the same member is called multiple times , Use reflection to call members （ No matter the method 、 Constructor or attribute gettersetter） The cost of has been greatly reduced . Typical fast gain 3-4 times .

Use BenchmarkDotNet package ：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Reflection;


namespace ReflectionBenchmarks
{
    internal class Program
    {
        static void Main(string[] args)
        {
            BenchmarkRunner.Run<InvokeTest>();
        }
    }


    public class InvokeTest
    {
        private MethodInfo? _method;
        private object[] _args = new object[1] { 42 };


        [GlobalSetup]
        public void Setup()
        {
            _method = typeof(InvokeTest).GetMethod(nameof(InvokeMe), BindingFlags.Public | BindingFlags.Static)!;
        }


        [Benchmark]
        // *** This went from ~116ns to ~39ns or 3x (66%) faster.***
        public void InvokeSimpleMethod() => _method!.Invoke(obj: null, new object[] { 42 });


        [Benchmark]
        // *** This went from ~106ns to ~26ns or 4x (75%) faster. ***
        public void InvokeSimpleMethodWithCachedArgs() => _method!.Invoke(obj: null, _args);


        public static int InvokeMe(int i) => i;
    }
}

• #67917 ：

  https://github.com/dotnet/runtime/pull/67917

ML.NET Text classification API

Text categorization is the process of applying labels or categories to text .

Common use cases include ：

• Classify e-mail as spam or non spam

• Analyze whether the emotion is positive or negative from the customer's comments

• Apply tags to support work orders

Text categorization is a subset of categorization , So today you can use ML.NET To solve the problem of text classification . However , These algorithms do not solve the common challenges of text classification and modern deep learning technology .

We are happy to launch ML.NET Text classification API, The API Make it easier for you to train a custom text classification model , And introduce the latest and most advanced deep learning technology for naturallanguageprocessing ML.NET.

For more details , Please refer to our ML.NET Specific announcements .

• ML.NET Specific announcements ：

  https://devblogs.microsoft.com/dotnet/introducing-the-ml-dotnet-text-classification-api-preview/?ocid=AID3042760

Code generation

Many thanks to the community contributors .

@singleaccretion In the preview 5 During this period, we made 23 term PR contribution , The highlight is ： 

Improve redundant branch optimization to handle more side effects #68447

PUTARG_STK/x86: Mark push [mem] The candidate reg Optional #68641

stay LCL_FLD Replication propagation on #68592

@Sandreenko Completion allows StoreLclVar src Become IND/FLD #[email protected] Repair the #68475 Medium CircleInConvex test .

come from @anthonycanino、@aromaa and @ta264 More contributions are included in the following sections .

▌Arm64

#68363 Merge “msub”（ Multiply the two register values , Subtract the product from the third register value ） and “madd”（ Multiply the two register values , Add a third register value ） Logic .

Arm64： Give Way CpBlkUnroll and InitBlkUnroll Use SIMD Register to initialize replication less than 128 Byte memory block （ See performance improvement details ）.

▌ Cycle optimization

#67930 More scenarios that deal with circular cloning now support > 1 A backward or forward loop of increments （ See performance improvement details ）.

#68588 promote “this” Null value checking of objects moves null value checking to objects outside the loop （ See performance improvement details ）.

• @singleaccretion:

  https://github.com/singleaccretion

• 23 term PR contribution :

  https://github.com/dotnet/runtime/pulls?q=is%3Apr+is%3Aclosed+label%3Aarea-CodeGen-coreclr+closed%3A2022-04-18..2022-05-24+author%3Asingleaccretion+

• #68447:

  https://github.com/dotnet/runtime/pull/68447

• #68641:

  https://github.com/dotnet/runtime/pull/68641

• #68592:

  https://github.com/dotnet/runtime/pull/68592

• @Sandreenko:

  https://github.com/Sandreenko

• #59315:

  https://github.com/dotnet/runtime/pull/59315

• @hez2010:

  https://github.com/hez2010

• #68475:

  https://github.com/dotnet/runtime/pull/68475

• @anthonycanino:

  https://github.com/anthonycanino

• @aromaa:

  https://github.com/aromaa

• @ta264:

  https://github.com/ta264

• #68363:

  https://github.com/dotnet/runtime/pull/68363

• Arm64： Give Way CpBlkUnroll and InitBlkUnroll Use SIMD register :

  https://github.com/dotnet/runtime/pull/68085

• Performance improvement details :

  https://pvscmdupload.blob.core.windows.net/autofilereport/autofilereports/04_28_2022/refs/heads/main_arm64_Windows 10.0.19041_Improvement/System.Numerics.Tests.Perf_Matrix4x4.html

• #67930 Dealing with more scenes of circular cloning :

  https://github.com/dotnet/runtime/pull/67930

• #68588 promote “this” Null value check of object :

  https://github.com/dotnet/runtime/pull/68588

• Performance improvement details :

  https://pvscmdupload.blob.core.windows.net/autofilereport/autofilereports/05_03_2022/refs/heads/main_x64_Windows 10.0.18362_Improvement/System.Text.Encodings.Web.Tests.Perf_Encoders.html

x86/x64 Optimize  

• #67182 stay x64 Admiral shlx、sarx、shrx Optimize to x64 Upper mov+shl、sar or shr To shlx、sarx or shrx.

• #68091 by x64 To enable the UMOD Optimize .

• @anthonycanino stay #68677 Added in X86Serialize Inherent in the hardware .

• @aromaa stay #66965 Lieutenant general bswap+mov Optimize to movbe.

• @ta264 Repair the #68046 in clr.alljits Subset of linux-x86 compile .

• #67182 stay x64 Admiral shlx：

  https://github.com/dotnet/runtime/pull/67182

• sarx：

  https://github.com/dotnet/runtime/pull/67182

• shrx Optimize to x64 :

  https://github.com/dotnet/runtime/pull/67182

• #68091：

  https://github.com/dotnet/runtime/pull/68091

• @anthonycanino ：

  https://github.com/anthonycanino

• #68677 ：

  https://github.com/dotnet/runtime/pull/68677

• @aromaa ：

  https://github.com/aromaa

• #66965：

  https://github.com/dotnet/runtime/pull/66965

• @ta264：

  https://github.com/ta264

• #68046 :

  https://github.com/dotnet/runtime/pull/68046

General optimization

• PR#68105 Multiple nested... Are enabled “no GC” Area request .

• PR#69034 Deleted “ Raise the parameters ” Tail call limit .

• PR#68105：

  https://github.com/dotnet/runtime/pull/68105

• PR#69034 ：

  https://github.com/dotnet/runtime/pull/69034

modernization JIT

As the community increases its awareness of JIT The contribution of the code base , It becomes very important to reorganize and modernize our code base so that our contributors can easily add and quickly develop code . 

stay Preview 5 in , We have done a lot of work internally , Cleaned up JIT In the middle of , And eliminates the limitations of past design decisions . in many instances , This work led to JIT It uses less memory and has higher throughput , And in other cases , It leads to better code quality . Here are some highlights ： 

• Delete CLS_VAR #68524

• Delete GT_ARGPLACE #68140

• Delete GT_PUTARG_TYPE #68748

The above allows us to use byte/sbyte/short/ushort Eliminate when inlining a function with arguments of type JIT Old restrictions in inlining , To improve code quality （ Allow inline substitution of small parameters #69068）

One area that needs improvement is a better understanding of unsafe code that involves reading and writing structures and structure fields [email protected] By way of JIT The internal model is transformed into a more general “ Physics ” Model , Great changes have been made in this field . This is JIT Use struct reinterpretation And other functions pave the way for better reasoning about unsafe code ：

• Physical value number #68712

• by VNF_BitCast Implement constant folding #68979

• Other small cleanups have been made to simplify JIT IR：

• Delete GTF_LATE_ARG #68617

• Replace... In inline candidate parameters GT_RET_EXPR #69117

• stay LIR #68460 Delete the store as the operand of the call

• #68524：

  https://github.com/dotnet/runtime/pull/68524

• #68140：

  https://github.com/dotnet/runtime/pull/68140

• #68748：

  https://github.com/dotnet/runtime/pull/68748

• #69068：

  https://github.com/dotnet/runtime/pull/69068

• @SingleAccretion ：

  https://github.com/SingleAccretion

• #68712：

  https://github.com/dotnet/runtime/pull/68712

• #68979：

  https://github.com/dotnet/runtime/pull/68979

• #68617：

  https://github.com/dotnet/runtime/pull/68617

• #69117：

  https://github.com/dotnet/runtime/pull/69117

• #68460 ：

  https://github.com/dotnet/runtime/pull/68460

Enable library pruning

As we described before , Trim let SDK Remove unused code from your self-contained application , To make them smaller . however , Pruning warnings may indicate that the application is incompatible with pruning . To make the application compatible , All references to them must also be compatible .

So , We need the library to also use pruning . In the preview 5 in , We try to use Roslyn The analyzer makes it easier to find and fix pruning warnings in the library . To view the pruning warnings for the library , Please put <IsTrimmable>true</IsTrimmable> Add to project file . After fixing the warning , Applications pruned with your library will be smaller and compatible with pruning . See preparing .NET Library for trimming - .NET | Microsoft Docs Learn more about Library pruning .

• trim ：

  https://docs.microsoft.com/dotnet/core/deploying/trimming/trim-self-contained?ocid=AID3042760

• See preparing .NET Library for trimming - .NET | Microsoft Docs ：

  https://docs.microsoft.com/en-us/dotnet/core/deploying/trimming/prepare-libraries-for-trimming?ocid=AID3042760

oriented .NET 7

Face .NET 7, You need to use... In the project file .NET 7 Target Framework Moniker (TFM). for example ： 

<TargetFramework>net7.0</TargetFramework>

full set .NET 7 TFM, Include operation specific TFM.

• net7.0

• net7.0- Android

• net7.0-ios

• net7.0-maccatalyst

• net7.0-macos

• net7.0-tvos

• net7.0-windows

We hope from .NET 6 Upgrade to .NET 7 It should be very simple . Please report that you are using .NET 7 Any significant changes found during testing of existing applications .

Support

.NET 7 It's a Short term support (STS) edition , This means that it will start from the date of release 18 Get free support and patches within months . It should be noted that , The quality of all versions is the same . The only difference is the length of the support . of .NET More information on supporting policies , see also .NET and .NET Core Official support policy .

We are going to “Current At present ” Change the name to “ Short term support (STS)”. We are introducing this change .

• .NET and .NET Core Official support policy ：

  https://dotnet.microsoft.com/platform/support/policy/dotnet-core?ocid=AID3042760

• Introduce this change ：

  https://github.com/dotnet/core/pull/7517

Major changes

 

You can read through .NET 7 Major changes in the document to find the latest .NET 7 List of major changes . It lists major changes by region and version , With links to detailed instructions .

To see what major changes have been proposed but are still under review , Please pay attention to Proposed .NET Breaking Changes GitHub problem .

• .NET 7 List of major changes ：

  https://docs.microsoft.com/dotnet/core/compatibility/7.0?ocid=AID3042760

• Proposed .NET Breaking Changes GitHub problem ：

  https://github.com/dotnet/core/issues/7131

The roadmap

.NET Version includes products 、 library 、 Runtime and tools , On behalf of Microsoft Collaboration between internal and external teams . You can learn more about these areas by reading the product roadmap ：

• ASP.NET Core 7 and Blazor The roadmap

• EF 7 The roadmap

• Machine learning network

• .NET MAUI

• WinForms

• WPF

• NuGet

• Roslyn

• Runtime

• ASP.NET Core 7 and Blazor The roadmap ：

  https://github.com/dotnet/aspnetcore/issues/39504

• EF 7 The roadmap ：

  https://docs.microsoft.com/ef/core/what-is-new/ef-core-7.0/plan

• Machine learning network ：

  https://github.com/dotnet/machinelearning/blob/main/ROADMAP.md

• .NET MAUI：

  https://github.com/dotnet/maui/wiki/Roadmap

• WinForms：

  https://github.com/dotnet/winforms/blob/main/docs/roadmap.md

• WPF：

  https://github.com/dotnet/wpf/blob/main/roadmap.md

• NuGet：

  https://github.com/NuGet/Home/issues/11571

• Roslyn：

  https://github.com/dotnet/roslyn/blob/main/docs/Language Feature Status.md

• Runtime：

  https://github.com/dotnet/core/blob/main/roadmap.md

We thank you for your interest in .NET All the support and contribution of . Please try .NET 7 Preview 5 And tell us what you think ！

• thank ：

  https://dotnet.microsoft.com/thanks?ocid=AID3042760

• Try .NET 7 Preview 5：

  https://dotnet.microsoft.com/download/dotnet/7.0?ocid=AID3042760