If we don't want to add IEnumerable (though it seems that IEnumerable could
be added in parallel with the existing pattern) could we add a bunch of
extension methods?
Something like the following...
{noformat}
public static class LuceneExtensions
{
public static IEnumerable<Term> GetEnumerable(this TermEnum termEnum)
{
yield return termEnum.Term();
while (termEnum.Next())
yield return termEnum.Term();
}
}
{noformat}
Then you can...
{noformat}
foreach(var e in myTernEnum.GetEnumerable())
{
// do stuff with e
}
{noformat}
Not as elegant as a direct implementation but gives easy enough access to
foreach sematics.
The second option is to realize that you don't need to explicitly implement
IEnumerable. You just need a GetEnumerator method.
So just add...
{noformat}
public IEnumerable<Term> GetEnumerator()
{
yield return Term();
while (Next())
yield return Term();
}
{noformat}
Now you get nice foreach sematics without even mentioning IEnumerable.
Compiler magic is your friend :-)
BTW: Dispose() is only called automatically when exiting a using block.
Exiting a foreach will not.
Cheers,
Andy
On 24 January 2012 06:37, Christopher Currens (Created) (JIRA) <
j...@apache.org> wrote:
> 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 3.0.3, Lucene.Net 2.9.4g
> Environment: all
> Reporter: Christopher Currens
> Fix For: Lucene.Net 3.0.3
>
>
> 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 is automatically generated by JIRA.
> If you think it was sent incorrectly, please contact your JIRA
> administrators:
> https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
> For more information on JIRA, see: http://www.atlassian.com/software/jira
>
>
>
