/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="instanceScopeFactory">The instance scope factory</param>
/// <param name="namingNormalizer">The naming normalizer</param>
/// <param name="migrations">The migrations found</param>
/// <param name="loggerFactory">The logger factory</param>
/// <exception cref="ArgumentNullException"></exception>
public MigrationRunner(
IMigrationInstanceScopeFactory instanceScopeFactory, INamingNormalizer <TContext> namingNormalizer,
IEnumerable <MigrationNormalizedMeta> migrations, IMigrationLoggerFactory loggerFactory = null)
{
if (namingNormalizer == null)
{
throw new ArgumentNullException(nameof(namingNormalizer));
}
if (migrations == null)
{
throw new ArgumentNullException(nameof(migrations));
}
Logger = loggerFactory?.Get(GetType().FullName) ?? NullMigrationLogger.Default;
ContextName = namingNormalizer.Normalize(typeof(TContext).Name);
NamingNormalizer = namingNormalizer;
InstanceScopeFactory = instanceScopeFactory ?? throw new ArgumentNullException(nameof(instanceScopeFactory));
_migrations = new SortedList <string, MigrationNormalizedMeta>();
foreach (var migration in migrations)
{
var meta = MigrationNormalizedMeta.Build(namingNormalizer, migration.Type);
if (_migrations.ContainsKey(meta.Id))
{
throw new ArgumentException(
$"Collection contains duplicated migrations with name '{meta.Id}' for context '{ContextName}'",
nameof(migrations));
}
_migrations.Add(migration.Id, meta);
}
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="context">The migration context</param>
/// <param name="normalizer"></param>
/// <param name="loggerFactory">The class logger factory</param>
/// <param name="contextName">The context name</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
protected MigrationManager(
TContext context, INamingNormalizer <TContext> normalizer, IMigrationLoggerFactory loggerFactory, string contextName)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (normalizer == null)
{
throw new ArgumentNullException(nameof(normalizer));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (contextName == null)
{
throw new ArgumentNullException(nameof(contextName));
}
if (string.IsNullOrWhiteSpace(contextName))
{
throw new ArgumentException("Value cannot be whitespace.", nameof(contextName));
}
ContextName = normalizer.Normalize(contextName);
Normalizer = normalizer;
Context = context;
Logger = loggerFactory.Get(GetType().FullName) ?? NullMigrationLogger.Default;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="options">The context options</param>
/// <param name="normalizer">The naming normalizer</param>
/// <param name="loggerFactory">An optional class logger factory</param>
/// <exception cref="ArgumentNullException"></exception>
protected MigrationContext(IMigrationOptions options, INamingNormalizer normalizer, IMigrationLoggerFactory loggerFactory = null)
{
Options = options ?? throw new ArgumentNullException(nameof(options));
Normalizer = normalizer ?? throw new ArgumentNullException(nameof(normalizer));
Logger = loggerFactory?.Get(GetType().FullName) ?? NullMigrationLogger.Default;
NormalizedName = normalizer.Normalize(options.ContextName);
}
/// <summary>
/// Uses the given naming normalizer for this context.
/// </summary>
/// <typeparam name="TContext">The context type</typeparam>
/// <param name="builder">The migrations builder</param>
/// <param name="namingNormalizer">The normalizer to use</param>
/// <returns>The builder instance</returns>
/// <exception cref="ArgumentNullException"></exception>
public static MigrationsBuilder <TContext> UseNamingNormalizer <TContext>(
this MigrationsBuilder <TContext> builder, INamingNormalizer <TContext> namingNormalizer)
where TContext : class, IMigrationContext
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (namingNormalizer == null)
{
throw new ArgumentNullException(nameof(namingNormalizer));
}
builder.ServiceCollection.AddSingleton(namingNormalizer);
return(builder);
}
/// <summary>
/// Builds a normalized migration metadata for the given type
/// </summary>
/// <typeparam name="TContext">The context type</typeparam>
/// <param name="normalizer">The normalizer to be used</param>
/// <param name="type">The migration type</param>
/// <returns>Normalized migration metadata instance</returns>
/// <exception cref="ArgumentNullException"></exception>
public static MigrationNormalizedMeta Build <TContext>(INamingNormalizer <TContext> normalizer, Type type)
where TContext : IMigrationContext
{
if (normalizer == null)
{
throw new ArgumentNullException(nameof(normalizer));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
return(new MigrationNormalizedMeta(
normalizer.Normalize(type.Name),
normalizer.Normalize(type.FullName),
type));
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="options">The context options</param>
/// <param name="normalizer">The naming normalizer</param>
/// <param name="loggerFactory">An optional class logger factory</param>
/// <exception cref="ArgumentNullException"></exception>
public OracleMigrationContext(IOracleMigrationOptions options, INamingNormalizer normalizer, IMigrationLoggerFactory loggerFactory = null)
: base(options, normalizer, loggerFactory)
{
Options = options;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="context">The migration context</param>
/// <param name="normalizer">The naming normalizer</param>
/// <param name="loggerFactory">The logger factory</param>
/// <param name="contextName">The context name</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public OracleMigrationManager(TContext context, INamingNormalizer <TContext> normalizer,
IMigrationLoggerFactory loggerFactory, string contextName)
: base(context, normalizer, loggerFactory, contextName)
{
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="context">The migration context</param>
/// <param name="normalizer">The naming normalizer</param>
/// <param name="loggerFactory">The logger factory</param>
/// <param name="contextName">The context name</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
protected RelationalMigrationManager(TContext context, INamingNormalizer <TContext> normalizer, IMigrationLoggerFactory loggerFactory, string contextName)
: base(context, normalizer, loggerFactory, contextName)
{
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="context">The migration context</param>
/// <param name="normalizer"></param>
/// <param name="loggerFactory">The logger factory</param>
/// <exception cref="ArgumentNullException"></exception>
protected MigrationManager(TContext context, INamingNormalizer <TContext> normalizer, IMigrationLoggerFactory loggerFactory)
: this(context, normalizer, loggerFactory, typeof(TContext).Name)
{
}
/// <inheritdoc />
public ApplyMigrationsContext(
SqlServerMigrationOptions options, INamingNormalizer normalizer, IMigrationLoggerFactory loggerFactory)
: base(options, normalizer, loggerFactory)
{
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="options">The relational context options</param>
/// <param name="normalizer">The naming normalizer</param>
/// <param name="loggerFactory">The logger factory to use</param>
/// <exception cref="ArgumentNullException"></exception>
protected RelationalMigrationContext(
IRelationalMigrationOptions options, INamingNormalizer normalizer, IMigrationLoggerFactory loggerFactory = null)
: base(options, normalizer, loggerFactory)
{
Options = options;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="context">The migration context</param>
/// <param name="normalizer">The naming normalizer</param>
/// <param name="loggerFactory">The logger factory</param>
/// <exception cref="ArgumentNullException"></exception>
public SqlServerMigrationManager(TContext context, INamingNormalizer <TContext> normalizer,
IMigrationLoggerFactory loggerFactory)
: base(context, normalizer, loggerFactory)
{
}
