QueryParser调用静态方法Parse后会返回Query的实例，原子查询。例如：“Info:电视台 AND ID:3329”会返回BooleanQuery，“Info:电视台”或“电视台”会返回PhraseQuery，“台”会返回TermQuery。

Lucene内建Query对象：

TermQuery：词条查询。通过对某个词条的指定，实现检索索引中存在该词条的所有文档。

BooleanQuery：布尔查询。Lucene中包含逻辑关系：“与”，“或”，“非”的复杂查询，最终都会表示成BooleanQuery。布尔查询就是一个由多个子句和子句之间组成的布尔逻辑所组成的查询。

RangeQuery：范围查询。这种范围可以是日期，时间，数字，大小等等。

PrefixQuery：前缀查询。

PhraseQuery：短语查询。默认为完全匹配，但可以指定坡度（Slop，默认为0）改变范围。比如Slop=1，检索短语为“电台”，那么在“电台”中间有一个字的也可以被查找出来，比如“电视台”。

MultiPhraseQuery：多短语查询。

FuzzyQuery：模糊查询。模糊查询使用的匹配算法是levenshitein算法。此算法在比较两个字符串时，将动作分为3种：加一个字母（Insert），删一个字母（Delete），改变一个字母（Substitute）。

WildcardQuery：通配符查询。“*”号表示0到多个字符，“？”表示单个字符。

SpanQuery：跨度查询。此类为抽象类。

SpanTermQuery：检索效果完全同TermQuery，但内部会记录一些位置信息，供SpanQuery的其它API使用，是其它属于SpanQuery的Query的基础。

SpanFirstQuery：查找方式为从Field的内容起始位置开始，在一个固定的宽度内查找所指定的词条。

SpanNearQuery：功能类似PharaseQuery。SpanNearQuery查找所匹配的不一定是短语，还有可能是另一个SpanQuery的查询结果作为整体考虑，进行嵌套查询。

SpanOrQuery：把所有SpanQuery查询结果综合起来，作为检索结果。

SpanNotQuery：从第一个SpanQuery查询结果中，去掉第二个SpanQuery查询结果，作为检索结果。

BooleanClause用于表示布尔查询子句关系的类，包括：BooleanClause.Occur.MUST，BooleanClause.Occur.MUST_NOT，BooleanClause.Occur.SHOULD。有以下6种组合：

1．MUST和MUST：取得连个查询子句的交集。

2．MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。

3．MUST_NOT和MUST_NOT：无意义，检索无结果。

4．SHOULD与MUST、SHOULD与MUST_NOT：SHOULD与MUST连用时，无意义，结果为MUST子句的检索结果。与MUST_NOT连用时，功能同MUST。

5．SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。

N：文档集合的大小

M：词项集合的大小

S_j=|PL（t_j）|：词项t_j所涉及文档的个数

DF（t_j）=s_j/N：词项t_j的文档频率

IDF（t_j）=-logDF（t_j）：倒置文档频率；其值越小表示出现的频率越高

f_i,j：第j个词项t_j在第i个文档d_i中出现的次数

T_N= f_i,j：系统所有文档分解后包含词项的总量（包括重复，即一个多重集（multi-set））

TF（t_j）=（ f_i，j）/T_N：词项t_j在文档中出现的频度（词频）

ITF（t_j）=logTF（t_j）：倒置词频；越小表示出现的频率越高

 
        public static string TimeToString(long l, Resolution resolution)
        {
            DateTime dt = LongToDateTime(l);

            string result = string .Empty ;

            switch (resolution)
            {
                case Resolution.YEAR:
                    result = dt.ToString(YEAR_FORMAT);

                    break;
                case Resolution.MONTH:
                    result = dt.ToString(MONTH_FORMAT);

                    break;
                case Resolution.DAY:
                    result = dt.ToString(DAY_FORMAT);

                    break;
                case Resolution.HOUR:
                    result = dt.ToString(HOUR_FORMAT);

                    break;
                case Resolution.MINUTE:
                    result = dt.ToString(MINUTE_FORMAT);

                    break;
                case Resolution.SECOND:
                    result = dt.ToString(SECOND_FORMAT);

                    break;
                case Resolution.MILLISECOND:
                    result = dt.ToString(MILLISECOND_FORMAT);

                    break;
            }

            return result;
        }

        public static string TimeToString(DateTime time, Resolution resolution)
        {
            return TimeToString(DateTimeToLong(time), resolution);
        }

        public static long Round(long time, Resolution resolution)
        {
            DateTime dt = BASE_UNIVERSAL_TIME.AddMilliseconds(time).ToUniversalTime();

            switch (resolution)
            {
                case Resolution.YEAR:
                    dt = dt.AddMonths(1 - dt.Month).AddDays(1 - dt.Day).AddHours(0 - dt.Hour).AddMinutes(0 - dt.Minute).AddSeconds(0 - dt.Second).AddMilliseconds(0 - dt.Millisecond);

                    break;
                case Resolution.MONTH:
                    dt = dt.AddDays(1 - dt.Day).AddHours(0 - dt.Hour).AddMinutes(0 - dt.Minute).AddSeconds(0 - dt.Second).AddMilliseconds(0 - dt.Millisecond);

                    break;
                case Resolution.DAY:
                    dt = dt.AddHours(0 - dt.Hour).AddMinutes(0 - dt.Minute).AddSeconds(0 - dt.Second).AddMilliseconds(0 - dt.Millisecond);

                    break;
                case Resolution.HOUR:
                   dt = dt.AddMinutes(0 - dt.Minute).AddSeconds(0 - dt.Second).AddMilliseconds(0 - dt.Millisecond);

                    break;
                case Resolution.MINUTE:
                    dt = dt.AddSeconds(0 - dt.Second) .AddMilliseconds(0 - dt.Millisecond);

                    break;
                case Resolution.SECOND:
                    dt = dt.AddMilliseconds(0 - dt.Millisecond);

                    break;
                case Resolution.MILLISECOND:
                    break;
            }

            return DateTimeToLong(dt);
        }

        public static DateTime Round(DateTime date, Resolution resolution)
        {
            return LongToDateTime(Round(DateTimeToLong(date), resolution));
        }

        public static long DateTimeToLong(DateTime time)
        {
            return (long)(time.ToUniversalTime() - BASE_UNIVERSAL_TIME).TotalMilliseconds;
        }

        public static DateTime LongToDateTime(long l)
        {
            return BASE_UNIVERSAL_TIME.AddMilliseconds(l).ToUniversalTime();
        }

        public enum Resolution
        {
            YEAR,
            MONTH,
            DAY,
            HOUR,
            MINUTE,
            SECOND,
            MILLISECOND
        }
    }

              for (int i = (s.Length-1),j=0; i >=0; i--,j++)
              {
                  char ch = char.ToLower(s[i]);

                  int v = char.IsDigit(ch)==true?int.Parse(ch.ToString()):(10+(int)(ch-'a'));

                  result = result + Convert.ToInt64(v * Math.Pow(fromBase, j));
              }

              return result;
          }

      //实现Java的Long.toString(long i，int radix)
      
      public static string ConvertToString(long l, int fromBase)
      {
              int maxP =(int) Math.Floor(Math.Log(l,fromBase));
              int maxN = (int)Math.Floor(l / Math.Pow(fromBase, maxP));

              char[] chs = new char[maxP+1];

              chs[0] = (maxN >= 0 && maxN <= 9) ? char.Parse(maxN.ToString()) : (char)((int)('a')+(maxN - 10));

              long n1 = (long)(l - maxN*Math.Pow(fromBase, maxP));
              long temp=n1;

              for (int i = (maxP-1),j=1; i >= 0;i--,j++)
              {
                  int n2 = (int)Math.Floor(temp/Math.Pow(fromBase,i));

                  chs[j]=(n2>=0 && n2<=9)?char.Parse(n2.ToString()):(char)((int)('a')+(n2-10));

                  temp=(long)(temp-n2*Math.Pow(fromBase,i));
              }

              return new string(chs);
          }

       这样替换Lucene.Net中的相关代码，就可以了。而且经过测试，发现.Net版本的查询速度比Java版本的快很多，很搞不清楚。