I've got it worked somehow. There is significant improvement in the performance but the fragments returned aren't the best.

Code:

public static string GetBestTextFragments(string content, string searchTerms, int previewLength)
        {

            Analyzer analyzer = new Lucene.Net.Analysis.Snowball.SnowballAnalyzer("English");
            Lucene.Net.Search.Query query = new Lucene.Net.QueryParsers.QueryParser(Lucene.Net.Util.Version.LUCENE_29, "content", analyzer).Parse(searchTerms);
            TokenStream tokenStream = analyzer.TokenStream("", new StringReader(content));
            Lucene.Net.Highlight.Highlighter highlighter = new Lucene.Net.Highlight.Highlighter(new SimpleHTMLFormatter(), new QueryScorer(query));

            string[] frag = highlighter.GetBestFragments(tokenStream, content, 5);

            return String.Join(".", frag);
        }

Some examples of fragments returned:

Starts with comma:

, hospitals and pharmacies text text text text text text text text text text text text text text text text text text text text text text text ..., text text text text text text ). Please refer

Starts with 'and'

and pharmacies text text text text text text text without a referral.

I've always found it to return good results. I usually use it conjunction with the search term that has been used, so it gets the relevant match. My basic implementation I've used before is something like this (I've created a class that abstracts it - some of this was found online and modified):

public class LuceneHighlighter
{
    private readonly Lucene.Net.Util.Version _luceneVersion = Lucene.Net.Util.Version.LUCENE_29;

    /// <summary>
    /// Initialises the queryparsers with an empty dictionary
    /// </summary>
    protected Dictionary<string, QueryParser> QueryParsers = new Dictionary<string, QueryParser>();

    /// <summary>
    /// Get or set the separator string (default = "...")
    /// </summary>
    public string Separator { get; set; }

    /// <summary>
    /// Get or set the maximum number of highlights to show (default = 5)
    /// </summary>
    public int MaxNumHighlights { get; set; }

    /// <summary>
    /// Get or set the Formatter to use (default = SimpleHTMLFormatter)
    /// </summary>
    public Formatter HighlightFormatter { get; set; }

    /// <summary>
    /// Get or set the Analyzer to use (default = StandardAnalyzer)
    /// </summary>
    public Analyzer HighlightAnalyzer { get; set; }

    /// <summary>
    /// Get the index search being used
    /// </summary>
    public IndexSearcher Searcher { get; private set; }

    /// <summary>
    /// Get the Query to be used for highlighting
    /// </summary>
    public Query LuceneQuery { get; private set; }

    /// <summary>
    /// Initialise a new LuceneHighlighter instance
    /// </summary>
    /// <param name="searcher">The IndexSearch being used</param>
    /// <param name="luceneQuery">The underlying Lucene Query being used</param>
    /// <param name="highlightCssClassName">The name of the CSS class used to wrap around highlighted words</param>
    public LuceneHighlighter(IndexSearcher searcher, Query luceneQuery, string highlightCssClassName)
    {
        this.Searcher = searcher;
        this.LuceneQuery = luceneQuery;
        this.Separator = "...";
        this.MaxNumHighlights = 5;
        this.HighlightAnalyzer = new StandardAnalyzer(_luceneVersion);
        this.HighlightFormatter = new SimpleHTMLFormatter("<span class=\"" + highlightCssClassName + "\">", "</span> ");
    }

    /*
    public string GetHighlight(string value, string highlightField, IndexSearcher searcher, string luceneRawQuery)
    {
        var query = GetQueryParser(highlightField).Parse(luceneRawQuery);
        var scorer = new QueryScorer(query.Rewrite(searcher.GetIndexReader()));

        var highlighter = new Highlighter(HighlightFormatter, scorer);

        var tokenStream = HighlightAnalyzer.TokenStream(highlightField, new StringReader(value));
        return highlighter.GetBestFragments(tokenStream, value, MaxNumHighlights, Separator);
    }
     */

    /// <summary>
    /// Get the highlighted string for a value and a field
    /// </summary>
    /// <param name="value">The field value</param>
    /// <param name="highlightField">The field name</param>
    /// <returns>A string containing the highlighted result</returns>
    public string GetHighlight(string value, string highlightField)
    {
        value = Regex.Replace(value, "content", "", RegexOptions.IgnoreCase); // weird bug in GetBestFragments always adds "content"

        var scorer = new QueryScorer(LuceneQuery.Rewrite(Searcher.GetIndexReader()));

        var highlighter = new Highlighter(HighlightFormatter, scorer);

        var tokenStream = HighlightAnalyzer.TokenStream(highlightField, new StringReader(value));
        return highlighter.GetBestFragments(tokenStream, value, MaxNumHighlights, Separator);
    }

    /// <summary>
    /// Get the highlighted field for a value and field
    /// </summary>
    /// <param name="value">The field value</param>
    /// <param name="searcher">The Examine searcher</param>
    /// <param name="highlightField">The hghlight field</param>
    /// <param name="luceneQuery">The query being used</param>
    /// <returns>A string containing the highlighted result</returns>
    public string GetHighlight(string value, IndexSearcher searcher, string highlightField, Query luceneQuery)
    {
        var scorer = new QueryScorer(luceneQuery.Rewrite(searcher.GetIndexReader()));
        var highlighter = new Highlighter(HighlightFormatter, scorer);

        var tokenStream = HighlightAnalyzer.TokenStream(highlightField, new StringReader(value));
        return highlighter.GetBestFragments(tokenStream, value, MaxNumHighlights, Separator);
    }

    /// <summary>
    /// Gets a query parser for a hightlight field
    /// </summary>
    /// <param name="highlightField">The field</param>
    /// <returns>A query parser</returns>
    protected QueryParser GetQueryParser(string highlightField)
    {
        if (!QueryParsers.ContainsKey(highlightField))
        {
            QueryParsers[highlightField] = new QueryParser(_luceneVersion, highlightField, HighlightAnalyzer);
        }
        return QueryParsers[highlightField];
    }
}

Then you can use... (last param is a CSS class that wraps words that match).

var highlighter = new LuceneHighlighter(luceneIndexSearcher, luceneQuery, "text-warning");

Then on a SearchResult you can do...

var summary = SearchResult result.GetSummary(highlighter);

It's a long time since I wrote this, so can't remember all the details, but hope it helps :)

is working on a reply...