private void ProgressForm_Activated(object sender, EventArgs e)
        {

            if (!IsProcessing)
            {
                this.Refresh();
                IsProcessing = false;
                genData1.OnProgress += new DBDiff.Schema.Events.ProgressEventHandler.ProgressHandler(genData1_OnProgress);
                genData2.OnProgress += new DBDiff.Schema.Events.ProgressEventHandler.ProgressHandler(genData2_OnProgress);
                /*Thread t1 = new Thread(delegate()
                {*/
                    origen = genData1.Process();
                /*});
                Thread t2 = new Thread(delegate()
                {*/
                    destino = genData2.Process();

                    origenClone = (Database)origen.Clone(null);
                /*});
                t1.Start();
                t2.Start();
                t1.Join();
                t2.Join();
                */
                destino = Generate.Compare(origen, destino);
                origen = origenClone;

                databaseProgressControl1.Message = "Complete";
                databaseProgressControl2.Message = "Complete";
                databaseProgressControl1.Value = Generate.MaxValue;
                databaseProgressControl2.Value = Generate.MaxValue;
                this.Dispose();
            }
        }
Exemple #2
0
        private void ProgressForm_Activated(object sender, EventArgs e)
        {
            var handler = new ProgressEventHandler.ProgressHandler(genData2_OnProgress);
            try
            {
                if (!IsProcessing)
                {
                    this.Refresh();
                    IsProcessing = false;
                    genData1.OnProgress += new ProgressEventHandler.ProgressHandler(genData1_OnProgress);
                    genData2.OnProgress += handler;
                    Generate.OnCompareProgress += handler;

                    /*Thread t1 = new Thread(delegate()
                    {*/
                    this.friendlyErrorLocation = "Loading " + databaseProgressControl1.DatabaseName;
                    origen = genData1.Process();
                    databaseProgressControl2.Message = "Complete";
                    databaseProgressControl2.Value = Generate.MaxValue;
                    /*});
                    Thread t2 = new Thread(delegate()
                    {*/
                    this.friendlyErrorLocation = "Loading " + databaseProgressControl2.DatabaseName;
                    destino = genData2.Process();

                    origenClone = (Database)origen.Clone(null);
                    /*});
                    t1.Start();
                    t2.Start();
                    t1.Join();
                    t2.Join();
                    */
                    this.friendlyErrorLocation = "Comparing Databases";
                    destino = Generate.Compare(origen, destino);
                    origen = origenClone;

                    databaseProgressControl1.Message = "Complete";
                    databaseProgressControl1.Value = Generate.MaxValue;
                }
            }
            catch (Exception err)
            {
                this.error = err;
            }
            finally
            {
                Generate.OnCompareProgress -= handler;
                this.Dispose();
            }
        }
Exemple #3
0
        public Model BuildComparisonObjects(IConnection sourceConnection, IConnection targetConnection)
        {
            SqlOption options = BuildOptions();

            OnComparisonStarted(EventArgs.Empty);

            var source = new Generate {ConnectionString = sourceConnection.ConnectionString, Options = options};

            source.OnProgress += args => OnFeedbackMessage(new FeedbackEventArgs
                                                               {
                                                                   Message = args.Message,
                                                                   ProgressPercent =
                                                                       args.Progress*(40/Generate.MaxValue)
                                                               });
            _source = source.Process();

            var target = new Generate {ConnectionString = targetConnection.ConnectionString, Options = options};
            target.OnProgress += args => OnFeedbackMessage(new FeedbackEventArgs
                                                               {
                                                                   Message = args.Message,
                                                                   ProgressPercent =
                                                                       40 + (args.Progress*(40/Generate.MaxValue))
                                                               });

            _target = target.Process();

            OnFeedbackMessage(new FeedbackEventArgs {Message = "Running comparison...", ProgressPercent = 90});
            _merged = Generate.Compare((Database) _target.Clone(null), _source);

            OnFeedbackMessage(new FeedbackEventArgs {Message = "Building Model...", ProgressPercent = 95});
            var model = new Model();

            _merged.Tables.ForEach(
                item => model.Add("Table", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Views.ForEach(
                item => model.Add("View", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Users.ForEach(
                item => model.Add("User", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.UserTypes.ForEach(
                item => model.Add("User Type", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.XmlSchemas.ForEach(
                item => model.Add("XML Schema", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Assemblies.ForEach(
                item =>
                model.Add("CLR Assemblie", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.CLRFunctions.ForEach(
                item =>
                model.Add("CLR Function", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.CLRProcedures.ForEach(
                item =>
                model.Add("CLR Procedure", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.DDLTriggers.ForEach(
                item =>
                model.Add("DDL Trigger", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Defaults.ForEach(
                item => model.Add("Default", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.ExtendedProperties.ForEach(
                item =>
                model.Add("Extended Property", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.FileGroups.ForEach(
                item =>
                model.Add("File Groups", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Functions.ForEach(
                item => model.Add("Functions", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.PartitionFunctions.ForEach(
                item =>
                model.Add("Partition Function", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.PartitionSchemes.ForEach(
                item =>
                model.Add("Partition Scheme", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Procedures.ForEach(
                item =>
                model.Add("Stored Procedure", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Roles.ForEach(
                item => model.Add("Role", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Schemas.ForEach(
                item => model.Add("Schema", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));
            _merged.Synonyms.ForEach(
                item => model.Add("Synonym", item.FullName, new Guid(item.Guid), item.Id, ResolveAction(item.Status)));

            OnFeedbackMessage(new FeedbackEventArgs {Message = "Comparison Complete", ProgressPercent = 100});
            OnComparisonCompleted(EventArgs.Empty);

            return model;
        }