# Quick.EntityFrameworkCore

**Repository Path**: fffirer/Quick.EntityFrameworkCore

## Basic Information

- **Project Name**: Quick.EntityFrameworkCore
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-01-17
- **Last Updated**: 2025-01-17

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Feature

添加DbContext可根据配置自动获取数据库提供程序，连接名称，连接字符串等功能。而无需硬编码。

# Example

~/Sample/Program.cs
```csharp

var builder = WebApplication.CreateBuilder(args);

// 数据库配置
AutoConfiguration.Configure(builder.Services);

// 添加DbContext调用IServiceProvider.AutoConfigure<TDbContext>(DbContextOptionsBuilder)以应用配置
builder.Services.AddDbContext<DataDbContext>(
    (sp, options) => 
    { 
        sp.AutoConfigure<DataDbContext>(options); 
    });


builder.Services.AddDbContextPool<DataDbContext>(
    (sp, options) => 
    { 
        sp.AutoConfigure<DataDbContext>(options); 
    });


builder.Services.AddDbContextFactory<DataDbContext>(
    (sp, options) => 
    { 
        sp.AutoConfigure<DataDbContext>(options); 
    });


builder.Services.AddPooledDbContextFactory<DataDbContext>(
    (sp, options) => 
    { 
        sp.AutoConfigure<DataDbContext>(options); 
    });

```

~/SampleModels/AutoConfiguration.cs
```csharp
public sealed class AutoConfiguration
{
    public static AutoConfigureDbContextOptionsBuilder Configure(IServiceCollection services)
    {
        return services.AutoConfigureDbContextOptions()
            .AddConnectionStringAccess<ConnectionStringAccessor>()
            .AddProviderNameAccessor<NameAccessor>()
            .AddDatabaseSupport<SqliteAutoConfigure>()
            .AddDatabaseSupport<NpgsqlAutoConfigure>();
    }

    public class NpgsqlAccessor : IProviderNameAccessor
    {
        public object Get() => Providers.Npgsql;
    }

    public class NameAccessor : IProviderNameAccessor
    {
        protected virtual IConfiguration Configuration { get; set; }
        protected virtual ILogger _logger { get; set; }
        public NameAccessor(IConfiguration configuration,
            ILogger<NameAccessor> logger)
        {
            Configuration = configuration;
            _logger = logger;
        }

        protected string? _name => Configuration.GetSection("DatabaseProvider").Value;

        public object Get()
        {
            _logger?.LogDebug("DatabaseProvider: {Value}", _name);

            var value = _name switch
            {
                "sqlite" => Providers.Sqlite,
                "postgres" => Providers.Npgsql,
                _ => throw new NotSupportedException(_name)
            };

            return value;
        }
    }

    public class Providers
    {
        public const string Sqlite = nameof(Sqlite);
        public const string Npgsql = nameof(Npgsql);
        public const string SqlServer = nameof(SqlServer);
    }

    public class ConnectionStringAccessor : IConnectionStringAccessor
    {
        protected virtual IConfiguration Configuration { get; set; }
        protected virtual ILogger _logger { get; set; }
        public ConnectionStringAccessor(IConfiguration configuration, 
            ILogger<ConnectionStringAccessor> logger)
        {
            Configuration = configuration;
            _logger = logger;
        }

        public string Get()
        {
            var connectionName = Configuration.GetSection("ConnectionName").Value ?? "Default";
            _logger?.LogDebug("Connection Name: {Value}", connectionName);

            var connectionString = Configuration.GetConnectionString(connectionName) ?? string.Empty;
            _logger?.LogDebug("Connection String: {Value}", connectionString);

            return connectionString;
        }
    }

    public class SqliteAutoConfigure : IEntityFrameworkCoreDatabaseOptionsProvider
    {
        public string Name => Providers.Sqlite;

        public void Configure<TDbContext>(IServiceProvider serviceProvider, DbContextOptionsBuilder builder) where TDbContext : DbContext
        {
            var accessor = serviceProvider.GetRequiredService<IConnectionStringAccessor>();
            var optionsActions = serviceProvider.GetServices<IDatabaseProviderOptions<SqliteDbContextOptionsBuilder>>();
            var dbContextOptionsActions = serviceProvider.GetServices<IDatabaseProviderOptions<TDbContext, SqliteDbContextOptionsBuilder>>();

            builder.UseSqlite(accessor.Get(), (options) =>
            {
                if (optionsActions is not null && optionsActions.Any())
                {
                    foreach (var action in optionsActions)
                    {
                        action.Configure(options);
                    }
                }

                if (dbContextOptionsActions is not null && dbContextOptionsActions.Any())
                {
                    foreach (var dbAction in dbContextOptionsActions)
                    {
                        dbAction.Configure(options);
                    }
                }
            });
        }
    }

    public class NpgsqlAutoConfigure : IEntityFrameworkCoreDatabaseOptionsProvider
    {
        public string Name => Providers.Npgsql;

        public void Configure<TDbContext>(IServiceProvider serviceProvider, DbContextOptionsBuilder builder) where TDbContext : DbContext
        {
            var accessor = serviceProvider.GetRequiredService<IConnectionStringAccessor>();
            var optionsActions = serviceProvider.GetServices<IDatabaseProviderOptions<NpgsqlDbContextOptionsBuilder>>();
            var dbContextOptionsActions = serviceProvider.GetServices<IDatabaseProviderOptions<TDbContext, NpgsqlDbContextOptionsBuilder>>();

            builder.UseNpgsql(accessor.Get(), (options) =>
            {
                if (optionsActions is not null && optionsActions.Any())
                {
                    foreach (var action in optionsActions)
                    {
                        action.Configure(options);
                    }
                }

                if (dbContextOptionsActions is not null && dbContextOptionsActions.Any())
                {
                    foreach (var dbAction in dbContextOptionsActions)
                    {
                        dbAction.Configure(options);
                    }
                }
            });
        }
    }
}
```