The .NET 7 framework has simply launched some wonderful new options that can change the best way you code. They have not been formally launched but, however you can begin enjoying with them and prepare for when it formally launched in november of this yr!
The most recent preview of the .NET Framework has been launched to the general public and it is filled with surprises. Try these Prime 7 options within the .NET 7 launch that can change the best way you code ceaselessly!
Exercise.Present New Commonplace
At present in .NET 6, to realize span context monitoring of the totally different threads being managed, the most typical is to make use of AsyncLocal<T> for this function.
In line with Jeremy Likness in his Saying .NET 7 Preview 4 submit:
“…with Exercise changing into the usual to characterize spans, as utilized by OpenTelemetry, it’s inconceivable to set the worth modified handler for the reason that context is tracked through
Exercise.Present.”
Now with Exercise.CurrentChanged we will obtain this to obtain notifications. Let’s have a look at Microsoft instance:
public partial class Exercise : IDisposable
{
public static occasion EventHandler<ActivityChangedEventArgs>? CurrentChanged;
}
And that is how it might be used:
Exercise.CurrentChanged += CurrentChanged;
void CurrentChanged(object? sender, ActivityChangedEventArgs e)
{
Console.WriteLine($"Exercise.Present worth modified from Exercise: {e.Earlier.OperationName} to Exercise: {e.Present.OperationName}");
}
📚 For extra in-depth particulars, I recomend you to examine the unique proposal: Api deal with Exercise.Present worth modifications
Uncovered Strategies in performance-critical situations
The primary downside this new function solves, as Mikel Blanchard relates, is that efficiency exams present many allocations incurred when utilizing enumeration interfaces.
This could now be solved by utilizing uncovered strategies to enumerate properties with fast entry to the weather and with no additional allocations.
Let’s have a look at Microsoft instance:
namespace System.Diagnostics
{
partial class Exercise
{
public Enumerator<KeyValuePair<string,object>> EnumerateTagObjects();
public Enumerator<ActivityLink> EnumerateLinks();
public Enumerator<ActivityEvent> EnumerateEvents();
public struct Enumerator<T>
{
public readonly Enumerator<T> GetEnumerator();
public readonly ref T Present;
public bool MoveNext();
}
}
}
And that is how it might be used:
Exercise a = new Exercise("Root");
a.SetTag("key1", "value1");
a.SetTag("key2", "value2");
foreach (ref readonly KeyValuePair<string, object?> tag in a.EnumerateTagObjects())
{
Console.WriteLine($"{tag.Key}, {tag.Worth}");
}
📚 For extra in-depth particulars, I recomend you to examine the unique proposal: System.Diagnostics.Exercise: Enumeration API
Microseconds and Nanoseconds in date/time buildings
The smallest time increment that could possibly be used was the “tick” and its worth is 100ns. The issue with that is that to find out a worth in microseconds or nanoseconds you needed to calculate all the things based mostly on the “tick” and this was not probably the most optimum factor on this planet.
As Microsoft experiences, they’ll now add microsecond and nanosecond values to the totally different date and time buildings that exist.
Let’s have a look at Microsoft instance:
With DateTime:
namespace System {
public struct DateTime {
public DateTime(int yr, int month, int day, int hour, int minute, int second, int millisecond, int microsecond);
public DateTime(int yr, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, System.DateTimeKind sort);
public DateTime(int yr, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, System.Globalization.Calendar calendar);
public int Microsecond { get; }
public int Nanosecond { get; }
public DateTime AddMicroseconds(double worth);
}
}
With TimeOnly:
namespace System {
public struct TimeOnly {
public TimeOnly(int hour, int minute, int second, int millisecond, int microsecond);
public int Microsecond { get; }
public int Nanosecond { get; }
}
}
📚 For extra in-depth particulars, I recomend you to examine the unique proposal: Add Microseconds and Nanoseconds to TimeStamp, DateTime, DateTimeOffset, and TimeOnly
One Reminiscence Cache
Now you may instantiate a single reminiscence cache with the AddMemoryCache API. As well as, it is possible for you to to get it injected so you may name GetCurrentStatistics. Let’s examine Microsoft instance:
// when utilizing `companies.AddMemoryCache(choices => choices.TrackStatistics = true);` to instantiate
[EventSource(Name = "Microsoft-Extensions-Caching-Memory")]
inside sealed class CachingEventSource : EventSource
{
public CachingEventSource(IMemoryCache memoryCache) { _memoryCache = memoryCache; }
protected override void OnEventCommand(EventCommandEventArgs command)
{
if (command.Command == EventCommand.Allow)
{
if (_cacheHitsCounter == null)
{
_cacheHitsCounter = new PollingCounter("cache-hits", this, () =>
_memoryCache.GetCurrentStatistics().CacheHits)
{
DisplayName = "Cache hits",
};
}
}
}
}
As well as, Microsoft leaves us an instance of how it might assist us to see stats with the dotnet-counters software (examine it right here):
Press p to pause, r to resume, q to stop.
Standing: Operating
[System.Runtime]
CPU Utilization (%) 0
Working Set (MB) 28
[Microsoft-Extensions-Caching-MemoryCache]
cache-hits 269
📚 For extra in-depth particulars, I recomend you to examine the unique proposal: Let customers of MemoryCache entry metrics
A number of Reminiscence Cache
As within the earlier function, which allowed instantiating a single cache reminiscence, we are able to additionally instantiate a number of reminiscence cache with GetCurrentStatistics . Let’s examine this Microsoft instance:
static Meter s_meter = new Meter("Microsoft.Extensions.Caching.Reminiscence.MemoryCache", "1.0.0");
static IMemoryCache? mc1;
static IMemoryCache? mc2;
static void Most important(string[] args)
{
s_meter.CreateObservableGauge<lengthy>("cache-hits", GetCacheHits);
mc1 = new MemoryCache(new MemoryCacheOptions() { TrackStatistics = true, SizeLimit = 30 });
mc2 = new MemoryCache(new MemoryCacheOptions() { TrackStatistics = true, SizeLimit = 30 });
// name to: mc1.TryGetValue(key1, out object? worth)
// or: mc2.TryGetValue(key2, out value2)
// increments TotalHits
}
// metrics callback for cache hits
static IEnumerable<Measurement<lengthy>> GetCacheHits()
{
return new Measurement<lengthy>[]
{
new Measurement<lengthy>(mc1!.GetCurrentStatistics()!.TotalHits, new KeyValuePair<string,object?>("CacheName", "mc1")),
new Measurement<lengthy>(mc2!.GetCurrentStatistics()!.TotalHits, new KeyValuePair<string,object?>("CacheName", "mc2")),
};
}
And in addition, as within the earlier function, Microsoft exhibits us that we are able to additionally measure stats with the dotnet-counters software (https://docs.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-counters):
Press p to pause, r to resume, q to stop.
Standing: Operating
[System.Runtime]
CPU Utilization (%) 0
Working Set (MB) 14
[Microsoft.Extensions.Caching.Memory.MemoryCache]
cache-hits
CacheName=mc1 13,204
CacheName=mc2 13,204
📚 For extra in-depth particulars, I recomend you to examine the unique proposal: Let customers of MemoryCache entry metrics
New Tar APIs
We are going to now have cross-platform APIS with which we are able to extract and modify (learn and write) tar archives. As standard, Microsoft has proven examples so let’s check out a few of them:
Archive
// Generates a tar archive the place all of the entry names are prefixed by the basis listing 'SourceDirectory'
TarFile.CreateFromDirectory(sourceDirectoryName: "/dwelling/dotnet/SourceDirectory/", destinationFileName: "/dwelling/dotnet/vacation spot.tar", includeBaseDirectory: true);
Extract
// Extracts the contents of a tar archive into the required listing, however avoids overwriting something discovered inside
TarFile.ExtractToDirectory(sourceFileName: "/dwelling/dotnet/vacation spot.tar", destinationDirectoryName: "/dwelling/dotnet/DestinationDirectory/", overwriteFiles: false);
📚 For extra in-depth particulars, I recomend you to examine the unique proposal: Implement Tar APIs
OSR (On Stack Alternative)
OSR (On Stack Alternative) is a good complement to tiered compilation. It permits, in the midst of the execution of a way, to change the code that’s being executed by the strategies which might be being executed in the meanwhile.
“OSR permits long-running strategies to change to extra optimized variations mid-execution, so the runtime can jit all strategies shortly at first after which transition to extra optimized variations when these strategies are referred to as continuously (through tiered compilation) or have long-running loops (through OSR).”
With OSR, we are able to get hold of as much as 25% additional velocity at start-up (Avalonia IL Spy take a look at) and based on TechEmpower, enhancements can vary from 10% to 30%.
Efficiency Affect (Supply: Microsoft)📚 If you wish to know in how OSR works, please refer: OSR Doc
From Dotnetsafer we need to thanks in your time in studying this text.
And bear in mind: Now you may attempt without spending a dime our .NET obfuscator. You can even defend your purposes straight from Visible Studio with the .NET Obfuscator Visible Studio Extension.
