Enhancing Startup and DI

[AmbulantRex]

I noticed an ancient comment suggesting there were plans to use the Microsoft interfaces to structure dependency injection here:

stride/sources/core/Stride.Core/IServiceRegistry.cs

Lines 28 to 31 in f523477

	/// <summary>
	/// A service registry is a <see cref="IServiceProvider"/> that provides methods to register and unregister services.
	/// </summary>
	public interface IServiceRegistry

. Do we know why this was never put into practice? Would it be valuable? Would it be performant?

On a tangential note, the generic host is something that could be leveraged to standardize application startup consistent with the .NET community. It offers some convenience for application lifetime management and configuration.

[tebjan]

This sounds like a good idea, but there is currently no one working on such improvements. Probably because other things have more impact on the users. If you want something to happen, it is up to you to start a pull request and set things in motion. Stride is supported only by its community.

[tagcode]

Microsoft's implementation is immutable, Stride's is mutable after construction.

All the serviceRegistry.GetOrCreateService() would need to be removed, and replaced with clear three phase initialization: 1) Read configurations, 2) Initialize DI service descriptors, 3) Initialize Game, 4) Start Game.

The methods and properties AddService(), RemoveService(), ServiceAdded and ServiceRemoved are not usable with System.IServiceProvider.

On plus side, there would be actual injection into class, and support from larger maintainer.

Best transition solution would be to add MS DI's along with Stride DI. Entity.Services would give deprecated warning.

class Entity {
    IServiceProvider ServiceProvider { get; }

    [Deprecated("Use ServiceProvider")]
    IServiceRegistry Services { get; }
}

There could be a layered implementation for IServiceRegistry where services could be added. And when read from, it can source from fallback location (IServiceProvider).

This is really easy to do. Most work would be with modifying the initialization structure of services and sample codes.

[raphaelschmitz00]

I have created a PR where I mostly copied how ASP Core does its startup,
just without the web stuff. I find it to be powerful in regards to extensibility,
while also quite easy to understand.

For anybody who's not familiar, the structure is this:

1. First create a builder, which sets up what we deem a good standard/default.
2. On that builder, a game can override those defaults and add its own dependencies and logging.
3. A call to builder.Build() then produces a StrideApplication. This can run the game.
4. Before we call Run(), though, we have the opportunity to set up things with the now fully established
   dependency tree. For example, choosing which EntityProcessors should run comes to mind.
5. Finally a call to Run() runs the application.

This is a breaking change, so it should be done in phases.

1. Alignment
   This phase right now. I ripped all the stuff from ASP except web stuff.
   So there's not just the IOC container, but also configuration, logging and environment.
   Let me know which parts we want.
2. Introduce the infrastructure
   Without really using it yet. This is the breaking change, which would require an update in minor version.
   Implementation details not added in the current PR also need to be added.
3. Migrate
   Migrate existing functionality to this new approach piece by piece.
4. Remove old functionality when not needed anymore

In the end we should check if we can just use the generic host which AmbulantRex mentioned in the beginning,
but for demonstrative purposes it's set up as an own implementation in the PR.

[amerkoleci]

Does all this stuff works well with Native AOT? Pay attention on that aspect as well, trimming and AOT analyzer should be considered.

[raphaelschmitz00]

@amerkoleci Good point, and that is not my expertise. The internet seems to suggest it's fine, though:
https://learn.microsoft.com/en-us/aspnet/core/grpc/native-aot?view=aspnetcore-8.0
https://andrewlock.net/exploring-the-dotnet-8-preview-the-minimal-api-aot-template/

These examples use WebApplication.CreateSlimBuilder(args);.
That's the ASP builder for web, but under the hood that uses the .NET generic host AmbulantRex already mentioned in the first post.
And the generic host basically just uses the same 4 components as in the example (Environment, Configuration, Services, Logging)

Additional note, .NET 7 has a nicer version of the host builder, which basically does what my "re-composition" of the parts of the .NET 6 version does in the PR. By the time we have decided on a scope for this change, .NET 8 (LTS) will be out and we could look at coordinating this with stride's update to .NET 8 (which will be a breaking change anyway).