refactor: Fix nullable and some XML warnings

src/Examine.Host/ServicesCollectionExtensions.cs

@@ -167,8 +167,8 @@ public static IServiceCollection AddExamineLuceneMultiSearcher(
             this IServiceCollection serviceCollection,
             string name,
             string[] indexNames,
-            Analyzer analyzer = null,
-            FacetsConfig facetsConfig = null)
+            Analyzer? analyzer = null,
+            FacetsConfig? facetsConfig = null)
             => serviceCollection.AddExamineSearcher<MultiIndexSearcher>(name, s =>
             {
                 IEnumerable<IIndex> matchedIndexes = s.GetServices<IIndex>()

src/Examine.Lucene/Directories/DirectoryFactory.cs

@@ -8,10 +8,10 @@ namespace Examine.Lucene.Directories
     public class GenericDirectoryFactory : DirectoryFactoryBase
     {
         private readonly Func<string, Directory> _factory;
-        private readonly Func<string, Directory> _taxonomyDirectoryFactory;
+        private readonly Func<string, Directory>? _taxonomyDirectoryFactory;
 
         /// <inheritdoc/>
-        public GenericDirectoryFactory(Func<string, Directory> factory, Func<string, Directory> taxonomyDirectoryFactory = null)
+        public GenericDirectoryFactory(Func<string, Directory> factory, Func<string, Directory>? taxonomyDirectoryFactory = null)
         {
             _factory = factory;
             _taxonomyDirectoryFactory = taxonomyDirectoryFactory;
@@ -31,6 +31,11 @@ protected override Directory CreateDirectory(LuceneIndex luceneIndex, bool force
         /// <inheritdoc/>
         protected override Directory CreateTaxonomyDirectory(LuceneIndex luceneIndex, bool forceUnlock)
         {
+            if(_taxonomyDirectoryFactory == null)
+            {
+                throw new InvalidOperationException("No taxonomy directory factory was specified");
+            }
+
             Directory dir = _taxonomyDirectoryFactory(luceneIndex.Name + "taxonomy");
             if (forceUnlock)
             {

src/Examine.Lucene/ExamineTaxonomyReplicator.cs

@@ -5,6 +5,7 @@
 using Lucene.Net.Replicator;
 using Lucene.Net.Store;
 using Microsoft.Extensions.Logging;
+using static Lucene.Net.Documents.Field;
 using static Lucene.Net.Replicator.IndexAndTaxonomyRevision;
 using Directory = Lucene.Net.Store.Directory;
 
@@ -142,12 +143,22 @@ public void StartIndexReplicationOnSchedule(int milliseconds)
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        private void SourceIndex_IndexCommitted(object sender, EventArgs e)
+        private void SourceIndex_IndexCommitted(object? sender, EventArgs? e)
         {
-            var index = (LuceneIndex)sender;
-            if (_logger.IsEnabled(LogLevel.Debug))
+            if(sender == null)
             {
-                _logger.LogDebug("{IndexName} committed", index.Name);
+                if (_logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug("SourceIndex_IndexCommitted was called with the sender parameter being null");
+                }
+            }
+            else
+            {
+                var index = (LuceneIndex)sender;
+                if (_logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug("{IndexName} committed", index.Name);
+                }
             }
             var rev = new IndexAndTaxonomyRevision(_sourceIndex.IndexWriter.IndexWriter, _sourceIndex.TaxonomyWriter as SnapshotDirectoryTaxonomyWriter);
             _replicator.Publish(rev);

src/Examine.Lucene/Indexing/DateTimeType.cs

@@ -49,14 +49,15 @@ public DateTimeType(string fieldName, ILoggerFactory logger, DateResolution reso
             _isFacetable = false;
         }
 
-        public override void AddValue(Document doc, object value)
+        /// <inheritdoc/>
+        public override void AddValue(Document doc, object? value)
         {
             // Support setting taxonomy path
             if (_isFacetable && _taxonomyIndex && value is object[] objArr && objArr != null && objArr.Length == 2)
             {
                 if (!TryConvert(objArr[0], out DateTime parsedVal))
                     return;
-                if (!TryConvert(objArr[1], out string[] parsedPathVal))
+                if (!TryConvert(objArr[1], out string[]? parsedPathVal))
                     return;
 
                 var val = DateToLong(parsedVal);

src/Examine.Lucene/Indexing/DoubleType.cs

@@ -42,14 +42,14 @@ public DoubleType(string fieldName, ILoggerFactory logger, bool store = true)
         public bool IsTaxonomyFaceted => _taxonomyIndex;
 
         /// <inheritdoc/>
-        public override void AddValue(Document doc, object value)
+        public override void AddValue(Document doc, object? value)
         {
             // Support setting taxonomy path
             if (_isFacetable && _taxonomyIndex && value is object[] objArr && objArr != null && objArr.Length == 2)
             {
                 if (!TryConvert(objArr[0], out double parsedVal))
                     return;
-                if (!TryConvert(objArr[1], out string[] parsedPathVal))
+                if (!TryConvert(objArr[1], out string[]? parsedPathVal))
                     return;
 
                 doc.Add(new DoubleField(FieldName, parsedVal, Store ? Field.Store.YES : Field.Store.NO));

src/Examine.Lucene/Indexing/FullTextType.cs

@@ -81,14 +81,14 @@ public FullTextType(string fieldName, ILoggerFactory logger, Analyzer? analyzer
         public bool IsTaxonomyFaceted => _taxonomyIndex;
 
         /// <inheritdoc/>
-        public override void AddValue(Document doc, object value)
+        public override void AddValue(Document doc, object? value)
         {
             // Support setting taxonomy path
             if (_isFacetable && _taxonomyIndex && value is object[] objArr && objArr != null && objArr.Length == 2)
             {
-                if (!TryConvert(objArr[0], out string str))
+                if (!TryConvert(objArr[0], out string? str))
                     return;
-                if (!TryConvert(objArr[1], out string[] parsedPathVal))
+                if (!TryConvert(objArr[1], out string[]? parsedPathVal))
                     return;
 
                 doc.Add(new TextField(FieldName, str, Field.Store.YES));
@@ -108,6 +108,7 @@ public override void AddValue(Document doc, object value)
             base.AddValue(doc, value);
         }
 
+        /// <inheritdoc/>
         protected override void AddSingleValue(Document doc, object value)
         {
             if (TryConvert<string>(value, out var str))

src/Examine.Lucene/Indexing/Int32Type.cs

@@ -42,14 +42,14 @@ public Int32Type(string fieldName, ILoggerFactory logger, bool store = true)
         public bool IsTaxonomyFaceted => _taxonomyIndex;
 
         /// <inheritdoc/>
-        public override void AddValue(Document doc, object value)
+        public override void AddValue(Document doc, object? value)
         {
             // Support setting taxonomy path
             if (_isFacetable && _taxonomyIndex && value is object[] objArr && objArr != null && objArr.Length == 2)
             {
                 if (!TryConvert(objArr[0], out int parsedVal))
                     return;
-                if (!TryConvert(objArr[1], out string[] parsedPathVal))
+                if (!TryConvert(objArr[1], out string[]? parsedPathVal))
                     return;
 
                 doc.Add(new Int32Field(FieldName, parsedVal, Store ? Field.Store.YES : Field.Store.NO));
@@ -61,6 +61,7 @@ public override void AddValue(Document doc, object value)
             base.AddValue(doc, value);
         }
 
+        /// <inheritdoc/>
         protected override void AddSingleValue(Document doc, object value)
         {
             if (!TryConvert(value, out int parsedVal))

src/Examine.Lucene/Indexing/Int64Type.cs

@@ -42,14 +42,14 @@ public Int64Type(string fieldName, ILoggerFactory logger, bool store = true)
         public bool IsTaxonomyFaceted => _taxonomyIndex;
 
         /// <inheritdoc/>
-        public override void AddValue(Document doc, object value)
+        public override void AddValue(Document doc, object? value)
         {
             // Support setting taxonomy path
             if (_isFacetable && _taxonomyIndex && value is object[] objArr && objArr != null && objArr.Length == 2)
             {
                 if (!TryConvert(objArr[0], out long parsedVal))
                     return;
-                if (!TryConvert(objArr[1], out string[] parsedPathVal))
+                if (!TryConvert(objArr[1], out string[]? parsedPathVal))
                     return;
 
                 doc.Add(new Int64Field(FieldName, parsedVal, Store ? Field.Store.YES : Field.Store.NO));
@@ -61,6 +61,7 @@ public override void AddValue(Document doc, object value)
             base.AddValue(doc, value);
         }
 
+        /// <inheritdoc/>
         protected override void AddSingleValue(Document doc, object value)
         {
             if (!TryConvert(value, out long parsedVal))

src/Examine.Lucene/Indexing/SingleType.cs

@@ -43,14 +43,14 @@ public SingleType(string fieldName, ILoggerFactory logger, bool store = true)
         public bool IsTaxonomyFaceted => _taxonomyIndex;
 
         /// <inheritdoc/>
-        public override void AddValue(Document doc, object value)
+        public override void AddValue(Document doc, object? value)
         {
             // Support setting taxonomy path
             if (_isFacetable && _taxonomyIndex && value is object[] objArr && objArr != null && objArr.Length == 2)
             {
                 if (!TryConvert(objArr[0], out float parsedVal))
                     return;
-                if (!TryConvert(objArr[1], out string[] parsedPathVal))
+                if (!TryConvert(objArr[1], out string[]? parsedPathVal))
                     return;
 
                 doc.Add(new DoubleField(FieldName, parsedVal, Store ? Field.Store.YES : Field.Store.NO));
@@ -62,6 +62,7 @@ public override void AddValue(Document doc, object value)
             base.AddValue(doc, value);
         }
 
+        /// <inheritdoc/>
         protected override void AddSingleValue(Document doc, object value)
         {
             if (!TryConvert(value, out float parsedVal))

src/Examine.Lucene/Providers/LuceneIndex.cs

@@ -39,7 +39,7 @@ protected LuceneIndex(
            string name,
            IOptionsMonitor<LuceneDirectoryIndexOptions> indexOptions,
            Func<LuceneIndex, IIndexCommiter> indexCommiterFactory,
-           IndexWriter writer = null)
+           IndexWriter? writer = null)
            : base(loggerFactory, name, indexOptions)
         {
             _options = indexOptions.GetNamedOptions(name);
@@ -190,7 +190,7 @@ internal LuceneIndex(
         /// <summary>
         /// Gets a Taxonomy searcher for the index
         /// </summary>
-        public virtual ILuceneTaxonomySearcher TaxonomySearcher => _taxonomySearcher.Value;
+        public virtual ILuceneTaxonomySearcher? TaxonomySearcher => _taxonomySearcher?.Value;
 
         /// <summary>
         /// The async task that runs during an async indexing operation
@@ -212,11 +212,11 @@ internal LuceneIndex(
         // tracks the latest Generation value of what has been indexed.This can be used to force update a searcher to this generation.
         private long? _latestGen;
 
-        private volatile DirectoryTaxonomyWriter _taxonomyWriter;
-        private ControlledRealTimeReopenThread<SearcherTaxonomyManager.SearcherAndTaxonomy> _taxonomyNrtReopenThread;
+        private volatile DirectoryTaxonomyWriter? _taxonomyWriter;
+        private ControlledRealTimeReopenThread<SearcherTaxonomyManager.SearcherAndTaxonomy>? _taxonomyNrtReopenThread;
 
-        private readonly Lazy<LuceneTaxonomySearcher> _taxonomySearcher;
-        private readonly Lazy<Directory> _taxonomyDirectory;
+        private readonly Lazy<LuceneTaxonomySearcher>? _taxonomySearcher;
+        private readonly Lazy<Directory>? _taxonomyDirectory;
 
         #region Properties
 
@@ -428,6 +428,12 @@ public void EnsureIndex(bool forceOverwrite)
                             {
                                 //Now create the taxonomy index
                                 var taxonomyDir = GetLuceneTaxonomyDirectory();
+
+                                if(taxonomyDir == null)
+                                {
+                                    throw new InvalidOperationException($"{Name} is configured to use a taxonomy index but the directory is null");
+                                }
+
                                 CreateNewTaxonomyIndex(taxonomyDir);
                             }
                         }
@@ -539,7 +545,7 @@ private void CreateNewIndex(Directory? dir)
         /// </summary>
         private void CreateNewTaxonomyIndex(Directory dir)
         {
-            DirectoryTaxonomyWriter writer = null;
+            DirectoryTaxonomyWriter? writer = null;
             try
             {
                 if (IsLocked(dir))
@@ -779,7 +785,7 @@ private bool IndexExistsImpl()
             return _exists.Value;
         }
 
-        // <summary>
+        /// <summary>
         /// This will check one time if the taxonomny index exists, we don't want to keep using IndexReader.IndexExists because that will literally go list
         /// every file in the index folder and we don't need any more IO ops
         /// </summary>
@@ -1082,7 +1088,7 @@ private bool ProcessQueueItem(IndexOperation item)
         /// Returns the Lucene Directory used to store the taxonomy index
         /// </summary>
         /// <returns></returns>
-        public Directory GetLuceneTaxonomyDirectory() => _taxonomyWriter != null ? _taxonomyWriter.Directory : _taxonomyDirectory.Value;
+        public Directory? GetLuceneTaxonomyDirectory() => _taxonomyWriter != null ? _taxonomyWriter.Directory : _taxonomyDirectory?.Value;
 
 
         /// <summary>
@@ -1211,9 +1217,9 @@ public TrackingIndexWriter IndexWriter
         /// Used to create an index writer - this is called in GetIndexWriter (and therefore, GetIndexWriter should not be overridden)
         /// </summary>
         /// <returns></returns>
-        private DirectoryTaxonomyWriter CreateTaxonomyWriterInternal()
+        private DirectoryTaxonomyWriter? CreateTaxonomyWriterInternal()
         {
-            Directory dir = GetLuceneTaxonomyDirectory();
+            Directory? dir = GetLuceneTaxonomyDirectory();
 
             // Unfortunatley if the appdomain is taken down this will remain locked, so we can 
             // ensure that it's unlocked here in that case.
@@ -1245,7 +1251,7 @@ private DirectoryTaxonomyWriter CreateTaxonomyWriterInternal()
         /// </summary>
         /// <param name="d"></param>
         /// <returns></returns>
-        protected virtual DirectoryTaxonomyWriter CreateTaxonomyWriter(Directory d)
+        protected virtual DirectoryTaxonomyWriter CreateTaxonomyWriter(Directory? d)
         {
             if (d == null)
             {
@@ -1279,7 +1285,7 @@ public DirectoryTaxonomyWriter TaxonomyWriter
 
                 }
 
-                return _taxonomyWriter;
+                return _taxonomyWriter;  // TODO: should this throw when null
             }
         }
 
@@ -1558,7 +1564,8 @@ protected virtual void Dispose(bool disposing)
                         _nrtReopenThread.Dispose();
                     }
 
-                    if (_taxonomyNrtReopenThread != null)
+                    // The type of _taxonomyNrtReopenThread has overriden the != operator and expects a non null value to compare the references. Therefore we use is not null instead of != null.
+                    if (_taxonomyNrtReopenThread is not null)
                     {
                         _taxonomyNrtReopenThread.Interrupt();
                         _taxonomyNrtReopenThread.Dispose();

src/Examine.Lucene/Providers/LuceneTaxonomySearcher.cs

@@ -7,6 +7,9 @@
 
 namespace Examine.Lucene.Providers
 {
+    /// <summary>
+    /// A searcher for taxonomy indexes
+    /// </summary>
     public class LuceneTaxonomySearcher : BaseLuceneSearcher, IDisposable, ILuceneTaxonomySearcher
     {
         private readonly SearcherTaxonomyManager _searcherManager;

src/Examine.Lucene/Search/LuceneFacetLabel.cs

@@ -25,7 +25,7 @@ public LuceneFacetLabel(FacetLabel facetLabel)
         public int Length => _facetLabel.Length;
 
         /// <inheritdoc/>
-        public int CompareTo(Examine.Search.IFacetLabel other) => _facetLabel.CompareTo(new FacetLabel(other.Components));
+        public int CompareTo(Examine.Search.IFacetLabel? other) => _facetLabel.CompareTo(new FacetLabel(other?.Components));
 
         /// <inheritdoc/>
         public Examine.Search.IFacetLabel Subpath(int length) => new LuceneFacetLabel(_facetLabel.Subpath(length));

src/Examine.Lucene/Search/LuceneSearchExecutor.cs

@@ -30,7 +30,7 @@ public class LuceneSearchExecutor
         private int? _maxDoc;
 
         internal LuceneSearchExecutor(QueryOptions? options, Query query, IEnumerable<SortField> sortField, ISearchContext searchContext,
-            ISet<string> fieldsToLoad, IEnumerable<IFacetField> facetFields, FacetsConfig facetsConfig)
+            ISet<string>? fieldsToLoad, IEnumerable<IFacetField> facetFields, FacetsConfig facetsConfig)
         {
             _options = options ?? QueryOptions.Default;
             _luceneQueryOptions = _options as LuceneQueryOptions;
@@ -131,7 +131,7 @@ public ISearchResults Execute()
                 {
                     topDocsCollector = TopScoreDocCollector.Create(numHits, scoreDocAfter, true);
                 }
-                FacetsCollector facetsCollector = null;
+                FacetsCollector? facetsCollector = null;
                 if (_facetFields.Any() && _luceneQueryOptions != null && _luceneQueryOptions.FacetRandomSampling != null)
                 {
                     var facetsCollectors = new RandomSamplingFacetsCollector(_luceneQueryOptions.FacetRandomSampling.SampleSize, _luceneQueryOptions.FacetRandomSampling.Seed);
@@ -216,7 +216,7 @@ private static FieldDoc GetScoreDocAfter(SearchAfterOptions searchAfterOptions)
             return scoreDocAfter;
         }
 
-        private static SearchAfterOptions GetSearchAfterOptions(TopDocs topDocs)
+        private static SearchAfterOptions? GetSearchAfterOptions(TopDocs topDocs)
         {
             if (topDocs.TotalHits > 0)
             {
@@ -242,8 +242,8 @@ private IReadOnlyDictionary<string, IFacetResult> ExtractFacets(FacetsCollector?
 
             var facetFields = _facetFields.OrderBy(field => field.FacetField);
 
-            SortedSetDocValuesReaderState sortedSetReaderState = null;
-            Facets fastTaxonomyFacetCounts = null;
+            SortedSetDocValuesReaderState? sortedSetReaderState = null;
+            Facets? fastTaxonomyFacetCounts = null;
 
 
             foreach (var field in facetFields)