WPF

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

public DataSet GetDataSet()
 {
 string queryCatStr = @"SELECT * FROM [Category]";
 string queryProdStr = @"SELECT * FROM [Products]";

 DataSet ds = new DataSet();

 SQLConnection dbConn = new SQLConnection("conn_str"))
 dbConn.Open(); 
 SQLCommand cmd = new SQLCommand(dbConn);

 cmd.CommandText = queryCatStr;
 SQLDataAdapter da = new SQLDataAdapter(cmd);
 da.Fill(ds, "Categories");

 cmd.CommandText = queryProdStr;
 da.Fill(ds, "Products");

 DataRelation drCat2Prod = new DataRelation("Cat2Prod", ds.Tables["categories"].Columns["CategoryID"], ds.Tables["Products"].Columns["CategoryID"]);
 ds.Relations.Add(drCat2Prod);
 
 return ds;
 }


 private void Window_Loaded(object sender, RoutedEventArgs e)
 {
 ds = GetDataSet();
 this.DataContext = ds.Tables["Category"];
 this.treeCategories.DisplayMemberPath = "CategoryName";
 }

<TreeView x:Name="treeCategories" ItemsSource="{Binding}" />
...

<ListView x:Name="lstProducts" IsSynchronizedWithCurrentItem="True" ItemsSource="{Binding Cat2Prod}" />