lucenenet-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Nicholas Paldino [.NET/C# MVP]" <casper...@caspershouse.com>
Subject RE: Implementing IDisposable / finalizer pattern to avoid index lock issues
Date Wed, 06 Jun 2012 01:56:00 GMT
Justin,

	I could be wrong here, but 2.9.4g is where the more .NET-like API is supposed to be exposed.
 It could very well be in there, if not, I'd say it's an oversight (assuming that IDisposable
is implemented in other places).

	The main branch is supposed to be a line-for-line port of the Java API, at least until enough
steam can be obtained to maintain the current version of the Java API in .NET.

	If you look in the archives for the dev mailing list, you'll see this topic come up more
than a few times.

		- Nick

-----Original Message-----
From: Kohlhepp, Justin W (Heritage Holdings (HHI)) [mailto:Justin.Kohlhepp@thehartford.com]

Sent: Monday, June 04, 2012 7:42 AM
To: lucene-net-user@lucene.apache.org
Subject: RE: Implementing IDisposable / finalizer pattern to avoid index lock issues

Nick,

I'm comfortable implementing dispose / finalizer pattern myself to make sure that the Lucene.NET
IndexWriter is cleaned up.  However, I don't understand why IndexWriter doesn't implement
the dispose / finalizer pattern itself?  Do you have an understanding of why this is?  Or
perhaps I should ask on the dev list?

Mostly I'm just curious.  My implementation seems to be working fine so that is not an issue.

Thanks,

~ Justin



-----Original Message-----
From: Nicholas Paldino [.NET/C# MVP] [mailto:casperOne@caspershouse.com]

Sent: Friday, June 01, 2012 3:09 PM
To: <lucene-net-user@lucene.apache.org>
Subject: Re: Implementing IDisposable / finalizer pattern to avoid index lock issues

Brian,

The specific WCF case that you mention, yes there is specific cleanup that is required that
IDisposable doesn't cover.

However, this is the case wherever you need *any* specialized cleanup.
This is more a fault of those that extended ICommunicationObject from IDisposable, not the
other way around.

Long story short, unless you have *very* specialized situations around cleanup which requires
specialized logic on the client, IDisposable is not the case.

Everything I've seen in Lucene.NET *doesn't* fall in this category and is suitable for having
IDisposable implementations.

Granted, it's not as easy as slapping on the IDisposable interface and then having it call
Close (note, a Close method with no return value and no parameters is a good indication that
IDisposable is applicable here), the finalizers that *should* be implemented should *not*
call IDisposable on references they hold, but it's not rocket science either.

- Nick



On Jun 1, 2012, at 2:59 PM, "Brian Sayatovic"
<bsayatovic@creditinfonet.com> wrote:

> Crap!  I went to look up the original information I read about the
using vs. try/finally and instead stumbled upon MSDN's own documentation or it confirming
your statement:
http://msdn.microsoft.com/en-us/library/yh598w02(v=vs.90).aspx.
However, MSDN also documents, for example within their WCF pages, about the risks of using
"using" if you're not fully aware:
http://msdn.microsoft.com/en-us/library/aa355056.aspx.  There's also supposed internal discussions:
http://social.msdn.microsoft.com/forums/en-US/wcf/thread/4cdc67e0-3069-4
d3b-b94f-27e2b8ff4429/. They're all around special clean-up scenarios and situations where
your cleanup itself might fail but not be obvious in the syntax of the code.  Those are all
more prevalent with WCF, I suspect, than Lucene.NET.
> 
> 
> Brian Sayatovic
> Senior Software Architect
> 
> 866-218-1003 toll-free ext. 8936
> 937-235-8936 office
> 4540 Honeywell Ct. Dayton, OH 45424
> 
> 
> This message may contain confidential/proprietary information from the
CINgroup or its subsidiaries.
> If you are not an intended recipient, please refrain from the
disclosure, copying, distribution or use of this information. All such unauthorized actions
are strictly prohibited. If you have received this transmission in error, please notify the
sender by e-mail and delete all copies of this material from any computer.
> 
> 
> -----Original Message-----
> From: Nicholas Paldino [.NET/C# MVP]
[mailto:casperOne@caspershouse.com]
> 
> 1) That is not true, using ultimately compiles down to a try/finally.
It's always called no matter how the block is exited.
> 
> 2) This is a fault of the implementation.  It is up to the implementer
to create a finalizer that disposes of resources that don't implement IDisposabe but need
disposal (think raw handles).  Regardless, try/finally doesn't improve the experience here;
whatever method you use to have the caller deterministically release resources won't do any
good if the finalizer isn't implemented correctly.  Implementing IDisposable doesn't get you
special consideration in the finalizer.
> 

************************************************************
This communication, including attachments, is for the exclusive use of addressee and may contain
proprietary, confidential and/or privileged information.  If you are not the intended recipient,
any use, copying, disclosure, dissemination or distribution is strictly prohibited.  If you
are not the intended recipient, please notify the sender immediately by return e-mail, delete
this communication and destroy all copies.
************************************************************




Mime
View raw message