ASP.NET

protected override void OnInit(EventArgs e)
{
    base.OnInit(e);

    if (!IsPostBack)
    {
        DXExtensions.Data.DXObjectDataSource dxOdsAddress = new DXExtensions.Data.DXObjectDataSource();
        dxOdsAddress.PageSize = gvAddress.SettingsPager.PageSize;
        dxOdsAddress.KeyFeildName = gvAddress.KeyFieldName;
        dxOdsAddress.DataType = typeof(DomainModel.AddressEntities.Address);
        dxOdsAddress.Request_DataSource += new EventHandler<DXExtensions.Data.DXObjectDataSource.PagingEventArgs>(dxodsAddress_RequestDataSource);
        dxOdsAddress.Request_TotalRowsCount += new EventHandler(dxodsAddress_RequestTotalRowsCount);
        dxOdsAddress.Request_GroupInfo += new EventHandler<DXExtensions.Data.DXObjectDataSource.GroupingEventArgs>(dxodsAddress_RequestGroupInfo);
        Session["dxOdsAddress"] = dxOdsAddress;        
    }

    gvAddress.DataSource = Session["dxOdsAddress"] as DXExtensions.Data.DXObjectDataSource;
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using DevExpress.Data;

namespace DXExtensions.Data
{
    public class DXObjectDataSource : IListServer, ITypedList
    {
        #region New
                
        #region Exceptions

        public class DataSourceNotBindedException : Exception
        {
            public DataSourceNotBindedException()
                : base()
            {}
        }

        public class DataSourceSubcriberNotFoundException : Exception
        {
            public DataSourceSubcriberNotFoundException()
                : base()
            { }
        }

        public class TotalRowsCountNotBindedException : Exception 
        {
            public TotalRowsCountNotBindedException()
                : base()
            { }
        }

        public class TotalRowsCountSubscriberNotFoundException : Exception
        {
            public TotalRowsCountSubscriberNotFoundException()
                : base()
            { }
        }

        public class UnexpectedLogicWayException : Exception
        {
            public UnexpectedLogicWayException()
                : base()
            { }
        }

        #endregion

        #region PublicConnectors

        /// <summary>
        /// For paging with sorting
        /// </summary>
        public class PagingEventArgs : EventArgs
        {
            private int _StartRowIndex;
            public int StartRowIndex
            {
                get
                {
                    return _StartRowIndex;
                }
                set
                {
                    _StartRowIndex = value;
                }
            }

            private int _RowsCount;
            public int RowsCount
            {
                get
                {
                    return _RowsCount;
                }
                set
                {
                    _RowsCount = value;
                }
            }

            private ICollection<ServerModeOrderDescriptor> _SortInfo;
            public ICollection<ServerModeOrderDescriptor> SortInfo
            {
                get
                {
                    return _SortInfo;
                }
                set
                {
                    _SortInfo = value;
                }
            }
        }

        /// <summary>
        /// For grouping with pagind and sorting
        /// </summary>
        public class GroupingEventArgs : EventArgs
        {
            ListSourceGroupInfo _ParentGroupInfo;
            public ListSourceGroupInfo ParentGroupInfo
            {
                get
                {
                    return _ParentGroupInfo;
                }
                set
                {
                    _ParentGroupInfo = value;
                }
            }

            List<ListSourceGroupInfo> _GroupInfo;

            public List<ListSourceGroupInfo> GroupInfo
            {
                get
                {
                    return _GroupInfo;
                }
                set
                {
                    _GroupInfo = value;
                }
            }
        }

        /// <summary>
        /// Fires when data source needs a specific page from the database
        /// </summary>
        public event EventHandler<PagingEventArgs> Request_DataSource;

        /// <summary>
        /// Fires when data source needs the number of rows using external filters
        /// </summary>
        public event EventHandler Request_TotalRowsCount;

        /// <summary>
        /// Fires when data source needs group info
        /// </summary>
        public event EventHandler<GroupingEventArgs> Request_GroupInfo;

        /// <summary>
        /// Used when external filters changed
        /// </summary>
        public void RefreshForNewFilters()
        {
            _ActualizeDataSource_StartIndex = 0;
            _DataSource = null;
        } //надо избавиться от этого метода, но это проблематично пока используем внешние фильтры

        #endregion

        #region Propertyes
        
        private Type _DataType;
        /// <summary>
        /// The data type must be defined before binding
        /// </summary>
        public Type DataType
        {
            get
            {
                return _DataType;
            }
            set
            {
                _DataType = value;
            }
        }

        private IList _DataSource;
        /// <summary>
        /// Stores range of rows
        /// </summary>
        public IList DataSource
        {
            get
            {
                return _DataSource;
            }
            set
            {
                _DataSource = value;
            }
        }

        private Int32 _TotalRowsCount = -1;
        public Int32 TotalRowsCount
        {
            get
            {
                return _TotalRowsCount;
            }
            set
            {
                _TotalRowsCount = value;
            }
        }

        private Int32 _PageSize;
        /// <summary>
        /// The page size must be defined before binding
        /// </summary>
        public Int32 PageSize
        {
            get
            {
                return _PageSize;
            }
            set
            {
                _PageSize = value;
            }
        }
        
        private string _KeyFeildName;
        /// <summary>
        /// The key field name must be defined before binding
        /// </summary>
        public string KeyFeildName
        {
            get
            {
                return _KeyFeildName;
            }
            set
            {
                _KeyFeildName = value;
            }
        }

        /// <summary>
        /// Stores the previous collection sorting
        /// Need to understand that sort has changed
        /// </summary>
        private ICollection<ServerModeOrderDescriptor> _SortInfo;

        #endregion

        /// <summary>
        /// Required not to send a query to the first page when it is not necessary
        /// </summary>
        bool IsZeroIndexActual;

        /// <summary>
        /// Start row index for stored rows range
        /// </summary>
        private int _ActualizeDataSource_StartIndex;

        /// <summary>
        /// Checks stored rows range and if necessary request a new range of rows from database using Request_DataSource event
        /// </summary>
        /// <param name="index">row index</param>
        /// <returns>page size row index, not table row index</returns>
        protected int ActualizeDataSource(int index)
        {
            bool isDataSourceActual = true;
            if (_DataSource == null)
            {                
                isDataSourceActual = false;                
            }
            else
            {
                if ((index == 0) && (!IsZeroIndexActual))
                {
                    return 0;
                }
                else
                {
                    if ((index >= _ActualizeDataSource_StartIndex + _PageSize) || ((index < _ActualizeDataSource_StartIndex)))
                    {
                        isDataSourceActual = false;
                    }
                }
            }

            if (!isDataSourceActual)
            {
                _ActualizeDataSource_StartIndex = index;

                PagingEventArgs pea = new PagingEventArgs();
                pea.StartRowIndex = index;
                pea.RowsCount = _PageSize;
                pea.SortInfo = _SortInfo;                

                if (Request_DataSource != null)
                {
                    Request_DataSource(this, pea);
                    if (_DataSource == null)
                    {
                        throw new DataSourceNotBindedException();
                    }
                }
                else
                {
                    throw new DataSourceSubcriberNotFoundException();
                }
            }
            int ret = index - _ActualizeDataSource_StartIndex;
            if (ret < 0)
            {
                ret = 0;
            }
            return ret;
        }

        #endregion

        #region IList Enabled

        object IList.this[int index]
        {
            get
            {
                int actualRecordIndex = ActualizeDataSource(index);

                if (_DataSource != null)
                {
                    return _DataSource[actualRecordIndex];
                }
                return null;
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        #endregion

        #region ICollection Enabled

        int ICollection.Count
        {
            get
            {
                return _TotalRowsCount;
            }
        }

        #endregion

        #region ITypedList Enabled

        PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
        {
            IsZeroIndexActual = false; //true in Aplly

            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(_DataType);

            if (Request_TotalRowsCount != null)
            {
                Request_TotalRowsCount(this, new EventArgs());
                if (_TotalRowsCount < 0)
                {
                    throw new TotalRowsCountNotBindedException();
                }
            }
            else
            {
                throw new TotalRowsCountSubscriberNotFoundException();
            }
            return pdc;
        }

        #endregion

        #region DevExpress.Data.IListServer Enabled

        void IListServer.Apply
            (
                DevExpress.Data.Filtering.CriteriaOperator filterCriteria,
                ICollection<ServerModeOrderDescriptor> sortInfo,
                int groupCount,
                ICollection<ServerModeSummaryDescriptor> groupSummaryInfo,
                ICollection<ServerModeSummaryDescriptor> totalSummaryInfo
            )
        {
            if ((_SortInfo != sortInfo)) //new sort collection
            {
                _ActualizeDataSource_StartIndex = 0;
                _DataSource = null;
                _SortInfo = sortInfo;
            }

            IsZeroIndexActual = true; //Now when you request the index 0 should search the data for the first page
        }

        object IListServer.GetRowKey(int index)
        {
            int actualRecordIndex = ActualizeDataSource(index);
                        
            if (_DataSource != null)
            {
                System.Reflection.PropertyInfo pi = _DataType.GetProperty(KeyFeildName);
                System.Reflection.MethodInfo mi = pi.GetGetMethod();
                object recordObject = _DataSource[actualRecordIndex];
                object ret = mi.Invoke(recordObject, null);
                return ret;
            }
            else
            {
                throw new UnexpectedLogicWayException();
            }
        }

        List<ListSourceGroupInfo> IListServer.GetGroupInfo(DevExpress.Data.ListSourceGroupInfo groupInfo)
        {
            GroupingEventArgs gea = new GroupingEventArgs();
            gea.ParentGroupInfo = groupInfo;
            if (Request_GroupInfo != null)
            {
                Request_GroupInfo(this, gea);
                return gea.GroupInfo;
            }
            else
            {
                throw new NotImplementedException();
            }
        }
                
        #endregion

        #region Disabled
        
        #region IList Disabled

        int IList.Add(object value)
        {
            throw new NotImplementedException();
        }

        void IList.Clear()
        {
            throw new NotImplementedException();
        }

        bool IList.Contains(object value)
        {
            throw new NotImplementedException();
        }

        int IList.IndexOf(object value)
        {
            throw new NotImplementedException();
        }

        void IList.Insert(int index, object value)
        {
            throw new NotImplementedException();
        }

        bool IList.IsFixedSize
        {
            get { throw new NotImplementedException(); }
        }

        bool IList.IsReadOnly
        {
            get { throw new NotImplementedException(); }
        }

        void IList.Remove(object value)
        {
            throw new NotImplementedException();
        }

        void IList.RemoveAt(int index)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region ICollection Disabled

        void ICollection.CopyTo(Array array, int index)
        {
            throw new NotImplementedException();
        }

        bool ICollection.IsSynchronized
        {
            get { throw new NotImplementedException(); }
        }

        object ICollection.SyncRoot
        {
            get { throw new NotImplementedException(); }
        }

        #endregion

        #region IEnumerable Disabled

        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }

        #endregion

        #region ITypedList Disabled

        string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
        {
            return "";
        }

        #endregion
        
        #region DevExpress.Data.IListServer Disabled

        /// <summary>
        /// disabled
        /// </summary>
        event EventHandler<ServerModeExceptionThrownEventArgs> IListServer.ExceptionThrown
        {
            add { throw new NotImplementedException(); }
            remove { throw new NotImplementedException(); }
        }

        /// <summary>
        /// disabled
        /// </summary>
        event EventHandler<ServerModeInconsistencyDetectedEventArgs> IListServer.InconsistencyDetected
        {
            add { throw new NotImplementedException(); }
            remove { throw new NotImplementedException(); }
        }

        /// <summary>
        /// disabled
        /// </summary>
        IList IListServer.GetAllFilteredAndSortedRows()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        int IListServer.GetRowIndexByKey(object key)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        int IListServer.FindIncremental
            (
                DevExpress.Data.Filtering.CriteriaOperator expression,
                string value,
                int startIndex,
                bool searchUp,
                bool ignoreStartRow,
                bool allowLoop
            )
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        Dictionary<object, object> IListServer.GetTotalSummary()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        object[] IListServer.GetUniqueColumnValues(DevExpress.Data.Filtering.CriteriaOperator expression, int maxCount,
        bool includeFilteredOut)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        int IListServer.LocateByValue(DevExpress.Data.Filtering.CriteriaOperator expression, object value, int
            startIndex, bool searchUp)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// disabled
        /// </summary>
        void IListServer.Refresh()
        {
            throw new NotImplementedException();
        }

        #endregion

        #endregion
    }
}

public partial class BasePage: Page
{
  protected void Page_Load(object sender, EventArgs e)
  {
  }
       
}

public partial class MainPage : BasePage
{
  protected void Page_Load(object sender, EventArgs e)
  {
  }
}

Response.Redirect(MainPage.aspx)