好久没写东西了，发一个泛型的搜索，排序的库

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace xxWare.Common
{
    public static class GenericExtension
    {
        #region List<T> search count
        public static int CountAll<T>(this List<T> _list, T _searchobj)
        {
            return (from t in _list where t.Equals(_searchobj) select t).Count();
        }

        //Must be Sort before use BinarySearchCountAll
        public static int BinarySearchCountAll<T>(this List<T> _list, T _searchobj)
        {
            int center = _list.BinarySearch(_searchobj);

            if (center >= 0)
            {
                int left = center;

                while (left > 0 && _list[left - 1].Equals(_searchobj))
                {
                    left -= 1;
                }

                int right = center;
                while (right < (_list.Count - 1) && _list[right + 1].Equals(_searchobj))
                {
                    right += 1;
                }

                return (right - left) + 1;
            }
            else
            {
                return center;
            }
        }

        public static List<T> FindAll<T>(this List<T> _list, T _searchobj)
        {
            List<T> _founditem = new List<T>();

            foreach (var v in _list)
            {
                if (v.Equals(_searchobj))
                {
                    _founditem.Add(v);
                }
            }

            return _founditem;
        }

        //Must be Sort before use BinarySearchAll
        public static List<T> BinarySearchAll<T>(this List<T> _list, T _searchobj)
        {
            List<T> _retobj = new List<T>();

            int center = _list.BinarySearch(_searchobj);

            if (center >= 0)
            {
                _retobj.Add(_list[center]);

                int left = center;

                while (left > 0 && _list[left - 1].Equals(_searchobj))
                {
                    left -= 1;
                    _retobj.Add(_list[left]);
                }

                int right = center;
                while (right < (_list.Count - 1) && _list[right + 1].Equals(_searchobj))
                {
                    right += 1;
                    _retobj.Add(_list[right]);
                }

            }

            return _retobj;

        }

        public static List<string> SearchStringAll(this List<string> _list, string _searchstr)
        {
            var v = from q in _list
                    where q.Contains(_searchstr)
                    select q;
            return v.ToList<string>();
        }

        #endregion

        #region IList<> Sort
        /// <summary>
        /// Sample:
        /// IList<string> iList = new [] { "Carlton", "Alison", "Bob", "Eric", "David" }; 
        /// // Sort in-place, by string length 
        /// iList.Sort((s1, s2) => s1.Length.CompareTo(s2.Length)); 
        /// // Or use OrderBy() 
        /// IEnumerable<string> ordered = iList.OrderBy((s1, s2) => s1.Length.CompareTo(s2.Length)); 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <param name="comparison"></param>
        public static void Sort<T>(this IList<T> list, Comparison<T> comparison)
        {
            ArrayList.Adapter((IList)list).Sort(new ComparisonComparer<T>(comparison));
        }
        public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> list, Comparison<T> comparison)
        {
            return list.OrderBy(t => t, new ComparisonComparer<T>(comparison));
        }

        public class ComparisonComparer<T> : IComparer<T>, IComparer
        {
            private readonly Comparison<T> _comparison;
            public ComparisonComparer(Comparison<T> comparison) { _comparison = comparison; }
            public int Compare(T x, T y) { return _comparison(x, y); }
            public int Compare(object o1, object o2) { return _comparison((T)o1, (T)o2); }
        }
        #endregion

    }
}