对与list<>泛型的一些操作方法

如果自己定义了一个结构

 1 public struct iPoint
 2     {
 3         private SinglePoint _c;
 4         /// <summary>
 5         /// 当前点的坐标
 6         /// </summary>
 7         public SinglePoint C
 8         {
 9             get { return _c; }
             set { _c = value; }
         }
         public iPoint(SinglePoint _c)
         {
                        this._c = _c;
         }
     }
     public struct SinglePoint
     {
         private int _y;
         private int _x;
         public int Y
         {
             get { return _y; }
             set { _y = value; }
         }
         public int X
         {
             get { return _x; }
             set { _x = value; }
         }
         public SinglePoint(int _y, int _x)
         {
             this._y = _y;
             this._x = _x;
         }
     }

但如果要iPoint[] list=new iPoint[1];这里势必要声明数组的初始大小，这样在实际操作中就比较麻烦，它不要javascript里的数组那样灵活。这个时候就需要用到泛型list<>来做一些处理，但是泛型也有很多不便，为了能记住我将泛型一些简单的操作记录下来
这些操作包括:
1.list<>.find();
2.list<>.sort();
先说find(),先声明一个list

  List<iPoint> List = new List<iPoint>();

这里当find的时候会发现 public T Find(Predicate<T> match); 这个Predicate<T> match我们改怎么处理呢？
下面我给出一个示例:我们首先要先建立一个finder，我们仅比较struct ipoint里的C的坐标是否相等 其他我们不做比较！

 1 public class Finder
 2     {
 3         private iPoint _c;
 4         /// <summary>
 5         /// 当前点的坐标
 6         /// </summary>
 7         public iPoint C
 8         {
 9             get { return _c; }
             set { _c = value; }
         }
         public Finder(iPoint cPoint)
         {
             this._c = cPoint;
         }
         public bool FindCurrentPoint(iPoint CurrPoint)
         {
             if (C.C.X == CurrPoint.C.X && C.C.Y == CurrPoint.C.Y)
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
     }

这里开始查找：

 iPoint tempPoint = new iPoint(1,2);
             Finder ifinder=new Finder(tempPoint);
             iPoint findRes= ClosedList.Find( new Predicate<iPoint>(ifinder.FindCurrentPoint));

OK，这里就找到了Y=1,X=2的iPoint对象了。
    再来说sort()
    我们要先建立一个继承自IComparer<>的类
    

 public class FComparer : IComparer<iPoint>
        {
            //实现C.X升序
            public int Compare(iPoint x, iPoint y)
            {
                return (x.C.X.CompareTo(y.C.X));
            }
        }

调用就更简单了
只需要

 list.Sort(new FComparer());

就可以了，至于为什么要这样写，我也说不出个所以然来，先记下来用的多了就会了！