Tamir Dresher - DotNet 7 What's new.pptx

What’s new in
.NET7
ecosystem
Tamir Dresher
@tamir_dresher
December 2022

Head of Architecture @
@tamir_dresher
Who am I?
Software Engineering Lecturer
Ruppin Academic Center
&

Payoneer at a glance
3
International
users
Locations and
counting
Countries
& territories
Growth in global cross-
border payments where
Payoneer has a local
presence
by thousands of leading
brands worldwide.

Agenda
4
• Static Abstract Members and Generic Math behind the scenes(+ IParsable<TSelf>)
• File scoped types
• Microseconds and nanoseconds in time related types
• StringSyntaxAttribute
• LINQ Brings Order and OrderDescending
• Rate limiting APIs to protect a resource by keeping traffic at a safe level
• Incremental migration from ASP.NET to ASP.NET
• NuGet - Central Package Management
• EF Core 7 Json columns
• EF Core 7 bulk update and delete
• EF Core 7 new interceptors
@tamir_dresher

Agenda
5
@tamir_dresher

Static Abstract Members & Generic Math behind the scenes
• In C# 11 you can add static abstract members in interface which allows generic math
and other method that can depend on the operatorsmembers
public class AmazingMathClass
{
public static T MidPoint<T>(T x, T y) where T : INumber<T>
=> (x + y) / T.CreateChecked(2);
public static T Max<T>(T x, T y) where T : IComparisonOperators<T, T, bool>
=>
x < y ? x : y;
}
@tamir_dresher

7
• In C# 11 you can add static abstract members in interface which allows generic math
• You can use this for advanced usages. For example, IParseable
// Summary: Defines a mechanism for parsing a string to a value.
// TSelf: The type that implements this interface.
public interface IParsable<TSelf> where TSelf : IParsable<TSelf>? {
static abstract TSelf Parse(string s, IFormatProvider? provider);
static abstract bool TryParse([NotNullWhen(true)] string? s,
IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result);
}
public static IEnumerable<T> ParseFile<T>(string path) where T : IParsable<T>
{
...
foreach (var line in lines)
{
yield return T.Parse(line, null);
}
}

8
public class Person : I Parsable<Person>
{
public string Name { get; set; } = "";
public static Person Parse(string s, IFormatProvider? provider){ ... }
public static bool TryParse(...) { ... }
}
public class VeryImportantPerson : Person
{
public required int Rating { get; set; }
}
@tamir_dresher

9
public class Person : I Parsable<Person>
{
public string Name { get; set; } = "";
public static Person Parse(string s, IFormatProvider? provider){ ... }
}
public class VeryImportantPerson : Person, IParsable<VeryImportantPerson>
{
public required int Rating { get; set; }
public static VeryImportantPerson Parse(string s, IFormatProvider? provider){ ... }
}
@tamir_dresher

Agenda
10
@tamir_dresher

File Scoped Type
11
• Permit a file modifier on top-level type
declarations.
• The type only exists in the file where it
is declared.
• Same type name can exist in multiple files
• Generally useful for generated code and
encapsulating private implementation
– Note: you won’t be able to the test the
file scoped types directly
https://github.com/dotnet/csharplang/issues/6011
namespace FileScopedTypes
{
file interface IWidget
{
int ProvideAnswer();
}
file class HiddenWidget
{
public int Work() => 1337;
}
public class Widget : IWidget
{
public int ProvideAnswer()
{
var worker = new
HiddenWidget();
return worker.Work();
}
}
} @tamir_dresher

File Scoped Type – behind the scenes
12
• The compiler renames types with the file restriction
<SourceFileNameWithoutExtension>F$identfier$_TypeName. identfier

Agenda
13
@tamir_dresher

Microseconds and Nanoseconds support
14
https://github.com/dotnet/runtime/issues/23799
Add Microseconds and Nanoseconds to TimeStamp, DateTime, DateTimeOffset, and TimeOnly · Issue #23799
DateTime.Parse("0001-01-01 00:00:00.0009990").Microsecond; // 999
DateTime.Parse("0001-01-01 00:00:00.0000009").Nanosecond; // 900
DateTimeOffset.Parse("0001-01-01 00:00:00.0009990 -7").Microsecond; //
999
DateTimeOffset.Parse("0001-01-01 00:00:00.0000009 -7").Nanosecond; //
900
new DateTimeOffset().AddMicroseconds(999).Ticks; // 9990
TimeSpan.Parse("00:00:00.0009990").Microseconds; // 999
TimeSpan.Parse("00:00:00.0000009").Nanoseconds; // 900

Agenda
15
@tamir_dresher

StringSyntaxAttribute
16
• allows marking a string as containing a specific type of value which result in
– Syntax highlighting for the specific type
– Basic validation for the specific type such as:
– DateOnlyFormat
– DateTimeFormat
– EnumFormat
– GuidFormat
– Json
– NumericFormat
– Regex
– Uri
– Xml
@tamir_dresher

StringSyntaxAttribute.Json
17
• allows marking a string as containing a specific type of value which result in
– Syntax highlighting for the specific type
– Basic validation for the specific type.
class MeetupParser
{
public Meetup ParseJson([StringSyntax(StringSyntaxAttribute.Json)]string
json)
{
return null;
}
}

Agenda
18
@tamir_dresher

LINQ - Order and OrderDescending
19
Before .NET 7
var data = new[] { 2, 1, 3 };
var sorted = data.OrderBy(static e => e);
var sortedDesc = data.OrderByDescending(static e => e);
After .NET 7
var data = new[] { 2, 1, 3 };
var sorted = data.Order();
var sortedDesc = data.OrderDescending();
@tamir_dresher

Agenda
20
@tamir_dresher

Rate limiting APIs
21
• Use Microsoft.AspNetCore.RateLimiting middleware to add rate limiting to your app
• You can define rate limiting policies and attach them to endpoints
• * currently state can’t be shared cross servers out of the box
0 1 2
- request
Tokens filled at
constant rate
Token emptied one
request at a time
1sec
req1
req2
req3
Fixed window Sliding window Token (Leaky) bucket Concurrency
limits the number of
concurrent requests
Window slides one
segment at a time
@tamir_dresher

Rate limiting APIs – policy config
builder.Services.AddRateLimiter(_ => _
.AddFixedWindowLimiter(policyName: "fixed", options =>
{
options.PermitLimit = 4;
options.Window = TimeSpan.FromSeconds(12);
options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
options.QueueLimit = 2;
}));
var app = builder.Build();
app.UseRateLimiter();
@tamir_dresher

Rate limiting APIs – endpoint rate-limit
app.MapGet("/", () => Results.Ok($"Hello"))
.RequireRateLimiting("fixed");
[EnableRateLimiting("fixed")]
[HttpGet("limited", Name = "GetWeatherForecastWithLimit")]
public IEnumerable<WeatherForecast> GetWithLimit()
{
...
}
[DisableRateLimiting]
public ActionResult NoLimit()
{
return Ok();
}
@tamir_dresher

Rate limiting APIs – rate-limit per user
builder.Services.AddRateLimiter(limiterOptions => {
limiterOptions.AddPolicy("userPolicy", context =>
{
var username = "anonymous user";
if (context.User.Identity?.IsAuthenticated is true)
{
username = context.User.ToString()!;
}
return RateLimitPartition.GetSlidingWindowLimiter(username,
_ => new SlidingWindowRateLimiterOptions
{
PermitLimit = 4,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 2,
Window = TimeSpan.FromSeconds(10),
SegmentsPerWindow = 4 //each segment is 2.5 seconds
});
});
});

Rate limiting APIs – under the hood
25
• Introducing the new, in .NET 7, nuget package System.Threading.RateLimiting!
https://devblogs.microsoft.com/dotnet/announcing-rate-limiting-for-dotnet/
public abstract class RateLimiter : IAsyncDisposable, IDisposable
{
public abstract int GetAvailablePermits();
public abstract TimeSpan? IdleDuration { get; }
public RateLimitLease Acquire(int permitCount = 1);
public ValueTask<RateLimitLease> WaitAsync(int permitCount = 1, CancellationToken cancellationToken = default);
public void Dispose();
public ValueTask DisposeAsync();
}
RateLimiter limiter = GetLimiter();
using RateLimitLease lease = limiter.Acquire(permitCount: 1);
if (lease.IsAcquired)
{
// Do action that is protected by limiter
}
else
{
// Error handling or add retry logic
}

Rate limiting APIs – under the hood
26
• Introducing the new, in .NET 7, nuget package System.Threading.RateLimiting!
https://devblogs.microsoft.com/dotnet/announcing-rate-limiting-for-dotnet/
public abstract class RateLimiter : IAsyncDisposable, IDisposable
{
public abstract int GetAvailablePermits();
public abstract TimeSpan? IdleDuration { get; }
public RateLimitLease Acquire(int permitCount = 1);
public ValueTask<RateLimitLease> WaitAsync(int permitCount = 1, CancellationToken cancellationToken = default);
public void Dispose();
public ValueTask DisposeAsync();
}
RateLimiter limiter = GetLimiter();
using RateLimitLease lease = limiter.Acquire(permitCount: 1);
if (lease.IsAcquired)
{
// Do action that is protected by limiter
}
else
{
// Error handling or add retry logic
}

Agenda
27
@tamir_dresher

Incremental migration from ASP.NET to ASP.NET
28
• The Microsoft.AspNetCore.SystemWebAdapters.* packages allows consuming
business logic libraries that depends on HttpContext and System.Web APIs
• Session, Cookies and Authentication can also be shared
@tamir_dresher

Incremental migration from ASP.NET to ASP.NET
29
https://marketplace.visualstudio.com/items?itemName=WebToolsTeam.aspnetprojectmigrations

Agenda
31
@tamir_dresher

Central-Package-Management
32
• Control packages version in all projects under a specific folder
• Place Directory.Packages.props file in the root folder and set the packages version
• Add <PackageReference> without a version to the dependent projects
Directory.Packages.pr
ops
App1.csproj
@tamir_dresher

Agenda
33
@tamir_dresher

EF Core 7 Json columns
34
• EF7 contains provider-agnostic support for JSON columns, with SQL Server
implementation.
• Allows mapping of aggregates built from .NET types to JSON documents.
• Normal LINQ queries can be used on the aggregates, and these will be translated to
the appropriate query constructs needed to drill into the JSON.
protected override void OnModelCreating(ModelBuilder mBuilder)
{
mBuilder.Entity<Author>().OwnsOne(
author => author.Contact, navigationBuilder =>
{
navigationBuilder.ToJson();
navigationBuilder.OwnsOne(contactDetails =>
contactDetails.Address);
});
}
public class Author
{
public int Id { get; set; }
public string Name { get; set; }
public ContactDetails Contact { get; set; }
}
public class ContactDetails
{
public Address Address { get; set; } = null!;
public string? Phone { get; set; }
}
public class Address
{
...
} @tamir_dresher

EF Core 7 Json columns
35
public class Author
{
public int Id { get; set; }
public string Name { get; set; }
public ContactDetails Contact { get; set; }
}
public class ContactDetails
{
public Address Address { get; set; } = null!;
public string? Phone { get; set; }
}
public class Address
{
...
}

Agenda
36
@tamir_dresher

EF Core 7 bulk delete
37
Before EF Core 7
EF Core 7
var furniture = await context.Products.Where(p => p.CategoryId ==
3).ToListAsync();
foreach (var product in furniture)
{
context.Remove(product);
}
await context.SaveChangesAsync();
await context.Products.Where(p => p.CategoryId == 3).ExecuteDeleteAsync();
await context.Products
.Where(p => p.Category.Name.StartsWith("Furntiture"))
.ExecuteDeleteAsync();
Calling ExecuteDelete or ExecuteDeleteAsync on a DbSet immediately deletes from the database.
@tamir_dresher

EF Core 7 bulk update
38
await context.Products
.Where(p => p.CategoryId==3 && p.Price > 100)
.ExecuteUpdateAsync(s => s
.SetProperty(p => p.Name, p =>
p.Name.EndsWith(" *") ? p.Name.Replace(" *", "") : p.Name + " *")
.SetProperty(p => p.Price, p => p.Price - 12));
@tamir_dresher

Agenda
39
@tamir_dresher

EF Core 7 - New interceptors
40
 Interception for creating and populating new entity instances (aka "materialization")
 Interception to modify the LINQ expression tree before a query is compiled
 Interception for optimistic concurrency handling (DbUpdateConcurrencyException)
 Interception for connections before checking if the connection string has been set
 Interception for when EF has finished consuming a result set, but before that result set is closed
 Interception for creation of a DbConnection by EF Core
 Interception for DbCommand after it has been initialized
public class SetRetrievedInterceptor : IMaterializationInterceptor
{
public object InitializedInstance(MaterializationInterceptionData materializationData, object instance)
{
if (instance is IHasRetrieved hasRetrieved)
{
hasRetrieved.Retrieved = DateTime.UtcNow;
}
return instance;
}
}
public interface IHasRetrieved
{
DateTime Retrieved { get; set; }
}

Summary
41
@tamir_dresher

Tamir Dresher - DotNet 7 What's new.pptx

More Related Content

Similar to Tamir Dresher - DotNet 7 What's new.pptx (20)

More from Tamir Dresher (20)

Recently uploaded (20)

Tamir Dresher - DotNet 7 What's new.pptx

Editor's Notes