public void Execute()
        {
            RowDictionary <WixBundleExePackageRow> exePackages = new RowDictionary <WixBundleExePackageRow>(this.ExePackageTable);
            RowDictionary <WixBundleMsiPackageRow> msiPackages = new RowDictionary <WixBundleMsiPackageRow>(this.MsiPackageTable);
            RowDictionary <WixBundleMspPackageRow> mspPackages = new RowDictionary <WixBundleMspPackageRow>(this.MspPackageTable);
            RowDictionary <WixBundleMsuPackageRow> msuPackages = new RowDictionary <WixBundleMsuPackageRow>(this.MsuPackageTable);

            Dictionary <string, PackageFacade> facades = new Dictionary <string, PackageFacade>(this.PackageTable.Rows.Count);

            foreach (WixBundlePackageRow package in this.PackageTable.Rows)
            {
                string        id     = package.WixChainItemId;
                PackageFacade facade = null;

                switch (package.Type)
                {
                case WixBundlePackageType.Exe:
                    facade = new PackageFacade(package, exePackages.Get(id));
                    break;

                case WixBundlePackageType.Msi:
                    facade = new PackageFacade(package, msiPackages.Get(id));
                    break;

                case WixBundlePackageType.Msp:
                    facade = new PackageFacade(package, mspPackages.Get(id));
                    break;

                case WixBundlePackageType.Msu:
                    facade = new PackageFacade(package, msuPackages.Get(id));
                    break;
                }

                facades.Add(id, facade);
            }

            this.PackageFacades = facades;
        }
        public void Execute()
        {
            List <PackageFacade> orderedFacades = new List <PackageFacade>();
            List <WixBundleRollbackBoundaryRow> usedBoundaries = new List <WixBundleRollbackBoundaryRow>();

            // Process the chain of packages to add them in the correct order
            // and assign the forward rollback boundaries as appropriate. Remember
            // rollback boundaries are authored as elements in the chain which
            // we re-interpret here to add them as attributes on the next available
            // package in the chain. Essentially we mark some packages as being
            // the start of a rollback boundary when installing and repairing.
            // We handle uninstall (aka: backwards) rollback boundaries after
            // we get these install/repair (aka: forward) rollback boundaries
            // defined.
            WixBundleRollbackBoundaryRow previousRollbackBoundary = null;
            WixBundleRollbackBoundaryRow lastRollbackBoundary     = null;
            bool boundaryHadX86Package = false;

            foreach (WixGroupRow row in this.WixGroupTable.Rows)
            {
                if (ComplexReferenceChildType.Package == row.ChildType && ComplexReferenceParentType.PackageGroup == row.ParentType && "WixChain" == row.ParentId)
                {
                    PackageFacade facade = null;
                    if (PackageFacades.TryGetValue(row.ChildId, out facade))
                    {
                        if (null != previousRollbackBoundary)
                        {
                            usedBoundaries.Add(previousRollbackBoundary);
                            facade.Package.RollbackBoundary = previousRollbackBoundary.ChainPackageId;
                            previousRollbackBoundary        = null;

                            boundaryHadX86Package = (facade.Package.x64 == YesNoType.Yes);
                        }

                        // Error if MSI transaction has x86 package preceding x64 packages
                        if ((lastRollbackBoundary != null) && (lastRollbackBoundary.Transaction == YesNoType.Yes) &&
                            boundaryHadX86Package &&
                            (facade.Package.x64 == YesNoType.Yes))
                        {
                            Messaging.Instance.OnMessage(WixErrors.MsiTransactionX86BeforeX64(lastRollbackBoundary.SourceLineNumbers));
                        }
                        boundaryHadX86Package = boundaryHadX86Package || (facade.Package.x64 == YesNoType.No);

                        orderedFacades.Add(facade);
                    }
                    else // must be a rollback boundary.
                    {
                        // Discard the next rollback boundary if we have a previously defined boundary.
                        WixBundleRollbackBoundaryRow nextRollbackBoundary = Boundaries.Get(row.ChildId);
                        if (null != previousRollbackBoundary)
                        {
                            Messaging.Instance.OnMessage(WixWarnings.DiscardedRollbackBoundary(nextRollbackBoundary.SourceLineNumbers, nextRollbackBoundary.ChainPackageId));
                        }
                        else
                        {
                            previousRollbackBoundary = nextRollbackBoundary;
                            lastRollbackBoundary     = nextRollbackBoundary;
                        }
                    }
                }
            }

            if (null != previousRollbackBoundary)
            {
                Messaging.Instance.OnMessage(WixWarnings.DiscardedRollbackBoundary(previousRollbackBoundary.SourceLineNumbers, previousRollbackBoundary.ChainPackageId));
            }

            // With the forward rollback boundaries assigned, we can now go
            // through the packages with rollback boundaries and assign backward
            // rollback boundaries. Backward rollback boundaries are used when
            // the chain is going "backwards" which (AFAIK) only happens during
            // uninstall.
            //
            // Consider the scenario with three packages: A, B and C. Packages A
            // and C are marked as rollback boundary packages and package B is
            // not. The naive implementation would execute the chain like this
            // (numbers indicate where rollback boundaries would end up):
            //      install:    1 A B 2 C
            //      uninstall:  2 C B 1 A
            //
            // The uninstall chain is wrong, A and B should be grouped together
            // not C and B. The fix is to label packages with a "backwards"
            // rollback boundary used during uninstall. The backwards rollback
            // boundaries are assigned to the package *before* the next rollback
            // boundary. Using our example from above again, I'll mark the
            // backwards rollback boundaries prime (aka: with ').
            //      install:    1 A B 1' 2 C 2'
            //      uninstall:  2' C 2 1' B A 1
            //
            // If the marked boundaries are ignored during install you get the
            // same thing as above (good) and if the non-marked boundaries are
            // ignored during uninstall then A and B are correctly grouped.
            // Here's what it looks like without all the markers:
            //      install:    1 A B 2 C
            //      uninstall:  2 C 1 B A
            // Woot!
            string        previousRollbackBoundaryId = null;
            PackageFacade previousFacade             = null;

            foreach (PackageFacade package in orderedFacades)
            {
                if (null != package.Package.RollbackBoundary)
                {
                    if (null != previousFacade)
                    {
                        previousFacade.Package.RollbackBoundaryBackward = previousRollbackBoundaryId;
                    }

                    previousRollbackBoundaryId = package.Package.RollbackBoundary;
                }

                previousFacade = package;
            }

            if (!String.IsNullOrEmpty(previousRollbackBoundaryId) && null != previousFacade)
            {
                previousFacade.Package.RollbackBoundaryBackward = previousRollbackBoundaryId;
            }

            this.OrderedPackageFacades  = orderedFacades;
            this.UsedRollbackBoundaries = usedBoundaries;
        }