Shad Storhaug commented on LUCENENET-469:

Ahh...I think I now know where we are getting our wires crossed.

You have become a victim of the Java developers' incessant need to abbreviate 
everything (which annoys the crap out of me, but unfortunately fixing it is a 
losing battle). 

Essentially, {{TermsEnum}} == {{IEnumerator<BytesRef>}}, {{TermsEnum}} != 
{{IEnumerable<BytesRef>}}. "Enum" could be interpreted as either one, hence the 
misunderstanding (hell, come to think of it, it could even be misinterpreted as 
an enumeration).

So, rather than loading up the {{IEnermerable<BytesRef>}} with all kinds of 
useful stuff like LINQ does, our Lucene friends have loaded up a 
{{IEnumerator<T>}} (or not - they didn't actually implement Java's analogue to 
this) with stuff that most {{IEnumerator}} s don't do. Which of course is 
leaving us scratching our heads.

So, when disposing {{TermsEnum}}, we are doing the standard 
{{IEnumerator<T>.Dispose()}} stuff that the foreach loop does not some funky 
other relationship.

> 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

Reply via email to