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;        Dictionary<object, object> totals;        CriteriaOperator filter;        ListSortDescriptionCollection sortInfo;        int groupCount;        List<ListSourceSummaryItem> summaryInfo;        List<ListSourceSummaryItem> 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 Dictionary<object, object>();        }        private void SummaryCollect(Dictionary<object, object> dict, List<ListSourceSummaryItem> info, object obj)        {            if (info == null || dict == null) return;            foreach (ListSourceSummaryItem item in info)            {                decimal acc = 0;                try                {                    acc = Convert.ToDecimal(dict[item.Key]);                }                catch { }                if (item.SummaryType == SummaryItemType.Count)                {                    acc++;                }                else                {                    decimal v = 0;                    try                    {                        v = Convert.ToDecimal(item.Descriptor.GetValue(obj));                    }                    catch { }                    switch (item.SummaryType)                    {                        case SummaryItemType.Sum:                            acc += v;                            break;                    }                }                dict[item.Key] = acc;            }        }        private void SummarySetUp(Dictionary<object, object> dict, List<ListSourceSummaryItem> info)        {            if (info == null || dict == null) return;            dict.Clear();            foreach (ListSourceSummaryItem item in info)            {                dict.Add(item.Key, 0);            }        }        private void ProcessCollection()        {            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(objectType);            ExpressionEvaluator evaluator = new ExpressionEvaluator(pdc, 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));            }            groups.Clear();        }        #region IListServer Members        public void ApplySort(ListSortDescriptionCollection sortInfo, int groupCount, List<ListSourceSummaryItem> summaryInfo, List<ListSourceSummaryItem> totalSummaryInfo)        {            this.sortInfo = sortInfo;            this.groupCount = groupCount;            this.summaryInfo = summaryInfo;            this.totalSummaryInfo = totalSummaryInfo;            ProcessCollection();        }        public CriteriaOperator FilterCriteria        {            get            {                return filter;            }            set            {                if (Equals(filter, value)) return;                filter = value;                ProcessCollection();            }        }        public int FindIncremental(PropertyDescriptor column, string value, int startIndex, bool searchUp)        {            throw new Exception("The method or operation is not implemented.");        }        public object FindKeyByBeginWith(PropertyDescriptor column, string value)        {            throw new Exception("The method or operation is not implemented.");        }        public object FindKeyByValue(PropertyDescriptor column, object value)        {            foreach (object o in storageProxy)            {                if (Equals(column.GetValue(o), value))                    return pdKey.GetValue(o);            }            return null;        }        public List<ListSourceGroupInfo> GetGroupInfo(ListSourceGroupInfo parentGroup)        {            List<ListSourceGroupInfo> rows = new List<ListSourceGroupInfo>();            ArrayList uniqueValues = new ArrayList();            int level = (parentGroup == null) ? 0 : (parentGroup.Level + 1);            PropertyDescriptor pd = sortInfo[level].PropertyDescriptor;            foreach (object o in storageProxy)            {                ListSourceGroupInfo group = parentGroup;                while (group != null)                {                    System.Diagnostics.Debug.Assert((group.Level == 0) || groups[group] != null);                    object fv = sortInfo[group.Level].PropertyDescriptor.GetValue(o);                    if (!Equals(fv, group.GroupValue)) goto Skip;                    group = (ListSourceGroupInfo)groups[group];                }                object v = pd.GetValue(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, summaryInfo);                    rows.Add(info);                    groups.Add(info, parentGroup);                }                else                {                    info = rows[index];                }                info.ChildDataRowCount++;                SummaryCollect(info.Summary, summaryInfo, o);                Skip:;            }            return rows;        }        public int GetRowIndexByKey(object key)        {            for (int i = 0; i < storageProxy.Count; i++)            {                if (Equals(pdKey.GetValue(storageProxy[i]), key))                    return i;            }            return -1;        }        public object GetRowKey(int index)        {            return pdKey.GetValue(this[index]);        }        public Dictionary<object, object> GetTotalSummary()        {            return totals;        }        public object[] GetUniqueColumnValues(PropertyDescriptor descriptor, int maxCount, bool includeFilteredOut, bool roundDataTime)        {            ArrayList uniqueValues = new ArrayList();            IList list = includeFilteredOut ? storage : storageProxy;            foreach (object o in list)            {                object v = descriptor.GetValue(o);                int index = uniqueValues.IndexOf(v);                if (index < 0)                {                    uniqueValues.Add(v);                    if (maxCount > 0 && uniqueValues.Count >= maxCount)                        break;                }            }            return uniqueValues.ToArray();        }        #endregion        #region IList Members        public int Add(object value)        {            throw new Exception("The method or operation is not implemented.");        }        public void Clear()        {            throw new Exception("The method or operation is not implemented.");        }        public bool Contains(object value)        {            throw new Exception("The method or operation is not implemented.");        }        public int IndexOf(object value)        {            throw new Exception("The method or operation is not implemented.");        }        public void Insert(int index, object value)        {            throw new Exception("The method or operation is not implemented.");        }        public bool IsFixedSize        {            get { throw new Exception("The method or operation is not implemented."); }        }        public bool IsReadOnly        {            get { throw new Exception("The method or operation is not implemented."); }        }        public void Remove(object value)        {            throw new Exception("The method or operation is not implemented.");        }        public void RemoveAt(int index)        {            throw new Exception("The method or operation is not implemented.");        }        public object this[int index]        {            get            {                return storageProxy[index];            }            set            {                throw new Exception("The method or operation is not implemented.");            }        }        #endregion        #region ICollection Members        public void CopyTo(Array array, int index)        {            throw new Exception("The method or operation is not implemented.");        }        public int Count        {            get { return storageProxy.Count; }        }        public bool IsSynchronized        {            get { throw new Exception("The method or operation is not implemented."); }        }        public object SyncRoot        {            get { throw new Exception("The method or operation is not implemented."); }        }        #endregion        #region IEnumerable Members        public IEnumerator GetEnumerator()        {            return storageProxy.GetEnumerator();        }        #endregion    }    class SimpleListSourceGroupInfo : ListSourceGroupInfo    {        private Dictionary<object, object> summary;        public override Dictionary<object, object> Summary        {            get { return summary; }        }        public SimpleListSourceGroupInfo()        {            summary = new Dictionary<object, object>();        }    }    class SimpleComparer : IComparer    {        ListSortDescriptionCollection sortInfo;        public SimpleComparer(ListSortDescriptionCollection sortInfo)        {            this.sortInfo = sortInfo;        }        #region IComparer Members        public int Compare(object x, object y)        {            foreach (ListSortDescription info in sortInfo)            {                object xx = info.PropertyDescriptor.GetValue(x);                object yy = info.PropertyDescriptor.GetValue(y);                int sign = Comparer.Default.Compare(xx, yy);                if (sign != 0)                    return (info.SortDirection == ListSortDirection.Ascending) ? sign : -sign;            }            return 0;        }        #endregion    }}