public class PhotoCollection : ObservableCollection<Photo>
{
        public PhotoCollection() { }

        public PhotoCollection(string path) : this(new DirectoryInfo(path)) { }

        public PhotoCollection(DirectoryInfo directory)
        {
            _directory = directory;
            Update();
        }

        public string Path
        {
            set
            {
                _directory = new DirectoryInfo(value);
                Update();
            }
            get { return _directory.FullName; }
        }

        private void Update()
        {
            this.Clear();
            try
            {
                int cnt = 0;
                foreach (FileInfo f in _directory.GetFiles("*.jpg"))
                {
                    Add(new Photo(f.FullName, cnt));
                    cnt++;
                }

            }
            catch (DirectoryNotFoundException)
            {
                MessageBox.Show("Указанная директория не найдена!", "", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        DirectoryInfo _directory;
}

private void LoadFiles()
{
     int cnt = 0;
     foreach (FileInfo f in _directory.GetFiles("*.jpg"))
     {
           Add(new Photo(f.FullName, cnt));
           cnt++;
           Thread.Sleep(0);
     }
}

Thread myThread = new Thread(LoadFiles); //Создаем новый объект потока (Thread)
myThread.Start(); //запускаем поток
myThread.Join();

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;

namespace MultiThreadingExample
{

    public class ActionAsyncCommand : ICommand
    {
        private Func<object, Task> _execute;

        public ActionAsyncCommand(Func<object, Task> execute)
        {
            _execute = execute;
        }

        public event EventHandler CanExecuteChanged;

        public bool CanExecute(object parameter)
        {
            return true;
        }

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

    public class ActionCommand : ICommand
    {
        private Action<object> _execute;

        public ActionCommand(Action<object> execute)
        {
            _execute = execute;
        }

        public event EventHandler CanExecuteChanged;

        public bool CanExecute(object parameter)
        {
            return true;
        }

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

    public class FileModel
    {
        public FileModel(FileInfo fileInfo)
        {
            Name = fileInfo.Name;
            Path = fileInfo.FullName;
            Size = fileInfo.Length;
        }

        public string Name { get; }
        public string Path { get; }
        public long Size { get; }
    }

    public class MainModel
    {
        public MainModel()
        {
            Files = new ObservableCollection<FileModel>();
        }

        public ObservableCollection<FileModel> Files { get; }

        private ICommand _loadFilesAsync;
        public ICommand LoadFilesAsync => _loadFilesAsync ?? (_loadFilesAsync = new ActionAsyncCommand(OnLoadFilesAsync));

        private ICommand _loadFilesSync;
        public ICommand LoadFilesSync => _loadFilesSync ?? (_loadFilesSync = new ActionCommand(OnLoadFilesSync));

        private void OnLoadFilesSync(object obj)
        {
            Files.Clear();
            var path = Environment.SystemDirectory;
            foreach (var fileModel in GetFilesModelsInternal(path))
            {
                Files.Add(fileModel);
            }
        }

        private async Task OnLoadFilesAsync(object obj)
        {
            Files.Clear();
            var filesModels = await OnGetFilesAsync(CancellationToken.None);
            foreach (var fileModel in filesModels)
            {
                Files.Add(fileModel);
            }
        }

        private Task<List<FileModel>> OnGetFilesAsync(CancellationToken token)
        {
            return Task.Run(() =>
            {
                var path = Environment.SystemDirectory;
                return GetFilesModelsInternal(path).ToList();
            }, token);
        }

        private IEnumerable<FileModel> GetFilesModelsInternal(string path, int max = 100)
        {
            int index = 0;
            foreach (var file in Directory.EnumerateFiles(path, "*", SearchOption.TopDirectoryOnly))
            {
                Task.Delay(5).Wait();
                var info = new FileInfo(file);
                var model = new FileModel(info);
                yield return model;
                if (++index > max) break;
            }
        }
    }
}

<Window x:Class="MultiThreadingExample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:MultiThreadingExample"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <local:MainModel/>
    </Window.DataContext>
    <Window.Resources>
        <Style TargetType="{x:Type ProgressBar}">
            <Style.Triggers>
                <EventTrigger RoutedEvent="Loaded">
                    <EventTrigger.Actions>
                        <BeginStoryboard>
                            <Storyboard>
                                <DoubleAnimation Storyboard.TargetProperty="Value"
                                                 From="0" To="100" AutoReverse="True"
                                                 RepeatBehavior="Forever"
                                                 Duration="0:0:2" >
                                    <DoubleAnimation.EasingFunction>
                                        <PowerEase Power="0.5"/>
                                    </DoubleAnimation.EasingFunction>
                                </DoubleAnimation>
                            </Storyboard>
                        </BeginStoryboard>
                    </EventTrigger.Actions>
                </EventTrigger>
            </Style.Triggers>
        </Style>
        <DataTemplate DataType="{x:Type local:FileModel}">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition/>
                    <ColumnDefinition/>
                </Grid.ColumnDefinitions>
                <TextBlock Grid.Column="0" Text="{Binding Name}" Margin="5,2"/>
                <TextBlock Grid.Column="1" Text="{Binding Size}" Margin="5,2"/>
            </Grid>
        </DataTemplate>
    </Window.Resources>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <ListBox Grid.Row="0" Margin="5" ItemsSource="{Binding Files}"/>
        <StackPanel Grid.Row="1" Orientation="Horizontal" Margin="5,0,5,5">
            <Button Content="Async Load" Command="{Binding LoadFilesAsync}" 
                    Padding="10,5" Margin="0,0,5,0"/>
            <Button Content="Sync Load" Command="{Binding LoadFilesSync}" 
                    Padding="10,5" Margin="0,0,5,0"/>
            <ProgressBar Maximum="100" Width="300"/>
        </StackPanel>
    </Grid>
</Window>

Application.Current.Dispatcher