C# ConfigFile.LoadXml方法代码示例

        public void TestLoadSaveSamples()
        {
            // \todo: don't use an embedded stream, this is a chicken/egg problem with rewriting sample xmls when configuration changes
            // make sure that every sample configuration loads and saves
            string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
            foreach (string manifestResourceName in manifestResourceNames)
            {
                if (! manifestResourceName.EndsWith(".Configuration.xml"))
                    continue;

                // fetch the configuration from the resource
                Console.WriteLine(manifestResourceName);
                Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream(manifestResourceName);
                StreamReader r = new StreamReader(s);
                XmlDocument configXml = new XmlDocument();
                configXml.LoadXml(r.ReadToEnd());
                // load as a configuration
                ConfigFile configFile = new ConfigFile();
                configFile.LoadXml(configXml);
                // compare trivial properties
                Assert.AreEqual("1.0.0.0", configFile.productversion, configFile.productversion);
                Assert.AreEqual(InstallUILevel.full, configFile.ui_level);
                // compare contents
                Assert.AreEqual(configFile.GetXml(null).OuterXml, configXml.OuterXml);
            }
        }

 public void TestLoadClear()
 {
     ConfigFile configFile = new ConfigFile();
     SetupConfiguration setupConfiguration = new SetupConfiguration();
     ComponentCmd cmd = new ComponentCmd();
     setupConfiguration.Children.Add(cmd);
     setupConfiguration.Children.Add(cmd);
     configFile.Children.Add(setupConfiguration);
     string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");
     configFile.SaveAs(configFilename);
     int previousConfigurationCount = configFile.ConfigurationCount;
     XmlDocument xmlConfigFile = new XmlDocument();
     xmlConfigFile.Load(configFilename);
     configFile.LoadXml(xmlConfigFile);
     Assert.AreEqual(previousConfigurationCount, configFile.ConfigurationCount);
     File.Delete(configFilename);
 }

        public static void CreateInstaller(InstallerLinkerArguments args)
        {
            args.Validate();

            args.WriteLine(string.Format("Creating \"{0}\" from \"{1}\"", args.output, args.template));
            System.IO.File.Copy(args.template, args.output, true);
            System.IO.File.SetAttributes(args.output, System.IO.FileAttributes.Normal);

            string configFilename = args.config;

            #region Version Information

            ConfigFile configfile = new ConfigFile();
            configfile.Load(configFilename);

            // \todo: check XML with XSD, warn if nodes are being dropped

            // filter the configuration
            string configTemp = null;
            if (!string.IsNullOrEmpty(args.processorArchitecture))
            {
                int configurationCount = configfile.ConfigurationCount;
                int componentCount = configfile.ComponentCount;
                args.WriteLine(string.Format("Applying processor architecture filter \"{0}\"", args.processorArchitecture));
                ProcessorArchitectureFilter filter = new ProcessorArchitectureFilter(args.processorArchitecture);
                XmlDocument filteredXml = configfile.GetXml(filter);
                configTemp = configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
                filteredXml.Save(configTemp);
                configfile.LoadXml(filteredXml);
                args.WriteLine(string.Format(" configurations: {0} => {1}", configurationCount, configfile.ConfigurationCount));
                args.WriteLine(string.Format(" components: {0} => {1}", componentCount, configfile.ComponentCount));
            }

            args.WriteLine(string.Format("Updating binary attributes in \"{0}\"", args.output));
            VersionResource rc = new VersionResource();
            rc.LoadFrom(args.output);

            // version information
            StringFileInfo stringFileInfo = (StringFileInfo)rc["StringFileInfo"];
            if (!string.IsNullOrEmpty(configfile.productversion))
            {
                rc.ProductVersion = configfile.productversion;
                stringFileInfo["ProductVersion"] = configfile.productversion;
            }

            if (!string.IsNullOrEmpty(configfile.fileversion))
            {
                rc.FileVersion = configfile.fileversion;
                stringFileInfo["FileVersion"] = configfile.fileversion;
            }

            foreach (FileAttribute attr in configfile.fileattributes)
            {
                args.WriteLine(string.Format(" {0}: {1}", attr.name, attr.value));
                stringFileInfo[attr.name] = attr.value;
            }

            rc.Language = ResourceUtil.NEUTRALLANGID;
            rc.SaveTo(args.output);

            #endregion

            #region Optional Icon
            // optional icon
            if (!string.IsNullOrEmpty(args.icon))
            {
                args.WriteLine(string.Format("Embedding icon \"{0}\"", args.icon));
                IconFile iconFile = new IconFile(args.icon);
                List<string> iconSizes = new List<string>();
                foreach (IconFileIcon icon in iconFile.Icons)
                    iconSizes.Add(icon.ToString());
                args.WriteLine(string.Format(" {0}", string.Join(", ", iconSizes.ToArray())));
                IconDirectoryResource iconDirectory = new IconDirectoryResource(iconFile);
                iconDirectory.Name = new ResourceId(128);
                iconDirectory.Language = ResourceUtil.NEUTRALLANGID;
                iconDirectory.SaveTo(args.output);
            }
            #endregion

            #region Manifest
            if (!string.IsNullOrEmpty(args.manifest))
            {
                args.WriteLine(string.Format("Embedding manifest \"{0}\"", args.manifest));
                ManifestResource manifest = new ManifestResource();
                manifest.Manifest.Load(args.manifest);
                manifest.SaveTo(args.output);
            }
            #endregion

            string supportdir = string.IsNullOrEmpty(args.apppath)
                ? Environment.CurrentDirectory
                : args.apppath;

            string templatepath = Path.GetDirectoryName(Path.GetFullPath(args.template));

            // create a temporary directory for CABs
            string cabtemp = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            Directory.CreateDirectory(cabtemp);
            args.WriteLine(string.Format("Writing CABs to \"{0}\"", cabtemp));

//.........这里部分代码省略.........

        public void TestProcessorArchitectureFilter()
        {
            // configurations
            SetupConfiguration nofilterConfiguration = new SetupConfiguration();
            SetupConfiguration x86Configuration = new SetupConfiguration();
            x86Configuration.processor_architecture_filter = "x86";
            SetupConfiguration x64Configuration = new SetupConfiguration();
            x64Configuration.processor_architecture_filter = "x64";
            SetupConfiguration mipsConfiguration = new SetupConfiguration();
            mipsConfiguration.processor_architecture_filter = "mips";
            // components
            ComponentCmd nofilterComponent = new ComponentCmd();
            ComponentCmd x86Component = new ComponentCmd();
            x86Component.processor_architecture_filter = "x86";
            ComponentCmd x64Component = new ComponentCmd();
            x64Component.processor_architecture_filter = "x64";
            ComponentCmd mipsComponent = new ComponentCmd();
            mipsComponent.processor_architecture_filter = "mips";
            // make a tree
            nofilterConfiguration.Children.Add(nofilterComponent);
            nofilterConfiguration.Children.Add(x86Component);
            nofilterConfiguration.Children.Add(x64Component);
            nofilterConfiguration.Children.Add(mipsComponent);
            x86Configuration.Children.Add(nofilterComponent);
            x86Configuration.Children.Add(x86Component);
            x86Configuration.Children.Add(x64Component);
            x86Configuration.Children.Add(mipsComponent);
            x64Configuration.Children.Add(nofilterComponent);
            x64Configuration.Children.Add(x86Component);
            x64Configuration.Children.Add(x64Component);
            x64Configuration.Children.Add(mipsComponent);
            mipsConfiguration.Children.Add(nofilterComponent);
            mipsConfiguration.Children.Add(x86Component);
            mipsConfiguration.Children.Add(x64Component);
            mipsConfiguration.Children.Add(mipsComponent);
            // configfile
            ConfigFile configFile = new ConfigFile();
            configFile.Children.Add(nofilterConfiguration);
            configFile.Children.Add(x86Configuration);
            configFile.Children.Add(x64Configuration);
            configFile.Children.Add(mipsConfiguration);

            // Console.WriteLine("Total : {0}x{1}", configFile.ConfigurationCount, configFile.ComponentCount);

            TestProcessorArchitectureFilter_TestData[] testdata =
            {
                new TestProcessorArchitectureFilter_TestData("", 4, 16),
                new TestProcessorArchitectureFilter_TestData("x86", 2, 4),
                new TestProcessorArchitectureFilter_TestData("x64", 2, 4),
                new TestProcessorArchitectureFilter_TestData("mips", 2, 4),
                new TestProcessorArchitectureFilter_TestData("sparc", 1, 1),
                new TestProcessorArchitectureFilter_TestData("x86,x64", 3, 9),
                new TestProcessorArchitectureFilter_TestData("alpha,x64", 2, 4),
            };

            foreach (TestProcessorArchitectureFilter_TestData test in testdata)
            {
                ProcessorArchitectureFilter filter = new ProcessorArchitectureFilter(test.Filter);
                XmlDocument filteredXml = configFile.GetXml(filter);
                ConfigFile filteredConfigFile = new ConfigFile();
                filteredConfigFile.LoadXml(filteredXml);
                //Console.WriteLine("{0} - {1}x{2}", test.Filter,
                //    filteredConfigFile.ConfigurationCount, filteredConfigFile.ComponentCount);
                Assert.AreEqual(test.ExpectedConfigs, filteredConfigFile.ConfigurationCount);
                Assert.AreEqual(test.ExpectedComponents, filteredConfigFile.ComponentCount);
            }
        }

 public void TestLinkProcessorArchitectureFilter()
 {
     // configurations
     SetupConfiguration nofilterConfiguration = new SetupConfiguration();
     SetupConfiguration x86Configuration = new SetupConfiguration();
     x86Configuration.processor_architecture_filter = "x86";
     SetupConfiguration x64Configuration = new SetupConfiguration();
     x64Configuration.processor_architecture_filter = "x64";
     SetupConfiguration mipsConfiguration = new SetupConfiguration();
     mipsConfiguration.processor_architecture_filter = "mips";
     // components
     ComponentCmd nofilterComponent = new ComponentCmd();
     ComponentCmd x86Component = new ComponentCmd();
     x86Component.processor_architecture_filter = "x86";
     ComponentCmd x64Component = new ComponentCmd();
     x64Component.processor_architecture_filter = "x64";
     ComponentCmd mipsComponent = new ComponentCmd();
     mipsComponent.processor_architecture_filter = "mips";
     // make a tree
     nofilterConfiguration.Children.Add(nofilterComponent);
     nofilterConfiguration.Children.Add(x86Component);
     nofilterConfiguration.Children.Add(x64Component);
     nofilterConfiguration.Children.Add(mipsComponent);
     x86Configuration.Children.Add(nofilterComponent);
     x86Configuration.Children.Add(x86Component);
     x86Configuration.Children.Add(x64Component);
     x86Configuration.Children.Add(mipsComponent);
     x64Configuration.Children.Add(nofilterComponent);
     x64Configuration.Children.Add(x86Component);
     x64Configuration.Children.Add(x64Component);
     x64Configuration.Children.Add(mipsComponent);
     mipsConfiguration.Children.Add(nofilterComponent);
     mipsConfiguration.Children.Add(x86Component);
     mipsConfiguration.Children.Add(x64Component);
     mipsConfiguration.Children.Add(mipsComponent);
     // configfile
     ConfigFile configFile = new ConfigFile();
     configFile.Children.Add(nofilterConfiguration);
     configFile.Children.Add(x86Configuration);
     configFile.Children.Add(x64Configuration);
     configFile.Children.Add(mipsConfiguration);
     // write a configuration
     InstallerLinkerArguments args = new InstallerLinkerArguments();
     args.processorArchitecture = "x86,alpha";
     args.config = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");
     args.output = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".exe");
     Console.WriteLine("Writing '{0}'", args.config);
     try
     {
         configFile.SaveAs(args.config);
         Console.WriteLine("Linking '{0}'", args.output);
         args.template = dotNetInstallerExeUtils.Executable;
         InstallerLib.InstallerLinker.CreateInstaller(args);
         // check that the linker generated output
         Assert.IsTrue(File.Exists(args.output));
         Assert.IsTrue(new FileInfo(args.output).Length > 0);
         using (ResourceInfo ri = new ResourceInfo())
         {
             ri.Load(args.output);
             List<Resource> custom = ri.Resources[new ResourceId("CUSTOM")];
             Assert.AreEqual(custom[1].Name, new ResourceId("RES_CONFIGURATION"));
             byte[] data = custom[1].WriteAndGetBytes();
             // skip BOM
             String config = Encoding.UTF8.GetString(data, 3, data.Length - 3);
             XmlDocument xmldoc = new XmlDocument();
             xmldoc.LoadXml(config);
             ConfigFile filteredConfig = new ConfigFile();
             filteredConfig.LoadXml(xmldoc);
             Assert.AreEqual(2, filteredConfig.ConfigurationCount);
             Assert.AreEqual(4, filteredConfig.ComponentCount);
         }
     }
     finally
     {
         if (File.Exists(args.config))
             File.Delete(args.config);
         if (File.Exists(args.output))
             File.Delete(args.output);
     }
 }