We are delighted to release .NET 6 Preview 7. It is the last preview before we enter the (two) Release Candidate (RC) period. The team has been burning the midnight oil and the candle at both ends getting the last set of features in before we slow the speed down on the release. It’s also the release where you will see the last bit of polish on various features and large it-took-the-whole-release features come in all at once. From this point, the team will be focused on bringing all the features to uniform (high) quality so that .NET 6 is ready for your production workloads.<\/p>\n
On the topic of production workloads, it’s worth reminding everyone that both the .NET website<\/a> and Bing.com<\/a> have been running on .NET 6 since Preview 1. We’re in talks with various teams (Microsoft and otherwise) about going into production with the .NET 6 RCs. If you are interested in that and want guidance on how to approach that, please reach out at dotnet@microsoft.com. We’re always happy to talk to early adopters.<\/p>\n You can download .NET 6 Preview 7<\/a> for Linux, macOS, and Windows.<\/p>\n See the .NET MAUI<\/a> and ASP.NET Core<\/a> for more detail on what\u2019s new for client and web application scenarios.<\/p>\n .NET 6 Preview 7 has been tested and is supported with Visual Studio 2022 Preview 3<\/a>. Visual Studio 2022 enables you to leverage the Visual Studio tools developed for .NET 6 such as development in .NET MAUI, Hot Reload for C# apps, new Web Live Preview for WebForms, and other performance improvements in your IDE experience. .NET 6 is also supported with Visual Studio Code<\/a>. The latest version of the C# extension for Visual Studio Code<\/a> has been updated for .NET 6 Preview 7 and includes support for C# 10.<\/p>\n Check out the new conversations posts<\/a> for in-depth engineer-to-engineer discussions on the latest .NET features. We also published posts on String Interpolation in C# 10 and .NET 6<\/a>\u00a0 Preview Features in .NET 6 \u2013 Generic Math<\/a>.<\/p>\n We updated .NET SDK templates<\/a> to use the latest C# language features and patterns. We hadn’t revisited the templates in terms of new language features in a while. It was time to do that and we’ll ensure that the templates use new and modern features going forward.<\/p>\n The following language features are used in the new templates:<\/p>\n You might wonder why we enable certain features via templates instead of enabling them by default when a project targets .NET 6. We’re OK with requiring some amount of work on your part to upgrade applications to a new version of .NET as a tradeoff for improving the default behavior of the platform. This allows us improve the product without complicating project files over time. However, some features can be quite disruptive with that model, such as nullable reference types. We don’t want to tie those features to the upgrade experience, but want to leave that choice to you, both when and if ever. The templates are a much lower risk pivot point, where we’re able to set what the new “good default model” is for new code without nearly as much downstream consequence. By enabling these features via project templates, we’re getting the best of both worlds: new code starts with these features enabled but existing code isn’t impacted when you upgrade.<\/p>\n The The .NET 5 version of the same template includes several lines of familiar ceremony that provide the structure previously necessary for even a single line of actual code.<\/p>\n The project file for the Other templates also enable nullability, implicit global usings, and file scoped namespaces, including ASP.NET Core and Class Library.<\/p>\n The The See the following documents for compatibility concerns with using the new templates.<\/p>\n Nullable reference types<\/a> is an important feature for writing reliable code. It works great for writing code but not (until now) for inspecting it. New Reflection APIs<\/a> enable you to determine the nullability nature of parameters and return values for a given method. These new APIs will be critical for Reflection-based tools and serializers, for example.<\/p>\n For context, we added nullable annotations to the .NET Libraries<\/a> in .NET 5 (and finished up in .NET 6) and are in the process of doing same with ASP.NET Core<\/a> this release. We also see developers adopting nullability<\/a> for their projects.<\/p>\n Nullability information is persisted in metadata using custom attributes<\/a>. In principle, anyone can already read the custom attributes, however, this is not ideal because the encoding is non-trivial to consume.<\/p>\n The following examples demonstrate using the new APIs for a couple different scenarios.<\/p>\n Imagine you’re implementing a serializer. Using these new APIs the serializer can check whether a given property can be set to Nullability has special treatment for objects that can (formally) hold other objects, like arrays and tuples. For example, you can specify that an array object (as a variable, or as part of a type member signature) must be non-null but that the elements can be null, or vice versa. This extra level of specificity is inspectable with the new Reflection APIs, as you see demonstrated in the following example.<\/p>\n The If a zip archive doesn’t contain file permissions (because it was created on Windows, or using a tool which didn’t capture the permissions, like an earlier version of .NET) extracted files get the default file permissions, just like any other newly created file.<\/p>\n The Unix file permissions work with other zip archive tools as well, including:<\/p>\n For .NET 6, we’ve built the capability to mark APIs as “in preview”<\/a>. This new approach will allow us to offer and evolve preview features across multiple major releases. In order to use preview APIs, projects need to explicitly opt-into using preview features. If you use preview features without explicitly opting-in, you will see build errors with actionable messages, starting in .NET 6 RC1. Preview features are expected to change, likely in breaking ways, in later releases. That’s why they are opt-in.<\/p>\n One of those features we’re previewing in .NET 6 is static abstract interface members. Those allow you to define static abstract methods (including operators) in interfaces. For example, it is now possible to implement algebraic generic methods. For some folks, this feature will be the absolute standout improvement we’re delivering this year. It is perhaps the most important new type system capability since The following example takes an This works because This is all powered by a new feature which allows All of the features mentioned are in preview for .NET 6 and not supported for use in production. We would appreciate your feedback using them. We intend to continue evolving and improving the generic math features and the runtime and C# features that support them in .NET 7. We expect to make breaking changes to the current experience, and that’s part of the reason why the new APIs are marked as “in preview”.<\/p>\n We added new native memory allocation APIs<\/a> exposed via You may be wondering about how to think about these APIs. First, they are low-level APIs that are intended for low-level code and algorithms. Application developers would rarely if ever use these. Another way to think about these APIs is similarly to the platform intrinsic<\/a> APIs, which are low-level .NET APIs for chip instructions. These APIs are similar but expose low-level APIs for memory-related operations.<\/p>\n The System.Text.Json serializer now exposes notifications as part of (de)serialization operations. They are useful for defaulting values and validation. To use them, implement one or more of the interfaces Here’s an example that validates during both Previously, you would need to implement a custom converter to achieve this functionality.<\/p>\n We’ve also added the ability to control the serialization order of properties, with Here’s an example that specifies JSON should be serialized in the order Previously, the serialization order was determined by reflection order which was neither deterministic nor resulting in a specific desired order.<\/p>\n There are times when you need to integrate “raw” JSON when writing JSON payloads<\/a> with Utf8JsonWriter.<\/p>\n For example:<\/p>\n The following is a description of what the code above — particularly We’ve added new synchronous APIs<\/a> to These new synchronous APIs include overloads that are compatible and usable with the new System.Text.Json source generator<\/a>, by accepting Support for the C# This change is considered a breaking change<\/a> from a .NET 6 preview to preview standpoint but not from .NET 5 to 6.<\/p>\n We’ve been improving support for OpenTelemetry<\/a> over the last couple years. One of the key aspects of enabling great support is ensuring that all components that need to participate in telemetry production produce network headers in the right format. It’s really hard to do that, particularly as the OpenTelemetry specification changes. OpenTelemetry defines the propagation<\/a> concept to help with this situation. We’re in the process of adopting propagation<\/a> to enable a general model for header customization.<\/p>\n Context on the broader concepts:<\/p>\n The following code demonstrates the general approach for using propagation.<\/p>\n You can also choose to use a different propagator.<\/p>\n The Most application code does not need to directly use this feature, however, it is likely that you will see it in a call-stack if you use OpenTelemetry. Some library code will want to participate in this model if it cares about tracing and causality.<\/p>\n The .NET encryption and decryption routines were designed around streaming, with no real concept for defining when the payload is already in memory. The new Encrypt- and Decrypt- methods on The new simplified methods offer a straightforward approach to using cryptographic APIs:<\/p>\n With the new Encrypt- and Decrypt-methods, only the key property is used from the SymmetricAlgorithm instance. The new DecryptCbc method supports choosing the padding algorithm, but PKCS#7 is used with CBC so often that it’s a default argument. If you like the clarity, just specify it:<\/p>\n You can see that the existing pattern — with .NET 5 — required significantly more plumbing for the same outcome.<\/p>\n Globalization Invariant Mode<\/a> enables you to remove application dependencies on globalization data and behavior in exchange for smaller applications (primarily on Linux). We’ve improved Globalization Invariant Mode<\/a> to support case mapping of the full Unicode character set. Previously, this mode only supported ASCII range characters for operations like Alpine-based .NET container images are the only environment where we enable globalization environment mode by default<\/a>.<\/p>\n The runtime now has a mode in which it doesn’t create or use any memory pages that are writeable and executable at the same time. All executable memory is mapped as read-execute only. This feature was enabled on macOS — for Apple Silicon — earlier in the release. On Apple Silicon machines, memory mappings that are writeable and executable at the same time are prohibited.<\/p>\n This capability is now enabled and supported on all other platforms as an opt-in experience. On these platforms, executable code generation \/ modification is done via separate read-write memory mappings. This is true for both JIT’d code and runtime-generated helpers. These mappings are created at virtual memory addresses that are different from the executable code address and exist only for a very brief period of time when the writing is performed. For example, the JIT now generates code into a scratch buffer that is copied into the executable memory using a single memory copy function call after the whole method is jitted. And the writeable mapping lifetime spans only the time of the memory copy.<\/p>\n This new feature can be enabled by setting the environment variable The following changes were made in code generation in Preview 7.<\/p>\n The following PRs were all from @SingleAccretion<\/a>:<\/p>\n The following PRs support the dynamic PGO project<\/a>.<\/p>\n\n
.NET SDK: C# project templates modernized<\/h2>\n
\n
Console template<\/h3>\n
console<\/code> template demonstrates the biggest change. It’s now (effectively) a one-liner by virtue of top-level statements and global using directives.<\/p>\n\/\/ See https:\/\/aka.ms\/new-console-template for more information\r\nConsole.WriteLine(\"Hello, World!\");<\/code><\/pre>\nusing System;\r\n\r\nnamespace Company.ConsoleApplication1\r\n{\r\n class Program\r\n {\r\n static void Main(string[] args)\r\n {\r\n Console.WriteLine(\"Hello, World!\");\r\n }\r\n }\r\n}<\/code><\/pre>\nconsole<\/code> template has also changed, to enable the nullable reference types<\/a> feature, as you can see in the following example.<\/p>\n<Project Sdk=\"Microsoft.NET.Sdk\">\r\n\r\n <PropertyGroup>\r\n <OutputType>Exe<\/OutputType>\r\n <TargetFramework>net6.0<\/TargetFramework>\r\n <Nullable>enable<\/Nullable>\r\n <\/PropertyGroup>\r\n\r\n<\/Project><\/code><\/pre>\nASP.NET web template<\/h3>\n
web<\/code> template is also similarly reduced in lines of code, using the same features.<\/p>\nvar builder = WebApplication.CreateBuilder(args);\r\nvar app = builder.Build();\r\n\r\nif (app.Environment.IsDevelopment())\r\n{\r\n app.UseDeveloperExceptionPage();\r\n}\r\n\r\napp.MapGet(\"\/\", () => \"Hello World!\");\r\n\r\napp.Run();<\/code><\/pre>\nASP.NET MVC template<\/h3>\n
mvc<\/code> template is similar in structure. In this case, we’ve merged Program.cs<\/code> and Startup.cs<\/code> into a single file (Program.cs<\/code>), creating a further simplification.<\/p>\nvar builder = WebApplication.CreateBuilder(args);\r\n\r\n\/\/ Add services to the container.\r\nbuilder.Services.AddControllersWithViews();\r\n\r\nvar app = builder.Build();\r\n\r\n\/\/ Configure the HTTP request pipeline.\r\nif (app.Environment.IsDevelopment())\r\n{\r\n app.UseDeveloperExceptionPage();\r\n}\r\nelse\r\n{\r\n app.UseExceptionHandler(\"\/Home\/Error\");\r\n \/\/ The default HSTS value is 30 days. You may want to change this for production scenarios, see https:\/\/aka.ms\/aspnetcore-hsts.\r\n app.UseHsts();\r\n}\r\n\r\napp.UseHttpsRedirection();\r\napp.UseStaticFiles();\r\n\r\napp.UseRouting();\r\n\r\napp.UseAuthorization();\r\n\r\napp.MapControllerRoute(\r\n name: \"default\",\r\n pattern: \"{controller=Home}\/{action=Index}\/{id?}\");\r\n\r\napp.Run();<\/code><\/pre>\nTemplate compatibility<\/h3>\n
\n
Libraries: Reflection APIs for nullability information<\/h2>\n
Getting top-level nullability information<\/h3>\n
null<\/code>:<\/p>\nprivate NullabilityInfoContext _nullabilityContext = new NullabilityInfoContext();\r\n\r\nprivate void DeserializePropertyValue(PropertyInfo p, object instance, object? value)\r\n{\r\n if (value is null)\r\n {\r\n var nullabilityInfo = _nullabilityContext.Create(p);\r\n if (nullabilityInfo.WriteState is not NullabilityState.Nullable)\r\n {\r\n throw new MySerializerException($\"Property '{p.GetType().Name}.{p.Name}'' cannot be set to null.\");\r\n }\r\n }\r\n\r\n p.SetValue(instance, value);\r\n}<\/code><\/pre>\nGetting nested nullability information<\/h3>\n
class Data\r\n{\r\n public string?[] ArrayField;\r\n public (string?, object) TupleField;\r\n}\r\nprivate void Print()\r\n{\r\n Type type = typeof(Data);\r\n FieldInfo arrayField = type.GetField(\"ArrayField\");\r\n FieldInfo tupleField = type.GetField(\"TupleField\");\r\n\r\n NullabilityInfoContext context = new ();\r\n\r\n NullabilityInfo arrayInfo = context.Create(arrayField);\r\n Console.WriteLine(arrayInfo.ReadState); \/\/ NotNull\r\n Console.WriteLine(arrayInfo.Element.State); \/\/ Nullable\r\n\r\n NullabilityInfo tupleInfo = context.Create(tupleField);\r\n Console.WriteLine(tupleInfo.ReadState); \/\/ NotNull\r\n Console.WriteLine(tupleInfo.GenericTypeArguments [0].State); \/\/ Nullable\r\n Console.WriteLine(tupleInfo.GenericTypeArguments [1].State); \/\/ NotNull\r\n}<\/code><\/pre>\nLibraries: ZipFile Respects Unix File Permissions<\/h2>\n
System.IO.Compression.ZipFile<\/code> class now captures Unix file permissions during create and set file permissions when extracting zip archives on Unix-like operating systems. This change allows for executable files to be round-tripped through a zip archive, which means you no longer have to modify file permissions to make files executable after extracting a zip archive. It also respects the read\/write permissions for user<\/code>, group<\/code>, and other<\/code> as well.<\/p>\n\n
Early .NET 7 Feature Preview: Generic Math<\/h2>\n
Span<T><\/code>.<\/p>\nIEnumerable<T><\/code> and is able to sum all the values due to the T<\/code> being constrained to INumber<T><\/code>, possibly an INumber<int><\/code>.<\/p>\npublic static T Sum<T>(IEnumerable<T> values)\r\n where T : INumber<T>\r\n{\r\n T result = T.Zero;\r\n\r\n foreach (var value in values)\r\n {\r\n result += value;\r\n }\r\n\r\n return result;\r\n}<\/code><\/pre>\nINumber<T><\/code><\/a> defines various (static) operator overloads<\/a> that must be satisfied by interface implementors. The IAdditionOperators<\/code><\/a> is perhaps the easiest new interface to understand, which INumber<T><\/code> itself is derived from.<\/p>\nstatic abstract<\/code> members to be declared in interfaces. This enables interfaces to expose operators and other static methods, such as Parse<\/code> or Create<\/code>, and for those to be implemented by a derived type. Please see our associated blog post<\/a> for more details!<\/p>\nLibraries: NativeMemory APIs<\/h2>\n
System.Runtime.InteropServices.NativeMemory<\/code>. These APIs represent equivalents to the malloc<\/code>, free<\/code>, realloc<\/code>, and calloc<\/code> C APIs and also includes APIs for doing aligned allocations.<\/p>\nLibraries: System.Text.Json serialization notifications<\/h2>\n
IJsonOnDeserialized<\/code>, IJsonOnDeserializing<\/code>, IJsonOnSerialized<\/code> or IJsonOnSerializing<\/code> within the System.Text.Json.Serialization<\/code> namespace.<\/p>\nJsonSerializer.Serialize()<\/code> and JsonSerializer.Deserialize()<\/code> to ensure a FirstName<\/code> property is not null<\/code>.<\/p>\n public class Person : IJsonOnDeserialized, IJsonOnSerializing\r\n {\r\n public string FirstName{ get; set; }\r\n\r\n void IJsonOnDeserialized.OnDeserialized() => Validate(); \/\/ Call after deserialization\r\n void IJsonOnSerializing.OnSerializing() => Validate(); \/\/ Call before serialization\r\n\r\n private void Validate()\r\n {\r\n if (FirstName is null)\r\n {\r\n throw new InvalidOperationException(\"The 'FirstName' property cannot be 'null'.\");\r\n }\r\n }\r\n }<\/code><\/pre>\nLibraries: System.Text.Json serialization property ordering<\/h2>\n
System.Text.Json.Serialization.JsonPropertyOrderAttribute<\/code>. An integer specifies the order. Smaller integers are serialized first; properties that have no attribute have a default ordering value of 0.<\/p>\nId, City, FirstName, LastName<\/code>:<\/p>\npublic class Person\r\n{\r\n public string City { get; set; } \/\/ No order defined (has the default ordering value of 0)\r\n\r\n [JsonPropertyOrder(1)] \/\/ Serialize after other properties that have default ordering\r\n public string FirstName { get; set; }\r\n\r\n [JsonPropertyOrder(2)] \/\/ Serialize after FirstName\r\n public string LastName { get; set; }\r\n\r\n [JsonPropertyOrder(-1)] \/\/ Serialize before other properties that have default ordering\r\n public int Id { get; set; }\r\n}<\/code><\/pre>\nLibraries: “write raw” JSON with System.Text.Json.Utf8JsonWriter<\/h2>\n
\n
JsonWriterOptions writerOptions = new() { WriteIndented = true, };\r\n\r\nusing MemoryStream ms = new();\r\nusing UtfJsonWriter writer = new(ms, writerOptions);\r\n\r\nwriter.WriteStartObject();\r\nwriter.WriteString(\"dataType\", \"CalculationResults\");\r\n\r\nwriter.WriteStartArray(\"data\");\r\n\r\nforeach (CalculationResult result in results)\r\n{\r\n writer.WriteStartObject();\r\n writer.WriteString(\"measurement\", result.Measurement);\r\n\r\n writer.WritePropertyName(\"value\");\r\n \/\/ Write raw JSON numeric value using FormatNumberValue (not defined in the example)\r\n byte[] formattedValue = FormatNumberValue(result.Value);\r\n writer.WriteRawValue(formattedValue, skipValidation: true);\r\n\r\n writer.WriteEndObject();\r\n}\r\n\r\nwriter.WriteEndArray();\r\nwriter.WriteEndObject();<\/code><\/pre>\nFormatNumberValue<\/code> — is doing. For performance, System.Text.Json<\/code> omits the decimal points\/values when the number is whole, like 1.0<\/code>. The rationale is that writing fewer bytes is good for perf. In some scenarios, it might be important to retain decimal values because the consumer treats numbers without decimals as integers, otherwise as doubles. This new “raw value” model allows you to have that level of control wherever you need it.<\/p>\nLibraries: Synchronous stream overloads on
JsonSerializer<\/code><\/h2>\nJsonSerializer<\/code> for serializing and deserializing JSON data to\/from a stream. You can see that demonstrated in the following example.<\/p>\nusing MemoryStream ms = GetMyStream();\r\nMyPoco poco = JsonSerializer.Deserialize<MyPoco>(ms);<\/code><\/pre>\nJsonTypeInfo<T><\/code> or JsonSerializerContext<\/code> instances.<\/p>\nLibraries: System.Text.Json.Nodes.JsonNode support for
dynamic<\/code> is removed<\/h2>\ndynamic<\/code><\/a> type in the JsonSerializer has been removed. We added dynamic<\/code> support in Preview 4 but later decided to be a poor design choice, including making it a required dependency of the JsonNode<\/code> type.<\/p>\nLibraries: System.Diagnostics Propagators<\/h2>\n
\n
DistributedContextPropagator propagator = DistributedContextPropagator.Current;\r\npropagator.Inject(activity, carrier, (object theCarrier, string fieldName, string value) =>\r\n{\r\n \/\/ Extract the context from the activity then inject it to the carrier.\r\n});<\/code><\/pre>\n\/\/ Set the current propagation behavior to not transmit any distributed context information in outbound network messages.\r\nDistributedContextPropagator.Current = DistributedContextPropagator.CreateNoOutputPropagator();<\/code><\/pre>\nDistributedContextPropagator<\/code> abstract class determines if and how distributed context information is encoded and decoded as it traverses the network. The encoding can be transported over any network protocol that supports key-value string pairs. DistributedContextPropagator<\/code> inject values into and extracts values from carriers as key\/value string pairs.\nBy adding support for propagators, we’ve enabled two things:<\/p>\n\n
Dictionary<string, string><\/code>)<\/li>\n<\/ul>\nLibraries: Simplified call patterns for cryptographic operations<\/h2>\n
SymmetricAlgorithm<\/code> accelerate the already-in-memory case, and are intended to provide clarity to the caller and the code reviewer. Additionally, they support reading from and writing to spans.<\/p>\nprivate static byte[] Decrypt(byte[] key, byte[] iv, byte[] ciphertext)\r\n{\r\n using (Aes aes = Aes.Create())\r\n {\r\n aes.Key = key;\r\n\r\n return aes.DecryptCbc(ciphertext, iv);\r\n }\r\n}<\/code><\/pre>\nprivate static byte[] Decrypt(byte[] key, byte[] iv, byte[] ciphertext)\r\n{\r\n using (Aes aes = Aes.Create())\r\n {\r\n aes.Key = key;\r\n\r\n return aes.DecryptCbc(ciphertext, iv, PaddingMode.PKCS7);\r\n }\r\n}<\/code><\/pre>\nprivate static byte[] Decrypt(byte[] key, byte[] iv, byte[] ciphertext)\r\n{\r\n using (Aes aes = Aes.Create())\r\n {\r\n aes.Key = key;\r\n aes.IV = iv;\r\n\r\n \/\/ These are the defaults, but let's set them anyways.\r\n aes.Padding = PaddingMode.PKCS7;\r\n aes.Mode = CipherMode.CBC;\r\n\r\n using (MemoryStream destination = new MemoryStream())\r\n using (ICryptoTransform transform = aes.CreateDecryptor())\r\n using (CryptoStream cryptoStream = new CryptoStream(destination, transform, CryptoStreamMode.Write))\r\n {\r\n cryptoStream.Write(ciphertext, 0, ciphertext.Length);\r\n cryptoStream.FlushFinalBlock();\r\n return destination.ToArray();\r\n }\r\n }\r\n}<\/code><\/pre>\nLibraries: Full Case Mapping Support in Globalization Invariant Mode<\/h2>\n
String.ToUpper<\/code>, String.ToLower<\/code>, and string comparisons and searching with the IgnoreCase option<\/a>.<\/p>\nRuntime: W^X (write xor execute) support for all platforms and architectures<\/h2>\n
DOTNET_EnableWriteXorExecute<\/code> to 1<\/code>. This feature is opt-in in .NET 6 because it has a startup regression (except on Apple Silicon). The regression is ~10% in our ASP.Net benchmark tests when compiled with Ready To Run (R2R). However, the steady state performance was measured to be the same with and without the feature enabled. For applications where startup performance isn’t critical, we recommend enabling this feature for the improved security that it offers. We intend to resolve the performance regression as part of .NET 7 and enable the feature by default at that time.<\/p>\nRuntime: CodeGen changelog<\/h2>\n
Community PRs<\/h3>\n
\n
CAST(int <- long)<\/code>\u00a0on 32 bit targets\u00a0runtime#53040<\/span><\/a><\/span><\/li>\ncgt.un(op, 0)<\/code>\u00a0as\u00a0NE(op, 0)<\/code>\u00a0runtime#54539<\/span><\/a><\/span><\/li>\nDynamic PGO<\/span><\/h2>\n