C# IMigration.GetType方法代码示例

 private long ExtractTimestamp(string moduleName, IMigration migration)
 {
     var timestampProvider = _timestampProviders.ContainsKey(moduleName)
         ? _timestampProviders[moduleName]
         : _timestampProviders[MigrationExportAttribute.DefaultModuleName];
     long timestamp = timestampProvider.GetTimestamp(migration.GetType());
     return timestamp;
 }

 public override void Migrate(IMigration migration)
 {
     _provider.BeginTransaction();
     MigrationAttribute attr = (MigrationAttribute)Attribute.GetCustomAttribute(migration.GetType(), typeof(MigrationAttribute));
     
     if (_provider.AppliedMigrations.Contains(attr.Version)) {
     	RemoveMigration(migration, attr);
     } else {
     	ApplyMigration(migration, attr);
     }
 }

        public override void Migrate(IMigration migration)
        {
            _provider.BeginTransaction();
            MigrationAttribute attr = (MigrationAttribute)Attribute.GetCustomAttribute(migration.GetType(), typeof(MigrationAttribute));

            var v = attr.GetVersion(migration.GetType());
            var contains = false;

            foreach (var appliedMigration in _provider.AppliedMigrations)
            {
                if (appliedMigration.Key != v.Key || appliedMigration.Value != v.Value) continue;
                contains = true;
                break;
            }

            if (contains)
            {
            	RemoveMigration(migration, attr);
            } else {
            	ApplyMigration(migration, attr);
            }
        }

        public void Down(IMigration migration)
        {
            var name = migration.GetType().Name;
            _announcer.Heading(name + ": reverting");

            CaughtExceptions = new List<Exception>();

            var context = new MigrationContext(Conventions, Processor);
            migration.GetDownExpressions(context);

            _stopWatch.Start();
            ExecuteExpressions(context.Expressions);
            _stopWatch.Stop();

            _announcer.Say(name + ": reverted");
            _announcer.ElapsedTime(_stopWatch.ElapsedTime());
        }

        public void Down(IMigration migration)
        {
            var name = migration.GetType().Name;
            _announcer.Announce(name + ": reverting");

            CaughtExceptions = new List<Exception>();

            var context = new MigrationContext(Conventions,Processor);
            migration.GetDownExpressions(context);

            _stopWatch.Start();

            ExecuteExpressions(context.Expressions);

            _stopWatch.Stop();

            var elapsed = _stopWatch.ElapsedTime().TotalSeconds;

            _announcer.Announce(name + ": reverted (" + elapsed + "s" + ")");
        }

        /// <summary>
        /// Validates each migration expression that has implemented the ICanBeValidated interface.
        /// It throws an InvalidMigrationException exception if validation fails.
        /// </summary>
        /// <param name="migration">The current migration being run</param>
        /// <param name="expressions">All the expressions contained in the up or down action</param>
        public void ApplyConventionsToAndValidateExpressions(IMigration migration, IEnumerable<IMigrationExpression> expressions)
        {
            var errorMessageBuilder = new StringBuilder();

            foreach (var expression in expressions)
            {
                expression.ApplyConventions(_conventions);

                var errors = new Collection<string>();
                expression.CollectValidationErrors(errors);

                if (errors.Count > 0)
                    AppendError(errorMessageBuilder, expression.GetType().Name, string.Join(" ", errors.ToArray()));
            }

            if (errorMessageBuilder.Length > 0)
            {
                var errorMessage = errorMessageBuilder.ToString();
                _announcer.Error("The migration {0} contained the following Validation Error(s): {1}", migration.GetType().Name, errorMessage);
                throw new InvalidMigrationException(migration, errorMessage);
            }
        }

        private string GetMigrationName(IMigration migration)
        {
            if (migration == null) throw new ArgumentNullException("migration");

            IMigrationMetadata metadata = migration as IMigrationMetadata;
            if (metadata != null)
            {
                return string.Format("{0}: {1}", metadata.Version, metadata.Type.Name);
            }
            return migration.GetType().Name;
        }

        public void Up(IMigration migration)
        {
            var name = GetMigrationName(migration);
            _announcer.Heading(string.Format("{0} migrating", name));

            CaughtExceptions = new List<Exception>();

            var context = new MigrationContext(Conventions, Processor, Assembly.GetAssembly(migration.GetType()), ApplicationContext);
            migration.GetUpExpressions(context);

            _stopWatch.Start();
            ExecuteExpressions(context.Expressions);
            _stopWatch.Stop();

            _announcer.Say(string.Format("{0} migrated", name));
            _announcer.ElapsedTime(_stopWatch.ElapsedTime());
        }

        public static IMigrationInfo GetMigrationInfoFor(IMigration migration)
        {
            var migrationAttribute = migration.GetType().GetOneAttribute<MigrationAttribute>();
            var migrationInfo = new MigrationInfo(migrationAttribute.Version, migrationAttribute.TransactionBehavior, migration);

            foreach (MigrationTraitAttribute traitAttribute in migration.GetType().GetAllAttributes<MigrationTraitAttribute>())
                migrationInfo.AddTrait(traitAttribute.Name, traitAttribute.Value);

            return migrationInfo;
        }

        public TimeSpan Up(IMigration migration)
        {
            var name = migration.GetType().Name;
            _announcer.Heading(name + ": migrating");

            CaughtExceptions = new List<Exception>();

            var context = new MigrationContext(Conventions, Processor,MigrationAssembly);
            migration.GetUpExpressions(context);

            _stopWatch.Start();
            ExecuteExpressions(context.Expressions);
            _stopWatch.Stop();

            _announcer.Say(name + ": migrated");
            _announcer.ElapsedTime(_stopWatch.ElapsedTime());

            return _stopWatch.ElapsedTime();
        }

 private void ApplyMigration(IMigration migration, MigrationAttribute attr)
 {
     // we're adding this one
     _logger.MigrateUp(Current, migration.Name);
     if(! DryRun)
     {
         migration.Up();
         var v = attr.GetVersion(migration.GetType());
         _provider.MigrationApplied(v.Value, v.Key);
         _provider.Commit();
         migration.AfterUp();
     }
 }

 private void RemoveMigration(IMigration migration, MigrationAttribute attr)
 {
     // we're removing this one
     _logger.MigrateDown(Current, migration.Name);
     if (! DryRun)
     {
         migration.Down();
         var v = attr.GetVersion(migration.GetType());
         _provider.MigrationUnApplied(v.Value, v.Key);
         _provider.Commit();
         migration.AfterDown();
     }
 }

        public static MigrationAttribute GetMigrationsAttributes(IMigration migration)
        {
            Trace.WriteLineIf(ts.TraceInfo, "MigrationService - GetMigrationsAttributes() - Start");
            Attribute[] attrs = Attribute.GetCustomAttributes(migration.GetType());
            MigrationAttribute results = null;

            foreach (var attr in attrs)
            {
                if (attr is MigrationAttribute)
                {
                    MigrationAttribute atr = attr as MigrationAttribute;
                    results = atr;
                    break;
                }
            }

            Trace.WriteLineIf(ts.TraceInfo, "MigrationService - GetMigrationsAttributes() - End");
            return results;
        }