public class Student
{
   
   public ObservableCollection<Discipline> Disciplines
   { 
        get { return _desciplines ; } 
   }
   public LoadDisciplines()
   { 
     _desciplines.Clear();
     //код для загрузки
   }
}


public class StudentViewModel :  INotifyPropertyChanged
{
   private _model;
   private ICollectionView _desciplinesViewModel;


   public StudentViewModel()
   {
      _model = new Student();
      _desciplinesViewModel = new CollectionViewModel<Discipline>(_model.Disciplines);
   }

    // The View binds to the desciplines ViewModel through the ICollectionView interface.
        public ICollectionView Disciplines
        {
            get { return _desciplinesViewModel ; }
        }


       public LoadDisciplines()
       {
           IsBusy = true;
           _model.LoadDisciplines();
           IsBusy = false;
       }

///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2008-2009 David Hill. All rights reserved.
//
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
///////////////////////////////////////////////////////////////////////////////
using System;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;
using System.Diagnostics;
using System.ComponentModel;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Collections.ObjectModel;

using Microsoft.Practices.Composite.Presentation.Commands;

namespace Helix.Samples.CollectionViewModel
{
    /// <summary>
    /// A generic ViewModel that wraps an underlying collection model.
    /// </summary>
    /// <typeparam name="T">The type of the items in the underlying collection</typeparam>
    public class CollectionViewModel<T> : ObservableCollection<T>, ICollectionView where T : class
    {
        // The underlying model that we're providing a CollectionViewModel for.
        private IEnumerable<T> _model;

        public CollectionViewModel( IEnumerable<T> model )
        {
            // Set reference to the underlying model.
            _model = model;

            // If the underlying model supports it,
            // monitor the underlying model for changes.
            INotifyCollectionChanged incc = _model as INotifyCollectionChanged;
            if ( incc != null )
            {
                incc.CollectionChanged += new NotifyCollectionChangedEventHandler( OnModelChanged );
            }

            // Initialize the view.
            UpdateView();

            // Initialize the CollectionViewModel's built-in commands.
            SelectNextCommand     = new DelegateCommand<object>( SelectNext, CanSelectNext );
            SelectPreviousCommand = new DelegateCommand<object>( SelectPrevious, CanSelectPrevious );
            SortByCommand         = new DelegateCommand<string>( SortBy );
            GroupByCommand        = new DelegateCommand<string>( GroupBy );
        }

        private int _currentIndex = -1;
        private SortDescriptionCollection _sortDescriptions;
        private ObservableCollection<GroupDescription> _groupDescriptions;

        // This should really be Predicate<T> but the ICollectionView
        // interface defines the filter predicate with an object type parameter.
        private Predicate<object> _filter;

        #region ICollectionView Members

        public event EventHandler CurrentChanged;

        public event CurrentChangingEventHandler CurrentChanging;

        public bool Contains( object item )
        {
            return base.Contains( item as T );
        }

        public object CurrentItem
        {
            get { return _currentIndex == -1 ? null : this[ _currentIndex ]; }
        }

        public int CurrentPosition
        {
            get { return _currentIndex; }
        }

        public bool IsCurrentAfterLast
        {
            get { return _currentIndex >= this.Count; }
        }

        public bool IsCurrentBeforeFirst
        {
            get { return _currentIndex < 0; }
        }

        public bool IsEmpty
        {
            get { return this.Count == 0; }
        }

        public bool MoveCurrentTo( object item )
        {
            if ( this.Contains( item ) )
            {
                return UpdateCurrentIndex( this.IndexOf( item as T ) );
            }

            // If item is not in collection or is null, move to unselected state.
            return UpdateCurrentIndex( -1 );
        }

        public bool MoveCurrentToFirst()
        {
            return UpdateCurrentIndex( 0 );
        }

        public bool MoveCurrentToLast()
        {
            return UpdateCurrentIndex( this.Count - 1 );
        }

        public bool MoveCurrentToNext()
        {
            return UpdateCurrentIndex( _currentIndex + 1 );
        }

        public bool MoveCurrentToPosition( int position )
        {
            return UpdateCurrentIndex( position );
        }

        public bool MoveCurrentToPrevious()
        {
            return UpdateCurrentIndex( _currentIndex > 0 ? _currentIndex - 1 : _currentIndex );
        }

        public void Refresh()
        {
            UpdateCurrentIndex( -1 );
        }

        public IEnumerable SourceCollection
        {
            get { Debug.Assert( _model != null ); return _model as IEnumerable; }
        }

        public bool CanFilter
        {
            get { return true; }
        }

        public Predicate<object> Filter
        {
            get { return _filter; }
            set { _filter = value; UpdateView(); }
        }

        public bool CanSort
        {
            get { return true; }
        }

        public SortDescriptionCollection SortDescriptions
        {
            get
            {
                if ( _sortDescriptions == null )
                {
                    _sortDescriptions = new SortDescriptionCollection();

                    // Monitor sort description collection for any changes.
                    ((INotifyCollectionChanged)_sortDescriptions).CollectionChanged += ( sender, e ) => UpdateView();
                }
                return _sortDescriptions;
            }
        }

        public bool CanGroup
        {
            get { return true; }
        }

        public ObservableCollection<GroupDescription> GroupDescriptions
        {
            get
            {
                if ( _groupDescriptions == null )
                {
                    _groupDescriptions = new ObservableCollection<GroupDescription>();

                    // Monitor group description collection for any changes.
                    _groupDescriptions.CollectionChanged += ( sender, e ) => UpdateView();
                }
                return _groupDescriptions;
            }
        }

        public ReadOnlyObservableCollection<object> Groups
        {
            get { throw new NotImplementedException(); }
        }

        public IDisposable DeferRefresh()
        {
            throw new NotImplementedException();
        }

        public System.Globalization.CultureInfo Culture
        {
            get
            {
                return System.Globalization.CultureInfo.InvariantCulture;
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        #endregion

        #region Commands - SelectNext, SelectPrevious, SortBy, GroupBy
        public DelegateCommand<object> SelectNextCommand { get; private set; }

        private bool CanSelectNext( object arg )
        {
            return ( _currentIndex < this.Count - 1 );
        }

        private void SelectNext( object obj )
        {
            MoveCurrentToNext();
        }

        public DelegateCommand<object> SelectPreviousCommand { get; private set; }
        private bool CanSelectPrevious( object arg )
        {
            return ( _currentIndex > 0 );
        }

        private void SelectPrevious( object obj )
        {
            MoveCurrentToPrevious();
        }

        public DelegateCommand<string> SortByCommand { get; private set; }

        private void SortBy( string property )
        {
            this.SortDescriptions.Clear();
            SortDescriptions.Add( new SortDescription( property, ListSortDirection.Ascending ) );
        }

        public DelegateCommand<string> GroupByCommand { get; private set; }

        private void GroupBy( string property )
        {
            this.GroupDescriptions.Clear();
            GroupDescriptions.Add( new PropertyGroupDescription( property ) );
        }
        #endregion

        private void UpdateView()
        {
            IQueryable<T> results = BuildQuery();

            base.Clear();

            foreach ( T item in results )
            {
                this.Add( item );
            }

            UpdateCurrentIndex( -1 );
        }

        private IQueryable<T> BuildQuery()
        {
            // Build up a dynamic query using Linq Expressions.
            IQueryable<T> query = _model.AsQueryable<T>();

            Expression viewExpression = query.Expression;

            // Start with the filter expression.
            if ( Filter != null )
            {
                Expression<Func<T, bool>> filterLambda = item => Filter( item );

                viewExpression = Expression.Call(
                    typeof( Queryable ),
                    "Where",
                    new Type[] { query.ElementType },   // TSource.
                    viewExpression,
                    filterLambda );
            }

            // Append the sorting expression(s).
            string sortMethodName = "OrderBy";
            foreach( SortDescription sort in SortDescriptions )
            {
                // Create local parameter for lambda - know your closures!
                string propertyName = sort.PropertyName;
                Expression<Func<T, object>> sortLambda = item => GetPropertyValue( item, propertyName );

                viewExpression = Expression.Call(
                    typeof( Queryable ),
                    sortMethodName + (sort.Direction == ListSortDirection.Ascending ? "" : "Descending"),
                    new Type[] { query.ElementType, typeof( object ) }, // TSource, TKey
                    viewExpression,
                    sortLambda );

                // Switch to ThenBy for subsequent sorting.
                sortMethodName = "ThenBy";
            }

            // Append the grouping expression(s).
            // TODO: Support nested grouping properly...
            foreach ( GroupDescription group in GroupDescriptions )
            {
                PropertyGroupDescription propGroup = group as PropertyGroupDescription;
                if (propGroup != null)
                {
                    // Create local parameter for lambda - know your closures!
                    string propertyName = propGroup.PropertyName;
                    Expression<Func<T, object>> groupLambda = item => GetPropertyValue( item, propertyName );

                    viewExpression = Expression.Call(
                    typeof( Queryable ),
                    "GroupBy",
                    new Type[] { query.ElementType, typeof( object ) }, // TSource, TKey
                    viewExpression,
                    groupLambda );

                    // Sort by the grouping key.
                    Expression<Func<IGrouping<object,T>, object>> sortLambda = g => g.Key;

                    viewExpression = Expression.Call(
                    typeof( Queryable ),
                    "OrderBy",
                    new Type[] { typeof(IGrouping<object,T>), typeof( object ) }, // TSource, TKey
                    viewExpression,
                    sortLambda );

                    // Flatten the groups using SelectMany.
                    Expression<Func<IGrouping<object, T>, IEnumerable<T>>> smLambda = g => g;

                    viewExpression = Expression.Call(
                    typeof( Queryable ),
                    "SelectMany",
                    new Type[] { typeof( IGrouping<object, T> ), query.ElementType }, // TSource, TResult
                    viewExpression,
                    smLambda );
                }
            }

            // Return the query.
            return query.Provider.CreateQuery<T>( viewExpression ); ;
        }

        private void OnModelChanged( object sender, NotifyCollectionChangedEventArgs args )
        {
            switch ( args.Action )
            {
                case NotifyCollectionChangedAction.Remove:
                    // If the removed item is in the current view, just remove it.
                    foreach ( T item in args.OldItems )
                    {
                        if ( base.Contains( item ) )
                        {
                            this.Remove( item );
                        }
                    }
                    break;
                case NotifyCollectionChangedAction.Add:
                case NotifyCollectionChangedAction.Replace:
                case NotifyCollectionChangedAction.Reset:
                    // Could optimize here, but just update the whole view for now...
                    UpdateView();
                    break;
            }
        }

        private object GetPropertyValue( T item, string propertyName )
        {
            PropertyInfo pi = item.GetType().GetProperty( propertyName );
            if ( pi != null )
            {
                return pi.GetValue( item, null );
            }
            return null;
        }

        private bool UpdateCurrentIndex( int index )
        {
            // Calculate new index bounded by -1 and the current collection size.
            int newIndex;
            newIndex = System.Math.Max( index, -1 );
            newIndex = System.Math.Min( newIndex, this.Count - 1 );

            if ( _currentIndex != newIndex )
            {
                if ( this.CurrentChanging != null )
                {
                    this.CurrentChanging( this, new CurrentChangingEventArgs( false ) );
                }

                _currentIndex = newIndex;

                if ( this.CurrentChanged != null )
                {
                    this.CurrentChanged( this, new EventArgs() );
                }

                OnPropertyChanged( new PropertyChangedEventArgs( "CurrentPosition" ) );
                OnPropertyChanged( new PropertyChangedEventArgs( "CurrentItem" ) );
                SelectNextCommand.RaiseCanExecuteChanged();
                SelectPreviousCommand.RaiseCanExecuteChanged();
            }

            return _currentIndex != -1;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2008-2009 David Hill. All rights reserved.
//
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
///////////////////////////////////////////////////////////////////////////////
using System;
using System.ComponentModel;
using System.Reflection;

namespace Helix.Samples.CollectionViewModel
{
    public class PropertyGroupDescription : GroupDescription
    {
        public string PropertyName { get; private set; }

        public PropertyGroupDescription( string propertyName )
        {
            PropertyName = propertyName;
        }

        public override object GroupNameFromItem( object item, int level, System.Globalization.CultureInfo culture )
        {
            PropertyInfo pi = item.GetType().GetProperty( PropertyName );
            if ( pi != null )
            {
                return pi.GetValue( item, null );
            }
            return null;
        }
    }
}