Download .NET 8 Preview 7<\/a> for Linux, macOS, and Windows.<\/p>\n Note: .NET 8 Preview 7 is incompatible with C# Dev Kit<\/a>. We’re in the process of resolving it and will update this tracking bug<\/a> with progress.<\/p><\/blockquote>\n There are several exciting posts you should check out as well:<\/p>\n This release includes several new improvements to System.Text.Json<\/a>.<\/p>\n An example This example generates a The serializer now has built-in support for You can see that behavior in the folowing examples (the second resulting in a Base64-encoded string).<\/p>\n It is now possible to opt non-public members into the serialization contract<\/a> for a given type using This new extension method<\/a> enables making modifications to serialization contracts of arbitrary For example, deep cloning.<\/p>\n Support for Credit to @RaymondHuy<\/a> for contributing the implementation.<\/p>\n Hosted services now have more options<\/a> for execution during the application lifecycle. Provides a means for registering and retrieving Dependency Injection (DI) services<\/a> using keys. Keys allow for scoping of registration and consumption of services. Support has been added to DI abstractions, as well as an implementation in the built in Microsoft.Extensions.DependencyInjection.<\/p>\n You can now use an HTTPS proxy<\/a> with HTTPS<\/a> is pervasive, effectively a requirement for public internet websites. However, there are plenty of scenarios where raw (unencrypted) HTTP is a fine choice. Those scenarios often pair well with a proxy<\/a>. An HTTPS proxy establishes an encrypted channel between client and the proxy, establishing complete communication privacy.<\/p>\n Proxy usage can be also controlled programmatically via WebProxy<\/a> class.<\/p>\n It can also be controlled via the For example, with Docker:<\/p>\n WPF now includes Credit to @miloush<\/a> for contributing extensively to this feature!<\/p>\n Mobile apps can now use a new globalization mode<\/a> that uses a 34%<\/strong> smaller ICU<\/a> bundle, reducing the size of apps. In hybrid mode, globalization data is partially pulled from the ICU bundle and partially from OS APIs. It supports all the locales supported by Mobile<\/a>.<\/p>\n InvariantGlobalization mode<\/a> was created to eliminate the dependency on ICU (which comes with a large size cost). This mode comes with a significant trade-off, as most globalization functionality is no longer supported. This new feature is a middle ground, significantly reducing size (34% reduction) while maintaining globalization functionality.<\/p>\n Set the It will load icudt_hybrid.dat file instead of icudt.dat.<\/p>\n To make sure your application will not be affected, read the section Behavioral differences for OSX<\/a>.<\/p>\n The following improvements were made to code generation.<\/p>\n dotnet\/runtime #88090<\/a> enables a new physical promotion optimization pass that generalizes the JIT’s ability to promote struct variables. This optimization (also commonly called scalar replacement of aggregates) replaces the fields of struct variables by primitive variables that the JIT is then able to reason about and optimize more precisely.<\/p>\n The JIT already supported this optimization but with several large limitations. Some of the largest limitations of the JIT’s existing support was that it was only supported for structs with 4 or fewer fields, and only if each field was of a primitive type, or a very simple struct wrapping a primitive type. Physical promotion removes these limitations which fixes a number of long-standing JIT issues (see the PR for some of the issues closed).<\/p>\n As an example: Consider the following benchmarks.<\/p>\n The improvement is significant.<\/p>\n\n
\n
System.Text.Json improvements<\/h2>\n
JsonSourceGenerationOptionsAttribute<\/code> feature parity https:\/\/github.com\/dotnet\/runtime\/pull\/88753<\/h3>\nJsonSourceGenerationOptionsAttribute<\/code><\/a> now has feature parity with the JsonSerializerOptions<\/code><\/a> class, enabling specifing serialization configuration at compile time.<\/p>\nJsonSourceGenerationOptions<\/code> instance.<\/p>\n[JsonSourceGenerationOptions(JsonSerializerDefaults.Web,\r\n AllowTrailingCommas = true,\r\n Converters = new[] { typeof(JsonStringEnumConverter<MyEnum>) },\r\n DefaultBufferSize = 1024,\r\n DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,\r\n DictionaryKeyPolicy = JsonKnownNamingPolicy.SnakeCaseUpper,\r\n IgnoreReadOnlyFields = true,\r\n IgnoreReadOnlyProperties = true,\r\n IncludeFields = true,\r\n MaxDepth = 1024,\r\n NumberHandling = JsonNumberHandling.WriteAsString,\r\n PreferredObjectCreationHandling = JsonObjectCreationHandling.Replace,\r\n PropertyNameCaseInsensitive = true,\r\n PropertyNamingPolicy = JsonKnownNamingPolicy.KebabCaseUpper,\r\n ReadCommentHandling = JsonCommentHandling.Skip,\r\n UnknownTypeHandling = JsonUnknownTypeHandling.JsonNode,\r\n UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,\r\n WriteIndented = true)]\r\n[JsonSerializable(typeof(MyPoco))]\r\npublic partial class MyContext : JsonSerializerContext { }<\/code><\/pre>\nMyContext.Default<\/code> property that is preconfigured with all the relevant options set, while taking advantage of source generation.<\/p>\nBuilt-in support for
Memory<T><\/code>\/ReadOnlyMemory<T><\/code><\/h3>\nMemory<T><\/code> and ReadOnlyMemory<T><\/code> values<\/a>, with semantics being equivalent to arrays:<\/p>\n\n
Memory<byte><\/code>\/ReadOnlyMemory<byte><\/code> values<\/li>\nJsonSerializer.Serialize<Memory<int>>(new int[] { 1, 2, 3 }); \/\/ [1,2,3]\r\nJsonSerializer.Serialize<ReadOnlyMemory<byte>>(new byte[] { 1, 2, 3 }); \/\/ \"AQID\"<\/code><\/pre>\nBuilt-in support for
Half<\/code>, Int128<\/code> and UInt128<\/code> numeric types<\/h3>\nHalf<\/code><\/a>, Int128<\/code><\/a>, and UInt128<\/code><\/a> types now have built-in serialization support<\/a>.<\/p>\nConsole.WriteLine(JsonSerializer.Serialize(new object[] { Half.MaxValue, Int128.MaxValue, UInt128.MaxValue }));\r\n\/\/ [65500,170141183460469231731687303715884105727,340282366920938463463374607431768211455]<\/code><\/pre>\nExtending
JsonIncludeAttribute<\/code> and JsonConstructorAttribute<\/code> to non-public members<\/h3>\nJsonInclude<\/code><\/a> and JsonConstructor<\/code><\/a> attribute annotations.<\/p>\nstring json = JsonSerializer.Serialize(new MyPoco(42)); \/\/ {\"X\":42}\r\nJsonSerializer.Deserialize<MyPoco>(json); \r\n\r\npublic class MyPoco\r\n{\r\n [JsonConstructor]\r\n internal MyPoco(int x) => X = x;\r\n\r\n [JsonInclude]\r\n internal int X { get; }\r\n}<\/code><\/pre>\nIJsonTypeInfoResolver.WithAddedModifier<\/code> extension method<\/h3>\nIJsonTypeInfoResolver<\/code> instances:<\/p>\nvar options = new JsonSerializerOptions\r\n{\r\n TypeInfoResolver = MyContext.Default\r\n .WithAddedModifier(static typeInfo =>\r\n {\r\n foreach (JsonPropertyInfo prop in typeInfo.Properties)\r\n {\r\n prop.Name = prop.Name.ToUpperInvariant();\r\n }\r\n })\r\n};\r\n\r\nJsonSerializer.Serialize(new MyPoco(42), options); \/\/ {\"VALUE\":42}\r\n\r\npublic record MyPoco(int value);\r\n\r\n[JsonSerializable(typeof(MyPoco))]\r\npublic partial class MyContext : JsonSerializerContext { }<\/code><\/pre>\nAdditional JsonNode functionality<\/h3>\n
JsonNode<\/code> has significantly updated functionality<\/a>.<\/p>\nJsonNode node = JsonNode.Parse(\"{\\\"Prop\\\":{\\\"NestedProp\\\":42}}\");\r\nJsonNode other = node.DeepClone();\r\nbool same = JsonNode.DeepEquals(node, other); \/\/ true<\/code><\/pre>\nIEnumerable<\/code>.<\/p>\nJsonArray jsonArray = new JsonArray(1, 2, 3, 2);\r\n\r\n\/\/ With the proposed GetValues this is simpler:\r\nIEnumerable<int> values = jsonArray.GetValues<int>().Where(i => i == 2);<\/code><\/pre>\nMicrosoft.Extensions.Hosting.IHostedLifecycleService<\/h2>\n
IHostedService<\/code> provided StartAsync<\/code> and StopAsync<\/code>. IHostedLifeCycleService<\/code> provides an additional StartingAsync<\/code>, StartedAsync<\/code>, StoppingAsync<\/code>, StoppedAsync<\/code> – which run before and after the existing points respectively.<\/p>\nUsing
IHostedLifecycleService<\/code><\/h3>\nIHostBuilder hostBuilder = new HostBuilder();\r\nhostBuilder.ConfigureServices(services =>\r\n{\r\n services.AddHostedService<MyService>();\r\n}\r\n\r\nusing (IHost host = hostBuilder.Build())\r\n{\r\n await host.StartAsync();\r\n}\r\n\r\npublic class MyService : IHostedLifecycleService\r\n{\r\n public Task StartingAsync(CancellationToken cancellationToken) => \/* add logic here *\/ Task.CompletedTask;\r\n public Task StartAsync(CancellationToken cancellationToken) => \/* add logic here *\/ Task.CompletedTask;\r\n public Task StartedAsync(CancellationToken cancellationToken) => \/* add logic here *\/ Task.CompletedTask;\r\n public Task StopAsync(CancellationToken cancellationToken) => \/* add logic here *\/ Task.CompletedTask;\r\n public Task StoppedAsync(CancellationToken cancellationToken) => \/* add logic here *\/ Task.CompletedTask;\r\n public Task StoppingAsync(CancellationToken cancellationToken) => \/* add logic here *\/ Task.CompletedTask;\r\n}<\/code><\/pre>\nKeyed services support in Microsoft.Extensions.DependencyInjection<\/h2>\n
Using Keyed services<\/h3>\n
using Microsoft.Extensions.Caching.Memory;\r\nusing Microsoft.Extensions.Options;\r\n\r\nvar builder = WebApplication.CreateBuilder(args);\r\n\r\nbuilder.Services.AddSingleton<BigCacheConsumer>();\r\nbuilder.Services.Addsingleton<SmallCacheConsumer>();\r\n\r\nbuilder.Services.AddKeyedsingleton<IMemoryCache, BigCache>(\"big\");\r\nbuilder.Services.AddKeyedSingleton<IMemoryCache, SmallCache>(\"small\");\r\n\r\nvar app = builder.Build();\r\n\r\napp.MapGet(\"\/big\", (BigCacheConsumer data) => data.GetData());\r\napp.MapGet(\"\/small\", (SmallCacheConsumer data) => data.GetData());\r\n\r\napp.Run();\r\n\r\nclass BigCacheConsumer([FromKeyedServices(\"big\")] IMemoryCache cache)\r\n{\r\n public object? GetData() => cache.Get(\"data\");\r\n}\r\n\r\nclass SmallCacheConsumer(IKeyedServiceProvider keyedServiceProvider)\r\n{\r\n public object? GetData() => keyedServiceProvider.GetRequiredKeyedService<IMemoryCache>(\"small\");\r\n}<\/code><\/pre>\nHTTPS proxy<\/h2>\n
HttpClient<\/code>. This can be a significant improvement to protect against interception attacks<\/a>.<\/p>\nHTTPS proxy usage<\/h3>\n
all_proxy<\/code> environment variable:<\/p>\nENV all_proxy=https:\/\/x.x.x.x:3218<\/code><\/pre>\nOpenFolderDialog<\/code> in WPF<\/h2>\nOpenFolderDialog<\/code><\/a> which allows users to browse and select folders in their application.<\/p>\nHow to use
OpenFolderDialog<\/code><\/h3>\nOpenFolderDialog openFolderDialog = new OpenFolderDialog()\r\n{\r\n Title = \"Select folder to open ...\",\r\n InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),\r\n};\r\n\r\nstring folderName = \"\";\r\nif (openFolderDialog.ShowDialog() == true)\r\n{\r\n folderName = openFolderDialog.FolderName;\r\n}<\/code><\/pre>\nHybridGlobalization mode on iOS\/tvOS\/MacCatalyst platforms<\/h2>\n
How to use HybridGlobalization<\/h3>\n
HybridGlobalization<\/code> MsBuild property:<\/p>\n<HybridGlobalization>true<\/HybridGlobalization><\/code><\/pre>\nDifferences from ICU<\/h3>\n
\n
CodeGen<\/h2>\n
Community PRs<\/h3>\n
\n
\n
Array<\/code> typed GetArrayDataReference<\/code>.<\/li>\nVolatile<\/code> to JIT intrinsics that removed VM implementation and improved codegen.<\/li>\n<\/ul>\n<\/li>\nand, andn, or, xor,\r\nmin, max,\r\ndiv, mul, mull, sub,\r\nvariable shiftleftlogical\/rightarithmetic\/rightlogical<\/code><\/pre>\n<\/li>\n<\/ul>\nStruct Physical Promotion<\/h3>\n
foreach<\/code> over a Dictionary<TKey, TValue><\/code> involves a struct enumerator with 5 fields, so before this change the JIT was not able to promote and reason about this enumerator. The JIT was similarly not able to reason about foreach<\/code> over a List<(int, int)><\/code> (the struct enumerator only has 4 fields, but one field is a (int, int)<\/code> tuple). These cases (and others like it) hae been resolved.<\/p>\nprivate readonly Dictionary<int, int> _dictionary = new(Enumerable.Range(0, 10000).Select(i => KeyValuePair.Create(i, i)));\r\n\r\n[Benchmark]\r\npublic int SumDict()\r\n{\r\n int sum = 0;\r\n foreach ((int key, int value) in _dictionary)\r\n {\r\n sum += key;\r\n sum += value;\r\n }\r\n return sum;\r\n}\r\n\r\nprivate readonly List<(int, int)> _list = Enumerable.Range(0, 10000).Select(i => (i, i)).ToList();\r\n\r\n[Benchmark]\r\npublic int SumList()\r\n{\r\n int sum = 0;\r\n foreach ((int key, int value) in _list)\r\n {\r\n sum += key;\r\n sum += value;\r\n }\r\n return sum;\r\n}<\/code><\/pre>\n![\"Chart](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2023\/08\/dotnet8-p7-sumdict-sumlist-chart.svg\")
<\/p>\n
![](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2023\/08\/community-contributor.jpeg\")
<\/p>\n