Lucene.Net 2.3.1版变化之TokenStream（搞笑了）

自己做分词，一般选择继承Tokenizer类。在以前的版本中只需要重写Next()方法就可以了。这个类比较简单，而塔的父类TokenStream则更加简单了，和接口没什么两样：

 

//2.1版
public abstract class TokenStream
    {
        /// <summary>Returns the next token in the stream, or null at EOS. </summary>
        public abstract Token Next();
        
        /// <summary>Releases resources associated with this stream. </summary>
        public virtual void  Close()
        {
        }
    }

 

 

到了2.3.1版本中，这个抽象类发生了很多变化.下面是2.3.1版的TokenStream类代码。

 

Code
 1    public abstract class TokenStream
 2    {
 3        
 4        /**//// <summary>Returns the next token in the stream, or null at EOS.
 5        /// The returned Token is a "full private copy" (not
 6        /// re-used across calls to next()) but will be slower
 7        /// than calling {@link #Next(Token)} instead.. 
 8        /// </summary>
 9        public virtual Token Next()
        {
            Token result = Next(new Token());
            
            if (result != null)
            {
                Payload p = result.GetPayload();
                if (p != null)
                {
                    result.SetPayload((Payload) p.Clone());
                }
            }
            
            return result;
        }
        
        /**//// <summary>Returns the next token in the stream, or null at EOS.
        /// When possible, the input Token should be used as the
        /// returned Token (this gives fastest tokenization
        /// performance), but this is not required and a new Token
        /// may be returned. Callers may re-use a single Token
        /// instance for successive calls to this method.
        /// <p>
        /// This implicitly defines a "contract" between 
        /// consumers (callers of this method) and 
        /// producers (implementations of this method 
        /// that are the source for tokens):
        /// <ul>
        /// <li>A consumer must fully consume the previously 
        /// returned Token before calling this method again.</li>
        /// <li>A producer must call {@link Token#Clear()}
        /// before setting the fields in it & returning it</li>
        /// </ul>
        /// Note that a {@link TokenFilter} is considered a consumer.
        /// </summary>
        /// <param name="result">a Token that may or may not be used to return
        /// </param>
        /// <returns> next token in the stream or null if end-of-stream was hit
        /// </returns>
        public virtual Token Next(Token result)
        {
            return Next();
        }
        
        /**//// <summary>Resets this stream to the beginning. This is an
        /// optional operation, so subclasses may or may not
        /// implement this method. Reset() is not needed for
        /// the standard indexing process. However, if the Tokens 
        /// of a TokenStream are intended to be consumed more than 
        /// once, it is necessary to implement reset(). 
        /// </summary>
        public virtual void  Reset()
        {
        }
        
        /**//// <summary>Releases resources associated with this stream. </summary>
        public virtual void  Close()
        {
        }
    }

 

 

可以看到，2.3.1版本中多了一个Reset方法和一个Next方法的重载。

在它的子类中重写了Reset和Close方法，但是Next方法没有变化。

 

Code
 1    public abstract class Tokenizer : TokenStream
 2    {
 3        /**//// <summary>The text source for this Tokenizer. </summary>
 4        protected internal System.IO.TextReader input;
 5        
 6        /**//// <summary>Construct a tokenizer with null input. </summary>
 7        protected internal Tokenizer()
 8        {
 9        }
        
        /**//// <summary>Construct a token stream processing the given input. </summary>
        protected internal Tokenizer(System.IO.TextReader input)
        {
            this.input = input;
        }
        
        /**//// <summary>By default, closes the input Reader. </summary>
        public override void  Close()
        {
            if (input != null)
            {
                input.Close();
            }
        }
        
        /**//// <summary>Expert: Reset the tokenizer to a new reader.  Typically, an
        /// analyzer (in its reusableTokenStream method) will use
        /// this to re-use a previously created tokenizer. 
        /// </summary>
        public virtual void  Reset(System.IO.TextReader input)
        {
            this.input = input;
        }
    }

 

如果，你建立一个类，继承自Tokenizer类，然后，这个时候你做其他事情去了，然后等你回来，你写了调用的代码，嘿嘿，问题来了。会报一个堆栈溢出错误。而你根本不知道这个错误是怎么产生的。这个父类写得太不厚道了，虽然Next方法是必然被重写掉的。