[ 
https://issues.apache.org/jira/browse/LUCENENET-511?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13467553#comment-13467553
 ] 

Maximilian Haru Raditya commented on LUCENENET-511:
---------------------------------------------------

Hi Simon,

Thanks for your comment.

Actually I'm aware of it. That's why I created the isDisposing parameter... :D

I initially thought the IndexWriter as a managed resource. And thus, I put the 
disposal inside the [if (isDisposing)] block.
But that way, it actually caused IndexWriter never get disposed by the 
finalizer.
Why? Because the finalizer set the isDisposing parameter to be false, and thus 
the block never get executed.
Further, it leads into an issue where "write.lock" file never get deleted as 
IndexWriter never get disposed.

That way, I came into my own conclusion that I shouldn't put it inside the [if 
(isDisposing)] block in order to get the finalizer executing it. Instead, I 
deleted the block and tried to treat IndexWriter as an unmanaged resource. But 
unfortunately, that decision caused ObjectDisposedException to be thrown.

So, to be fair, both ways didn't lead to a way where IndexWriter should have 
been disposed correctly.

Now I wonder whether I understand this issue correctly.
                
> ObjectDisposedException thrown when IndexWriter disposed by finalizer
> ---------------------------------------------------------------------
>
>                 Key: LUCENENET-511
>                 URL: https://issues.apache.org/jira/browse/LUCENENET-511
>             Project: Lucene.Net
>          Issue Type: Bug
>          Components: Lucene.Net Core
>    Affects Versions: Lucene.Net 3.0.3
>         Environment: Windows 7 x64, .NET Framework 4.5
>            Reporter: Maximilian Haru Raditya
>
> I'm having an issue of ObjectDisposedException with an error message "Cannot 
> access a closed file." when working IndexWriter.
> I manage to reproduce it when I create a new WPF (4.5) app and install 
> 3.0.3-RC2 from NuGet. I then create a LuceneManager which implements 
> IDisposable, and I create a finalizer for it. I wrap IndexWriter inside it, 
> and dispose it inside Dispose(bool). The implementation code looks like this:
> {code}
> namespace WpfApplication
> {
>     using System;
>     using System.Collections.Generic;
>     using System.IO;
>     using Lucene.Net.Analysis.Standard;
>     using Lucene.Net.Index;
>     using Lucene.Net.Store;
>     using Version = Lucene.Net.Util.Version;
>     public class LuceneManager : IDisposable
>     {
>         public static readonly string IndexPath =
>             Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Index");
>         private IndexWriter _indexWriter;
>         private bool _isDisposed;
>         public LuceneManager()
>         {
>             var directory = FSDirectory.Open(IndexPath);
>             var analyzer = new StandardAnalyzer(Version.LUCENE_30, new 
> HashSet<string>());
>             this._indexWriter = new IndexWriter(directory, analyzer, 
> IndexWriter.MaxFieldLength.UNLIMITED);
>         }
>         ~LuceneManager()
>         {
>             this.Dispose(false);
>         }
>         public void Dispose()
>         {
>             this.Dispose(true);
>             GC.SuppressFinalize(this);
>         }
>         private void Dispose(bool isDisposing)
>         {
>             if (!this._isDisposed)
>             {
>                 if (this._indexWriter != null)
>                 {
>                     this._indexWriter.Dispose();
>                 }
>                 this._indexWriter = null;
>                 this._isDisposed = true;
>             }
>         }
>     }
> }
> {code}
> And the calling code looks like this:
> {code}
> namespace WpfApplication
> {
>     using System.Windows;
>     public partial class MainWindow : Window
>     {
>         public MainWindow()
>         {
>             this.InitializeComponent();
>         }
>         private void OnLoaded(object sender, RoutedEventArgs e)
>         {
>             var lucenceManager = new LuceneManager();
>         }
>     }
> }
> {code}
> The app run just fine until I close it and it throws ObjectDisposedException 
> as described above.
> The exception details:
> {code}
> System.ObjectDisposedException was unhandled
>   HResult=-2146232798
>   Message=Cannot access a closed file.
>   Source=mscorlib
>   ObjectName=""
>   StackTrace:
>        at System.IO.__Error.FileNotOpen()
>        at System.IO.FileStream.get_Length()
>        at Lucene.Net.Store.NativeFSLock.Release()
>        at Lucene.Net.Index.IndexWriter.CloseInternal(Boolean waitForMerges)
>        at Lucene.Net.Index.IndexWriter.Dispose(Boolean disposing, Boolean 
> waitForMerges)
>        at Lucene.Net.Index.IndexWriter.Dispose(Boolean waitForMerges)
>        at Lucene.Net.Index.IndexWriter.Dispose()
>        at WpfApplication.LuceneManager.Dispose(Boolean isDisposing)
>        at WpfApplication.LuceneManager.Finalize()
>   InnerException: 
> {code}

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira

Reply via email to