WPF

class LanguageItem
    {
        public int ID { get; set; }
        public string Word { get; set; }
    }

ObservableCollection<LanguageItem> words = new ObservableCollection<LanguageItem>();
       public ObservableCollection<LanguageItem> Words
       {
           get
           {
               return words;
           }
           set
           {
               if (words != value)
               {
                   words = value;
                   NotifyPropertyChanged("Words");
               }
           }
       }

<Label Content="{Binding Path=Words[0].Word}"/>
<Label Content="{Binding Path=Words[1].Word}" Grid.Column="1"/>

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
using System.IO;

namespace SwitchLanguage
{
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        string folderPath = @"C:\Users\SwitchLanguage\";
        ObservableCollection<LanguageItem> words;
        public event PropertyChangedEventHandler PropertyChanged;

        public MainWindow()
        {
            InitializeComponent();

            // Must instance event or else PropertyChanged is ALWAYS null
            PropertyChanged += new PropertyChangedEventHandler(MainWindow_PropertyChanged);
        }


        private void btnUK_Click(object sender, RoutedEventArgs e)
        {
            ReadFile("UK.txt");
        }

        private void btnUS_Click(object sender, RoutedEventArgs e)
        {
            ReadFile("US.txt");
        }



        private void ReadFile(string file)
        {
            if (!File.Exists(folderPath + file))
            {
                throw new FileNotFoundException("Language file doesn't exist");
            }

            StreamReader sr = new StreamReader(folderPath + file);
            ObservableCollection<LanguageItem> words = new ObservableCollection<LanguageItem>();

            while (!sr.EndOfStream)
            {
                string[] parts = sr.ReadLine().Split('=');

                LanguageItem languageItem = new LanguageItem();
                languageItem.ID = int.Parse(parts[0]);
                languageItem.Word = parts[1];
                words.Add(languageItem);
            }

            Words = words;

            sr.Close();
        }

        public ObservableCollection<LanguageItem> Words
        {
            get { return words; }
            set
            {
                if (words != value)
                {
                    words = value;
                    PropertyChanged(this, new PropertyChangedEventArgs("Words"));
                }
            }
        }

        void MainWindow_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            Console.WriteLine("");
        }
    }

    public class LanguageItem
    {
        public int ID { get; set; }
        public string Word { get; set; }
    }
}

<Window x:Class="SwitchLanguage.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Label Name="lblWord" Content="{Binding Path=Words[0].Word}" Margin="50,-100,0,0" Width="200" Height="30"></Label>
        <Button Width="100" Height="40" Click="btnUK_Click" Content="UK" Margin="-100,0,0,0"></Button>
        <Button Width="100" Height="40" Click="btnUS_Click" Content="US" Margin="100,0,0,0"></Button>
    </Grid>
</Window>

DataContext = this;

Pete O'Hanlon wrote:

We use a custom localisable MarkupExtension to handle this

class LanguageItem
   {
       public int ID { get; set; }
       public string Word { get; set; }
   }

class LanguageViewModel : INotifyPropertyChanged
    {
        enum LanguageChoice
        {
            UK,
            US
        }

        private LanguageChoice selectedLanguage = LanguageChoice.UK;
        private string languageText = "Switch to US English";

        public string LanguageText
        {
            get
            {
                return languageText;
            }
            set
            {
                if (languageText != value)
                {
                    languageText = value;
                    NotifyPropertyChanged("LanguageText");
                }
             }
        }

        ObservableCollection<LanguageItem> words = new ObservableCollection<LanguageItem>();
        public ObservableCollection<LanguageItem> Words
        {
            get
            {
                return words;
            }
            set
            {
                if (words != value)
                {
                    words = value;
                    NotifyPropertyChanged("Words");
                }
            }
        }

        public LanguageViewModel()
        {
            LoadLanguage(selectedLanguage);
        }

        private RelayCommand switchCommand;
        public ICommand SwitchCommand
        {
            get
            {
                return switchCommand ?? (switchCommand = new RelayCommand(() => ObeySwitchCommand()));
            }
        }

        private void ObeySwitchCommand()
        {
            selectedLanguage = selectedLanguage == LanguageChoice.UK ? LanguageChoice.US : LanguageChoice.UK;
            LanguageText = selectedLanguage == LanguageChoice.UK ? "Switch to US English" : "Switch to UK English";
            LoadLanguage(selectedLanguage);
        }

        void LoadLanguage(LanguageChoice languageToLoad)
        {
            string path;
            if (languageToLoad == LanguageChoice.UK)
            {
                path = @"C:\Users\SwitchLanguage\UK.txt";
            }
            else
            {
                path = @"C:\Users\SwitchLanguage\US.txt";
            }
            StreamReader sr = new StreamReader(path);
            ObservableCollection<LanguageItem> newWords = new ObservableCollection<LanguageItem>();
            while (!sr.EndOfStream)
            {
                string[] parts = sr.ReadLine().Split(new char[] { ',' });
                int index;
                int.TryParse(parts[0], out index);
                LanguageItem li = new LanguageItem() { ID = index, Word = parts[1] };
                newWords.Add(li);
            }
            Words = newWords;
        }

        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged;

        public void NotifyPropertyChanged(String info)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

        #endregion
    }

<Grid.ColumnDefinitions>
           <ColumnDefinition />
           <ColumnDefinition />
       </Grid.ColumnDefinitions>
       <Grid.RowDefinitions>
           <RowDefinition />
           <RowDefinition />
       </Grid.RowDefinitions>
       <Label Content="{Binding Path=Words[0].Word}"/>
       <Label Content="{Binding Path=Words[1].Word}" Grid.Column="1"/>
       <Button Grid.Row="1" Grid.Column="1" HorizontalAlignment="Right" VerticalAlignment="Bottom"
               Command="{Binding Path=SwitchCommand}" Content="{Binding Path=LanguageText}"
               Width="100" Height="23"/>

protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            LanguageViewModel vm = new LanguageViewModel();
            LanguageTest lt = new LanguageTest();
            lt.DataContext = vm;
            lt.ShowDialog();
        }

public class RelayCommand : ICommand
    {
        readonly Action execute;
        readonly Func<bool> canExecute;

        public RelayCommand(Action execute)
            : this(execute, null)
        {
        }

        public RelayCommand(Action execute, Func<bool> canExecute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");

            this.execute = execute;
            this.canExecute = canExecute;
        }
        
        public bool CanExecute(object parameter)
        {
            return canExecute == null ? true : canExecute();
        }

        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (canExecute != null)
                    CommandManager.RequerySuggested += value;
            }
            remove
            {
                if (canExecute != null)
                    CommandManager.RequerySuggested -= value;
            }
        }

        public void Execute(object parameter)
        {
            execute();
        }
    }

arkiboys wrote:

on the client side, to use threading, I can use background worker