如何在依赖注入中注册Lucene组件及管理生命周期？

Great call reusing the IndexWriter—that’s absolutely the right move since it’s heavyweight, thread-safe for concurrent writes, and expensive to spin up repeatedly. Let’s break down how to handle the other components you’re confused about, fix some efficiency issues in your current code, and adjust your DI setup for optimal performance.

Key Lifecycle & DI Recommendations #

Let’s go through each component you’re uncertain about:

1. IndexReader & IndexSearcher #

• Lifecycle: DirectoryReader is thread-safe for reads but needs to be refreshed when the index is updated (via Commit on IndexWriter). Creating a new reader every time you search is costly—you want to reuse a single instance and refresh it only when necessary.
• DI Approach: Don’t register IndexReader directly. Instead, create a singleton service to manage the reader’s lifecycle, handle refreshes, and serve the latest instance to consumers.

2. LuceneDictionary #

• Lifecycle: This is a lightweight wrapper around an IndexReader—it’s cheap to create on demand and doesn’t need to be registered in DI. Just instantiate it when you need to build your suggester.

3. AnalyzingInfixSuggester #

• Lifecycle: Building the suggester (via Build()) is expensive because it scans the entire index. You should reuse a single instance and only rebuild it when the index is updated.
• DI Approach: Let your index management service hold the suggester instance and refresh it alongside the IndexReader.

Updated Implementation #

Step 1: Create a Singleton Index Management Service #

This service will handle refreshing the reader and suggester, ensuring you always use the latest index state without wasting resources:

public class LuceneIndexProvider : IDisposable
{
    private readonly IndexWriter _writer;
    private readonly StandardAnalyzer _analyzer;
    private DirectoryReader _currentReader;
    private AnalyzingInfixSuggester _currentSuggester;
    private readonly object _lock = new object();

    public LuceneIndexProvider(IndexWriter writer, StandardAnalyzer analyzer)
    {
        _writer = writer;
        _analyzer = analyzer;
        // Initialize with the first reader and suggester
        _currentReader = DirectoryReader.Open(_writer, applyAllDeletes: true);
        _currentSuggester = BuildSuggester(_currentReader);
    }

    public DirectoryReader GetCurrentReader()
    {
        lock (_lock)
        {
            // Refresh reader if the index has been updated since last access
            var updatedReader = DirectoryReader.OpenIfChanged(_currentReader);
            if (updatedReader != null)
            {
                _currentReader.Dispose();
                _currentReader = updatedReader;
                // Rebuild suggester to match the updated index
                _currentSuggester.Dispose();
                _currentSuggester = BuildSuggester(_currentReader);
            }
            return _currentReader;
        }
    }

    public AnalyzingInfixSuggester GetCurrentSuggester()
    {
        lock (_lock)
        {
            return _currentSuggester;
        }
    }

    // Call this after committing index writes to trigger a refresh on next access
    public void NotifyIndexUpdated()
    {
        // No immediate refresh—we'll handle it when someone requests the reader/suggester
    }

    private AnalyzingInfixSuggester BuildSuggester(DirectoryReader reader)
    {
        var dictionary = new LuceneDictionary(reader, nameof(SearchResult.Header));
        var suggester = new AnalyzingInfixSuggester(LuceneVersion.LUCENE_48, _writer.Directory, _analyzer);
        suggester.Build(dictionary);
        return suggester;
    }

    public void Dispose()
    {
        _currentReader.Dispose();
        _currentSuggester.Dispose();
    }
}

Step 2: Update DI Registration #

Add the new singleton provider to your setup:

public static IServiceCollection AddLucene(this IServiceCollection services)
{
    var version = Lucene.Net.Util.LuceneVersion.LUCENE_48;
    var directory = new RAMDirectory();
    var analyzer = new StandardAnalyzer(version);
    var config = new IndexWriterConfig(version, analyzer);
    var writer = new IndexWriter(directory, config);

    services.AddSingleton(writer);
    services.AddSingleton(analyzer);
    services.AddSingleton(directory);
    // Register our index provider to manage reader/suggester lifecycle
    services.AddSingleton<LuceneIndexProvider>();

    services.AddTransient<SearchService>();
    services.AddTransient<IndexService>();
    
    return services;
}

Step 3: Modify IndexService to Trigger Refreshes #

After committing writes, notify the provider that the index needs to be refreshed:

public class IndexService
{
    private readonly IndexWriter _writer;
    private readonly LuceneIndexProvider _indexProvider;

    public IndexService(IndexWriter writer, LuceneIndexProvider indexProvider)
    { 
        _writer = writer;
        _indexProvider = indexProvider;
    }

    public void WriteIndex()
    {        
        var searchResults = QueryDatabase();
        
        var idField = new StringField(nameof(SearchResult.DatabaseId), "", Field.Store.YES);
        var headField = new StringField(nameof(SearchResult.Header), "", Field.Store.YES);
        var bodyField = new TextField(nameof(SearchResult.Body), "", Field.Store.YES);
        var typeField = new TextField(nameof(SearchResult.Type), "", Field.Store.YES);

        var doc = new Document
        {
            idField,
            headField,
            bodyField,
            typeField
        };

        foreach (var result in searchResults)
        {
            idField.SetStringValue(result.DatabaseId);
            headField.SetStringValue(result.Header);
            bodyField.SetStringValue(result.Body);
            typeField.SetStringValue(result.Type);
            _writer.AddDocument(doc);
        }
        _writer.Commit();
        // Tell the provider to refresh reader/suggester on next use
        _indexProvider.NotifyIndexUpdated();
    }
}

Step 4: Optimize SearchService to Reuse Components #

No more creating readers/suggesters every time—use the provider to get shared instances:

public class SearchService
{
    private readonly StandardAnalyzer _analyzer;
    private readonly LuceneIndexProvider _indexProvider;
    private readonly string[] _searchFields = new[] { nameof(SearchResult.Header), nameof(SearchResult.Body) };

    public SearchService(StandardAnalyzer analyzer, LuceneIndexProvider indexProvider)
    { 
        _analyzer = analyzer;
        _indexProvider = indexProvider;
    }

    public SearchResponse Search(string input, int page)
    { 
        var reader = _indexProvider.GetCurrentReader();
        var searcher = new IndexSearcher(reader);

        var multiFieldQP = new MultiFieldQueryParser(LuceneVersion.LUCENE_48, _searchFields, _analyzer);
        var inputTerm = EscapeSearchTerm(input.Trim());
        var query = multiFieldQP.Parse(inputTerm);

        var docs = searcher.Search(query, null, 1000).ScoreDocs;
        // ... rest of your search logic
    }

    public List<string> SearchAhead(string input)
    {
        var suggester = _indexProvider.GetCurrentSuggester();
        var lookupResultList = suggester.DoLookup(input.Trim(), false, 9);
        // ... rest of your autocomplete logic
    }
}

Why This Works #

• Singleton Heavyweights: IndexWriter, StandardAnalyzer, and RAMDirectory stay as singletons—they’re thread-safe and expensive to recreate.
• Efficient Reader/Suggester Management: The LuceneIndexProvider ensures you only refresh the reader and rebuild the suggester when the index actually changes, avoiding unnecessary overhead.
• No Wasteful Instantiations: You no longer create new readers or suggesters on every search/autocomplete request, which will drastically improve performance.

内容的提问来源于stack exchange，提问作者jeb