What is SignalR?

SignalR is a library that allows you to add real-time web functionality to your applications. It provides a simple API for creating server-to-client remote procedure calls (RPC) that can be called from the server and client. Now SignalR supports trimming and Native AOT in .NET 8.0 and .NET 9.0. You can learn more about SignalR new features in this article.

What is trimming and Native AOT?

AOT (Ahead-of-Time) compilation is a feature that allows you to compile your application into native code before running it. This can help improve performance and reduce startup times. Trimming is a feature that allows you to remove unused code from your application, reducing its size and improving performance. You can learn more about Native AOT Compilation in this article.

How to use SignalR with trimming and Native AOT?

You can create ASP.NET Core AOT application with using the following command:

dotnet new webapiaot -n Acme.Sample

The created application uses CreateSlimBuilder method to create minimal builder for the application. You can use CreateBuilder method to create a builder with all the services registered. However, deploying an application with CreateSlimBuilder method is more convenient because it reduces the size of the application. You can learn more about CreateSlimBuilder vs CreateBuilder.

Replace the Program.cs file with the following code:

using Microsoft.AspNetCore.SignalR;
using System.Text.Json.Serialization;

var builder = WebApplication.CreateSlimBuilder(args);

builder.Services.AddSignalR();
builder.Services.Configure<JsonHubProtocolOptions>(o =>
{
    o.PayloadSerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
});

var app = builder.Build();

app.MapHub<ChatHub>("/chatHub");
app.MapGet("/", () => Results.Content("""
<!DOCTYPE html>
<html>
<head>
    <title>SignalR Chat</title>
</head>
<body>
    <input id="userInput" placeholder="Enter your name" />
    <input id="messageInput" placeholder="Type a message" />
    <button onclick="sendMessage()">Send</button>
    <ul id="messages"></ul>

    <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/8.0.7/signalr.min.js"></script>
    <script>
        const connection = new signalR.HubConnectionBuilder()
            .withUrl("/chatHub")
            .build();

        connection.on("ReceiveMessage", (user, message) => {
            const li = document.createElement("li");
            li.textContent = `${user}: ${message}`;
            document.getElementById("messages").appendChild(li);
        });

        async function sendMessage() {
            const user = document.getElementById("userInput").value;
            const message = document.getElementById("messageInput").value;
            await connection.invoke("SendMessage", user, message);
        }

        connection.start().catch(err => console.error(err));
    </script>
</body>
</html>
""", "text/html"));

app.Run();

[JsonSerializable(typeof(string))]
internal partial class AppJsonSerializerContext : JsonSerializerContext { }

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

It is a simple chat application that uses SignalR to send and receive messages.

Before deploying the application, ensure that Desktop development with C++ is installed on your machine if you're using Windows OS. For more details, you can check the pre-requisites.

You can deploy the application with the following command:

dotnet publish -c Release

Limitations

Since we are using Native AOT, there are some limitations that you should be aware of:

• Only the JSON protocol is supported: For the payload serialization in SignalR, only the JSON protocol is supported. You need to configure the JsonHubProtocolOptions to use the AppJsonSerializerContext for serialization/deserialization.
• Reflection: Native AOT does not support reflection. You need to use the JsonSerializable attribute to specify the types that should be serialized/deserialized. In this example, we have used the JsonSerializable attribute for the string type in the AppJsonSerializerContext class.

For more details, you can check the limitations of Native AOT.

Conclusion

In this article, we learned how to use SignalR with trimming and Native AOT in .NET 8.0 and .NET 9.0. We created a simple chat application that uses SignalR to send and receive messages. We also discussed the limitations of using Native AOT and how to overcome them.

For more information, you can refer to the Microsoft's official document.

What can we do when we want to store a list of primitive types? Before EF Core 8, there were two options:

• Create a wrapper class and a related table, then add a foreign key linking each value to its owner of the collection.
• Use value converter to serialize-deserialize as JSON.

The first option covers most scenarios if we need to add some additional properties to this type but let's say we're never gonna need this type additionality.

Which collection types are supported ?

EF Core has the capability to map the IEnumerable<T> public properties that have both a getter and a setter, with the T representing a primitive type

public class PrimitiveCollections
{
    public IEnumerable<int> Ints { get; set; }
    public ICollection<string> Strings { get; set; }
    public ISet<DateTime> DateTimes { get; set; }
    public IList<DateOnly> Dates { get; set; }
    public uint[] UnsignedInts { get; set; }
    public List<bool> Booleans { get; set; }
    public List<Uri> Urls { get; set; }
}

Some generic arguments are not considered primitive on the database side, such as uint and Uri. However, these types are also considered as primitive because there are built-in value converters.

Demo

In this sample, we have a Car class with a Color enum, and the Car class has a Colors property.

public enum Color
{
    Black,
    White,
    Red,
    Blue
}

public class Car
{
    public int Id { get; set; }
    public string Brand { get; set; }
    public string Model { get; set; }
    public ISet<Color> Colors { get; set; } = new HashSet<Color>();

    public Car(string brand, string model)
    {
        Brand = brand;
        Model = model;
    }
}

When we want to list the cars if they have any of the specific colors.

var colors = new HashSet<Color> { Color.Blue, Color.White };
var cars = await context
    .Cars
    .Where(x=> x.Colors.Intersect(colors).Any())
    .ToListAsync();

The SQL result looks like this; as you can see, it sends colors as parameters instead of adding them inline. It also uses the json_each function to deserialize on the database side.

SELECT "c"."Id", "c"."Brand", "c"."Colors", "c"."Model"
      FROM "Cars" AS "c"
      WHERE EXISTS (
          SELECT 1
          FROM (
              SELECT "c0"."value"
              FROM json_each("c"."Colors") AS "c0"
              INTERSECT
              SELECT "c1"."value"
              FROM json_each(@__colors_0) AS "c1"
          ) AS "t")

When we insert to the car table.

var car = new Car("Maserati", "GranTurismo")
{
    Colors = new HashSet<Color>()
    {
        Color.Black,
        Color.Blue
    }
};
context.Cars.Add(car);
await context.SaveChangesAsync();

The SQL statement looks like this, and as you can see, it automatically serializes into the Colors parameter as JSON.

 Executed DbCommand (0ms) [Parameters=
 [@p0='Maserati' (Nullable = false) (Size = 8),
  @p1='[0,3]' (Nullable = false) (Size = 5),
  @p2='GranTurismo' (Nullable = false) (Size = 4)
 ], CommandType='Text', CommandTimeout='30']
      INSERT INTO "Cars" ("Brand", "Colors", "Model")
      VALUES (@p0, @p1, @p2)
      RETURNING "Id";

Conclusion

We don't need to do anything if we just use a collection of primitive types. It serializes and deserializes them as JSON automatically. Additionally, it sends the primitive collection as a parameter to cache the query.

References

• EF Core 8 Primitive collections
• .NET Data Community Standup - Collections of primitive values in EF Core