System.Threading.Thread.CurrentThread.CurrentUICulture 
    = System.Threading.Thread.CurrentThread.CurrentCulture;

SM>System.Threading.Thread.CurrentThread.CurrentUICulture 
SM>    = System.Threading.Thread.CurrentThread.CurrentCulture;
SM>

        private void langEnglish_Click(object sender, System.EventArgs e)
        {
            //System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US", false);
            Application.CurrentCulture   = new CultureInfo("en-US", true);
            System.Threading.Thread.CurrentThread.CurrentUICulture 
                = System.Threading.Thread.CurrentThread.CurrentCulture;
            MessageBox.Show("Current UI Culture: " + CultureInfo.CurrentUICulture.Name);
            
            langEnglish.Checked = true;
            langRussian.Checked = false;
        }

// author : Andrew A. Golyakov
// 

using System;
using System.Xml;
using System.Windows.Forms;
using System.Collections;
using System.Collections.Specialized;

namespace Language
{
    /// <summary>
    /// Languages enumeration <br>
    /// - English<br>
    /// - Russian<br>
    /// - Dutch<br>
    /// </summary>    
    public enum Languages
    {
        English,
        Russian,
        Dutch,
        Swedish
    }

    /// <summary>
    /// Langeage Lybrary - helps to translate your applications to any language.<br>
    /// Developed with the XML Technology.<br>
    /// Just create your own language file with specefied language and use it any time you need.<br>
    /// <br>
    /// Now it provide processing such controls as:<br>
    /// - MainMenu<br>
    /// - Button<br>
    /// - Label<br>
    /// - TextBox<br>
    /// - CheckBox<br>
    /// - RadioButton<br>
    /// - ComboBox<br>
    /// - ListBox<br>
    /// - TabControl<br>
    /// - GroupBox<br>
    /// </summary>
    public class CLanguage
    {
        /// <summary>
        /// <font color='red'>Private.</font> Xml document to store language information.
        /// </summary>
        private XmlDocument doc;
        /// <summary>
        /// <font color='red'>Private.</font> The root node of xml docement.
        /// </summary>
        private XmlNode root;
        /// <summary>
        /// <font color='red'>Private.</font> Node to store Mainmenu control.
        /// </summary>
        private XmlNode MainMenuNode;
        /// <summary>
        /// <font color='red'>Private.</font> Node to store other controls.
        /// </summary>
        private XmlNode ControlsNode;
        /// <summary>
        /// <font color='red'>Private.</font> Node to store other context menus of controls.
        /// </summary>
        private XmlNode ContextMenusNode;
        /// <summary>
        /// <font color='red'>Private.</font> Node to store string resources.
        /// </summary>
         private XmlNode StringsNode;
        /// <summary>
        /// <font color='red'>Private.</font> Node to store form caption.
        /// </summary>
        private XmlNode FormCaptionNode;
        /// <summary>
        /// <font color='red'>Private.</font> Contains directory of languages files.
        /// </summary>
        private string filename_prefix;
        /// <summary>
        /// <font color='red'>Private.</font> Contains extention of languages files.
        /// </summary>
        private string filename_postfix;

        private Languages mCurrentLanguage;

        /// <summary>
        /// <font color='blue'><b>Public.</b></font> Use this property to choose another language.
        /// </summary>
        public Languages currentLanguage
        {
            get
            {
                return mCurrentLanguage;
            }
            set
            {
                mCurrentLanguage = value;
                //LoadStringResources();
            }
        }

        private ArrayList mStringResources;
            
        /// <summary>
        /// <font color='blue'><b>Public.</b></font> Simple constructor sets the current language.
        /// </summary>
        /// <param name="newCurrentLanguage">Current language to default parameters</param>
        public CLanguage(Languages newCurrentLanguage)
        {
            // creating xml-document
            doc = new XmlDocument();
            root = doc.CreateNode(XmlNodeType.Element, "Language", "");
         MainMenuNode = doc.CreateNode(XmlNodeType.Element, "MainMenu", "");
            ControlsNode = doc.CreateNode(XmlNodeType.Element, "Controls", "");
            FormCaptionNode = doc.CreateNode(XmlNodeType.Element, "FormCaption", "");
            ContextMenusNode = doc.CreateNode(XmlNodeType.Element, "ContextMenus", "");

            root.AppendChild(FormCaptionNode);
            root.AppendChild(MainMenuNode);
            root.AppendChild(ControlsNode);
            root.AppendChild(ContextMenusNode);

            doc.AppendChild(root);
            XmlDeclaration xmldecl;
            xmldecl = doc.CreateXmlDeclaration("1.0",null,null);
            doc.InsertBefore(xmldecl, root);

            // set default language
            currentLanguage = newCurrentLanguage;

         // file name
            filename_prefix = "Language/";
            filename_postfix = ".lng.xml";

            // creating string resources array
            mStringResources = new ArrayList();
            LoadStringResources();
        }
        
        /// <summary>
        /// 
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string GetStringResource(string key)
        {
            foreach(DictionaryEntry mStringResource in mStringResources)
            {
                if (mStringResource.Key as string == key)
                {
                    return mStringResource.Value as string;
                }
            }
            return String.Empty;
        }

        /// <summary>
        /// <font color='red'>Private.</font> Saving menu items from the Menu.
        /// </summary>
        /// <param name="m">Menu to save</param>
        /// <param name="parent_node">Parent node to save</param>
        private void SaveMenuItem(Menu m, XmlNode parent_node)
        {
            foreach (MenuItem mi in m.MenuItems)
            {                
                XmlNode Elem = doc.CreateNode(XmlNodeType.Element, "Item" + mi.Index.ToString(), "");
                XmlAttribute LanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                LanguageText.Value = mi.Text;
                Elem.Attributes.Append(LanguageText);
                parent_node.AppendChild(Elem);                

                if (mi.IsParent == true)
                {
                    SaveMenuItem(mi, Elem);                    
                }
            }
        }


        /// <summary>
        /// <font color='red'>Private.</font> Loading menu items to the Menu.
        /// </summary>
        /// <param name="m">Menu to load</param>
        /// <param name="parent_node">Parent node to load</param>
        private void LoadMenuItem(Menu m, XmlNode parent_node)
        {
            foreach (MenuItem mi in m.MenuItems)
            {
                XmlNode cur_item = parent_node.SelectSingleNode("Item" + mi.Index.ToString());
                mi.Text = cur_item.Attributes["LanguageText"].Value;
                
                if (mi.IsParent == true)
                {
                    LoadMenuItem(mi, cur_item);
                }
            }
        }


        /// <summary>
        /// <font color='red'>Private.</font> Saving all menuitems (with sub-menus) from  form's MainMenu.
        /// </summary>
        /// <param name="lang">Language to save</param>
        /// <param name="frm">Form name</param>
        /// <returns>True if all correct, or False</returns>
        private bool SaveMenuItems(Languages lang, Form frm)
        {
            if (frm.Menu == null) return true;

         MainMenuNode.RemoveAll();
            SaveMenuItem(frm.Menu, MainMenuNode);

            return true;
        }


        /// <summary>
        /// <font color='red'>Private.</font> Loading all menuitems (with sub-menus) to form's MainMenu.
        /// </summary>
        /// <param name="lang">Language to load</param>
        /// <param name="frm">Form name</param>
        /// <returns>True if all correct, or False</returns>
        private bool LoadMenuItems(Languages lang, Form frm)
        {
            if (frm.Menu == null) return true;
        
            LoadMenuItem(frm.Menu, MainMenuNode);            

            return true;
        }

        /// <summary>
        /// <font color='red'>Private.</font> Saving all controls to the Xml-Node.
        /// </summary>
        /// <param name="lang">Target language</param>
        /// <param name="ctrls">Control collection</param>
        /// <param name="parentNode">Parent node</param>
        /// <returns>True if all correct, or False</returns>
        private bool SaveContextMenus(Languages lang, Form frm, XmlNode parentNode)
        {
            ContextMenusNode.RemoveAll();

            foreach (Control c in frm.Controls)
            {
                if (c.ContextMenu != null)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    parentNode.AppendChild(Elem);
                    
                    SaveMenuItem(c.ContextMenu, Elem);
                }
            }
            return true;
        }

        /// <summary>
        /// <font color='red'>Private.</font> Loading all controls from the Xml-Node.
        /// </summary>
        /// <param name="lang">Target language</param>
        /// <param name="ctrls">Control collection</param>
        /// <param name="parentNode">Parent node</param>
        /// <returns>True if all correct, or False</returns>
        private bool LoadContextMenus(Languages lang, Form frm, XmlNode parentNode)
        {
            foreach (Control c in frm.Controls)
            {
            if (c.ContextMenu != null)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name)
                            LoadMenuItem(c.ContextMenu, xmlnode);
                    }                    
                }
            }
            return true;
        }

        /// <summary>
        /// <font color='red'>Private.</font> Loading all controls from the Xml-Node.
        /// </summary>
        /// <param name="lang">Target language</param>
        /// <param name="ctrls">Control collection</param>
        /// <param name="parentNode">Parent node</param>
        /// <returns>True if all correct, or False</returns>
        private bool LoadControls(Languages lang, Control.ControlCollection ctrls, XmlNode parentNode)
        {
            foreach (Control c in ctrls)
            {
                if (c is Button || c is Label || c is TextBox || c is CheckBox || c is RadioButton)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name)
                            c.Text = xmlnode.Attributes["LanguageText"].Value;
                    }
                }

                if (c is ComboBox)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name)
                        {
                            if (
                                (c as ComboBox).DropDownStyle == ComboBoxStyle.DropDown ||
                                (c as ComboBox).DropDownStyle == ComboBoxStyle.Simple
                                )
                            c.Text = xmlnode.Attributes["LanguageText"].Value;

                            if (xmlnode.HasChildNodes == true)
                            {
                                int i = -1;
                                foreach (XmlNode node in xmlnode.ChildNodes)
                                {                                    
                                    (c as ComboBox).Items[++i] = node.Attributes["LanguageText"].Value;
                                }
                            }
                        }
                    }                    
                }
                if (c is ListBox)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name && xmlnode.HasChildNodes == true)
                        {
                            int i = -1;
                            foreach (XmlNode node in xmlnode.ChildNodes)
                            {
                                (c as ListBox).Items[++i] = node.Attributes["LanguageText"].Value;
                            }
                        }                    
                    }
                }
                if (c is TabControl)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name)
                        {
                            foreach (XmlNode node in parentNode.ChildNodes)
                            {
                                if (node.Name == c.Name && node.HasChildNodes == true)
                                {
                                    System.Collections.IEnumerator e = (c as TabControl).TabPages.GetEnumerator();
                     
                                    foreach (XmlNode n in xmlnode.ChildNodes)
                                    {
                                        e.MoveNext();
                                        (e.Current as TabPage).Text =    n.Attributes["LanguageText"].Value;

                                        if (n.HasChildNodes == true)
                                            LoadControls(lang, (e.Current as TabPage).Controls, n);
                                    }
                                }                    
                            }
                        }
                    }
                }

                if (c is GroupBox)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name && xmlnode.HasChildNodes == true)
                        {
                            c.Text = xmlnode.Attributes["LanguageText"].Value;
                            LoadControls(lang, (c as GroupBox).Controls, xmlnode);
                        }
                    }
                }
                
                if (c is StatusBar)
                {
                    foreach (XmlNode xmlnode in parentNode.ChildNodes)
                    {
                        if (xmlnode.Name == c.Name && xmlnode.HasChildNodes == true)
                        {
                            int i = -1;
                            foreach (XmlNode node in xmlnode.ChildNodes)
                            {
                                (c as StatusBar).Panels[++i].Text = node.Attributes["LanguageText"].Value;
                            }
                        }                    
                    }
                }
            }
        
            return true;
        }

        private bool SaveFormCaption(Languages lang, Form frm)
        {
            FormCaptionNode.RemoveAll();

            XmlAttribute LanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
            LanguageText.Value = frm.Text;
            FormCaptionNode.Attributes.Append(LanguageText);
      
            return true;
        }

        private bool LoadFormCaption(Languages lang, Form frm)
        {
            frm.Text = FormCaptionNode.Attributes["LanguageText"].Value;
            return true;
        }

        /// <summary>
        /// <font color='red'>Private.</font> Saving all controls to the Xml-Node.
        /// </summary>
        /// <param name="lang">Target language</param>
        /// <param name="ctrls">Control collection</param>
        /// <param name="parentNode">Parent node</param>
        /// <returns>True if all correct, or False</returns>
        private bool SaveControls(Languages lang, Control.ControlCollection ctrls, XmlNode parentNode)
        {
            foreach (Control c in ctrls)
            {
                if (c is Button || c is Label || c is TextBox || c is CheckBox || c is RadioButton)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    XmlAttribute LanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                    LanguageText.Value = c.Text;
                    Elem.Attributes.Append(LanguageText);
                    parentNode.AppendChild(Elem);
                }
                if (c is ComboBox)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    if (
                        (c as ComboBox).DropDownStyle == ComboBoxStyle.DropDown ||
                        (c as ComboBox).DropDownStyle == ComboBoxStyle.Simple
                        )
                    {
                        XmlAttribute LanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                        LanguageText.Value = c.Text;
                        Elem.Attributes.Append(LanguageText);
                    }
                    parentNode.AppendChild(Elem);
                    
                    if ((c as ComboBox).Items.Count > 0)
                    {
                        for(int i=0; i<(c as ComboBox).Items.Count; i++)
                        {
                            XmlNode SubElem = doc.CreateNode(XmlNodeType.Element, "Item" + i.ToString(), "");
                            XmlAttribute SubLanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                            SubLanguageText.Value = (c as ComboBox).Items[i].ToString();
                            SubElem.Attributes.Append(SubLanguageText);
                            Elem.AppendChild(SubElem);
                        }
                    }
                }

                if (c is ListBox)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    parentNode.AppendChild(Elem);
                    
                    if ((c as ListBox).Items.Count > 0)
                    {
                        for(int i=0; i<(c as ListBox).Items.Count; i++)
                        {
                            XmlNode SubElem = doc.CreateNode(XmlNodeType.Element, "Item" + i.ToString(), "");
                            XmlAttribute SubLanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                            SubLanguageText.Value = (c as ListBox).Items[i].ToString();
                            SubElem.Attributes.Append(SubLanguageText);
                            Elem.AppendChild(SubElem);
                        }
                    }
                }
                if (c is TabControl)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    parentNode.AppendChild(Elem);

                    foreach (TabPage p in (c as TabControl).TabPages)
                    {
                        XmlNode SubElem = doc.CreateNode(XmlNodeType.Element, p.Name, "");                        
                        XmlAttribute SubLanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                        SubLanguageText.Value = p.Text;
                        SubElem.Attributes.Append(SubLanguageText);
                        Elem.AppendChild(SubElem);
                        parentNode.AppendChild(Elem);                 
                        SaveControls(lang, p.Controls, SubElem);
                    }
                }

                if (c is GroupBox)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    XmlAttribute LanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                    LanguageText.Value = c.Text;
                    Elem.Attributes.Append(LanguageText);
                    parentNode.AppendChild(Elem);          
                    SaveControls(lang, (c as GroupBox).Controls, Elem);
                }

                if (c is StatusBar)
                {
                    XmlNode Elem = doc.CreateNode(XmlNodeType.Element, c.Name, "");
                    parentNode.AppendChild(Elem);

                    SaveStatusBarPanels(lang, (c as StatusBar).Panels, Elem);
                }
            }
            return true;
        }

        private void SaveStatusBarPanels(Languages lang, StatusBar.StatusBarPanelCollection  ctrls, XmlNode parentNode)
        {
            int index = 0;                 // index of panels 
            foreach (StatusBarPanel p in ctrls)
            {
                XmlNode Elem = doc.CreateNode(XmlNodeType.Element, "Panel"+index.ToString(), "");
                XmlAttribute LanguageText = doc.CreateAttribute(String.Empty, "LanguageText", "");
                LanguageText.Value = p.Text;
                Elem.Attributes.Append(LanguageText);
                parentNode.AppendChild(Elem);
                index++;
            }
        }

        /// <summary>
        /// <font color='blue'><b>Public.</b></font> Loading luanguage data (of current language) of window's controls from xml-file.
        /// </summary>
        /// <param name="frm">Form, which controls must be translated</param>
        /// <returns>True if all correct, or False</returns>
        public bool Load(Form frm)
        {
            string filename = "";
            if (currentLanguage == Languages.Russian) filename = "russian";
            if (currentLanguage == Languages.English) filename = "english";
            if (currentLanguage == Languages.Dutch) filename = "dutch";
            if (currentLanguage == Languages.Swedish) filename = "swedish";
            filename = filename_prefix + filename;
            filename += "." + frm.Name;
            filename += filename_postfix;

            try 
            {
                doc.Load(filename);                
            }
            catch (Exception e) 
            {
                if (e is System.IO.FileNotFoundException)
                    MessageBox.Show(String.Format("Can't find language file \"{0}\"\nPlease sure that it placed in the application directory!", filename), "File not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return false;
            }
            
            root = doc.DocumentElement;
            
            // reading nodes
            FormCaptionNode = root.ChildNodes.Item(0);
            MainMenuNode =    root.ChildNodes.Item(1);
            ControlsNode = root.ChildNodes.Item(2);
            ContextMenusNode = root.ChildNodes.Item(3);

            LoadFormCaption(currentLanguage, frm);
         LoadMenuItems(currentLanguage, frm);
            LoadControls(currentLanguage, frm.Controls, ControlsNode);
            LoadContextMenus(currentLanguage, frm, ContextMenusNode);
        
            return true;        
        }

        /// <summary>
        /// <font color='red'><b>Private.</b></font> Loading luanguage data (of current language) of string resources from xml-file.
        /// </summary>
        /// <returns>True if all correct, or False</returns>
        private bool LoadStringResources()
        {
            string filename = "";
            if (currentLanguage == Languages.Russian) filename = "russian";
            if (currentLanguage == Languages.English) filename = "english";
            if (currentLanguage == Languages.Dutch) filename = "dutch";
            if (currentLanguage == Languages.Swedish) filename = "swedish";
            filename = filename_prefix + filename;
            filename += ".resources";
            filename += filename_postfix;

            XmlDocument doc = new XmlDocument();
            XmlNode root = doc.CreateNode(XmlNodeType.Element, "Language", "");

            StringsNode = doc.CreateNode(XmlNodeType.Element, "StringRecources", "");
            root.AppendChild(StringsNode);

            doc.AppendChild(root);
            XmlDeclaration xmldecl;
            xmldecl = doc.CreateXmlDeclaration("1.0",null,null);
            doc.InsertBefore(xmldecl, root);

            try 
            {
                doc.Load(filename);                
            }
            catch (Exception e) 
            {
                if (e is System.IO.FileNotFoundException)
                    MessageBox.Show(String.Format("Can't find language file \"{0}\"\nPlease sure that it placed in the application directory!", filename), "File not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return false;
            }
            
            root = doc.DocumentElement;
            
            // reading nodes
            StringsNode = root.ChildNodes.Item(0);

            mStringResources.Clear();
            foreach (XmlNode xmlnode in StringsNode.ChildNodes)
            {
                DictionaryEntry mStringResource = new DictionaryEntry(xmlnode.Name, xmlnode.Attributes["LanguageText"].Value);
                mStringResources.Add(mStringResource);
            }

            return true;        
        }

        /// <summary>
        /// <font color='blue'><b>Public.</b></font> Saving luanguage data of window's controls to xml-file.<br>
        /// <font color='red'><b>NOTE!</b></font> It's not used only during projetion process to create sample language file.<br>
        /// <font color='blue'>This method creates directory [/Language] if needed.</font>
        /// </summary>
        /// <param name="lang">Target language of saving file ()</param>
        /// <param name="frm">Form, which control's texts must be saved</param>
        /// <returns>True if all correct, or False</returns>
        public bool Save(Languages lang, Form frm)
        {
            SaveFormCaption(lang, frm);
            SaveMenuItems(lang, frm);            
            ControlsNode.RemoveAll();
            SaveControls(lang, frm.Controls, ControlsNode);
            SaveContextMenus(lang, frm, ContextMenusNode);

            if (System.IO.Directory.Exists(filename_prefix) == false)
                System.IO.Directory.CreateDirectory(filename_prefix);

            string filename = "";
            if (lang == Languages.Russian) filename = "russian";
            if (lang == Languages.English) filename = "english";
            if (lang == Languages.Dutch) filename = "dutch";
            if (lang == Languages.Swedish) filename = "swedish";
            filename = filename_prefix + filename;
            filename += "." + frm.Name;
            filename += filename_postfix;

         try 
            {
                doc.Save(filename);
            }
            catch (Exception e)
            {
            MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            return false;
            }
            
            return true;
        }
    }
}

enum