Aspire 9.0 is the next major release, supporting both .NET 8 and .NET 9. This version includes new features and improvements.

Upgrade to Aspire

Now, you don't need workloads to develop Aspire applications. In your project, you can add an SDK reference to Aspire.AppHost.Sdk. For more information, you can check out https://aspire.dev/whats-new/aspire-9/#upgrade-to-aspire-9 which explains upgrading an existing project in details.

Dashboard

Aspire offers a nice dashboard for developers to observe the performance and behavior of their applications. In this version, there are some enhancements;

• Manage resource lifecycle: You can stop, start, and restart resources.
• Mobile and responsive support: The Aspire dashboard is now mobile-friendly.
• Sensitive properties: Properties can be marked as sensitive, automatically masking them in the dashboard UI.
• Volumes: Configured container volumes are listed in resource details.
• Health checks: Aspire 9 adds support for health checks.

Telemetry

Aspire 9 comes with many new features to the Telemetry service.

• Improve telemetry filtering: Telemetry data can now be filtered by attribute values.
• Combine telemetry from multiple resources: If a resource has multiple replicas, you can now filter telemetry data to view from all instances.
• Browser telemetry support: The dashboard now supports OpenTelemetry Protocol (OTLP) over HTTP and cross-origin resource sharing (CORS).

Orchestration

The .NET App Host is a core component of the .NET runtime that helps launch and execute .NET applications. Aspire 9 introduces many new features to the app host. Let's take a look;

• Waiting for dependencies: You can configure a resource to wait for another resource to start before starting.
• Resource health checks: The Waiting for dependencies feature uses health checks to determine if a resource is ready.

Integrations

Aspire has integrations with some services and tools that make it easy to get started. New integrations are coming with Aspire 9.

• Redis Insight
• OpenAI (Preview)
• MongoDB
• Azure

For Azure part, it is better to check the official documentation here https://aspire.dev/whats-new/aspire-9/#important-azure-improvements because it has a very detailed explanation.

ABP Studio

Aspire and ABP Studio are tools for different purposes with different scopes, and they have different approaches to solving problems; many developers may still be confused since they also have some similar functionalities and solve some common problems. You can check the comparison of Aspire and ABP Studio in this article.

The System.Text.Json namespace provides functionality for serializing to and deserializing from JSON. In .NET 8, there have been many improvements to the System.Text.Json serialization and deserialization functionality.

Source generator

.NET 8 includes enhancements of the System.Text.Json source generator that are aimed at making the Native AOT experience on par with the reflection-based serializer. This is important because now you can select the source generator for System.Text.Json. To see a comparison of Reflection versus source generation in System.Text.Json, check out the comparison documentation.

Interface hierarchies

.NET 8 adds support for serializing properties from interface hierarchies. Here is a code sample that shows this feature.

ICar car = new MyCar { Color = "Red", NumberOfWheels = 4 };
JsonSerializer.Serialize(car); // {"Color":"Red","NumberOfWheels":4}

public interface IVehicle
{
    public string Color { get; set; }
}

public interface ICar : IVehicle
{
    public int NumberOfWheels { get; set; }
}

public class MyCar : ICar
{
    public string Color { get; set; }
    public int NumberOfWheels { get; set; }
}

Naming policies

Two new naming policies snake_case and kebab-case have been added. You can use them as shown below:

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower };
JsonSerializer.Serialize(new { CreationTime = new DateTime(2023,11,6) }, options); // {"creation_time":"2023-11-06T00:00:00"}

Read-only properties

With .NET 8, you can deserialize onto read-only fields or properties. This feature can be globally enabled by setting PreferredObjectCreationHandling to JsonObjectCreationHandling.Populate. You can also enable this feature for a class or one of its members by adding the [JsonObjectCreationHandling(JsonObjectCreationHandling.Populate)] attribute. Here is a sample:

using System.Text.Json;
using System.Text.Json.Serialization;

var book = JsonSerializer.Deserialize<Book>("""{"Contributors":["John Doe"],"Author":{"Name":"Sample Author"}}""")!;
Console.WriteLine(JsonSerializer.Serialize(book));

class Author
{
    public required string Name { get; set; }
}

[JsonObjectCreationHandling(JsonObjectCreationHandling.Populate)]
class Book
{
    // Both of these properties are read-only.
    public List<string> Contributors { get; } = new();
    public Author Author { get; } = new() {Name = "Undefined"};
}

Before .NET 8, the output was like this:

{"Contributors":[],"Author":{"Name":"Undefined"}}

With .NET 8, the output now looks like this:

{"Contributors":["John Doe"],"Author":{"Name":"Sample Author"}}

Disable reflection-based default

One of the nice features about Serialization is, now you can disable using the reflection-based serializer by default. To disable default reflection-based serialization, set the JsonSerializerIsReflectionEnabledByDefault MSBuild property to false in your project file.

Streaming deserialization APIs

.NET 8 includes new IAsyncEnumerable<T> streaming deserialization extension methods. The new extension methods invoke streaming APIs and return IAsyncEnumerable<T>. Here is a sample code that uses this new feature.

const string RequestUri = "https://yourwebsite.com/api/saas/tenants?skipCount=0&maxResultCount=10";
using var client = new HttpClient();
IAsyncEnumerable<Tenant> tenants = client.GetFromJsonAsAsyncEnumerable<Tenant>(RequestUri);

await foreach (Tenant tenant in tenants)
{
    Console.WriteLine($"* '{tenant.name}' uses '{tenant.editionName
}' edition");
}

I have mentioned some of the items for Serialization Improvements in .NET 8. If you want to check the full list, you can read it in the .NET 8's What's new document.

In this article, I will show you one of the new features of EF Core 7 named "Model building conventions".

Entity Framework Core uses a metadata model to describe how entity types are mapped to the database. Before EF Core 7.0, it was not possible to remove or replace existing conventions or add new conventions. With EF Core 7.0, this is now possible. To read more about it, you can visit its documentation.

EF Core uses many built-in conventions. You can see the full list of the conventions on IConvetion Interface API documentation.

If you want to add, remove or replace a convention, you need to override ConfigureConventions method of your DbContext as shown below;

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.Conventions.Add(_ =>  new MyCustomConvention());
}

Allowed Operations

Removing an existing convention

Existing conventions provided by EF Core are well thought and useful, but sometimes some of them might not be a good candidate for your application. In such cases, you can remove an existing convention as shown below;

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.Conventions.Remove(typeof(ForeignKeyIndexConvention));
}

Adding a new convention

Just like removing a convention, we can add a completely new convention as well. You can define many different conventions here. For example, you can specify a standard precision for all decimal fields in your entities.

public class DecimalPrecisionConvention : IModelFinalizingConvention
    {
        public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
        {
            foreach (var property in modelBuilder.Metadata.GetEntityTypes()
                         .SelectMany(
                             entityType => entityType.GetDeclaredProperties()
                                 .Where(
                                     property => property.ClrType == typeof(decimal))))
            {
                property.Builder.HasPrecision(2);
            }
        }
    }

Note that, conventions are executed in the order they are added. So you need to be careful in which order they are added.

Replacing an existing convention

Sometimes, a default convention might work slightly different than what your app expects. In such cases, you can create your own implementation by inheriting from that convention and replace the default one. For example, you can create a convention as shown below;

public class MyCustomConvention : ADefaultEfCoreConvention
{
    public MyCustomConvention(ProviderConventionSetBuilderDependencies dependencies)
            : base(dependencies)
        {
        }    
    // override the methods you want to change.
}

Then, you can replace the default one with your implementation as shown below;

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.Conventions.Replace<ADefaultEfCoreConvention>(
        serviceProvider => new MyCustomConvention(
            serviceProvider.GetRequiredService<ProviderConventionSetBuilderDependencies>()));
}

As a final note, conventions never override configuration marked as DataAnnotation or Explicit. This means that, even if there is a convention, if the property has a DataAnnotation attribute or configuration in OnModelCreating, convetion will not be used. Here are the configuration types EF Core uses;

• Explicit: The model element was explicitly configured in OnModelCreating
• DataAnnotation: The model element was configured using a mapping attribute (aka data annotation) on the CLR type
• Convention: The model element was configured by a model building convention

Using in ABP-based solution

Since ABP uses EF Core, you can use this feature in ABP as well.