public void Run()
        {
            Catalog catalog = new Catalog();
            foreach(string fileName in Options.InputFiles)
            {
                Catalog temp = new Catalog();
                temp.Load(fileName);
                catalog.Append(temp);
            }

            using (ResourceWriter writer = new ResourceWriter(Options.OutFile))
            {
                foreach (CatalogEntry entry in catalog)
                {
                    try
                    {
                        writer.AddResource(entry.Key, entry.IsTranslated ? entry.GetTranslation(0) : entry.String);
                    }
                    catch (Exception e)
                    {
                        string message = String.Format("Error adding item {0}", entry.String);
                        if (!String.IsNullOrEmpty(entry.Context))
                            message = String.Format("Error adding item {0} in context '{1}'",
                                                    entry.String, entry.Context);
                        throw new Exception(message, e);
                    }
                }
                writer.Generate();
            }
        }

        public void SystemResourceTests_Should_WriteUpdateValueToResx()
        {
            var filename = Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid().ToString() + ".resx");

            var inputData = "TheInputData";

            using (ResourceWriter w = new ResourceWriter(filename))
            {

                w.AddResource("InvariantName", inputData);
                w.Generate();
            }

            inputData = "TheUpdatedInputData";

            using (ResourceWriter w = new ResourceWriter(filename))
            {

                w.AddResource("InvariantName", inputData);
                w.Generate();
            }

            var data = string.Empty;

            using( var r = new ResourceReader(filename))
            {
                var rr = r.GetEnumerator();
                rr.MoveNext();

                data = rr.Value as string;

            }

            Assert.IsTrue(inputData == data);
        }

 /// <summary>
 /// 写入 英文 资源文件.
 /// </summary>
 public void WriteEnglishResource()
 {
     // 构造写入器.
     ResourceWriter rw = new ResourceWriter("English.resource");
     rw.AddResource("Hello", "Hello");
     rw.Close();
 }

 /// <summary>
 /// 写入 中文 资源文件.
 /// </summary>
 public void WriteChinaResource()
 {
     // 构造写入器.
     ResourceWriter rw = new ResourceWriter("China.resource");
     rw.AddResource("Hello", "你好");
     rw.Close();
 }

        /// <summary>
        /// Build .resx file to .resource
        /// </summary>
        /// <param name="input"></param>
        /// <param name="output"></param>
        public static void Build(string input)
        {
            var resxs = Directory.GetFiles(input, "*.resx");
            foreach (var resxFile in resxs)
            {
                var binFile = Path.GetDirectoryName(resxFile) +"\\"+ Path.GetFileNameWithoutExtension(resxFile) + ".resources";
                if (File.Exists(binFile)) {
                    var resxFileInfo = new FileInfo(resxFile);
                    var binFileInfo = new FileInfo(binFile);
                    if (resxFileInfo.LastWriteTime > binFileInfo.LastWriteTime)
                        File.Delete(binFile); //Re-complied
                }

                if (!File.Exists(binFile))
                {
                    using (var reader = new ResXResourceReader(resxFile))
                    {
                        using (var writer = new ResourceWriter(binFile))
                        {
                            foreach (DictionaryEntry d in reader)
                            {
                                writer.AddResource(d.Key.ToString(), d.Value);
                            }
                        }
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            ResourceWriter myResource = new ResourceWriter("Images.resources");
            myResource.AddResource("flash", new Bitmap("flashScreen.png"));
            Image simpleImage = new Image();
            simpleImage.Margin = new Thickness(0);

            BitmapImage bi = new BitmapImage();
            //BitmapImage.UriSource must be in a BeginInit/EndInit block
            bi.BeginInit();





            bi.UriSource = new Uri(@"pack://siteoforigin:,,,/alarm3.png");
            bi.EndInit();
            //set image source
            simpleImage.Source = bi;
            //        simpleImage.Stretch = Stretch.None;
            simpleImage.HorizontalAlignment = HorizontalAlignment.Center;
            simpleImage.Visibility = Visibility.Hidden;
            simpleImage.Name = "AlarmIndicator";
            simpleImage.Width = 13;


            myResource.AddResource("alarm", new Image("alarm3.png"));
            myResource.Close(); 


        }

        private static void WriteResourceFile(string resxFilePath)
        {
            using (var fs = File.OpenRead(resxFilePath))
            {
                var document = XDocument.Load(fs);

                var binDirPath = Path.Combine(Path.GetDirectoryName(resxFilePath), "bin");
                if (!Directory.Exists(binDirPath))
                {
                    Directory.CreateDirectory(Path.Combine(Path.GetDirectoryName(resxFilePath), "bin"));
                }

                // Put in "bin" sub-folder of resx file
                var targetPath = Path.Combine(binDirPath, Path.ChangeExtension(Path.GetFileName(resxFilePath), ".resources"));

                using (var targetStream = File.Create(targetPath))
                {
                    var rw = new ResourceWriter(targetStream);

                    foreach (var e in document.Root.Elements("data"))
                    {
                        var name = e.Attribute("name").Value;
                        var value = e.Element("value").Value;

                        rw.AddResource(name, value);
                    }

                    rw.Generate();
                }
            }
        }

        public SpecialResourceWriter()
        {
            // Load all bunlde
            IList<IResourceBundle> allBundle = new List<IResourceBundle>(20);
            allBundle.Add(ResourceBundleFactory.CreateBundle("CanonMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("CasioMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("Commons", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("ExifInteropMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("ExifMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("FujiFilmMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("GpsMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("IptcMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("JpegMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("KodakMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("KyoceraMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("NikonTypeMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("OlympusMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("PanasonicMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("PentaxMarkernote", null, ResourceBundleFactory.USE_TXTFILE));
            allBundle.Add(ResourceBundleFactory.CreateBundle("SonyMarkernote", null, ResourceBundleFactory.USE_TXTFILE));

            foreach(IResourceBundle bdl in allBundle)
            {
                ResourceWriter rw = new ResourceWriter(bdl.Fullname+".resources");
                IDictionary<string,string> idic = bdl.Entries;
                IDictionaryEnumerator enumDic =  (IDictionaryEnumerator)idic.GetEnumerator();
                while (enumDic.MoveNext())
                {
                    rw.AddResource((string)enumDic.Key, (string)enumDic.Value);
                }
                rw.Close();
                rw.Dispose();

            }
        }

		private void InitRes()
		{
			if(rw == null)
			{
				resourceFilePath = OutDirMan.MakeOutFileName(resourceFilePath);
				rw = new ResourceWriter(resourceFilePath);
			}
		}

 public static void ExceptionforResWriter01()
 {
     Assert.Throws<ArgumentNullException>(() =>
         {
             MemoryStream ms2 = null;
             var rw = new ResourceWriter(ms2);
         });
 }

 private void WriteCollectedBamlStreams(ResourceWriter resourceWriter)
 {
     foreach (var bamlStream in _bamlStreams)
     {
         resourceWriter.AddResourceData(
             GetResourceName(bamlStream.Key, bamlStream.Value), bamlStream.Key.type, bamlStream.Key.data);
     }
 }

        public void Process(EmbeddedResource embeddedResource, ResourceWriter resourceWriter)
        {
            if (_bamlStreams.Count == 0)
                return;

            WriteCollectedBamlStreams(resourceWriter);
            PatchGenericThemesBaml(resourceWriter);
        }

 public void BuildResource(string outputPath)
 {
     using (ResourceWriter w1 = new ResourceWriter(outputPath))
     {
         foreach (Item item in _items)
             w1.AddResource(item.Name, item.Value);
     }
 }

 public static void AddFileAsStringResource(string resourceFile, string resourceName, string inputFile)
 {
     ResourceWriter writer = new ResourceWriter(resourceFile);
     StreamReader reader = new StreamReader(inputFile);
     string s = reader.ReadToEnd();
     reader.Close();
     writer.AddResource(resourceName, s);
     writer.Close();
 }

 private static Stream MakeResourceStream()
 {
     var stream = new MemoryStream();
     var resourceWriter = new ResourceWriter(stream);            
     resourceWriter.AddResource("TestName", "value");
     resourceWriter.Generate();
     stream.Position = 0;
     return stream;
 }

        static void Main(string[] args)
        {
            var getopt = new Getopt(Assembly.GetExecutingAssembly().GetName().Name, args, "i:o:") { Opterr = false };

            string input = null;
            string output = null;

            int option;
            while (-1 != (option = getopt.getopt()))
            {
                switch (option)
                {
                    case 'i': input = getopt.Optarg; break;
                    case 'o': output = getopt.Optarg; break;

                    default: PrintUsage(); return;
                }
            }

            if (input == null || output == null)
            {
                PrintUsage();
                return;
            }

            try
            {
                if (!File.Exists(input))
                {
                    Console.WriteLine("File {0} not found", input);
                    return;
                }

                Dictionary<string, string> entries;
                var parser = new PoParser();
                using (var reader = new StreamReader(input))
                {
                    entries = parser.ParseIntoDictionary(reader);
                }

                using (var writer = new ResourceWriter(output))
                {
                    foreach (var kv in entries)
                    {
                        try { writer.AddResource(kv.Key, kv.Value); }
                        catch (Exception e) { Console.WriteLine("Error adding item {0}: {1}", kv.Key, e.Message); }
                    }
                    writer.Generate();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error during execution: {0}", ex.Message);
                return;
            }
        }

        public bool Process(
            AssemblyDefinition containingAssembly, Res resource, ResReader resourceReader, ResourceWriter resourceWriter)
        {
            if (!resource.IsBamlStream)
                return false;

            resource.data = GetProcessedResource(resource, containingAssembly);

            return false;
        }

 internal ResWriterData(ResourceWriter resWriter, Stream memoryStream, string strName, string strFileName, string strFullFileName, ResourceAttributes attribute)
 {
     this.m_resWriter = resWriter;
     this.m_memoryStream = memoryStream;
     this.m_strName = strName;
     this.m_strFileName = strFileName;
     this.m_strFullFileName = strFullFileName;
     this.m_nextResWriter = null;
     this.m_attribute = attribute;
 }

 public static void InsertEmployee(ResourceObj emp)
 {
     l.Add(emp);
     ResourceWriter rsxw = new ResourceWriter(path);
     for (int i = 0; i < l.Count; i++)
     {
         rsxw.AddResource("obj" + i.ToString(), l[i]);
     }
     rsxw.Close();
 }

 internal void EnsureRepositoryFileExists()
 {
     if (!File.Exists(this.RepositoryFilename))
     {
         using (IResourceWriter writer = new ResourceWriter(this.RepositoryFilename))
         {
             writer.Generate();
         }
     }
 }