lucenenet-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Christopher Currens <currens.ch...@gmail.com>
Subject Re: [Lucene.Net] [jira] [Created] (LUCENENET-469) Convert Java Iterator classes to implement IEnumerable<T>
Date Fri, 08 Jun 2012 23:15:40 GMT
I've used extension methods as well.  I'm +1 as well, though a vote, I'm
sure, isn't necessary; we've all been wanting IEnumerable for a long time.
 I've used them on TermEnum, TermDocs, and TermPositions.  I think we just
need to create an issue in JIRA for it and get it done.  Should be fairly
easy to do, and I don't see any reason why we can't put the extension
methods in core, in the same namespace where they're used.  That way,
they're automatically seen by users.


Thanks,
Christopher

On Fri, Jun 8, 2012 at 3:19 PM, Digy <digydigy@gmail.com> wrote:

> Hi Andy,
>
> I have used similar extension methods for a long time. What I like
> especially in extension methods is that they don't require changes in
> Lucene.Net kernel and make further ports of Lucene.java independent from
> .Net structures.
>
> +1 for a Lucene.Net extensions in contrib. Even a +1 for a
> "Lucene.Net.Extensions" for the core.
>
> DIGY
>
> -----Original Message-----
> From: Andy Pook [mailto:andy.pook@gmail.com]
> Sent: Friday, June 08, 2012 10:26 PM
> To: lucene-net-dev@lucene.apache.org
> Subject: Re: [Lucene.Net] [jira] [Created] (LUCENENET-469) Convert Java
> Iterator classes to implement IEnumerable<T>
>
> 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) <
> jira@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.js
> > pa For more information on JIRA, see:
> > http://www.atlassian.com/software/jira
> >
> >
> >
>
> -----
>
> Checked by AVG - www.avg.com
> Version: 2012.0.2177 / Virus Database: 2433/5056 - Release Date: 06/08/12
>
>

Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message