49. Playwright v1.45 makes you a Time Wizard

The latest release of Playwright, version 1.45, introduces a new feature called Clock. This feature allows you to manipulate the time in your tests, making it easier to test time-sensitive scenarios.

 content_paste
import { test, expect } from '@playwright/test';
 
test('🧙‍♂️ Time wizard plays with time 🪄', async ({ page }) => {
  // Initialize clock and let the page load naturally.
  await page.clock.install({ time: new Date('2024-06-25, 08:00') });
  await page.goto('http://localhost:4200');
 
  await expect(page.getByTestId('current-time')).toHaveText('25/06/2024, 08:00');
 
  // Set a fixed time (Date.now and new Date() return fixed fake time at all times)
  await page.clock.setSystemTime('2024-06-25T09:45:00');
  await expect(page.getByTestId('current-time')).toHaveText('25/06/2024, 09:45');
 
  // Pretend that the user closed the laptop lid and opened it again at 10am,
  // Pause the time once reached that point.
  await page.clock.pauseAt(new Date('2024-06-25T10:00:00'));
  await expect(page.getByTestId('current-time')).toHaveText('25/06/2024, 10:00');
 
  // Close the laptop lid again and open it at 10:30am.
  await page.clock.fastForward('30:00');
  await expect(page.getByTestId('current-time')).toHaveText('25/06/2024, 10:30');
 
  // Resume the time to normal flow
  await page.clock.resume();
 
  // Fake Date value while keeping the timers going
  await page.clock.setFixedTime('2024-06-25T16:00:00');
  await expect(page.getByTestId('current-time')).toHaveText('25/06/2024, 16:00');
});

Additional Resources link

• Clock Documentation
• v1.45.0 Release Notes

48. Inferred Type Predicates

It's finally here! While working with TypeScript, I assume we all have been in a situation where we have to write a type predicate to help TypeScript understand the type of a variable. For most cases this is fine, but it can be a pain to write these while using the filter method.

Now with the TypeScript 5.5 release, TypeScript introduces a new feature called Inferred Type Predicates. This feature allows TypeScript to infer type predicates automatically. This means that TypeScript can now understand the type of a variable or return value based on the conditions that are checked in the code.

Functions that previously required a Type Predicate can now be simplified. This is a great improvement for developers, as it reduces the amount of boilerplate code needed to write type predicates.

 content_paste
type Person = { name: string };
const persons: (Person | null)[] = [];
 
const personNames = persons.filter((person) => !!person).map((person) => person.name); // ^? Person

 content_paste
type Person = {name:string};
const persons: (Person|null)[] = []
 
const personNames = persons
  .filter(person => !!person)
  .map(person => person.name)
                 ~~~~~~ 'person' is possibly 'null'.
                 // ^? Person | null

Take a look at the following TypeScript playground examples to see the difference between TypeScript 5.5.0-beta and TypeScript 5.4.5.

Additional resources link

• Announcing TypeScript 5.5 RC by Daniel Rosenwasser - the official announcement of the feature
• The Making of a TypeScript Feature: Inferring Type Predicates by Dan Vanderkam - why and how Dan implemented this feature
• Type Predicate Inference: The TS 5.5 Feature No One Expected by Matt Pocock - a detailed explanation of the feature (with examples)

47. Automatic Service Discovery and Registration using Scrutor

Scrutor, created by Kristian Hellang, is a library that extends the functionality of the built-in ASP.NET Core Dependency Injection (DI) container (Microsoft.Extensions.DependencyInjection).

The name "Scrutor" is derived from the Latin verb "scrutor", which can be translated as "explore" / "search" / "examine thoroughly". And that's exactly what Scrutor does: it allows you to scan assemblies for specific types.

Before Scrutor, we have to manually register the dependencies in the DI container. The problem with this approach is that as your application grows, maintaining this list of registrations can become cumbersome.

Enter Scrutor, to simplify this process! It provides a fluent API that allows automatic assembly scanning and dependency registration. The API provides a flexible (and clean) way to discover types that meet the specified criteria (e.g. a specific name condition), and define the configuration options (e.g. service lifetimes) that are used for their registration within the container.

Because this significantly improves the developer experience, I encourage you to explore its capabilities and give it a try. Once you’ve experienced the convenience of Scrutor, manual registration will feel like a thing of the past!

To start using Scrutor, add the package to your project using the following command:

 content_paste
dotnet add package Scrutor

 content_paste
// Automatically register all interface implementations
builder.Services.Scan(scan =>
  scan
    .FromAssemblyOf<IFoo>()
    .AddClasses(publicOnly: false)
    .UsingRegistrationStrategy(RegistrationStrategy.Throw)
    .AsImplementedInterfaces()
    .WithScopedLifetime());

 content_paste
builder.Services.AddScoped<IFoo, FooImpl>();
builder.Services.AddScoped<IBar, BarImpl>();
builder.Services.AddScoped<IBaz, BazImpl>();
// Manually add new service(s) here ...

Additional resources link

• Using Scrutor to automatically register your services with the ASP.NET Core DI container by Andrew Lock
• Improving ASP.NET Core Dependency Injection With Scrutor by Milan Jovanović

46. Interacting with GitHub through the GitHub CLI

Throughout the last few years, GitHub has provided us with more and more tools that improve the experience with their platform. The development never stops, and new features are added frequently. This can be seen in the GitHub UI, but it reaches more than that.

One of the tools that I use daily is the GitHub CLI. The GitHub CLI is a command-line tool that brings GitHub directly to your terminal and enables you to interact with GitHub through various commands.

For me, the GitHub CLI makes contributing to open-source projects simpler and faster. For most of the tasks, the CLI provides a single command that can be used to perform the task, which otherwise could require multiple steps. The commands are easy to remember and are also suggested via the GitHub UI, which makes it easier to get started.

Here are some of the commands that I use frequently:

 content_paste
# Open the current repository in the browser
gh browse
 
# Checkout a pull request
gh pr checkout 47
 
# Create a pull request or issue
gh pr/issue create
 
# Sync a forked repository with the upstream repository
gh repo sync OWNER/REPO
 
# Interact with GitHub Copilot via the CLI
gh copilot suggest/explain "Undo the last commit"

Of course, there are many more commands available, to explore them see the GitHub CLI documentation. To take it a step further, you can also create extensions for it. An example is the gh dash, which provides a dashboard for your pull requests and issues in which you're participating. Instead of using the commands to query issues or repositories, you can use the dashboard to get a nice visual overview.

Besides using the GitHub CLI with GitHub, I'm catching myself using the gh copilot command more and more. This command uses GitHub Copilot to answer your questions and generate commands that can be executed or copied. I find it a useful way to learn new commands or to get a quick reminder of how to use a command.

To bring the power of the GitHub CLI to your IDE, you can also install GitHub extensions for your favorite IDE. These will make it easier to review pull requests directly from your IDE.

For one-off tasks while working in repositories you don't frequently visit, a GitHub codespace is a great way to quickly spin up a (pre-configured) development environment with all the tools that are required.

45. Empathy Matters (as a Software Developer)

The most challenging aspect of software development isn't the technical side of the coding process, but rather the human interactions involved. To quote Gerald M. Weinberg, "No matter what the problem is, it's always a people problem".

This is something I've heard in some variations by experienced developers and leaders over the years, and the more experience I gain the more I think it's true. From my own experience, I can say that most of the problems I've encountered were (more or less) solvable from a technical side. The real challenge was to understand, really understand, the problem and the people involved.

True, as you're starting your career, you're focused on learning the technical skills, and that's important. However, as you advance, you'll realize that people (soft) skills are equally, if not more, vital.

Empathy, in my opinion, plays a crucial part in connecting with people and understanding the way they feel and how they express themselves. It’s an essential skill that fosters both personal and professional relationships. From a software development side, mastering empathy enables you to collaboratively build a better product as a team. Teams that actively listen to each other and effectively communicate their emotions and thoughts with the aim of mutual understanding are the ones that deliver the best results.

Recently, I came across a piece by Jacob Morgan on the practice of empathy that I thought would be beneficial to share. Here's a brief excerpt from the post outlining a four-step method to cultivate empathy (the complete article can be accessed via the source link provided):

• Perspective taking, or putting yourself in someone else’s shoes. Imagine things from their point of view.
• Stay out of judgment and listen. Don’t rush into judgment; focus on listening to the other person.
• Recognize the emotion the other person is feeling. Think of a time you have felt similarly.
• Communicate that you recognize that emotion. Sharing understanding builds trust and connection.

Source: 4-Step Approach to Practicing Empathy by Jacob Morgan.

44. Enforce module boundaries with no-restricted-imports

Define module boundaries in your project by restricting specific imports using ESLint's no-restricted-imports rule. The rule allows you to prevent certain modules from being imported in specific files or directories.

From an architectural point of view this is useful to enforce module boundaries e.g. to prevent feature A to be imported within feature B, or prevent circular dependencies between modules.

There are also some alternative tools that allow you to define module boundaries such as Sherrif or Nx. If you're already using these tools, I think it's better to stick with them as they provide more flexibility and features. However, I find the ESLint approach to be straightforward and the easiest to configure, and it doesn't require an additional dependency.

For more information about the ESLint rule, refer to the official ESLint documentation, or the TypeScript-variant at the TypeScript ESLint documentation. If you're using Biome, see the Biome documentation.

 .eslintrc.js content_paste
module.exports = {
  rules: {
    'no-restricted-imports': [
      'error',
      {
        patterns: [
          {
            group: ['@feature-a'],
            message: 'You cannot import feature A from this module.',
          },
        ],
      },
    ],
  },
};

43. Different scenarios require different Entity Framework behaviors

Don't just duplicate the way you query entities in your project, consider tweaking how entities are retrieved for some specific scenarios. Being attentive to how you query entities improves the performance of your application and reduces the load.

Let's go over some differences and compare their results using the Northwind database.

The default behavior retrieves a "full-blown" entity with all its properties, and it's tracked by the Entity Framework context to allow efficient updates.

For read-only scenarios, where you don't intend to update the entities, you can improve the performance by using the AsNoTracking method. Using AsNoTracking reduces the overhead of the change tracker, for more information see the documentation. From my experience, this improves the performance of the application by 18.9%.

When querying entities, avoid selecting all columns when it's applicable. Instead, select only the columns you need and create your Data Transfer Objects (DTO). This reduces the amount of data transferred between the database and your application, resulting in better performance. From my experience, this improves the performance of the application by +15.3% (compared to the AsNoTracking solution). As a bonus, this approach also makes your application more resilient to relational changes as you don't need to manually include child entities using the Include method.

 content_paste
var customers = await context.Set<Customer>()
      .ToListAsync(cancellationToken);

 content_paste
var customers = await context.Set<Customer>()
      .AsNoTracking()
      .ToListAsync(cancellationToken);

 content_paste
var customers = await context.Set<Customer>()
      .Select(c => new CustomerDto(c.Id, c.Name))
      .ToListAsync(cancellationToken);

To be complete, the following variations are also possible:

• context.Database.SqlQuery<Customer> doesn't track changes;
• context.Customers.FromSql does track changes;
• context.Set<Customer>.FromSql does track changes;

42. Using ngxtension to migrate towards "Modern" Angular

In recent versions, Angular has introduced a new set of APIs and features that are considered "modern" Angular. The inject method, signal based inputs, and the new output method, immediately come to my mind.

These new APIs are not only more powerful but also more readable and easier to use. That's why it's encouraged to use it in new projects.

But what about existing projects? You can have a mix of old and new Angular code in your project, or you might want to migrate to the new Angular version. I prefer the latter because it keeps things consistent, but in large codebases this can be a daunting task that consumes some time and effort.

To automate this task there's a tool that can help you with this: NG Extension (ngxtension), which is created by Chau Tran and Enea Jahollari. This library provides a collection of utility methods to write Angular code, and it also provides a set of schematics to help you migrate to the new Angular APIs.

Let's see how we can use ngxtension to migrate towards "modern" Angular with some before and after examples.

 content_paste
@Component({
  template: `
        @if (showTitle) {  
            <h1>{{ title }}</h1>
        }
        <button (click)="onClick()">Click me!</button> 
  `,
})
export class AwesomeComponent {
  @Input({ required: true }) title: string = '';
  @Input({ required: true, transform: booleanAttribute })
  showTitle: boolean = false;
  @Output() buttonClicked = new EventEmitter<string>();
  constructor(private service: AwesomeService) {}
  onClick() {
    this.buttonClicked.emit(this.title);
    this.service.magic();
  }
}

 content_paste
@Component({
  template: `
        @if (showTitle()) {
            <h1>{{ title() }}</h1>
        }
        <button (click)="onClick()">Click me!</button>
  `,
})
export class AwesomeComponent {
  private service = inject(AwesomeService);
  title = input.required<string>();
  showTitle = input.required<boolean, boolean>({ transform: booleanAttribute });
  buttonClicked = output<string>();
 
  onClick() {
    this.buttonClicked.emit(this.title());
    this.service.magic();
  }
}

ngxtension:convert-di-to-inject link

 content_paste
@Component()
export class AwesomeComponent {
  contructor(private service: AwesomeService) {}
}

 content_paste
@Component()
export class AwesomeComponent {
  private service = inject(AwesomeService);
}

ngxtension:convert-signal-inputs link

 content_paste
@Component()
export class AwesomeComponent {
  @Input({ required: true }) title: string = '';
  protected log() {
    console.log(this.title);
  }
}

 content_paste
@Component()
export class AwesomeComponent {
  title = input.required<string>();
  protected log() {
    console.log(this.title());
  }
}

ngxtension:convert-outputs link

 content_paste
@Component()
export class AwesomeComponent {
  @Output() logOutpout = new EventEmitter<string>();
  protected log() {
    this.logOutpout.emit('👋 Hello');
  }
}

 content_paste
@Component()
export class AwesomeComponent {
  logOutpout = output<string>();
  protected log() {
    this.logOutpout.emit('👋 Hello');
  }
}

41. Simplified Dictionary Lookups

When accessing values from a dictionary, it is common to check if the key exists before accessing the value to avoid exceptions when the key does not exist in the dictionary. This can be done using the ContainsKey method followed by an index identifier.

At first glance, this seems like a good practice. However, by turning on the code analysis rule CA1854 on our codebase, we learned that this isn't the case.

To fix this violation, the rule suggests using the TryGetValue method instead. This method avoids redundant lookups while accessing values from a dictionary. And, I also find that using TryGetValue makes the code easier to read.

After this change, which can be auto-fixed, the JetBrains tooling went a step further to simplify this code. The CanSimplifyDictionaryTryGetValueWithGetValueOrDefault code inspection, refactors this code block into a one-liner using the GetValueOrDefault method (also with an auto-fix). This is only applicable when a default value is used for values that do not exist in the dictionary.

As a result, we can make our codebases more efficient and concise.

 content_paste
var value = "fallback";
if (dictionary.ContainsKey("key"))
{
  value = dictionary["key"];
}

 content_paste
if (!dictionary.TryGetValue("key", out var value))
{
  value = "fallback";
}

 content_paste
var value = dictionary.GetValueOrDefault("key", "fallback");

40. An improved content projection experience with fallback content

In Angular 18 you will be able to specify fallback content for ng-content slots. This feature allows you to define default content within ng-content tags, if no content is projected into these slots then the specified default content will be displayed.

In previous versions this was also possible, but included a hacky workaround to make this work. This hack involves using a directive to check if the projected content is empty and then conditionally rendering the default content. This approach is not ideal as it requires additional code that's hard to read and can be error-prone.

 child.component.html content_paste
<ng-content select="[super-header]">
  <h1>Default Header</h1>
</ng-content>
<ng-content>
  <p>Default Content</p>
</ng-content>

 parent.component.html content_paste
<app-child>
  <div>Some content</div>
</app-child>

 rendered.html content_paste
<h1>Default Header</h1>
<div>Some content</div>

39. Take control of query parameterization in EF 9

In Entity Framework 9 we will have more control on how parameters and constants are used within the generated SQL queries. Using the two new methods EF.Parameter and EF.Constant you can decide on how the query parameters are generated, which is useful when you want to force or prevent query parameterization.

• EF.Parameter is used to indicate that the parameter should be used as a parameter in the generated SQL query.
• EF.Constant is used to indicate that the parameter should be used as an inline constant in the generated SQL query.

This feature makes it easier to manage the query plans that are created, and thus can help to improve the performance of your queries and application.

 content_paste
var blogs = await ctx.Set<Blog>()
    .Where(blog => blog.Title.Contains(EF.Parameter("entity framework")))
    .ToListAsync();

 content_paste
SELECT [b].[Id], [b].[Tags], [b].[Title]
FROM [Blog] AS [b]
WHERE [b].[Title] LIKE @__p_0_contains
WHERE [b].[Title] LIKE '%entity framework%' -- before using EF.Parameter

 content_paste
var blog = await ctx.Set<Blog>()
    .Where(blog => blog.Id == EF.Constant(id))
    .SingleAsync();

 content_paste
SELECT TOP(2) [b].[Id], [b].[Tags], [b].[Title]
FROM [Blog] AS [b]
WHERE [b].[Id] = 1
WHERE [b].[Id] = @__id_0 -- before using EF.Constant

For more information, see the "What's New in EF Core 9" documentation.

38. Improvements to `dotnet test` in .NET9

So far, the preview versions of .NET 9 have introduced two improvements to the dotnet test command.

• 💅 The output logs will use the new terminal logger by default, resulting in a better experience with more clearly arranged output. The terminal logger was introduced in .NET 8 as an opt-in alternative to the normal console logger. The new behavior uses the new terminal logger by default for environments that support this, and can be disabled using the --tl:off switch. For more information and the reasoning for this new behavior see Terminal logger is default
• 🏎️ Test projects that hit different Target Frameworks will be run in parallel. This means that you will receive the test results faster. By default the number of parallel processes will be the number of processors on the computer, it can also be configured using the -maxcpucount:N switch.

This results in a better experience for developers and faster feedback loops when running tests.

For more info about Unit Testing .NET 9 see the documentation.

37. Load testing

To measure is to know. As a developer, it's crucial to evaluate your system's capability for building robust and reliable software applications.

Load testing is a key aspect of this evaluation process. It helps you understand how your system performs under varying loads, from real-world loads to anticipated peak load conditions. By subjecting your system to different levels of load, you can identify potential performance bottlenecks, stability issues, and scalability concerns. This information is invaluable for optimizing your system, ensuring it can handle the expected user loads resulting in a positive user experience and preventing system failures under high loads.

Why is Load Testing Important? link

• Performance Optimization: Load testing helps identify the (maximum) operating capacity of an application, any bottlenecks or weak points in your system, and determine which element is causing degradation. This can help you optimize the performance of your application.
• Regression Testing: Load testing helps you to identify performance trends in your application. By introducing tests you can ensure that new features or changes do not negatively impact the performance of your application.
• Scalability Planning: Measuring is knowing. You can plan the infrastructure better when you know the number of users your application can handle and act accordingly.
• Improved User Experience: By ensuring that your application can handle expected user loads, you can provide a better user experience. Slow or unresponsive applications can lead to user dissatisfaction.

Why Invest Time in Load Testing? link

Investing time in load testing is a preventive measure to ensure system readiness and performance capability. It’s about being proactive rather than reactive. Without proper load testing, your application could fail spectacularly at the worst possible time - when there are maximum users on the system.

In conclusion, load testing is not just a one-time task but a crucial part of the continuous delivery process. It ensures that your application will perform well under pressure, providing a seamless experience for your users, and ultimately, contributing to the success of your software or application.

How to Perform Load Testing? link

There are several tools available for load testing, here are a few that I've used in the past:

• Bombardier: a simple CLI tool for load testing a single URL. Useful for quick tests, for example, to test the configured Rate limiting on an API. East to configure.
• Artillery: define test scenarios with various load phases using YAML. Artillery has a built-in Playwright engine. Easy to configure in your CI/CD pipeline.
• K6: write test scripts in JavaScript. It has a (paid) cloud service for running tests at scale. Easy to be added to your CI/CD pipeline. K6 has a useful browser extension to record user flows.
• Apache JMeter: for if you like a GUI to create and execute tests. A battle-tested tool.

36. SQL Temporal Tables

SQL Temporal Tables is a feature that allows you to keep a history of changes to a table without an effort. By enabling SYSTEM_VERSIONING on a table, SQL Server creates a history table and keeps track of changes to the table. This is useful for auditing purposes, or for tracking changes to data over time.

 content_paste
CREATE TABLE dbo.Person (
  [Id] UNIQUEIDENTIFIER NOT NULL,
  [Name] NVARCHAR(100) NOT NULL,
  [ValidFrom] DATETIME2 GENERATED ALWAYS AS ROW START,
  [ValidTo] DATETIME2 GENERATED ALWAYS AS ROW END,
  PERIOD FOR SYSTEM_TIME(ValidFrom, ValidTo),
  CONSTRAINT [PK_Person] PRIMARY KEY CLUSTERED (Id)
)
WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = dbo.PersonHistory));

format_quote

Temporal tables (also known as system-versioned temporal tables) are a database feature that brings built-in support for providing information about data stored in the table at any point in time, rather than only the data that is correct at the current moment in time. Because it keeps a full history of data changes, it allows for easy point-in-time analysis.

This is useful for:

• Auditing all data changes and performing data forensics when necessary
• Reconstructing state of the data as of any time in the past
• Recovering from accidental data changes and application errors
• Insights to data trends

For more info see the documentation.

Temporal tables are supported by Entity Framework, as I've mentioned in my blog post Entity framework features I wish I knew earlier.

35. Creating a good-looking Windows Terminal

As a developer, I spend a "lot" of time in the terminal. I use it to run various other commands ranging from navigating to folders, running my environment, executing git commands, ...

I want my terminal to be a place that I enjoy spending time in. I want it to be a place where I can be productive.

With my daily driver, the Windows Terminal, I can make it look good and be productive at the same time. The Windows Terminal is highly customizable, and I make use the following tools to make it look good:

• Powershell: the default shell. The Windows terminal also supports other shells.
• Oh My Posh: Make use of one of the beautiful looking themes that are available (or create your own), and add "Segments" to add more information to your prompt. For example, the current git branch (including changes), the .NET/Node.js version, the current Spotify song, ...
• Nerd Fonts: to make sure that the icons are displayed correctly.
• Terminal-Icons: display icons to known directories and files to make the terminal more visually appealing.
• Predictive Intellisense: to get suggestions for commands => this boosts my productivity.

Some bonus tips:

• You can open multiple tabs and screens in the terminal.
• Use the Quake mode to open the terminal (which has the focus) on top of your screen with a hotkey.
• Via the settings, you can customize the colors (including the background) and shortcuts to your preference.

I hope this helps you to make your terminal a place where you enjoy spending time in. For more tips and tricks you can check out my blog How I've set up my new Windows development environment (2022), or one of Scott Hanselman's blog posts about customizing the Windows Terminal.

34. Rate limiting in ASP.NET

Rate limiting is a technique used to control the number of requests a client can make to a server. It is often used to prevent abuse of an API, e.g. to protect against denial-of-service attacks.

This feature is implemented as a middleware. To enable rate limiting in your application, add the rate limiter to the service collection, and then enable the middleware within the application.

To configure the rate limiter, you can use one of the built-in limiters to create policies, which can be applied to the whole application or to specific endpoints. The built-in limiters are the following (the descriptions are taken from the official documentation):

• Fixed Window Limiter: uses a fixed time window to limit requests. When the time window expires, a new time window starts and the request limit is reset.
• Sliding Window Limiter: similar to the fixed window limiter but adds segments per window. The window slides one segment each segment interval. The segment interval is (window time)/(segments per window).
• Token Bucket Limiter: similar to the sliding window limiter, but rather than adding back the requests taken from the expired segment, a fixed number of tokens are added each replenishment period. The tokens added each segment can't increase the available tokens to a number higher than the token bucket limit.
• Concurrency Limiter: limits the number of concurrent requests. Each request reduces the concurrency limit by one. When a request completes, the limit is increased by one. Unlike the other requests limiters that limit the total number of requests for a specified period, the concurrency limiter limits only the number of concurrent requests and doesn't cap the number of requests in a time period.

 content_paste
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRateLimiter(options =>
{
    /* Policy configuration here */
});
 
var app = builder.Build();
app.UseRateLimiter();
app.Run();

 content_paste
// Global configuration
builder.Services.AddRateLimiter(options =>
{
    options.GlobalLimiter = /* Implementation here */
});
 
// Specific endpoints (also works with MVC Controllers/Endpoints)
app.MapGet("/", () => Results.Ok("Hello world"))
     .RequireRateLimiting(Policy);
 

 content_paste
builder.Services.AddRateLimiter(_ => _
    .AddFixedWindowLimiter(policyName: "fixed", options =>
    {
        options.PermitLimit = myOptions.PermitLimit;
        options.Window = TimeSpan.FromSeconds(myOptions.Window);
        options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        options.QueueLimit = myOptions.QueueLimit;
    }));

 content_paste
builder.Services.AddRateLimiter(_ => _
    .AddSlidingWindowLimiter(policyName: "sliding", options =>
    {
        options.PermitLimit = myOptions.PermitLimit;
        options.Window = TimeSpan.FromSeconds(myOptions.Window);
        options.SegmentsPerWindow = myOptions.SegmentsPerWindow;
        options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        options.QueueLimit = myOptions.QueueLimit;
    }));

 content_paste
builder.Services.AddRateLimiter(_ => _
    .AddSlidingWindowLimiter(policyName: "token-bucket", options =>
    {
        options.TokenLimit = myOptions.TokenLimit;
        options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        options.QueueLimit = myOptions.QueueLimit;
        options.ReplenishmentPeriod = TimeSpan.FromSeconds(myOptions.ReplenishmentPeriod);
        options.TokensPerPeriod = myOptions.TokensPerPeriod;
        options.AutoReplenishment = myOptions.AutoReplenishment;
    }));

 content_paste
builder.Services.AddRateLimiter(_ => _
    .AddConcurrencyLimiter(policyName: concurrencyPolicy, options =>
    {
        options.PermitLimit = myOptions.PermitLimit;
        options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        options.QueueLimit = myOptions.QueueLimit;
    }));

See the documentation for more details and example implementations. For more examples I also encourage you to take a look at Maarten Balliauw's blog ASP.NET Core rate limiting middleware in .NET 7.

33. The Methods to Update an Array: Cheat Sheet

ECMAScript 2023 (ES2023 or ES14) introduces a fresh set of array instance methods to enhance the way arrays can be modified.

In total four new methods are added, toSorted() (vs sort()), toReversed() (vs reverse()), toSpliced() (vs splice()), and with (vs bracket notation). These methods use immutable operations on arrays, making it easier and more predictable to work with data without directly modifying the original array.

If you're use TypeScript, these methods are available in version 5.2.

Let's dive into these new methods, and at the same time refresh our knowledge for the existing methods.

 content_paste
/**
 * Sorts the array - by id
 * sort: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
 * toSorted: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toSorted
 */
update('sort', (persons) => persons.sort((a, b) => a.id - b.id));
update('sort immutable', (persons) => persons.toSorted((a, b) => a.id - b.id));
 
/**
 * Reverses the array
 * reverse: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse
 * toReversed: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toReversed
 */
update('reverse', (persons) => persons.reverse());
update('reverse immutable', (persons) => persons.toReversed());
 
/**
 * Changes an element in the array
 * bracket notation
 * toSpliced: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/with
 */
update('change (bracket notation)', (persons) => {
  persons[1] = { id: 9, name: 'Updated Person' };
  return persons;
});
update('with immutable', (persons) => persons.with(1, { id: 9, name: 'Updated Person' })); // 🎉 New in ES2023 (and TS 5.2)
 
/**
 * Changes the contents of the array - remove person at index 2 and 3, add new person at index 0
 * splice: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
 * toSpliced: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toReversed
 */
update('splice', (persons) => {
  console.log(persons.splice(2, 2)); // returns the deleted item
  console.log(persons.splice(0, 0, { id: 9, name: 'New Person' })); // returns the deleted item (empty in this case)
  return persons;
});
update('toSpliced immutable', (persons) =>
  persons.toSpliced(2, 2).toSpliced(0, 0, { id: 9, name: 'New Person' }),
); // 🎉 New in ES2023 (and TS 5.2)
 
/**
 * Removes the last element
 * pop: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop
 * slice: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
 */
update('pop', (persons) => {
  console.log(persons.pop()); // returns the deleted item
  return persons;
});
update('slice (remove last) immutable', (persons) => persons.slice(0, -1));
 
/**
 * Removes the first element
 * shift: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift
 * slice: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
 */
update('shift', (persons) => {
  console.log(persons.shift()); // returns the deleted item
  return persons;
});
update('slice (remove first) immutable', (persons) => persons.slice(1));
 
/**
 * Adds element(s) to the end of the array
 * push: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push
 * concat: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat
 */
update('push', (persons) => {
  console.log(persons.push({ id: 9, name: 'New Person' })); // returns the new length
  return persons;
});
update('concat immutable', (persons) => persons.concat({ id: 9, name: 'New Person' }));
 
/**
 * Adds element(s) to the start of the array
 * unshift: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift
 * toSpliced: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toSpliced
 */
update('unshift', (persons) => {
  console.log(persons.unshift({ id: 9, name: 'New Person' }, { id: 10, name: 'Other New Person' })); // returns the new length
  return persons;
});
update('toSpliced immutable', (persons) =>
  persons.toSpliced(0, 0, { id: 9, name: 'New Person' }, { id: 10, name: 'Other Person' }),
);
 
/**
 * Changes all elements within a range to a static value
 * fill: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill
 * ❌: has no immutable version
 */
update('fill', (persons) => persons.fill({ id: 9, name: 'New Person' }, 2, 4));
 
/**
 * Shallow copies part of this array to another location in the same array
 * copyWithin: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin
 * ❌: has no immutable version
 */
update('copyWithin', (persons) => persons.copyWithin(1, 2, 3));
 
// Helpers
function update(description: string, updater: (original: Person[]) => Person[]) {
  const original: Person[] = initPersons();
  const updated = updater(original);
  console.log(`[${description}]`, {
    updated,
    original,
  });
}
 
function initPersons(): Person[] {
  return [
    { id: 2, name: 'Mike Johnson' },
    { id: 1, name: 'Sarah Williams' },
    { id: 5, name: 'David Wilson' },
    { id: 4, name: 'Emily Davis' },
    { id: 3, name: 'Michael Johnson' },
  ];
}
type Person = { id: number; name: string };

For additional details, check out the MDN documentation. Besides the new mutable methods, the ES2023 also added the findLast, and findLastIndex methods for an easy lookup of the last element in an array.

A runnable example can be found in the following the TypeScript Playground.

32. Angular DevTools

The Angular DevTools is a browser extension that provides debugging and profiling capabilities for Angular applications. With the DevTools you can explore the component tree and investigate (and edit) the state of your components.

Using the profiler you can visualize the execution of Angular’s change detection and use this to identify performance bottlenecks.

This feature makes it easy to compare the different change detection strategies. The benefits of local change detection, which Rainer Hahnekamp explains in his blog Local Change Detection in Angular, will clearly be visible in the profiler.

31. Snapshot testing in C# with Verify

Why snapshot testing link

Snapshot testing is a powerful technique that allows you to compare the output of your code with a previously stored value, also known as a snapshot. This way, you create a quick feedback loop to easily detect any changes or regressions in your code without having to write complex assertions.

I like to write snapshot tests to compare the output of a (large or complex) contract against a pre-defined data model. This is often faster to write and easier to read (also by non-technical people) in comparison to writing a complex assertion with code.

How does it work link

Snapshot testing usually stores a previously generated output as a separate file. When the test case is re-executed it compares the new output (local, not included in git) against the stored file (which is included in git). If the new output matches the existing output the test will pass, otherwise the test will fail. When the latter is the case, you can either update the snapshot if the change is desired or investigate the change(s) if the output is unexpected.

Using Verify in C# link

For snapshot testing in C# you can use the Verify snapshot tool.

Verify is a simple library that you can use as a standalone tool, or you can use one of its opt-in integrations with popular testing frameworks, such as NUnit, xUnit, and MSTest. A killer feature is that Verify also provides a rich diffing tool (think of a git compare) to help you understand the differences between snapshots, including helpful "accept" and "reject" features to update the snapshots.

To write a snapshot test with Verify use one of the Verify methods within a test to return the model under test. By default it uses the fully qualified method name of the test case to create the existing output file (*.verified.*) and the newly generated file (*.received.*). Every time the test case is executed, the received file is re-created and compared with the verified file.

To make the managing of snapshots easier, you can make use of IDE plugins (ReSharper Plugin or Rider Plugin) or the dotnet cli tool.

As an example let's take a look at the following flow using Verify.

 Tests.cs content_paste
public class Tests
{
    [Test]
    public Task Person_matches_with_contract()
    {
        var person = new Person(7, "Tim", "Running");
        return Verify(person);
    }
}

 The initial file that is received content_paste
 {
    id: 7,
    name: Tim,
    hobby: Running,
 }

 The compare between the received and existing files after a change content_paste
{
     id: 7,
     name: Tim,
    hobby: Running
}

 Test outcome to accept or reject content_paste
Failed Person_matches_with_contract
Error Message:
   VerifyException
NotEqual:
  - Received: Tests.Person_matches_with_contract.received.txt
    Verified: Tests.Person_matches_with_contract.verified.txt
FileContent:
NotEqual:
Received: Tests.Person_matches_with_contract.received.txt
{
   Id: 7,
   Name: Tim
}
Verified: Tests.Person_matches_with_contract.verified.txt
{
  Id: 7,
  Name: Tim,
  Hobby: Running
}

30. Simplify Grouping Arrays in JavaScript with Object.groupBy()

Grouping an array of objects in JavaScript no longer needs to be complex. The new Object.groupBy() static method simplifies this task by allowing you to group elements based on string values returned by the callback function.

Previously, achieving this required manual grouping (using methods like reduce) or relying on external libraries like Lodash. However, with Object.groupBy(), you can achieve the same result in a more readable and concise manner.

Here are the key points:

• 💫 Functionality: group elements based on a specified string (object key or custom string).
• 💁 Browser Compatibility: available in modern browsers.
• 🛠️ TypeScript Support: included in v5.4-beta.

 content_paste
type Player = { name: string; team: string; yearsActive: number };
const players: Player[] = [
  {
    name: 'Player 1.1',
    team: 'Team One',
    yearsActive: 3,
  },
  {
    name: 'Player 1.2',
    team: 'Team One',
    yearsActive: 5,
  },
  {
    name: 'Player 2.1',
    team: 'Team Two',
    yearsActive: 1,
  },
  {
    name: 'Player 3.1',
    team: 'Team Three',
    yearsActive: 8,
  },
  {
    name: 'Player 3.2',
    team: 'Team Three',
    yearsActive: 2,
  },
];

 content_paste
const playersByTeam = Object.groupBy(players, (player) => {
  return player.team;
});

 content_paste
const playersByExperience = Object.groupBy(players, (player) => {
  // instead of creating groups based on a property
  // we can also return a generated group key
  return player.yearsActive <= 2 ? 'Rookies' : 'Veterans';
});

 content_paste
const playersByTeam = players.reduce(
  (group, player) => {
    if (group.hasOwnProperty(player.team)) {
      group[player.team] = [...group[player.team], player];
      return group;
    }
 
    group[player.team] = [player];
    return group;
  },
  {} as Record<string, Player[]>,
);

To explore and experiment with Object.groupBy(), check out the following TypeScript playground to see the code in action.

29. Entity Framework Include Filters

The location where you filter (included) entities is important, as it has a significant impact on the result set. Without knowing the details, it's easy to make assumptions and make a subtle mistake while filtering entities.

I know I made the mistake numerous times, even not so long ago, and I'm sure I'm not the only one. That's why I decided to write this Bit, to raise awareness about the small but important details.

The following examples illustrate the difference between including filtered entities (using Where), and filtering entities after the include (using Any in this example) statement.

 content_paste
[
  {
    "FullName": "Tiffany Gerlach",
    "Addresses": [
      {
        "Street": "70 Delmer Ways",
        "ZipCode": "2377"
      },
      {
        "Street": "61 Trisha River",
        "ZipCode": "7470"
      }
    ]
  },
  {
    "FullName": "Milford Nader",
    "Addresses": [
      {
        "Street": "86 Feeney Pine",
        "ZipCode": "6560"
      },
      {
        "Street": "23 Hauck Run",
        "ZipCode": "3610"
      }
    ]
  }
]

The first example retrieves all persons and only includes the addresses matching the ZipCode predicate. Does not filter the "root" entity.

 content_paste
var persons = await dbContext.Set<Person>()
  .Include(p => p.Addresses.Where(a => a.ZipCode == "7470"))
  .ToListAsync();

 content_paste
[
  {
    "FullName": "iffany Gerlach",
    "Addresses": [
      {
        "Street": "61 Trisha River",
        "ZipCode": "7470"
      }
    ]
  },
  {
    "FullName": "Milford Nader",
    "Addresses": []
  }
]

The second example only retrieves persons that contain the specified ZipCode condition, with all their addresses. Filters the "root" entity, not the children.

 content_paste
var persons = await dbContext.Set<Person>()
  .Include(p => p.Addresses)
  .Where(p => p.Addresses.Any(a => a.ZipCode == "7470"))
  .ToListAsync();

 content_paste
[
  {
    "FullName": "Tiffany Gerlach",
    "Addresses": [
      {
        "Street": "70 Delmer Ways",
        "ZipCode": "2377"
      },
      {
        "Street": "61 Trisha River",
        "ZipCode": "7470"
      }
    ]
  }
]

28. Automatically verify that team rules are met using Architectural Tests

Every team has rules and agreements on how to write and structure code. In the best case, these are documented, and yes we all know that developers don't like to read documentation, also every team has its unwritten rules. Some of these rules carry over across teams e.g. best practices, while others do not and are team-specific e.g. a personal preference or some historical reason.

So how do you make sure that everyone including new team members follow the team's style? We already established that it's hard to stick to the rules using a wiki. Pair programming and pull requests do help, but this doesn't scale well. This also leaves room for inconsistencies.

Instead of a human verifying if the rules are followed, we need a way to automate this process. While doing so, the agreed team rules are set in stone and cannot be ignored or misinterpreted.

Teams already rely on automated tests to test the functional requirements (and probably the non-functional requirements) of the application. So why not include test cases to test if your team rules are met?

As a solution, we can resort to Architectural Tests. Architectural Tests are comparable to unit tests and are focused on the architecture as a way to enforce team rules and agreements.

Automating this process gives the same benefits as other tests, it saves time and shortens the feedback loop. And one needs to be the bad guy while (repeatedly) commenting on someone else's code. As a result, this widens the pit of success. The same rules apply to every team member, this greatly improves the consistency within your codebase.

Some good candidates that qualify to write Architectural Tests are:

• Naming rules
• Dependency rules (Namespace and Types)
• Folder/namespace structure rules
• Attribute-based rules

To write architecture tests we use the ArchUnitNET package (a port from the popular ArchUnit package in the Java ecosystem). Using its FluentAPI rules (tests) can be created to assert the structure of a system. When a test fails, it provides a descriptive and clear error message, in which you can also include a reason.

Some practical examples:

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Domain.AssemblyReference).Assembly
        ).Build();
 
    [Test]
    public void Only_AggregateRoots_end_with_root_in_the_name()
    {
        IArchRule classesToEndWithRoot = Classes()
            .That()
            .ResideInNamespace("Domain")
            .And()
            .ImplementInterface(typeof(IAggegrateRoot))
            .Should()
            .HaveNameEndingWith("Root");
 
        IArchRule classesDontEndWithRoot = Classes()
            .That()
            .ResideInNamespace("Domain")
            .And()
            .HaveNameEndingWith("Root")
            .Should()
            .ImplementInterface(typeof(IAggegrateRoot))
            .Because("To prevent confusion, only aggregate roots can end with 'Root'.")
            .AndShould()
            .BeSealed();
 
        IArchRule rootRules = classesToEndWithRoot
                .And(classesDontEndWithRoot);
 
        rootRules.Check(Architecture);
    }
}

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Domain.AssemblyReference).Assembly,
        ).Build();
 
    [Test]
    public void Core_doesnt_have_a_dependency_on_infrastructure()
    {
         IObjectProvider<IType> forbiddenLayer = Types()
             .That()
             .ResideInNamespace("Infrastructure")
             .As("Infrastructure Layer");
 
        TypesShouldConjunction violations = Types()
            .That()
            .ResideInAssembly(typeof(Domain.Domain).Assembly)
            .Should()
            .NotDependOnAny(forbiddenLayer);
 
        violations.Check(Architecture);
    }
}

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Migrations.AssemblyReference).Assembly
        ).Build();
 
    [Test]
    public void Migrations_are_annotated_with_the_MigrationsAttribute_and_follow_the_agreed_upon_name_convention()
    {
        IArchRule migrationConventionRule = Classes()
            .That()
            .ResideInNamespace("Migrations.Migrations")
            .Should()
            .HaveAnyAttributes(typeof(FluentMigrator.MigrationAttribute))
            .Because("Otherwise the migration isn't run")
            .AndShould()
            .HaveFullName("^Migration_\\d{12}_[A-Za-z0-9_]+?$", true)
            .Because("The filename impacts the order of execution");
 
        migrationConventionRule.Check(Architecture);
    }
}

 content_paste
public class ArchituralTests
{
    private static readonly Architecture Architecture =
        new ArchLoader().LoadAssemblies(
            typeof(Domain.AssemblyReference).Assembly,
            typeof(WebApi.AssemblyReference).Assembly
        ).Build();
 
    [Test]
    public void Empty_classes_are_not_allowed()
    {
        var classesWithoutBody = Classes()
            .GetObjects(Architecture)
            .Where(clazz =>
            {
                return !clazz.GetFieldMembers().Any()
                       && !clazz.GetPropertyMembers().Any()
                       && clazz.GetMethodMembers().All(methodMember => methodMember.IsConstructor());
            });
 
        Assert.Multiple(() =>
        {
            foreach (var clazz in classesWithoutBody)
            {
                Assert.Fail($"The class '{clazz.Name}' doesn't have a body, did you forget to clean this up?");
            }
        });
    }
 
    [Test]
    public void Models_always_have_an_empty_internal_constructor()
    {
        var modelsWithoutCtor = Classes()
            .That()
            .ResideInNamespace("Models")
            .GetObjects(Architecture)
            .Where(clazz =>
            {
                var internalCtors = clazz.Constructors.Where(c => c.Visibility == Visibility.Internal);
                return !internalCtors.Any() || internalCtors.All(c => c.Parameters.Count() != 0);
            });
 
        Assert.Multiple(() =>
        {
            foreach (var model in modelsWithoutCtor)
            {
                Assert.Fail($"Make sure that '{model.Name}' has an empty constructor it's serializable.");
            }
        });
    }
}

While I was writing this Bit I also noticed Milan Jovanović created two videos (How To Create Better .NET Applications with Architecture Tests and How to Write Architecture Tests for the Clean Architecture) on Architectural Tests using a similar library NetArchTest. Both libraries serve the same purpose, and have a similar Fluent API, but are different in some small details e.g. in the way they assert the rules.

A little side note, there isn't a lot of documentation about both of these libraries and this will require some trial and error while writing your first architectural tests, at least this was the case for myself.

27. Generate code with NSwag using the OpenAPI Specification

I was always skeptical about code generation tools using the OpenAPI specification. But recently, I decided to give it another go, and surprisingly it was a positive experience!

My use case was an integration with a 3rd party, instead of writing all the DTO models and endpoints manually I resorted to NSwag to generate an HTTP client (including all of its dependencies) for me. You can also use this for code that you own.

NSwag provides different methods for generating code, ranging from a manual operation to an automated way. Besides C# HTTP Clients, it also supports the generation of C# Models/Controllers, as well as TypeScript clients for most front-end technologies, e.g. Angular.

• NSwagStudio: a Windows Desktop application to import an OpenAPI specification, and configure the parameters to generate the output file. Based on the configuration you can generate a client and/or save the configuration to an NSwag configuration document (*.nswag.json), which can be used later again with the intent to regenerate the client.

• A CommandLine Tool with commands to generate code based on an NSwag configuration document (which is created with NSwagStudio)

 content_paste
#          👇 created with NSwagStudio
nswag run ./petstore.nswag.json /runtime:Net70
# There's currently an issue with using Net80

• NSwag.MSBuild to incorporate the generation process during a build (this also uses the NSwag config file)

 content_paste
<PropertyGroup>
  <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
</PropertyGroup>
 
<Target Name="NSwag" AfterTargets="PostBuildEvent" Condition=" '$(Configuration)' == 'Debug' ">
  <Exec WorkingDirectory="$(ProjectDir)" EnvironmentVariables="ASPNETCORE_ENVIRONMENT=Development" Command="$(NSwagExe_Net70) run nswag.json /variables:Configuration=$(Configuration)" />
</Target>

• NSwag.CodeGeneration.CSharp, a NuGet package to generate code using C#. There's also a TypeScript equivalent NSwag.CodeGeneration.TypeScript to generate TypeScript code.

 content_paste
using NSwag;
using NSwag.CodeGeneration.CSharp;
 
await GenerateCSharpClient("https://petstore.swagger.io/v2/swagger.json", "PetStoreClient");
 
static async Task GenerateCSharpClient(string openApiLocation, string className)
{
    var document = await OpenApiDocument.FromUrlAsync(openApiLocation);
    var settings = new CSharpClientGeneratorSettings
    {
        UseBaseUrl = false,
        ClassName = className,
        GenerateClientInterfaces = true,
        CSharpGeneratorSettings =
        {
            Namespace = "HttpClients",
        },
    };
 
    var generator = new CSharpClientGenerator(document, settings);
    var generatedCode = generator.GenerateFile();
 
    var path = $"../../../{settings.CSharpGeneratorSettings.Namespace}/{settings.ClassName}";
    var file = new FileInfo(path);
    file.Directory.Create();
    await File.WriteAllTextAsync(file.FullName, generatedCode);
}

All of these gives you a working C# HTTP Client, including the needed models, interfaces, ... as output.

 Generated.cs content_paste
[System.CodeDom.Compiler.GeneratedCode("NSwag", "14.0.2.0 (NJsonSchema v11.0.0.0 (Newtonsoft.Json v13.0.0.0))")]
public partial interface IPetStoreClient
{
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    /// <summary>
    /// Add a new pet to the store
    /// </summary>
    /// <param name="body">Pet object that needs to be added to the store</param>
    /// <exception cref="ApiException">A server side error occurred.</exception>
    System.Threading.Tasks.Task AddPetAsync(Pet body, System.Threading.CancellationToken cancellationToken);
 
    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    /// <summary>
    /// Find pet by ID
    /// </summary>
    /// <remarks>
    /// Returns a single pet
    /// </remarks>
    /// <param name="petId">ID of pet to return</param>
    /// <returns>successful operation</returns>
    /// <exception cref="ApiException">A server side error occurred.</exception>
    System.Threading.Tasks.Task<Pet> GetPetByIdAsync(long petId, System.Threading.CancellationToken cancellationToken);
 
    ...
}

Tip

There's also the .NET Core Global Tool Microsoft.dotnet-openapi to generate HTTP clients using the OpenAPI specification. Internally it uses NSwag for the generation. From my limited experience with it, it isn't as versatile as the toolkit that NSwag provides, NSwag is also better documented. But, dotnet openapi definitely something to keep an eye out for in the future.

 content_paste
dotnet openapi add url https://petstore.swagger.io/v2/swagger.json --code-generator NSwagCSharp --output-file petstore.swagger.json
dotnet openapi refresh --updateProject ./MyProject.csproj https://petstore.swagger.io/v2/swagger.json

The add will also create an OpenApiReference within the project, which is +/- the same as adding an OpenAPI specification via Visual Studio. Because of this, it can also be interpreted by Visual Studio, and the generated client can be viewed and refreshed via the UI.

26. Use Zod to parse Unknown Data

How many times was there an issue within your application because you trusted data that you don't control (e.g. incoming data), or worse, how many times did the application entirely crash because of it? Thinking back, was this easy to detect and could it have been prevented?

Instead of trusting the data that you don't own, it's better to guard yourself against unexpected cases. Using zod it becomes an easy task to detect unexpected data structures and act accordingly.

format_quote

Zod is a TypeScript-first schema declaration and validation library. I'm using the term "schema" to broadly refer to any data type, from a simple string to a complex nested object.
Zod is designed to be as developer-friendly as possible. The goal is to eliminate duplicative type declarations. With Zod, you declare a validator once and Zod will automatically infer the static TypeScript type. It's easy to compose simpler types into complex data structures.

Because an example says more than words, let's revise and refactor an example from my latest blog post Multiple releases using the same, but configurable, Angular Standalone Application build. In the blog post, the environment configuration is defined as a JSON structure and is assigned to an instance at run-time. This can go horribly wrong when the interface and the JSON model aren't in sync anymore, e.g. after updating the model but not the JSON file.

 environment-config.ts content_paste
import { z } from 'zod';
 
export const environmentConfigSchema = z.object({
  apiUrl: z.string().min(1),
});
export type EnvironmentConfig = z.infer<typeof environmentConfigSchema>;

 main.ts content_paste
import { bootstrapApplication } from '@angular/platform-browser';
import { AppComponent } from './app/app.component';
import { createAppConfig } from './app/app.config';
import { environmentConfigSchema } from './app/environment-config';
 
fetch('./assets/environment-config.json')
  .then((resp) => resp.json())
  .then((config) => {
    const environmentConfig = environmentConfigSchema.parse(config);
    //    ^? { apiUrl: string }
    bootstrapApplication(AppComponent, createAppConfig(environmentConfig));
  });

Before the application is bootstrapped, the config is parsed and when the apiUrl isn't present in config file (or is empty), the following error is thrown in a clean and concise format that contains all the necessary information.

 content_paste
ZodError: [
  {
    "code": "too_small",
    "minimum": 1,
    "type": "string",
    "inclusive": true,
    "exact": false,
    "message": "String must contain at least 1 character(s)",
    "path": [
      "apiUrl"
    ]
  }
]

Using this example, we see the benefits that Zod brings to a team:

• Eliminates Duplicative Type Declarations: With Zod, you declare a schema once and Zod can infer the static TypeScript type.
• Ensures Data Consistency: Zod helps ensure that the data your team works with is consistent and adheres to the defined schema.
• Enhances Developer Experience: using Zod simplifies the process of validating and parsing data, instead of introducing a big blob of messy code to validate objects, Zod streamlines and unifies this process making development easier and more efficient.

Other scenarios where Zod is useful involve other parts in a codebase that interacts with the "outside world", such as HTTP responses, URL parameters, CLI input, and it can even be useful for form validation.

As you can see, it's usually data that the application receives, or in other words data that you don't control, that needs to be parsed before it can be safely accessed/used.

While Zod is small in size (8kb minified + zipped), the only caveat is that it cannot be threeshaken. If that's a requirement there are a couple of alternatives inspired by Zod, e.g. Valibot.

If you're interested, take a look at the Zod articles on my blog. Here you will see more use cases, such as generating test data using zod-fixture.

25. New in Entity Framework 8: Primitive collection properties

Starting from EF 8, EF automatically stores a collection of primitive values directly in a column (as JSON), whereas previously a separate table was required.

To query data, the OPENJSON table-valued function is used. This creates a rowset view of the JSON data, which can be compared as a "normal" relational table, and can thus be queried as you're used to.

A use case for using primitive collection properties is to save a data collection that's retrieved via its parent. If you need to query this set, it's probably better to store the collection in a seperate table. This allows you to create indecies in order to optimize search-based scenarios, that otherwise isn't possible using a JSON column.

Let's explore how this translates into code and SQL.

 content_paste
public class Person
{
    public required Guid Id { get; init; }
    public required int[] LuckyNumbers { get; init; }
}
 
/*
  CREATE TABLE [dbo].[Persons](
    [Id] [uniqueidentifier] NOT NULL,
    [LuckyNumbers] [nvarchar](max) NOT NULL,
    CONSTRAINT [PK_Persons] PRIMARY KEY CLUSTERED ([Id] ASC)
  )
*/

 content_paste
var person = new Person
{
    Id = Guid.NewGuid(),
    LuckyNumbers = [1, 3, 5, 7]
};
 
dbContext.Add(person);
dbContext.SaveChanges();
 
/*
  exec sp_executesql N'SET IMPLICIT_TRANSACTIONS OFF;
  SET NOCOUNT ON;
  INSERT INTO [dbo].[Persons] ([Id], [LuckyNumbers])
  VALUES (@p0, @p1);
  ',N'@p0 uniqueidentifier,@p1 nvarchar(4000)',
  @p0='691dbfdd-62b3-43f5-a9bb-498985ac7952',
  @p1=N'[1,3,5,7]'
*/

 content_paste
--------------------------------------+--------------+
| Id | LuckyNumbers |
--------------------------------------+--------------+
| 691dbfdd-62b3-43f5-a9bb-498985ac7952 | [1,3,5,7] |
--------------------------------------+--------------+

 content_paste
var persons = dbContext.Set<Person>()
  .Where(p => p.LuckyNumbers.Contains(3))
  .ToList();
 
/*
  SELECT [p].[Id], [p].[LuckyNumbers]
  FROM [dbo].[Persons] AS [p]
  WHERE 3 IN (
    SELECT [l].[value]
    FROM OPENJSON([p].[LuckyNumbers])
    WITH ([value] int '$') AS [l]
  )
*/

For more info and new features introced in EF 8 see the documentation.

24. Improve your development tasks with Windows Dev Drive

If you know me, you know that I like to fully optimize my workflow, and a Dev Drive helps to improve it.

A Dev Drive is a virtual drive (using the ReFS technology) that speeds up file-related tasks. This makes it ideal for many daily development related jobs such as building applications, installing packages, running test suites, and so on.

I find that this is the ideal time of the year to make changes before hitting the ground again because you'll benefit from this for the rest of the upcoming year. That's why I recommend you to take a look at a Dev Drive, since it just takes a moment to set up a Dev Drive on Windows.

Here's a comparison after migrating my projects and cache locations (for NuGet and npm) to a Dev Drive. As you can notice, all of the commands that I use frequently have improved by 20% to 25%.

Check it out and see the difference for yourself!

I also found Maarten Balliauw's blog Test-Driving Windows 11 Dev Drive for .NET helpful and easy to follow, it also contains useful scripts to automate the migration.

For more Windows tips and tricks to improve your development workflow, see How I've set up my new Windows development environment in 2022.

23. Optimize your bundle size with source-map-explorer

Recently I was able to reduce the initial load of our Angular application from 2.8MB to 750kb (a 75% reduction!) in just a few minutes.

Using source-map-explorer I was able to detect eagerly loaded modules that should've been lazy loaded, and dependencies that could be moved or removed.

If you want to optimize your bundle size, run the following command (replace PROJECT-NAME) and analyze the main.js file to start your investigation.

 content_paste
npx source-map-explorer ./dist/PROJECT-NAME/*.js

This command should open a new browser window with the output details in which you can see all the included dependencies (from your own or 3rd parties).

Make sure that you've built your project with source-maps enabled. If that's not the case, either update your source map configation, or pass the --source-map option flag to the Angular build command.

For the next step, explore the remaining files and be attentive to what can be trimmed down.

22. Simpler code with Using Declarations

The using declaration is a feature (introduced in C# 8.0) that allows you to declare a disposable object with the using keyword.

The lifetime of a using local will extend to the end of the scope in which it is declared. The using locals will then be disposed in the reverse order in which they are declared.

I prefer this syntax compared to the "older" using statements because it's easier to read and follow. You no longer have to create scope blocks with curly brackets (and the accompanying indentation(s)) to dispose objects.

 UsingDeclarion content_paste
int CountOccurences(string fileName, string word)
{
    using var fileStream = new FileStream(fileName, FileMode.Open);
    using var reader = new StreamReader(fileStream);
    /* Logic here */
}

 UsingStatement.cs content_paste
int CountOccurences(string fileName, string word)
{
    using (var fileStream = new FileStream(fileName, FileMode.Open))
    {
        using (var reader = new StreamReader(fileStream))
        {
           /* Logic here */
        }
    }
}

21. 👋 Hello @ngrx/signals

Exciting news for Angular developers!

With the release of Angular Signals, the NgRx team - especially Marko Stanimirović who came up with the idea and did the heavy lifting - built a new state management solution that provides a reactive state management solution and a set of utilities for Angular Signals.

@ngrx/signals consists of two big blocks and includes multiple smaller convenient Lego blocks to make working with state simple and intuitive.

• The signalState utility method provides a lightweight solution that manages state in a concise and minimalistic manner;
• While signalStoreprovides a full-blown state management solution (with optional plugins, e.g. Entity Management);

These tools provide an opinionated, but flexible, development experience to build your application.

Check out the v17 blog post for more info, or the in-depth blog posts from the Angular Architects team!

 counter.component.ts content_paste
import { Component } from '@angular/core';
import { signalState, patchState } from '@ngrx/signals';
 
@Component({
  selector: 'app-counter',
  standalone: true,
  template: `
    Count: {{ state.count() }}
 
    <button (click)="increment()">Increment</button>
    <button (click)="decrement()">Decrement</button>
    <button (click)="reset()">Reset</button>
  `,
})
export class CounterComponent {
  state = signalState({ count: 0 });
 
  increment() {
    patchState(this.state, (state) => ({ count: state.count + 1 }));
  }
 
  decrement() {
    patchState(this.state, (state) => ({ count: state.count - 1 }));
  }
 
  reset() {
    patchState(this.state, { count: 0 });
  }
}

 counter.store.ts content_paste
import { computed } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { interval } from 'rxjs';
import {
  signalStore,
  withState,
  patchState,
  withComputed,
  withHooks,
  withMethods,
} from '@ngrx/signals';
 
export const CounterStore = signalStore(
  withState({ count: 0 }),
  withComputed(({ count }) => ({
    doubleCount: computed(() => count() * 2),
  })),
  withMethods(({ count, ...store }) => ({
    increment() {
      patchState(store, { count: count() + 1 });
    },
    decrement() {
      patchState(store, { count: count() - 1 });
    },
  })),
  withHooks({
    onInit({ increment }) {
      interval(2_000)
        .pipe(takeUntilDestroyed())
        .subscribe(() => increment());
    },
    onDestroy({ count }) {
      console.log('count on destroy', count());
    },
  }),
);

 counter.component.ts content_paste
import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
import { CounterStore } from './counter.store';
 
@Component({
  selector: 'app-counter',
  standalone: true,
  template: `
    <p>Count: {{ store.count() }}</p>
    <p>Double Count: {{ store.doubleCount() }}</p>
 
    <button (click)="store.increment()">Increment</button>
    <button (click)="store.decrement()">Decrement</button>
  `,
  providers: [CounterStore],
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export default class CounterComponent {
  readonly store = inject(CounterStore);
}