Avoid unnecessary FileInfo/DirectoryInfo allocations, #832

Author: paulirwin

Lucene.Net.sln.DotSettings

@@ -2,5 +2,7 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Coord/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=csharpsquid/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=LUCENENET/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=stopword/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=stopwords/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=synch/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=testsettings/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs

@@ -127,9 +127,7 @@ protected virtual string UnpackValues(int k)
         /// <param name="filename"> the filename </param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(string filename)
-        {
-            LoadPatterns(filename, Encoding.UTF8);
-        }
+            => LoadPatterns(filename, Encoding.UTF8);
 
         /// <summary>
         /// Read hyphenation patterns from an XML file.
@@ -149,9 +147,7 @@ public virtual void LoadPatterns(string filename, Encoding encoding)
         /// <param name="f"> a <see cref="FileInfo"/> object representing the file </param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(FileInfo f)
-        {
-            LoadPatterns(f, Encoding.UTF8);
-        }
+            => LoadPatterns(f.FullName, Encoding.UTF8);
 
         /// <summary>
         /// Read hyphenation patterns from an XML file.
@@ -160,20 +156,15 @@ public virtual void LoadPatterns(FileInfo f)
         /// <param name="encoding">The character encoding to use</param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(FileInfo f, Encoding encoding)
-        {
-            var src = new FileStream(f.FullName, FileMode.Open, FileAccess.Read);
-            LoadPatterns(src, encoding);
-        }
+            => LoadPatterns(f.FullName, encoding);
 
         /// <summary>
         /// Read hyphenation patterns from an XML file.
         /// </summary>
         /// <param name="source"> <see cref="Stream"/> input source for the file </param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(Stream source)
-        {
-            LoadPatterns(source, Encoding.UTF8);
-        }
+            => LoadPatterns(source, Encoding.UTF8);
 
         /// <summary>
         /// Read hyphenation patterns from an XML file.

src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs

@@ -80,9 +80,7 @@ public virtual IPatternConsumer Consumer
         /// <param name="path">The complete file path to be read.</param>
         /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(string path)
-        {
-            Parse(path, Encoding.UTF8);
-        }
+            => Parse(path, Encoding.UTF8);
 
         /// <summary>
         /// Parses a hyphenation pattern file.
@@ -103,9 +101,7 @@ public virtual void Parse(string path, Encoding encoding)
         /// <param name="file">  a <see cref="FileInfo"/> object representing the file  </param>
         /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(FileInfo file)
-        {
-            Parse(file, Encoding.UTF8);
-        }
+            => Parse(file.FullName, Encoding.UTF8);
 
         /// <summary>
         /// Parses a hyphenation pattern file.
@@ -114,12 +110,7 @@ public virtual void Parse(FileInfo file)
         /// <param name="encoding">The character encoding to use</param>
         /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(FileInfo file, Encoding encoding)
-        {
-            var xmlReaderSettings = GetXmlReaderSettings();
-
-            using var src = XmlReader.Create(new StreamReader(file.OpenRead(), encoding), xmlReaderSettings);
-            Parse(src);
-        }
+            => Parse(file.FullName, encoding);
 
         /// <summary>
         /// Parses a hyphenation pattern file.

src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs

@@ -131,9 +131,7 @@ public HyphenationCompoundWordTokenFilter(LuceneVersion matchVersion, TokenStrea
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(string hyphenationFilename)
-        {
-            return GetHyphenationTree(hyphenationFilename, Encoding.UTF8);
-        }
+            => GetHyphenationTree(hyphenationFilename, Encoding.UTF8);
 
         /// <summary>
         /// Create a hyphenator tree
@@ -143,9 +141,7 @@ public static HyphenationTree GetHyphenationTree(string hyphenationFilename)
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(string hyphenationFilename, Encoding encoding)
-        {
-            return GetHyphenationTree(new FileStream(hyphenationFilename, FileMode.Open, FileAccess.Read), encoding);
-        }
+            => GetHyphenationTree(new FileStream(hyphenationFilename, FileMode.Open, FileAccess.Read), encoding);
 
         /// <summary>
         /// Create a hyphenator tree
@@ -154,9 +150,7 @@ public static HyphenationTree GetHyphenationTree(string hyphenationFilename, Enc
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(FileInfo hyphenationFile)
-        {
-            return GetHyphenationTree(hyphenationFile, Encoding.UTF8);
-        }
+            => GetHyphenationTree(hyphenationFile.FullName, Encoding.UTF8);
 
         /// <summary>
         /// Create a hyphenator tree
@@ -166,9 +160,7 @@ public static HyphenationTree GetHyphenationTree(FileInfo hyphenationFile)
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(FileInfo hyphenationFile, Encoding encoding)
-        {
-            return GetHyphenationTree(new FileStream(hyphenationFile.FullName, FileMode.Open, FileAccess.Read), encoding);
-        }
+            => GetHyphenationTree(hyphenationFile.FullName, encoding);
 
         /// <summary>
         /// Create a hyphenator tree
@@ -177,9 +169,7 @@ public static HyphenationTree GetHyphenationTree(FileInfo hyphenationFile, Encod
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(Stream hyphenationSource)
-        {
-            return GetHyphenationTree(hyphenationSource, Encoding.UTF8);
-        }
+            => GetHyphenationTree(hyphenationSource, Encoding.UTF8);
 
         /// <summary>
         /// Create a hyphenator tree

src/Lucene.Net.Analysis.Common/Analysis/Core/StopAnalyzer.cs

@@ -77,6 +77,19 @@ public StopAnalyzer(LuceneVersion matchVersion, CharArraySet stopWords)
         {
         }
 
+        /// <summary>
+        /// Builds an analyzer with the stop words from the given file. </summary>
+        /// <seealso cref="WordlistLoader.GetWordSet(TextReader, LuceneVersion)"/>
+        /// <param name="matchVersion"> See <see cref="LuceneVersion"/> </param>
+        /// <param name="stopwordsFileName"> File name to load stop words from  </param>
+        /// <remarks>
+        /// LUCENENET: This overload takes a string file name to avoid allocating a <see cref="FileInfo"/> object.
+        /// </remarks>
+        public StopAnalyzer(LuceneVersion matchVersion, string stopwordsFileName)
+            : this(matchVersion, LoadStopwordSet(stopwordsFileName, matchVersion))
+        {
+        }
+
         /// <summary>
         /// Builds an analyzer with the stop words from the given file. </summary>
         /// <seealso cref="WordlistLoader.GetWordSet(TextReader, LuceneVersion)"/>

src/Lucene.Net.Analysis.Common/Analysis/Util/FilesystemResourceLoader.cs

@@ -1,6 +1,7 @@
 // Lucene version compatibility level 4.8.1
 using System;
 using System.IO;
+#nullable enable
 
 namespace Lucene.Net.Analysis.Util
 {
@@ -38,7 +39,7 @@ namespace Lucene.Net.Analysis.Util
     /// </summary>
     public sealed class FilesystemResourceLoader : IResourceLoader
     {
-        private readonly DirectoryInfo baseDirectory;
+        private readonly string? baseDirectory; // LUCENENET specific: changed to use string directory name instead of allocating a DirectoryInfo (#832)
         private readonly IResourceLoader @delegate;
 
         /// <summary>
@@ -47,7 +48,7 @@ public sealed class FilesystemResourceLoader : IResourceLoader
         /// are delegated to context classloader.
         /// </summary>
         public FilesystemResourceLoader()
-            : this((DirectoryInfo)null)
+            : this((string?)null)
         {
         }
 
@@ -57,22 +58,44 @@ public FilesystemResourceLoader()
         /// Files not found in file system and class lookups are delegated to context
         /// classloader.
         /// </summary>
-        public FilesystemResourceLoader(DirectoryInfo baseDirectory)
+        public FilesystemResourceLoader(string? baseDirectory)
             : this(baseDirectory, new ClasspathResourceLoader(typeof(FilesystemResourceLoader)))
         {
         }
 
+        /// <summary>
+        /// Creates a resource loader that resolves resources against the given
+        /// base directory (may be <c>null</c> to refer to CWD).
+        /// Files not found in file system and class lookups are delegated to context
+        /// classloader.
+        /// </summary>
+        public FilesystemResourceLoader(DirectoryInfo? baseDirectory)
+            : this(baseDirectory?.FullName, new ClasspathResourceLoader(typeof(FilesystemResourceLoader)))
+        {
+        }
+
+        /// <summary>
+        /// Creates a resource loader that resolves resources against the given
+        /// base directory (may be <c>null</c> to refer to CWD).
+        /// Files not found in file system and class lookups are delegated
+        /// to the given delegate <see cref="IResourceLoader"/>.
+        /// </summary>
+        public FilesystemResourceLoader(DirectoryInfo? baseDirectory, IResourceLoader @delegate)
+            : this(baseDirectory?.FullName, @delegate)
+        {
+        }
+
         /// <summary>
         /// Creates a resource loader that resolves resources against the given
         /// base directory (may be <c>null</c> to refer to CWD).
         /// Files not found in file system and class lookups are delegated
         /// to the given delegate <see cref="IResourceLoader"/>.
         /// </summary>
-        public FilesystemResourceLoader(DirectoryInfo baseDirectory, IResourceLoader @delegate)
+        public FilesystemResourceLoader(string? baseDirectory, IResourceLoader @delegate)
         {
             // LUCENENET NOTE: If you call DirectoryInfo.Create() it doesn't set the DirectoryInfo.Exists
             // flag to true, so we use the Directory object to check the path explicitly.
-            if (baseDirectory is not null && !Directory.Exists(baseDirectory.FullName))
+            if (baseDirectory is not null && !Directory.Exists(baseDirectory))
             {
                 throw new ArgumentException("baseDirectory is not a directory or is null");
             }
@@ -89,35 +112,35 @@ public Stream OpenResource(string resource)
         {
             try
             {
-                FileInfo file = null;
+                string? file = null; // LUCENENET specific: changed to use string file name instead of allocating a FileInfo (#832)
 
                 // First try absolute.
                 if (File.Exists(resource))
                 {
-                    file = new FileInfo(resource);
+                    file = resource;
                 }
                 else
                 {
                     // Try as a relative path
                     var fullPath = System.IO.Path.GetFullPath(resource);
                     if (File.Exists(fullPath))
                     {
-                        file = new FileInfo(fullPath);
+                        file = fullPath;
                     }
                     else if (baseDirectory != null)
                     {
                         // Try to combine with the base directory
-                        string based = System.IO.Path.Combine(baseDirectory.FullName, resource);
+                        string based = System.IO.Path.Combine(baseDirectory, resource);
                         if (File.Exists(based))
                         {
-                            file = new FileInfo(based);
+                            file = based;
                         }
                     }
                 }
 
                 if (file != null)
                 {
-                    return file.OpenRead();
+                    return new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read);
                 }
 
                 // Fallback on the inner resource loader (this could fail)

src/Lucene.Net.Analysis.Common/Analysis/Util/StopwordAnalyzerBase.cs

@@ -104,6 +104,35 @@ protected static CharArraySet LoadStopwordSet(bool ignoreCase, Type aClass, stri
             }
         }
 
+        /// <summary>
+        /// Creates a <see cref="CharArraySet"/> from a file.
+        /// </summary>
+        /// <param name="stopwordsFileName">
+        ///          the stopwords file name to load
+        /// </param>
+        /// <param name="matchVersion">
+        ///          the Lucene version for cross version compatibility </param>
+        /// <returns> a <see cref="CharArraySet"/> containing the distinct stopwords from the given
+        ///         file </returns>
+        /// <exception cref="IOException">
+        ///           if loading the stopwords throws an <see cref="IOException"/> </exception>
+        /// <remarks>
+        /// LUCENENET: This overload takes a string file name to avoid allocating a <see cref="FileInfo"/> object.
+        /// </remarks>
+        protected static CharArraySet LoadStopwordSet(string stopwordsFileName, LuceneVersion matchVersion)
+        {
+            TextReader reader = null;
+            try
+            {
+                reader = IOUtils.GetDecodingReader(stopwordsFileName, Encoding.UTF8);
+                return WordlistLoader.GetWordSet(reader, matchVersion);
+            }
+            finally
+            {
+                IOUtils.Dispose(reader);
+            }
+        }
+
         /// <summary>
         /// Creates a <see cref="CharArraySet"/> from a file.
         /// </summary>

src/Lucene.Net.Analysis.Kuromoji/Dict/BinaryDictionary.cs

@@ -7,6 +7,7 @@
 using System;
 using System.IO;
 using System.Security;
+using Directory = System.IO.Directory;
 
 namespace Lucene.Net.Analysis.Ja.Dict
 {
@@ -67,21 +68,21 @@ private static string LoadDataDir()
             // variable. If it is null or empty after this process, we need to
             // load the embedded files.
             string candidatePath = System.IO.Path.Combine(currentPath, DATA_SUBDIR);
-            if (System.IO.Directory.Exists(candidatePath))
+            if (Directory.Exists(candidatePath))
             {
                 return candidatePath;
             }
 
-            while (new DirectoryInfo(currentPath).Parent != null)
+            while (Directory.GetParent(currentPath) is { } parent) // LUCENENET: Reduce DirectoryInfo allocations by only getting parent once per iteration (#832)
             {
                 try
                 {
-                    candidatePath = System.IO.Path.Combine(new DirectoryInfo(currentPath).Parent.FullName, DATA_SUBDIR);
-                    if (System.IO.Directory.Exists(candidatePath))
+                    candidatePath = System.IO.Path.Combine(parent.FullName, DATA_SUBDIR);
+                    if (Directory.Exists(candidatePath))
                     {
                         return candidatePath;
                     }
-                    currentPath = new DirectoryInfo(currentPath).Parent.FullName;
+                    currentPath = parent.FullName;
                 }
                 catch (SecurityException)
                 {

src/Lucene.Net.Analysis.Kuromoji/Tools/TokenInfoDictionaryBuilder.cs

@@ -53,9 +53,10 @@ public TokenInfoDictionaryBuilder(DictionaryBuilder.DictionaryFormat format, str
         public virtual TokenInfoDictionaryWriter Build(string dirname)
         {
             JCG.List<string> csvFiles = new JCG.List<string>();
-            foreach (FileInfo file in new DirectoryInfo(dirname).EnumerateFiles("*.csv"))
+            // LUCENENET specific: changed to use string file names instead of allocating a FileInfo (#832)
+            foreach (string file in Directory.EnumerateFiles(dirname, "*.csv"))
             {
-                csvFiles.Add(file.FullName);
+                csvFiles.Add(file);
             }
             csvFiles.Sort(StringComparer.Ordinal);
             return BuildDictionary(csvFiles);

src/Lucene.Net.Analysis.SmartCn/AnalyzerProfile.cs

@@ -80,18 +80,17 @@ private static void Init()
                 return;
             }
 
-
             try
             {
-                while (new DirectoryInfo(currentPath).Parent != null)
+                while (Directory.GetParent(currentPath) is { } parent) // LUCENENET: Reduce DirectoryInfo allocations by only getting parent once per iteration (#832)
                 {
-                    candidatePath = System.IO.Path.Combine(new DirectoryInfo(currentPath).Parent.FullName, dirName);
+                    candidatePath = System.IO.Path.Combine(parent.FullName, dirName);
                     if (Directory.Exists(candidatePath))
                     {
                         ANALYSIS_DATA_DIR = candidatePath;
                         return;
                     }
-                    currentPath = new DirectoryInfo(currentPath).Parent.FullName;
+                    currentPath = parent.FullName;
                 }
             }
             catch (SecurityException)