在List范型集合中实现自定义条件复杂查询

 说明：在List<T>范型集合中提供了一类委托，以确定要寻找集合中的哪些符合条件的单个元素或者集合
msdn里描述如下：Predicate 委托，用于定义要搜索的元素应满足的条件。
这一点msdn帮助里面说得很简单，只以List<string>范型集合为例说了一些简单应用，这些完全不能满足
一些复杂的应用，比如查找集合中符合某些特性的单个元素或者元素集合，因为Predicate 委托只能使用
一个参数，写本文的目的就是说明如何满足复杂的要求在范型集合中查找元素
作者：周公
日期：2007-12-28（没办法，去年写好的文章，因为csdn的博客不行，拖到今年发了 ）
 首发地址： http://blog.csdn.net/zhoufoxcn

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

namespace  ListDemo
{
     ///   <summary>
     ///  首发地址： http://blog.csdn.net/zhoufoxcn
     ///  大类别
     ///   </summary>
     public   class  CatalogInfo
    {
         private   int  catalogId;
         private   string  catalogName;

         public   string  CatalogName
        {
             get  {  return  catalogName; }
             set  { catalogName  =  value; }
        }
    
         public   int  CatalogId
        {
             get  {  return  catalogId; }
             set  { catalogId  =  value; }
        }

         public  CatalogInfo( int  catalogId,  string  catalogName)
        {
             this .catalogId  =  catalogId;
             this .catalogName  =  catalogName;
        }
    
    }
}

 

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

namespace  ListDemo
{
     ///   <summary>
     ///  首发地址： http://blog.csdn.net/zhoufoxcn
     ///  查找符合特定条件的CatalogInfo类
     ///   </summary>
     public   class  CatalogFinder
    {
         private   int  catalogId;

         public   int  CatalogId
        {
             get  {  return  catalogId; }
             set  { catalogId  =  value; }
        }

         public  CatalogFinder()
        {
        }
    
         public  CatalogFinder( int  catalogId)
        {
             this .catalogId  =  catalogId;
        }
         ///   <summary>
         ///  符合Predicate&gt;T&lt; match的方法
         ///   </summary>
         ///   <param name="info"></param>
         ///   <returns></returns>
         public   bool  FindByCatalogId(CatalogInfo info)
        {
             return  info.CatalogId  ==  catalogId;
        }
    }
}

 

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

namespace  ListDemo
{
     ///   <summary>
     ///  首发地址： http://blog.csdn.net/zhoufoxcn
     ///  小类别
     ///   </summary>
     public   class  BoardInfo
    {
         private   int  boardId;
         private   string  boardName;
         private   int  catalogId;
         ///   <summary>
         ///  所在大类别编号
         ///   </summary>
         public   int  CatalogId
        {
             get  {  return  catalogId; }
             set  { catalogId  =  value; }
        }
    

         public   string  BoardName
        {
             get  {  return  boardName; }
             set  { boardName  =  value; }
        }
    
         public   int  BoardId
        {
             get  {  return  boardId; }
             set  { boardId  =  value; }
        }

         public  BoardInfo( int  boardId,  string  boardName,  int  catalogId)
        {
             this .boardId  =  boardId;
             this .boardName  =  boardName;
             this .catalogId  =  catalogId;
        }
    
    }
}

上面分别是两个范型集合中用到的实体，以及将来要用于查找这些实体的辅助类，下面距离说明用法：

using  System;
using  System.Collections.Generic;
using  System.Drawing.Imaging;
using  ListDemo;

///   <summary>
///  说明：在List <T> 范型集合中提供了一类委托，以确定要寻找集合中的哪些符合条件的单个元素或者集合
///  msdn里描述如下：Predicate 委托，用于定义要搜索的元素应满足的条件。
///  这一点msdn帮助里面说得很简单，只以List <string> 范型集合为例说了一些简单应用，这些完全不能满足
///  一些复杂的应用，比如查找集合中符合某些特性的单个元素或者元素集合，因为Predicate 委托只能使用
///  一个参数，写本文的目的就是说明如何满足复杂的要求在范型集合中查找元素
///  作者：周公
///  日期：2007-12-28
///  首发地址： http://blog.csdn.net/zhoufoxcn
///   </summary>
public   class  Example
{
     public   static   void  Main()
    {
         // 初始化大类别集合
        List < CatalogInfo >  catalogList  =   new  List < CatalogInfo > ( 10 );
         for  ( int  i  =   0 ; i  < 10 ; i ++ )
        {
            catalogList.Add( new  CatalogInfo(i,  " 大类别 "   +  i));
        }

         // 初始化小类别集合，随机指定它们的大类别编号
        List < BoardInfo >  boardList  =   new  List < BoardInfo > ( 50 );
        Random random = new  Random( 100 );
         for  ( int  i  =   0 ; i  <   100 ; i ++ )
        {
            boardList.Add( new  BoardInfo(i,  " 小类别 "   +  i, random.Next()  %   10 ));
        }
        Console.WriteLine( " =======在大类别中查找======== " );
        CatalogFinder catalogFinder  =   new  CatalogFinder( 5 );
        CatalogInfo catalogInfo  =  catalogList.Find(catalogFinder.FindByCatalogId);
        Console.WriteLine( " 该大类别的名称： "   +  catalogInfo.CatalogName);

        Console.WriteLine( " =======在小类别中查找======== " );
        BoardFinder boardFinder  =   new  BoardFinder();
        boardFinder.BoardId  =   25 ;
        BoardInfo boardInfo  =  boardList.Find(boardFinder.FindByBoardId);
        Console.WriteLine( " 该小类别信息：小类别名称{0},所属大类别编号{1} " , boardInfo.BoardName, boardInfo.CatalogId);

        Console.WriteLine( " =======在小类别中按大类别编号查找======== " );
        boardFinder.CatalogId  =   9 ;
        List < BoardInfo >  boardInfoList  =  boardList.FindAll(boardFinder.FindByCatalogId);
         foreach  (BoardInfo info  in  boardInfoList)
        {
            Console.WriteLine( " 该小类别信息：小类别名称{0},所属大类别编号{1} " , info.BoardName, info.CatalogId);
        }

             Console.ReadLine();
    }
}

以下是输出结果：