C# DbMigrator.GetPendingMigrations方法代码示例

        public DbMigratorEventArgs(DbMigrationsConfiguration migrationConfiguration)
        {
            this.MigrationConfiguration = migrationConfiguration;

            DbMigrator migrator = new DbMigrator(migrationConfiguration);
            this.PendingMigrations = migrator.GetPendingMigrations();
            this.CompletedMigrations = migrator.GetDatabaseMigrations();
        }

        public static void Main(string[] args)
        {
            Console.WriteLine(@"Migrating database...");
            var migrator = new DbMigrator(new Configuration());
            Console.WriteLine(@"Connection: " + GetConnectionString(migrator));

            var migrations = migrator.GetPendingMigrations().ToList();

            if (!migrations.Any()) {
                Console.WriteLine(@"No pending migrations.");
            } else {
                foreach (var migration in migrations) {
                    Console.WriteLine(migration);
                    migrator.Update(migration);
                }
            }

            if (args.Contains("--seed")) {
                Console.WriteLine(@"Seeding the database...");
                var context = new EntityContext();

                DatabaseSeeder.Seed(context);

                context.SaveChanges();
            } else {
                Console.WriteLine(@"No seeding required.");
            }
            Console.WriteLine(@"Migration done.");
        }

        public ActionResult Migrations(string errorMsg)
        {
            var configuration = new Configuration();
            var migrator = new DbMigrator(configuration);
            ViewBag.AppliedMigrations = migrator.GetDatabaseMigrations();
            ViewBag.PendingMigrations = migrator.GetPendingMigrations();
            ViewBag.ErrorMessage = errorMsg;

            return View();
        }

        private static void DoMigrations()
        {
            Database.SetInitializer<AddressFormDbContext>(null);

            var migrator = new DbMigrator(new Configuration());
            if (migrator.GetPendingMigrations().Any())
            {
                migrator.Update();
            }
        }

        public ZsValidateItem Validate()
        {
            var result = new ZsValidateItem() { Title = _label };
            try
            {
                _migrationsConfiguration.TargetDatabase = new DbConnectionInfo(_connectionName);

                var migrator = new DbMigrator(_migrationsConfiguration);


                if (migrator.GetPendingMigrations().Any())
                {
                    result.State = ZsValidateState.Fail;
                    result.Description = "<b>Pending Migrations Found</b><br/>";
                    result.Description += "<ul>";
                    foreach (var migration in migrator.GetPendingMigrations().OrderBy(b => b))
                    {
                        result.Description += "<li>" + migration + "</li>";
                    }
                    result.Description += "</ul>";

                }
                else
                {
                    result.State = ZsValidateState.Ok;
                    result.Description = "<b>Migrations Up to Date</b><br/>";
                    result.Description += "<ul>";
                    foreach (var migration in migrator.GetDatabaseMigrations().OrderBy(b => b))
                    {
                        result.Description += "<li>" + migration + "</li>";
                    }
                    result.Description += "</ul>";
                }

            }
            catch (Exception ex)
            {
                result.State = ZsValidateState.Fail;
                result.Description = "Exception occurred: " + ex.Message;
            }
            return result;
        }

 private static void PrintMigrationStatus(DbMigrator migrator)
 {
     foreach (var applied in migrator.GetDatabaseMigrations())
     {
         Console.WriteLine("\tApplied: {0}", applied);
     }
     foreach (var pending in migrator.GetPendingMigrations())
     {
         Console.WriteLine("\tPending: {0}", pending);
     }
     Console.WriteLine();
 }

 public static void EnableCodeFirstMigrations()
 {
     if (bool.Parse(ConfigurationManager.AppSettings["checkForPendingDatabaseMigrations"]))
     {
         var configuration = new Migrations.Configuration();
         var migrator = new DbMigrator(configuration);
         if (migrator.GetPendingMigrations().Count() > 0)
         {
             migrator.Update();
         }
     }
 }

        public static void UpdateDatabase(string connectionString)
        {
            var configuration = new Configuration
              {
            TargetDatabase = new DbConnectionInfo(connectionString, "System.Data.SqlClient")
              };

              var migrator = new DbMigrator(configuration);
              var pending = migrator.GetPendingMigrations().ToArray();
              var local = migrator.GetLocalMigrations().ToArray();
              var db = migrator.GetDatabaseMigrations().ToArray();
              migrator.Update();
        }

        public ActionResult Databases()
        {
            // TODO: Find types from all assemblies
            var contexts = this.GetType()
                .Assembly
                .GetTypes()
                .Where(t => typeof(DbContext).IsAssignableFrom(t));

            var result = new List<DatabaseViewModel>();
            foreach (var context in contexts)
            {
                // TODO: Deal with non-default ctors
                using (var db = (DbContext)Activator.CreateInstance(context))
                {
                    var model = new DatabaseViewModel
                    {
                        ContextName = context.Name,
                        ContextAssemblyQualifiedName = context.AssemblyQualifiedName,
                        DatabaseExists = db.Database.Exists()
                    };

                    var configBaseType = typeof(DbMigrationsConfiguration<>).MakeGenericType(context);
                    var configType = context.Assembly.GetTypes().SingleOrDefault(t => configBaseType.IsAssignableFrom(t));
                    if(configType != null)
                    {
                        model.MigrationsEnabled = true;
                        model.MigrationsConfigurationAssemblyQualifiedName = configType.AssemblyQualifiedName;

                        var config = (DbMigrationsConfiguration)Activator.CreateInstance(configType);
                        var migrator = new DbMigrator(config);
                        model.PendingMigrations = migrator.GetPendingMigrations();

                        // We can only check for model changes if the database exists
                        // This restriction should be removed in EF7 as we can just check the snapshot file
                        if(model.DatabaseExists)
                        {
                            model.PendingModelChanges = !db.Database.CompatibleWithModel(throwIfNoMetadata: false);
                        }
                    }

                    result.Add(model);
                }
            }

            return View(result);
        }

        public ActionResult MigrateDatabaseToLatestVersion()
        {
            var configuration = new Configuration();
            var migrator = new DbMigrator(configuration);

            var pending = migrator.GetPendingMigrations();

            if (pending.Any())
            {
                Response.Write("Updated");
                migrator.Update();
            }

            Change1();

            //			using (var a = new EfContext())
            //			{
            //				//Database.SetInitializer(new MigrateDatabaseToLatestVersion<EfContext, data.Migrations.Configuration>());
            //				Response.Write(a.ApplicationSettings.ToList());
            //			}
            return View();
        }

        /// <summary>
        /// Получить список столбцов которые будут удалены
        /// </summary>
        /// <param name="configuration">Конфигурация миграций</param>
        /// <returns>Список столбцов которые будут удалены</returns>
        private IEnumerable<ColumnInfo> GetDroppingColumnFromMigrationsConfiguration(DbMigrationsConfiguration configuration)
        {
            var droppingColumn = new List<ColumnInfo>();

            if (configuration != null)
            {
                var migrator = new DbMigrator(configuration);

                var pendingMigrations = migrator.GetPendingMigrations();
                if (pendingMigrations.Any())
                {
                    var targetMigration = pendingMigrations.Last();

                    var scriptor = new MigratorScriptingDecorator(migrator);
                    string script = scriptor.ScriptUpdate(sourceMigration: null, targetMigration: targetMigration);
                    var parts = script.Split(new[] {"\r\n\r\n", "\r\n"}, StringSplitOptions.RemoveEmptyEntries).ToList();//разбиваем скрипт по миграциям
                    parts.RemoveAll(p => p.StartsWith("INSERT [dbo].[__MigrationHistory]") || p.StartsWith("VALUES"));//удаляем вставки в MigrationHistory

                    var dropColumnParts = parts.Where(p => p.Contains("DROP COLUMN"));//находим DROP COLUMN
                    foreach (var dropColumnPart in dropColumnParts)
                    {
                        Regex regex = new Regex("ALTER TABLE (?<schemaWithTable>.*) DROP COLUMN (?<column>.*)");
                        Match match = regex.Match(dropColumnPart);
                        string[] schemaWithTable = match.Groups["schemaWithTable"].Value.Split(new[] { '.', '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
                        string schema = schemaWithTable.First();
                        string table = schemaWithTable.Last();
                        string column = match.Groups["column"].Value.Trim(new[] { '[', ']' });

                        droppingColumn.Add(new ColumnInfo(new TableInfo(schema, table), column));
                    }
                }
            }
            return droppingColumn;
        }

        public static void UpgradeDB()
        {
            var fi = new FileInfo(System.Web.Hosting.HostingEnvironment.MapPath(dbfile));
            if (fi.Exists && fi.Length > Settings.Default.MaxFileSizeMB * 1024 * 1024)
            {
                fi.Delete();
            }

            Database.SetInitializer<DataContext>(null);
            try
            {
                var configuration = new Configuration();
                configuration.TargetDatabase = new DbConnectionInfo( cecs, "System.Data.SqlServerCe.4.0");
                var dbMigrator = new DbMigrator(configuration);

                if (dbMigrator.GetPendingMigrations().Count() > 0)
                {
                    dbMigrator.Update();
                    dbMigrator.Update();
                }

            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
                throw ex;
            }
        }