public static void InitResource()
        {
            string path = HttpContext.Current.Server.MapPath("/") + "Resource\\";

            foreach (string lang in LangList)
            {
                ResXResourceReader reader = new ResXResourceReader(path + lang + ".resx");

                try
                {
                    foreach (DictionaryEntry d in reader)
                    {
                        dataCollection.Add(new KeyValuePair<string, string>(AssmbleKey(d.Key.ToString(), lang), d.Value.ToString()));
                    }
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    reader.Close();
                }
            }
        }

		public void Test ()
		{
			Thread.CurrentThread.CurrentCulture =
					Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de-DE");

			ResXResourceWriter w = new ResXResourceWriter (fileName);
			w.AddResource ("point", new Point (42, 43));
			w.Generate ();
			w.Close ();

			int count = 0;
			ResXResourceReader r = new ResXResourceReader (fileName);
			IDictionaryEnumerator e = r.GetEnumerator ();
			while (e.MoveNext ()) {
				if ((string) e.Key == "point") {
					Assert.AreEqual (typeof (Point), e.Value.GetType (), "#1");
					Point p = (Point) e.Value;
					Assert.AreEqual (42, p.X, "#2");
					Assert.AreEqual (43, p.Y, "#3");
					count++;
				}
			}
			r.Close ();
			Assert.AreEqual (1, count, "#100");
		}

        public ResXViewForm(string fileName)
        {
            const int BASEWIDTH = 1000;
            const int BASEHEIGHT = 250;
            ClientSize = new Size((BASEWIDTH + 20), BASEHEIGHT + 100);

            resxFile = new FileInfo(fileName);

            using (var resxSet = new ResXResourceSet(resxFile.FullName))
            {
                Text = resxSet.GetString("FormTitle");
                Icon = (Icon)resxSet.GetObject("ShieldIcon");
            }

            const int margin = 10;
            var resList = new ListView
            {
                Bounds = new Rectangle(new Point(margin, margin), new Size(BASEWIDTH, BASEHEIGHT)),
                View = View.Details,
                GridLines = true,
            };

            var columnWidth = (resList.ClientSize.Width / 3);
            resList.Columns.Add("Resource Name", columnWidth);
            resList.Columns.Add("Type", columnWidth);
            resList.Columns.Add("Value", columnWidth);

            using (var resxReader = new ResXResourceReader(resxFile.FullName))
            {
                foreach (DictionaryEntry entry in resxReader)
                {
                    var resItem = new ListViewItem((string)entry.Key);
                    resItem.SubItems.Add(entry.Value.GetType().FullName);
                    resItem.SubItems.Add(entry.Value.ToString());
                    resList.Items.Add(resItem);
                }
            }

            var resxButton = new Button
            {
                Text = "Show ResX",
                Location = new Point(resList.Bounds.Left, resList.Bounds.Bottom + margin)
            };
            resxButton.Click += (sender, args) => Process.Start("Notepad.exe", resxFile.FullName);

            var exitButton = new Button { Text = "Exit" };
            exitButton.Location = new Point(resList.Bounds.Right - exitButton.Width, resList.Bounds.Bottom + margin);
            exitButton.Click += (sender, args) => Application.Exit();

            FormBorderStyle = FormBorderStyle.Sizable;
            MaximizeBox = true;
            MinimizeBox = false;
            StartPosition = FormStartPosition.CenterScreen;

            Controls.Add(resList);
            Controls.Add(resxButton);
            Controls.Add(exitButton);

            InitializeComponent();
        }

 protected override IResourceReader GetResourceReader(Stream inputStream)
 {
     ResXResourceReader reader = new ResXResourceReader(inputStream);
     string path = HostingEnvironment.MapPath(base.VirtualPath);
     reader.BasePath = Path.GetDirectoryName(path);
     return reader;
 }

        /// <summary>
        /// To Get the user credentials from Customer Resource file
        /// </summary>
        /// Authour: Pradeep
        /// <param name="custType">Type of the customer</param>
        /// <returns>returns an array with UserName and Password</returns>
        /// Created Date: 22-Dec-2011
        /// Modified Date: 22-Dec-2011
        /// Modification Comments
        public static string[] GetCustomerCredentials(string custType)
        {
            try
            {
                Stream stream = new System.IO.FileStream(ResFilePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
                var resFileData = new ResXResourceReader(stream);
                IDictionaryEnumerator resFileDataDict = resFileData.GetEnumerator();
                var customerCreds = new string[2];
                while (resFileDataDict.MoveNext())
                {
                    if (custType.ToString(CultureInfo.InvariantCulture) == resFileDataDict.Key.ToString())
                    {
                        string temp = resFileDataDict.Value.ToString();
                        customerCreds = temp.Split(';');
                        break;
                    }
                }

                resFileData.Close();
                stream.Dispose();
                return customerCreds;

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
                return null;

            }
        }

        public static void UpdateResourceFile(Hashtable data, string path, TranslatorForm form)
        {
            form.TextOutput = "Writing " + path + "...";

            Hashtable resourceEntries = new Hashtable();
            bool check = false;

            //Get existing resources
            ResXResourceReader reader = new ResXResourceReader(path);
            if (reader != null)
            {
                IDictionaryEnumerator id = reader.GetEnumerator();
                foreach (DictionaryEntry d in reader)
                {
                    if (d.Value == null)
                        resourceEntries.Add(d.Key.ToString(), "");
                    else
                        resourceEntries.Add(d.Key.ToString(), d.Value.ToString());
                }
                reader.Close();
            }

            //Modify resources here...
            foreach (String key in data.Keys)
            {
                if (!resourceEntries.ContainsKey(key))
                {

                    String value = data[key].ToString();
                    if (value == null) value = "";

                    resourceEntries.Add(key, value);
                }
            }

            //Write the combined resource file
            ResXResourceWriter resourceWriter = new ResXResourceWriter(path);

            foreach (String key in resourceEntries.Keys)
            {
                resourceWriter.AddResource(key, resourceEntries[key]);
            }
            resourceWriter.Generate();
            resourceWriter.Close();

            //Check if entered correctly
            reader = new ResXResourceReader(path);
            if (reader != null)
            {
                foreach (DictionaryEntry d in reader)
                    foreach (String key in resourceEntries.Keys)
                    {
                        if ((string) d.Key == key && (string) d.Value == (string) resourceEntries[key]) check = true;
                    }
                reader.Close();
            }

            if (check) form.TextOutput = path + " written successfully";
            else form.TextOutput = path + " not written !!";
        }

 void LoadResources(ResXResourceReader resxReader)
 {
     IDictionaryEnumerator enumerator = resxReader.GetEnumerator ();
     while (enumerator.MoveNext ()) {
         Resources.Add (enumerator.Value as ResXDataNode);
     }
 }

        public LocalizationMessageProvider(string pluginName)
        {
            string path = "";
            //NOTE: Modified by [email protected] original is at revision 1668
            try
            {
                path = HttpContext.Current.Server.MapPath("/").Replace("IUDICO.LMS", "IUDICO." + pluginName);
            }
            catch(Exception exception)
            {
                path = Assembly.GetExecutingAssembly().CodeBase;
                path = Path.GetDirectoryName(path);
                path = Path.GetDirectoryName(path);
                path = Path.GetDirectoryName(path);
                path = Path.GetDirectoryName(path);
                path = Path.Combine(path, "IUDICO.LMS");
                path=path.Replace("IUDICO.LMS", "IUDICO." + pluginName);
                path = path.Remove(0, 6);
                path += @"\";
            }   
            //NOTE: End of modifiation from revision 1668
            foreach (var culture in cultures)
            {
                var rsxr = new ResXResourceReader(path + "Resource." + culture + ".resx");

                Dictionary<string, string> temp = new Dictionary<string, string>();
                foreach (DictionaryEntry d in rsxr)
                {
                    temp.Add(d.Key.ToString(), d.Value.ToString());
                }

                resource.Add(culture, temp);
            }
        }

 public ResourceHandler(string fileName)
 {
     Resources = new List<ResXDataNode> ();
     using (var reader = new ResXResourceReader (fileName) { UseResXDataNodes = true }) {
         LoadResources (reader);
     }
 }

        public static void Init_ResourceCache()
        {
            string resourceFolder = HttpContext.Current.Server.MapPath("~/App_GlobalResources");
            var dir = new DirectoryInfo(resourceFolder);
            var files = dir.GetFiles();

            for (int i = 0; i < files.Length; i++)
            {
                var file = files[i];
                string extension = Path.GetExtension(file.FullName).ToLower();

                if (extension == C_ResourceFileExtension)
                {
                    string dicKey = file.Name.ToLower();
                    Dictionary<string,string> resourceItems =new Dictionary<string, string>();
                    using (var reader = new ResXResourceReader(file.FullName))
                    {
                        foreach (DictionaryEntry item in reader)
                        {
                            var val = item.Value == null ? string.Empty : item.Value.ToString();
                            resourceItems.Add(item.Key.ToString(), val);
                        }
                    }
                    cacheLangResources.Add(dicKey, resourceItems);
                }
            }
        }

        public List<ResxStringResource> ResxToResourceStringDictionary(TextReader resxFileContent)
        {
            try
            {
                var result = new List<ResxStringResource>();

                // Reading comments: http://msdn.microsoft.com/en-us/library/system.resources.resxdatanode.aspx
                using (var reader = new ResXResourceReader(resxFileContent))
                {
                    reader.UseResXDataNodes = true;
                    var dict = reader.GetEnumerator();

                    while (dict.MoveNext())
                    {
                        var node = (ResXDataNode)dict.Value;

                        result.Add(new ResxStringResource()
                        {
                            Name = node.Name,
                            Value = (string)node.GetValue((ITypeResolutionService)null),
                            Comment = node.Comment
                        });
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.ToString());
            }

            return null;
        }

        public static void getBMPFiles(string resxFile)
        {
            // Create a Resource Reader
            ResXResourceReader rsxr = new ResXResourceReader(resxFile);

            // Create a enumerator
            IDictionaryEnumerator id = rsxr.GetEnumerator();

            int i = 0;
            foreach (DictionaryEntry d in rsxr)
            {

                Bitmap b = d.Value as Bitmap;

                if (b != null)
                {
                    b.Save(resxFile + "__" + i.ToString() + ".bmp");
                    i++;
                }

            }

            //Close the reader.
            rsxr.Close();
        }

        protected void LoadResource(string pluginName)
        {
            string path;

            try
            {
                path = HttpContext.Current.Server.MapPath("/").Replace("IUDICO.LMS", pluginName);
            }
            catch (Exception)
            {
                path = Path.Combine(Assembly.GetExecutingAssembly().CodeBase.Remove(0, 8) + @"\..\..\..\..\", pluginName) + @"\";
            }

            this.resource.Add(pluginName, new Dictionary<string, Dictionary<string, string>>());

            foreach (var culture in Cultures)
            {
                try
                {
                    var resourceReader = new ResXResourceReader(path + "Resource." + culture + ".resx");
                    var resourceEntries = resourceReader.Cast<DictionaryEntry>().ToDictionary(d => d.Key.ToString(), d => d.Value.ToString());

                    this.resource[pluginName].Add(culture, resourceEntries);
                }
                catch (Exception)
                {
                    
                }
            }
        }

        public override IEnumerable<ILocalizationUnit> Parse ()
        {
            foreach (var path in resx_paths) {
                var reader = new ResXResourceReader(path) { UseResXDataNodes = true };

                foreach (DictionaryEntry item in reader) {
                    var name = (string)item.Key;
                    var node = (ResXDataNode)item.Value;
                    var localized_string = new LocalizedString {
                        Name = name,
                        DeveloperComments = node.Comment,
                        UntranslatedSingularValue = name,
                        TranslatedValues = new string [] {(string)node.GetValue(null as ITypeResolutionService) }
                    };

                    for (int i = 0; i < localized_string.TranslatedValues.Length; i++)
                    {
                        var s = localized_string.TranslatedValues [i];
                        s = s.Replace ("\r", "");
                        localized_string.TranslatedValues[i] = s;
                    }

                    yield return localized_string;
                }
            }

            yield break;
        }

 /// <summary>
 /// 加载配置数据.如果加载失败，将抛异常
 /// </summary>
 public void LoadConfig()
 {
     SecurityOpr secOpr = new SecurityOpr(GlobalVar.Instanse.SecurityKey);
     string Datas = secOpr.ReadFromFile(m_StrPath);
     StringReader reader = new StringReader(Datas);
     using (m_Reader = new ResXResourceReader(reader))
     {
         try
         {
             foreach (DictionaryEntry item in m_Reader)
                 m_cfgDatas[item.Key.ToString()] = item.Value;
         }
         catch (FileNotFoundException)
         { }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     //finally
     //{
     //    if (m_Reader != null)
     //        m_Reader.Close();
     //}
 }

			public static void TestReader (string fileName)
			{
				ResXResourceReader r = new ResXResourceReader (fileName);
				Hashtable h = new Hashtable ();
				foreach (DictionaryEntry e in r) {
					h.Add (e.Key, e.Value);
				}
				r.Close ();

				Assert.AreEqual ("hola", (string) h ["String"], fileName + "#1");
				Assert.AreEqual ("hello", (string) h ["String2"], fileName + "#2");
				Assert.AreEqual (42, (int) h ["Int"], fileName + "#3");
				Assert.AreEqual (PlatformID.Win32NT, (PlatformID) h ["Enum"], fileName + "#4");
				Assert.AreEqual (43, ((Point) h ["Convertible"]).X, fileName + "#5");
				Assert.AreEqual (2, (byte) ((ArrayList) h ["Serializable"]) [1], fileName + "#6");
				Assert.AreEqual (13, ((byte []) h ["ByteArray"]) [1], fileName + "#7");
				Assert.AreEqual (16, ((byte []) h ["ByteArray2"]) [1], fileName + "#8");
				Assert.AreEqual (1013, ((int []) h ["IntArray"]) [1], fileName + "#9");
				Assert.AreEqual ("world", ((string []) h ["StringArray"]) [1], fileName + "#10");
#if NET_2_0
				Assert.IsNull (h ["InvalidMimeType"], "#11");
#else
				Assert.IsNotNull (h ["InvalidMimeType"], "#11a");
				Assert.AreEqual ("AAEAAAD/////AQAAAAAAAAARAQAAAAIAAAAGAgAAAAVoZWxsbwYDAAAABXdvcmxkCw==",
					h ["InvalidMimeType"], "#11b");
#endif
				Assert.IsNotNull (h ["Image"], fileName + "#12");
				Assert.AreEqual (typeof (Bitmap), h ["Image"].GetType (), fileName + "#13");
			}

        /// <summary>
        /// get all the values from the resource file 
        /// </summary>
        /// <param name="path"></param>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public static List<ResourceData> GetResourceData(string path, string moduleName)
        {
            List<ResourceData> resourceData = new List<ResourceData>();
            string defaultLanguagePath = GetResourceFilePath(moduleName, "en-IN");
            if (File.Exists(path))
            {

                ResXResourceReader reader = new ResXResourceReader(path);
                if (reader != null)
                {
                    IDictionaryEnumerator id = reader.GetEnumerator();
                    foreach (DictionaryEntry d in reader)
                    {

                        resourceData.Add(new ResourceData
                        {
                            Key = d.Key.ToString(),
                            Value = GetResourceDataByKey(defaultLanguagePath, d.Key.ToString()).Value,
                            NewValue = d.Value.ToString(),
                            ModuleName = moduleName
                        });
                    } reader.Close();
                }

            }
            return resourceData;
        }

        /// <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);
                            }
                        }
                    }
                }
            }
        }

        public void SaveResxAsTypeScriptFile(string[] resxFiles, string outputTSFilePAth)
        {
            var sb = new StringBuilder();
            sb.AppendLine("// This file is auto generated");
            sb.AppendLine("");
            sb.AppendLine("export class PortalResources");
            sb.AppendLine("{");

            foreach (var resxFile in resxFiles)
            {
                if (File.Exists(resxFile))
                {

                    ResXResourceReader rsxr = new ResXResourceReader(resxFile);
                    foreach (DictionaryEntry d in rsxr)
                    {
                        sb.AppendLine(string.Format("    public static {0}: string = \"{0}\";", d.Key.ToString()));
                    }

                    //Close the reader.
                    rsxr.Close();
                }
            }
            sb.AppendLine("}");

            using (System.IO.StreamWriter file = new System.IO.StreamWriter(outputTSFilePAth))
            {
                file.WriteLine(sb.ToString());
            }
        }

        public void TestWriter01()
        {
            List<ILocanRow> expectedValues = new List<ILocanRow> {
                new LocanRow(id:"Key01",translatedString:"Value01"),
                new LocanRow(id:"Key02",translatedString:"Value02"),
                new LocanRow(id:"Key03",translatedString:"Value03"),
            };

            string filepath = this.GetTempFilename(true, ".resx");
            using (ResxFileLocanWriter writer = new ResxFileLocanWriter(filepath)) {
                writer.WriteRows(expectedValues);
            }

            // now we need to read that file
            using (ResXResourceReader reader = new ResXResourceReader(filepath)) {
                int currentIndex = 0;
                foreach (DictionaryEntry de in reader) {
                    string expectedKey = expectedValues[currentIndex].Id;
                    string expectedValue = expectedValues[currentIndex].TranslatedString;

                    Assert.AreEqual(expectedKey, de.Key);
                    Assert.AreEqual(expectedValue, de.Value);

                    currentIndex++;
                }
            }
        }