Simple IListServer implementation

Files to look at:

DataSource.cs (VB: DataSource.vb)

This simple IListServer interface implementation was made to illustrate interface members: what data should be passed in arguments and what result these members are expected to produce.

This is a basic implementation that doesn't demonstrate the efficiency of server mode data sources. To make all the grid functionality work, it is necessary to implement the remaining methods of this interface and modify methods implemented in this sample to use features of the actual underlying data source. For an example of a complete implementation of this interface, refer to the source code of the built-in server mode components:

c:\Program Files (x86)\DevExpress 17.1\Components\Sources\DevExpress.Data\DataController\ServerMode\
c:\Program Files (x86)\DevExpress 17.1\Components\Sources\DevExpress.Xpo\DevExpress.Xpo\ServerModeGridSource.cs
c:\Program Files (x86)\DevExpress 17.1\Components\Sources\DevExpress.Xpf.Core\DevExpress.Xpf.Core\Editors\Controls\LookUp\DataLayer\DataController\ServerMode\

Does this example address your development requirements/objectives?

(you will be redirected to DevExpress.com to submit your response)

Example Code

SimpleIListServer/DataSource.cs(vb)

C#
VB.NET

C#
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Collections;
using DevExpress.Data;
using DevExpress.Data.Filtering;
using DevExpress.Data.Filtering.Helpers;

namespace DevExpress.Sample
{
    public class SimpleServerModeDataSource : IListServer {
        Type objectType;
        PropertyDescriptor pdKey;

        ArrayList storage; //hoax
        ArrayList storageProxy;
        Hashtable groups;
        List<object> totals;

        CriteriaOperator filter;
        IList<ServerModeOrderDescriptor> sortInfo;
        int groupCount;
        ICollection<ServerModeSummaryDescriptor> groupSummaryInfo;
        ICollection<ServerModeSummaryDescriptor> totalSummaryInfo;


        public SimpleServerModeDataSource(Type objectType, string keyProperty, ICollection data)
            : this(objectType, keyProperty) {
            storage.AddRange(data);
            ProcessCollection();
        }

        public SimpleServerModeDataSource(Type objectType, string keyProperty) {
            this.objectType = objectType;
            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(objectType);
            pdKey = pdc[keyProperty];

            storage = new ArrayList();
            storageProxy = new ArrayList();
            groups = new Hashtable();
            totals = new List<object>();
        }

        private void SummaryCollect(List<object> dict, ICollection<ServerModeSummaryDescriptor> info, object obj) {
            if (info == null || dict == null) return;
            int index = 0;
            foreach (ServerModeSummaryDescriptor item in info) {
                decimal acc = 0;
                try {
                    acc = Convert.ToDecimal(dict[index]);
                } catch { }
                if (item.SummaryType == Aggregate.Count) {
                    acc++;
                } else {
                    decimal v = 0;
                    try {
                        ExpressionEvaluator evaluator = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), item.SummaryExpression);
                        v = Convert.ToDecimal(evaluator.Evaluate(obj));
                    } catch { }
                    switch (item.SummaryType) {
                        case Aggregate.Sum:
                            acc += v;
                            break;
                    }
                }
                dict[index] = acc;
                index++;
            }
        }

        private void SummarySetUp(List<object> dict, ICollection<ServerModeSummaryDescriptor> info) {
            if (info == null || dict == null) return;
            dict.Clear();
            foreach (ServerModeSummaryDescriptor item in info) {
                dict.Add(0);
            }
        }

        private void ProcessCollection() {
            ExpressionEvaluator evaluator = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), filter);
            storageProxy.Clear();
            SummarySetUp(totals, totalSummaryInfo);
            foreach (object o in storage) {
                if (evaluator.Fit(o)) {
                    storageProxy.Add(o);
                    SummaryCollect(totals, totalSummaryInfo, o);
                }
            }
            if (sortInfo != null) {
                storageProxy.Sort(new SimpleComparer(sortInfo, objectType));
            }
            groups.Clear();
        }

        #region IListServer Members

        object objectLock = new object();

        event EventHandler<ServerModeExceptionThrownEventArgs> _ExceptionThrown;
        event EventHandler<ServerModeExceptionThrownEventArgs> IListServer.ExceptionThrown {
            add { lock (objectLock) { _ExceptionThrown += value; } }
            remove { lock (objectLock) { _ExceptionThrown -= value; } }
        }

        event EventHandler<ServerModeInconsistencyDetectedEventArgs> _InconsistencyDetected;
        event EventHandler<ServerModeInconsistencyDetectedEventArgs> IListServer.InconsistencyDetected {
            add { lock (objectLock) { _InconsistencyDetected += value; } }
            remove { lock (objectLock) { _InconsistencyDetected -= value; } }
        }

        void IListServer.Apply(CriteriaOperator filterCriteria, ICollection<ServerModeOrderDescriptor[]> sortInfo, int groupCount, ICollection<ServerModeSummaryDescriptor> groupSummaryInfo, ICollection<ServerModeSummaryDescriptor> totalSummaryInfo) {
            this.filter = filterCriteria;
            List<ServerModeOrderDescriptor> sorts= new List<ServerModeOrderDescriptor>();
            if (sortInfo != null) {
                foreach (ServerModeOrderDescriptor[] orderDescriptors in sortInfo) {
                    if (orderDescriptors.Length > 1)
                        throw new NotSupportedException("Multi-grouping is not supported by this collection");
                    sorts.Add(orderDescriptors[0]);
                }
            }
            this.sortInfo = sorts;
            this.groupCount = groupCount;
            this.groupSummaryInfo = groupSummaryInfo;
            this.totalSummaryInfo = totalSummaryInfo;
            ProcessCollection();
        }

        void IListServer.Refresh() {
            throw new NotImplementedException();
        }

        int IListServer.FindIncremental(CriteriaOperator expression, string value, int startIndex, bool searchUp, bool ignoreStartRow, bool allowLoop){
            throw new NotImplementedException();
        }

        int IListServer.LocateByValue(CriteriaOperator expression, object value, int startIndex, bool searchUp) {
            throw new NotImplementedException();
        }

        IList IListServer.GetAllFilteredAndSortedRows() {
            throw new NotImplementedException();
        }

        List<ListSourceGroupInfo> IListServer.GetGroupInfo(ListSourceGroupInfo parentGroup) {
            List<ListSourceGroupInfo> rows = new List<ListSourceGroupInfo>();
            ArrayList uniqueValues = new ArrayList();
            int level = (parentGroup == null) ? 0 : (parentGroup.Level + 1);
            ExpressionEvaluator evaluator = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), sortInfo[level].SortExpression);
            foreach (object o in storageProxy) {
                ListSourceGroupInfo group = parentGroup;
                while (group != null) {
                    System.Diagnostics.Debug.Assert((group.Level == 0) || groups[group] != null);
                    ExpressionEvaluator evaluator2 = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), sortInfo[group.Level].SortExpression);
                    object fv = evaluator2.Evaluate(o);
                    if (!Equals(fv, group.GroupValue)) goto Skip;
                    group = (ListSourceGroupInfo)groups[group];
                }
                object v = evaluator.Evaluate(o);
                ListSourceGroupInfo info;
                int index = uniqueValues.IndexOf(v);
                if (index < 0) {
                    uniqueValues.Add(v);
                    info = new SimpleListSourceGroupInfo();
                    info.GroupValue = v;
                    info.Level = level;
                    SummarySetUp(info.Summary, groupSummaryInfo);
                    rows.Add(info);
                    groups.Add(info, parentGroup);
                } else {
                    info = rows[index];
                }
                info.ChildDataRowCount++;
                SummaryCollect(info.Summary, groupSummaryInfo, o);
            Skip: ;
            }
            return rows;
        }

        int IListServer.GetRowIndexByKey(object key) {
            for (int i = 0; i < storageProxy.Count; i++) {
                if (Equals(pdKey.GetValue(storageProxy[i]), key))
                    return i;
            }
            return -1;
        }

        object IListServer.GetRowKey(int index) {
            return pdKey.GetValue(((IList)this)[index]);
        }

        List<object> IListServer.GetTotalSummary() {
            return totals;
        }

        object[] IListServer.GetUniqueColumnValues(CriteriaOperator valuesExpression, int maxCount, CriteriaOperator filterExpression, bool ignoreAppliedFilter) {
            ArrayList uniqueValues = new ArrayList();
            CriteriaOperator filterCriteria = ignoreAppliedFilter ? filterExpression : CriteriaOperator.And(filterExpression, this.filter);
            ExpressionEvaluator fitEvaluator = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), filterCriteria);
            ExpressionEvaluator evaluator = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), valuesExpression);
            foreach (object o in storage) {
                if (!fitEvaluator.Fit(o)) continue;
                object v = evaluator.Evaluate(o);
                int index = uniqueValues.IndexOf(v);
                if (index < 0) {
                    uniqueValues.Add(v);
                    if (maxCount > 0 && uniqueValues.Count >= maxCount)
                        break;
                }
            }
            return uniqueValues.ToArray();
        }

        bool IListServer.PrefetchRows(ListSourceGroupInfo[] groupsToPrefetch, System.Threading.CancellationToken cancellationToken) {
            throw new NotImplementedException();
        }

        int IListServer.LocateByExpression(CriteriaOperator expression, int startIndex, bool searchUp) {
            throw new NotImplementedException();
        }

        #endregion

        #region IList Members

        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 { return true; }
        }

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

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

        object IList.this[int index] {
            get {
                return storageProxy[index];
            }
            set {
                throw new NotImplementedException();
            }
        }

        #endregion

        #region ICollection Members

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

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

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

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

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator() {
            return storageProxy.GetEnumerator();
        }

        #endregion

    }

    class SimpleListSourceGroupInfo : ListSourceGroupInfo
    {
        private List<object> summary;
        public override List<object> Summary
        {
            get { return summary; }
        }
        public SimpleListSourceGroupInfo()
        {
            summary = new List<object>();
        }
    }

    class SimpleComparer : IComparer
    {
        ICollection<ServerModeOrderDescriptor> sortInfo;
        Type objectType;

        public SimpleComparer(ICollection<ServerModeOrderDescriptor> sortInfo, Type objectType)
        {
            this.sortInfo = sortInfo;
            this.objectType = objectType;
        }

        #region IComparer Members

        public int Compare(object x, object y)
        {
            foreach (ServerModeOrderDescriptor info in sortInfo)
            {
                ExpressionEvaluator evaluator = new ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), info.SortExpression);
                object xx = evaluator.Evaluate(x);
                object yy = evaluator.Evaluate(y);
                int sign = Comparer.Default.Compare(xx, yy);
                if (sign != 0)
                    return (info.IsDesc) ? -sign : sign;
            }
            return 0;
        }

        #endregion
    }
}

Visual Basic
Imports System
Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Collections
Imports DevExpress.Data
Imports DevExpress.Data.Filtering
Imports DevExpress.Data.Filtering.Helpers

Namespace DevExpress.Sample

    Public Class SimpleServerModeDataSource
        Implements IListServer

        Private objectType As Type

        Private pdKey As PropertyDescriptor

        Private storage As ArrayList 'hoax

        Private storageProxy As ArrayList

        Private groups As Hashtable

        Private totals As List(Of Object)

        Private filter As CriteriaOperator

        Private sortInfo As IList(Of ServerModeOrderDescriptor)

        Private groupCount As Integer

        Private groupSummaryInfo As ICollection(Of ServerModeSummaryDescriptor)

        Private totalSummaryInfo As ICollection(Of ServerModeSummaryDescriptor)

        Public Sub New(ByVal objectType As Type, ByVal keyProperty As String, ByVal data As ICollection)
            Me.New(objectType, keyProperty)
            storage.AddRange(data)
            ProcessCollection()
        End Sub

        Public Sub New(ByVal objectType As Type, ByVal keyProperty As String)
            Me.objectType = objectType
            Dim pdc As PropertyDescriptorCollection = TypeDescriptor.GetProperties(objectType)
            pdKey = pdc(keyProperty)
            storage = New ArrayList()
            storageProxy = New ArrayList()
            groups = New Hashtable()
            totals = New List(Of Object)()
        End Sub

        Private Sub SummaryCollect(ByVal dict As List(Of Object), ByVal info As ICollection(Of ServerModeSummaryDescriptor), ByVal obj As Object)
            If info Is Nothing OrElse dict Is Nothing Then Return
            Dim index As Integer = 0
            For Each item As ServerModeSummaryDescriptor In info
                Dim acc As Decimal = 0
                Try
                    acc = Convert.ToDecimal(dict(index))
                Catch
                End Try

                If item.SummaryType = Aggregate.Count Then
                    acc += 1
                Else
                    Dim v As Decimal = 0
                    Try
                        Dim evaluator As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), item.SummaryExpression)
                        v = Convert.ToDecimal(evaluator.Evaluate(obj))
                    Catch
                    End Try

                    Select Case item.SummaryType
                        Case Aggregate.Sum
                            acc += v
                    End Select
                End If

                dict(index) = acc
                index += 1
            Next
        End Sub

        Private Sub SummarySetUp(ByVal dict As List(Of Object), ByVal info As ICollection(Of ServerModeSummaryDescriptor))
            If info Is Nothing OrElse dict Is Nothing Then Return
            dict.Clear()
            For Each item As ServerModeSummaryDescriptor In info
                dict.Add(0)
            Next
        End Sub

        Private Sub ProcessCollection()
            Dim evaluator As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), filter)
            storageProxy.Clear()
            SummarySetUp(totals, totalSummaryInfo)
            For Each o As Object In storage
                If evaluator.Fit(o) Then
                    storageProxy.Add(o)
                    SummaryCollect(totals, totalSummaryInfo, o)
                End If
            Next

            If sortInfo IsNot Nothing Then
                storageProxy.Sort(New SimpleComparer(sortInfo, objectType))
            End If

            groups.Clear()
        End Sub

'#Region "IListServer Members"
        Private objectLock As Object = New Object()

        Private Event _ExceptionThrown As EventHandler(Of ServerModeExceptionThrownEventArgs)

        Private Custom Event ExceptionThrown As EventHandler(Of ServerModeExceptionThrownEventArgs) Implements IListServer.ExceptionThrown
            AddHandler(ByVal value As EventHandler(Of ServerModeExceptionThrownEventArgs))
                SyncLock objectLock
                    AddHandler _ExceptionThrown, value
                End SyncLock
            End AddHandler

            RemoveHandler(ByVal value As EventHandler(Of ServerModeExceptionThrownEventArgs))
                SyncLock objectLock
                    RemoveHandler _ExceptionThrown, value
                End SyncLock
            End RemoveHandler

            RaiseEvent(ByVal sender As Object, ByVal e As ServerModeExceptionThrownEventArgs)
            End RaiseEvent
        End Event

        Private Event _InconsistencyDetected As EventHandler(Of ServerModeInconsistencyDetectedEventArgs)

        Private Custom Event InconsistencyDetected As EventHandler(Of ServerModeInconsistencyDetectedEventArgs) Implements IListServer.InconsistencyDetected
            AddHandler(ByVal value As EventHandler(Of ServerModeInconsistencyDetectedEventArgs))
                SyncLock objectLock
                    AddHandler _InconsistencyDetected, value
                End SyncLock
            End AddHandler

            RemoveHandler(ByVal value As EventHandler(Of ServerModeInconsistencyDetectedEventArgs))
                SyncLock objectLock
                    RemoveHandler _InconsistencyDetected, value
                End SyncLock
            End RemoveHandler

            RaiseEvent(ByVal sender As Object, ByVal e As ServerModeInconsistencyDetectedEventArgs)
            End RaiseEvent
        End Event

        Private Sub Apply(ByVal filterCriteria As CriteriaOperator, ByVal sortInfo As ICollection(Of ServerModeOrderDescriptor()), ByVal groupCount As Integer, ByVal groupSummaryInfo As ICollection(Of ServerModeSummaryDescriptor), ByVal totalSummaryInfo As ICollection(Of ServerModeSummaryDescriptor)) Implements IListServer.Apply
            filter = filterCriteria
            Dim sorts As List(Of ServerModeOrderDescriptor) = New List(Of ServerModeOrderDescriptor)()
            If sortInfo IsNot Nothing Then
                For Each orderDescriptors As ServerModeOrderDescriptor() In sortInfo
                    If orderDescriptors.Length > 1 Then Throw New NotSupportedException("Multi-grouping is not supported by this collection")
                    sorts.Add(orderDescriptors(0))
                Next
            End If

            Me.sortInfo = sorts
            Me.groupCount = groupCount
            Me.groupSummaryInfo = groupSummaryInfo
            Me.totalSummaryInfo = totalSummaryInfo
            ProcessCollection()
        End Sub

        Private Sub Refresh() Implements IListServer.Refresh
            Throw New NotImplementedException()
        End Sub

        Private Function FindIncremental(ByVal expression As CriteriaOperator, ByVal value As String, ByVal startIndex As Integer, ByVal searchUp As Boolean, ByVal ignoreStartRow As Boolean, ByVal allowLoop As Boolean) As Integer Implements IListServer.FindIncremental
            Throw New NotImplementedException()
        End Function

        Private Function LocateByValue(ByVal expression As CriteriaOperator, ByVal value As Object, ByVal startIndex As Integer, ByVal searchUp As Boolean) As Integer Implements IListServer.LocateByValue
            Throw New NotImplementedException()
        End Function

        Private Function GetAllFilteredAndSortedRows() As IList Implements IListServer.GetAllFilteredAndSortedRows
            Throw New NotImplementedException()
        End Function

        Private Function GetGroupInfo(ByVal parentGroup As ListSourceGroupInfo) As List(Of ListSourceGroupInfo) Implements IListServer.GetGroupInfo
            Dim rows As List(Of ListSourceGroupInfo) = New List(Of ListSourceGroupInfo)()
            Dim uniqueValues As ArrayList = New ArrayList()
            Dim level As Integer = If(parentGroup Is Nothing, 0, parentGroup.Level + 1)
            Dim evaluator As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), sortInfo(level).SortExpression)
            For Each o As Object In storageProxy
                Dim group As ListSourceGroupInfo = parentGroup
                While group IsNot Nothing
                    System.Diagnostics.Debug.Assert(group.Level = 0 OrElse groups(group) IsNot Nothing)
                    Dim evaluator2 As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), sortInfo(group.Level).SortExpression)
                    Dim fv As Object = evaluator2.Evaluate(o)
                    If Not Equals(fv, group.GroupValue) Then
                        GoTo Skip
                    End If

                    group = CType(groups(group), ListSourceGroupInfo)
                End While

                Dim v As Object = evaluator.Evaluate(o)
                Dim info As ListSourceGroupInfo
                Dim index As Integer = uniqueValues.IndexOf(v)
                If index < 0 Then
                    uniqueValues.Add(v)
                    info = New SimpleListSourceGroupInfo()
                    info.GroupValue = v
                    info.Level = level
                    SummarySetUp(info.Summary, groupSummaryInfo)
                    rows.Add(info)
                    groups.Add(info, parentGroup)
                Else
                    info = rows(index)
                End If

                info.ChildDataRowCount += 1
                SummaryCollect(info.Summary, groupSummaryInfo, o)
Skip:
            Next

            Return rows
        End Function

        Private Function GetRowIndexByKey(ByVal key As Object) As Integer Implements IListServer.GetRowIndexByKey
            For i As Integer = 0 To storageProxy.Count - 1
                If Equals(pdKey.GetValue(storageProxy(i)), key) Then Return i
            Next

            Return -1
        End Function

        Private Function GetRowKey(ByVal index As Integer) As Object Implements IListServer.GetRowKey
            Return pdKey.GetValue(CType(Me, IList)(index))
        End Function

        Private Function GetTotalSummary() As List(Of Object) Implements IListServer.GetTotalSummary
            Return totals
        End Function

        Private Function GetUniqueColumnValues(ByVal valuesExpression As CriteriaOperator, ByVal maxCount As Integer, ByVal filterExpression As CriteriaOperator, ByVal ignoreAppliedFilter As Boolean) As Object() Implements IListServer.GetUniqueColumnValues
            Dim uniqueValues As ArrayList = New ArrayList()
            Dim filterCriteria As CriteriaOperator = If(ignoreAppliedFilter, filterExpression, CriteriaOperator.And(filterExpression, filter))
            Dim fitEvaluator As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), filterCriteria)
            Dim evaluator As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), valuesExpression)
            For Each o As Object In storage
                If Not fitEvaluator.Fit(o) Then Continue For
                Dim v As Object = evaluator.Evaluate(o)
                Dim index As Integer = uniqueValues.IndexOf(v)
                If index < 0 Then
                    uniqueValues.Add(v)
                    If maxCount > 0 AndAlso uniqueValues.Count >= maxCount Then Exit For
                End If
            Next

            Return uniqueValues.ToArray()
        End Function

        Private Function PrefetchRows(ByVal groupsToPrefetch As ListSourceGroupInfo(), ByVal cancellationToken As Threading.CancellationToken) As Boolean Implements IListServer.PrefetchRows
            Throw New NotImplementedException()
        End Function

        Private Function LocateByExpression(ByVal expression As CriteriaOperator, ByVal startIndex As Integer, ByVal searchUp As Boolean) As Integer Implements IListServer.LocateByExpression
            Throw New NotImplementedException()
        End Function

'#End Region
'#Region "IList Members"
        Private Function Add(ByVal value As Object) As Integer Implements IList.Add
            Throw New NotImplementedException()
        End Function

        Private Sub Clear() Implements IList.Clear
            Throw New NotImplementedException()
        End Sub

        Private Function Contains(ByVal value As Object) As Boolean Implements IList.Contains
            Throw New NotImplementedException()
        End Function

        Private Function IndexOf(ByVal value As Object) As Integer Implements IList.IndexOf
            Throw New NotImplementedException()
        End Function

        Private Sub Insert(ByVal index As Integer, ByVal value As Object) Implements IList.Insert
            Throw New NotImplementedException()
        End Sub

        Private ReadOnly Property IsFixedSize As Boolean Implements IList.IsFixedSize
            Get
                Throw New NotImplementedException()
            End Get
        End Property

        Private ReadOnly Property IsReadOnly As Boolean Implements IList.IsReadOnly
            Get
                Return True
            End Get
        End Property

        Private Sub Remove(ByVal value As Object) Implements IList.Remove
            Throw New NotImplementedException()
        End Sub

        Private Sub RemoveAt(ByVal index As Integer) Implements IList.RemoveAt
            Throw New NotImplementedException()
        End Sub

        Private Property Item(ByVal index As Integer) As Object Implements IList.Item
            Get
                Return storageProxy(index)
            End Get

            Set(ByVal value As Object)
                Throw New NotImplementedException()
            End Set
        End Property

'#End Region
'#Region "ICollection Members"
        Private Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements ICollection.CopyTo
            Throw New NotImplementedException()
        End Sub

        Private ReadOnly Property Count As Integer Implements ICollection.Count
            Get
                Return storageProxy.Count
            End Get
        End Property

        Private ReadOnly Property IsSynchronized As Boolean Implements ICollection.IsSynchronized
            Get
                Throw New NotImplementedException()
            End Get
        End Property

        Private ReadOnly Property SyncRoot As Object Implements ICollection.SyncRoot
            Get
                Throw New NotImplementedException()
            End Get
        End Property

'#End Region
'#Region "IEnumerable Members"
        Private Function GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator
            Return storageProxy.GetEnumerator()
        End Function
'#End Region
    End Class

    Friend Class SimpleListSourceGroupInfo
        Inherits ListSourceGroupInfo

        Private summaryField As List(Of Object)

        Public Overrides ReadOnly Property Summary As List(Of Object)
            Get
                Return summaryField
            End Get
        End Property

        Public Sub New()
            summaryField = New List(Of Object)()
        End Sub
    End Class

    Friend Class SimpleComparer
        Implements IComparer

        Private sortInfo As ICollection(Of ServerModeOrderDescriptor)

        Private objectType As Type

        Public Sub New(ByVal sortInfo As ICollection(Of ServerModeOrderDescriptor), ByVal objectType As Type)
            Me.sortInfo = sortInfo
            Me.objectType = objectType
        End Sub

'#Region "IComparer Members"
        Public Function Compare(ByVal x As Object, ByVal y As Object) As Integer Implements IComparer.Compare
            For Each info As ServerModeOrderDescriptor In sortInfo
                Dim evaluator As ExpressionEvaluator = New ExpressionEvaluator(TypeDescriptor.GetProperties(objectType), info.SortExpression)
                Dim xx As Object = evaluator.Evaluate(x)
                Dim yy As Object = evaluator.Evaluate(y)
                Dim sign As Integer = Comparer.Default.Compare(xx, yy)
                If sign <> 0 Then Return If(info.IsDesc, -sign, sign)
            Next

            Return 0
        End Function
'#End Region
    End Class
End Namespace

DevExpress Support Team

last modified 8 years ago

Modified: November 23, 2016 4:07 PM

Platform: ASP.NET Web Forms UWP (Windows 10) ASP.NET Bootstrap Office File API WinForms ASP.NET Core Bootstrap App Frameworks (UI, API, ORM) ASP.NET MVC ASP.NET Core WPF

Product: Data Library

Disclaimer: The information provided on DevExpress.com and affiliated web properties (including the DevExpress Support Center) is provided "as is" without warranty of any kind. Developer Express Inc disclaims all warranties, either express or implied, including the warranties of merchantability and fitness for a particular purpose. Please refer to the DevExpress.com Website Terms of Use for more information in this regard.

Confidential Information: Developer Express Inc does not wish to receive, will not act to procure, nor will it solicit, confidential or proprietary materials and information from you through the DevExpress Support Center or its web properties. Any and all materials or information divulged during chats, email communications, online discussions, Support Center tickets, or made available to Developer Express Inc in any manner will be deemed NOT to be confidential by Developer Express Inc. Please refer to the DevExpress.com Website Terms of Use for more information in this regard.

Simple IListServer implementation

Does this example address your development requirements/objectives?

Example Code

Recently viewed tickets