Proposal: Implement Orleans.Providers.IProviderBuilder, support RegisterProviderAttribute

[vrecluse]

For aspire, it's much more easier to use this library.
Example (untested):

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Orleans.Hosting;
using Orleans.Providers;
using Orleans.Providers.MongoDB.Configuration;

[assembly: RegisterProvider("MongoDB", "GrainStorage", "Silo",
    typeof(Orleans.Providers.MongoDB.Hosting.MongoDBGrainStorageProviderBuilder))]

namespace Orleans.Providers.MongoDB.Hosting
{
    internal sealed class MongoDBGrainStorageProviderBuilder : IProviderBuilder<ISiloBuilder>
    {
        public void Configure(ISiloBuilder builder, string? name, IConfigurationSection configurationSection)
        {
            name ??= ProviderConstants.DEFAULT_STORAGE_PROVIDER_NAME;

            builder.AddMongoDBGrainStorage(name, optionsBuilder =>
            {
                optionsBuilder.Configure<IConfiguration>((options, rootConfiguration) =>
                {
                    var databaseName = configurationSection["DatabaseName"];
                    if (!string.IsNullOrWhiteSpace(databaseName))
                    {
                        options.DatabaseName = databaseName;
                    }

                    var clientName = configurationSection["ClientName"];
                    if (!string.IsNullOrWhiteSpace(clientName))
                    {
                        options.ClientName = clientName;
                    }

                    var collectionPrefix = configurationSection["CollectionPrefix"];
                    if (!string.IsNullOrWhiteSpace(collectionPrefix))
                    {
                        options.CollectionPrefix = collectionPrefix;
                    }

                    var createShardKey = configurationSection["CreateShardKeyForCosmos"];
                    if (bool.TryParse(createShardKey, out var shouldCreateShardKey))
                    {
                        options.CreateShardKeyForCosmos = shouldCreateShardKey;
                    }
                });
            });
        }
    }
}

using Microsoft.Extensions.Configuration;
using Orleans.Hosting;
using Orleans.Providers;
using Orleans.Providers.MongoDB.Configuration;

[assembly: RegisterProvider("MongoDB", "Clustering", "Silo",
    typeof(Orleans.Providers.MongoDB.Hosting.MongoDBClusteringProviderBuilder))]
[assembly: RegisterProvider("MongoDB", "Clustering", "Client",
    typeof(Orleans.Providers.MongoDB.Hosting.MongoDBClusteringProviderBuilder))]

namespace Orleans.Providers.MongoDB.Hosting
{
    internal sealed class MongoDBClusteringProviderBuilder :
        IProviderBuilder<ISiloBuilder>,
        IProviderBuilder<IClientBuilder>
    {
        public void Configure(ISiloBuilder builder, string? name, IConfigurationSection configurationSection)
        {
            builder.UseMongoDBClustering(optionsBuilder =>
            {
                optionsBuilder.Configure<IConfiguration>((options, rootConfiguration) =>
                {
                    ApplyCommonOptions(options, configurationSection);
                });
            });
        }

        public void Configure(IClientBuilder builder, string? name, IConfigurationSection configurationSection)
        {
            builder.UseMongoDBClustering(optionsBuilder =>
            {
                optionsBuilder.Configure<IConfiguration>((options, rootConfiguration) =>
                {
                    ApplyCommonOptions(options, configurationSection);
                });
            });
        }

        private static void ApplyCommonOptions(
            MongoDBMembershipTableOptions options,
            IConfigurationSection configurationSection)
        {
            var databaseName = configurationSection["DatabaseName"];
            if (!string.IsNullOrWhiteSpace(databaseName))
            {
                options.DatabaseName = databaseName;
            }

            var clientName = configurationSection["ClientName"];
            if (!string.IsNullOrWhiteSpace(clientName))
            {
                options.ClientName = clientName;
            }

            var collectionPrefix = configurationSection["CollectionPrefix"];
            if (!string.IsNullOrWhiteSpace(collectionPrefix))
            {
                options.CollectionPrefix = collectionPrefix;
            }

            var createShardKey = configurationSection["CreateShardKeyForCosmos"];
            if (bool.TryParse(createShardKey, out var shouldCreateShardKey))
            {
                options.CreateShardKeyForCosmos = shouldCreateShardKey;
            }

            var strategy = configurationSection["Strategy"];
            if (!string.IsNullOrWhiteSpace(strategy) &&
                Enum.TryParse<MongoDBMembershipStrategy>(strategy, ignoreCase: true, out var parsedStrategy))
            {
                options.Strategy = parsedStrategy;
            }
        }
    }
}

[wassim-k]

Hi @vrecluse, I personally don't have any experience with Aspire, but I'd be open to a pull request. It will need to:

• Implement it as a separate package: Orleans.Providers.MongoDB.Aspire
• Include test coverage
• Update github actions to build and publish the package.

[justin-lovell]

@vrecluse , I've been using Aspire and assembled the host like a caveman (this is before the new model).

I am keen to modernize our host app though.

Are you actively working on this? Otherwise, I can start some progress on this.