public sealed class LoadingTreeItem : BaseTreeItem
    {
        public override string DisplayName
        {
            get { return "Loading..."; }
        }
    }

    public abstract class BaseTreeItem : INotifyPropertyChanged
    {
        public static ObservableCollection<BaseTreeItem> LoadingItems { set; get; }

        static BaseTreeItem()
        {
            LoadingItems = new ObservableCollection<BaseTreeItem> {new LoadingTreeItem()};
        }

        private bool _isExpanded;
        private ObservableCollection<BaseTreeItem> _children;
        public virtual string DisplayName { set; get; }

        public ObservableCollection<BaseTreeItem> Children
        {
            set
            {
                if (Equals(value, _children)) return;
                _children = value;
                OnPropertyChanged();
            }
            get
            {
                ObservableCollection<BaseTreeItem> result;
                if (IsLoaded && HasItems) return _children;
                if (!IsLoaded && HasItems) return LoadingItems;
                return null;
            }
        }

        public BaseTreeItem Parent { set; get; }

        public bool HasItems
        {
            set
            {
                if (value.Equals(_hasItems)) return;
                _hasItems = value;
                OnPropertyChanged();
            }
            get { return _hasItems; }
        }

        public virtual bool IsLoaded { set; get; }
        public virtual bool IsLoading { set; get; }
        public Func<BaseTreeItem, IEnumerable<BaseTreeItem>> LoadChildrenFunc { set; get; }
        public bool IsSelected { set; get; }

        public bool IsExpanded
        {
            set
            {
                if (!CanExpand) return;
                if (value.Equals(_isExpanded)) return;
                _isExpanded = value;
                if (_isExpanded) LoadChildren();
                OnPropertyChanged();
            }
            get { return _isExpanded; }
        }

        private Task<IEnumerable<BaseTreeItem>> GetChildren()
        {
            var factory = new TaskFactory();
            return factory.StartNew(() => LoadChildrenFunc(this));
        }

        public bool CanExpand { get { return LoadChildrenFunc != null; } }

        private bool _hasItems;

        private async void LoadChildren()
        {
            if (!CanExpand) return;

            IsLoading = true;
            var result = await GetChildren();
            IsLoading = false;
            IsLoaded = true;
            Children = new ObservableCollection<BaseTreeItem>(result);
        }

        public event PropertyChangedEventHandler PropertyChanged;

        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

        
        <Style TargetType="{x:Type TreeViewItem}">
            <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}"/>
            <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}"/>
        </Style>