[
https://issues.apache.org/jira/browse/LUCENENET-469?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Shad Storhaug updated LUCENENET-469:
------------------------------------
Affects Version/s: Lucene.Net 4.8.0
Fix Version/s: Lucene.Net 4.8.0
We should probably look into doing this. There are several places in the code
base where the dispose pattern is not used correctly in conjunction with
iterators/enumerators.
I am not sure if it makes sense to make every type of iterator into an
enumerator. For example BreakIterator is designed to navigate forward,
backward, and to skip to specific points. Perhaps we could still implement
IEnumerable<T> but also create other interfaces with extra functionality. In
any case, this is a major API change that should be looked at before the 4.8.0
release.
> Convert Java Iterator classes to implement IEnumerable<T>
> ---------------------------------------------------------
>
> Key: LUCENENET-469
> URL: https://issues.apache.org/jira/browse/LUCENENET-469
> Project: Lucene.Net
> Issue Type: Sub-task
> Components: Lucene.Net Contrib, Lucene.Net Core
> Affects Versions: Lucene.Net 2.9.4, Lucene.Net 2.9.4g, Lucene.Net 3.0.3,
> Lucene.Net 4.8.0
> Environment: all
> Reporter: Christopher Currens
> Fix For: Lucene.Net 4.8.0
>
>
> The Iterator pattern in Java is equivalent to IEnumerable in .NET. Classes
> that were directly ported in Java using the Iterator pattern, cannot be used
> with Linq or foreach blocks in .NET.
> {{Next()}} would be equivalent to .NET's {{MoveNext()}}, and in the below
> case, {{Term()}} would be as .NET's {{Current}} property. In cases as below,
> it will require {{TermEnum}} to become an abstract class with {{Term}} and
> {{DocFreq}} properties, which would be returned from another class or method
> that implemented {{IEnumerable<TermEnum>}}.
> {noformat}
> public abstract class TermEnum : IDisposable
> {
> public abstract bool Next();
> public abstract Term Term();
> public abstract int DocFreq();
> public abstract void Close();
> public abstract void Dispose();
> }
> {noformat}
> would instead look something like:
> {noformat}
> public class TermFreq
> {
> public abstract Term { get; }
> public abstract int { get; }
> }
> public abstract class TermEnum : IEnumerable<TermFreq>, IDisposable
> {
> // ...
> }
> {noformat}
> Keep in mind that it is important that if the class being converted
> implements {{IDisposable}}, the class that is enumerating the terms (in this
> case {{TermEnum}}) should inherit from both {{IEnumerable<T>}} *and*
> {{IDisposable}}. This won't be any change to the user, as the compiler
> automatically calls {{IDisposable}} when used in a {{foreach}} loop.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
