blocks|key|2360511|text|当代码将类转换到非泛型接口时，将执行非泛型IEnumerator：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2360512|((IEnumerable)myWords).GetEnumerator();+//+this+calls+the+non-generic+one|code-block|syntax|javascript|2360513|如果您将类传递给某些需要非泛型IEnumerator的遗留函数，则这主要是相关的。|2360514|因此，如果您有一个包含函数的库，并且将类传递给这个函数，它将使用非泛型IEnumerator。|2360515|DoSomeStuffWithAnIEnumerable(IEnumerable+x)
{
+++var+foo+=+x.GetEnumerator();

+++//+or,+as+stackx+said,+an+example+with+foreach:
+++foreach+(var+foo2+in+x)
+++Console.WriteLine(foo2);
}


DoSomeStuffWithAnIEnumerable(new+myWords());|2360516|请注意，简单地使用泛型IEnumerator实现非泛型是完全有效的：|2360517|public+class+myWords+:+IEnumerable<string>
{
++++....++++
++++IEnumerator+IEnumerable.GetEnumerator()
++++{
++++++++return+this.GetEnumerator();
++++}
}|2360518|这样你就可以确定它们都有相同的效果。|2360519|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

The non-generic IEnumerator will be executed whenever code casts the class to the non-generic interface:

<pre><code>((IEnumerable)myWords).GetEnumerator(); // this calls the non-generic one
</code></pre>

This is mostly relevant if you pass your class to some legacy function that requires a non-generic IEnumerator.

So if you have some library that contains a function and you pass your class to this function, it will use the non-generic IEnumerator

<pre><code>DoSomeStuffWithAnIEnumerable(IEnumerable x)
{
 var foo = x.GetEnumerator();

 // or, as stackx said, an example with foreach:
 foreach (var foo2 in x)
 Console.WriteLine(foo2);
}


DoSomeStuffWithAnIEnumerable(new myWords());
</code></pre>

 
Note that it is perfectly valid to simply implement the non-generic IEnumerator using the generic one:

<pre><code>public class myWords : IEnumerable&lt;string&gt;
{
 .... 
 IEnumerator IEnumerable.GetEnumerator()
 {
 return this.GetEnumerator();
 }
}
</code></pre>

That way you can be sure that they both have the same effects.

blocks|key|249900|text|IEnumerable的非泛型版本是通过显式接口实现实现的。这意味着您只能通过转换到接口来调用显式实现的函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|249901|之所以显式实现IEnumerable，是因为除了返回类型之外，方法签名是相同的。|249902|将myWords显式转换为IEnumerable允许您调用非通用版本，如：(IEnumerable)myWords。|249903|C#指南解释了这是如何工作的：显式接口实现。|249904|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/vstudio/ms173157.aspx^0|0|B|0|7|B|0|1|7|D|B|11|K|0|F|6|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|L|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

The non-generic version of the <code>IEnumerable</code> is implemented with an explicit interface implementation. This means that you can only call the explicitly implemented function by casting to the interface.

The reason <code>IEnumerable</code> is implemented explicitly is that the method signatures are the same except for the return type. 

Casting <code>myWords</code> explicitly to <code>IEnumerable</code> allows you to call the non-generic version like this: <code>(IEnumerable)myWords</code>.

The C# Guide explains how this works: <a href="http://msdn.microsoft.com/en-us/library/vstudio/ms173157.aspx" rel="nofollow">Explicit interface implementation</a>.

blocks|key|2360558|text|其他的回答有点漏掉了重点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2360559|如果foreached的编译时类型有一个名为GetEnumerator的非泛型非静态方法，则接口根本不重要，该方法采用零参数。(此方法的返回类型可以是任何类型，泛型或非泛型:接口不重要。)|offset|length|style|CODE|2360560|因此，调用第一个方法的原因是，这是public方法。|2360561|你可以改变这一点：|2360562|public+class+myWords+:+IEnumerable<string>
{
++++string[]+f+=+"I+love+you".Split(new+string[]{"lo"},StringSplitOptions.RemoveEmptyEntries);

++++IEnumerator<string>+IEnumerable<string>.GetEnumerator()
++++{
++++++++return+f.Select(s+=>+s+%2B+"2").GetEnumerator();
++++}

++++public+IEnumerator+GetEnumerator()
++++{
++++++++return+f.Select(s+=>+s+%2B+"3").GetEnumerator();
++++}
}|code-block|syntax|javascript|2360563|要证明不需要接口，请尝试如下：|2360564|public+class+myWords+//+no+interfaces!
{
++++string[]+f+=+"I+love+you".Split(new+string[]{"lo"},StringSplitOptions.RemoveEmptyEntries);

++++public+IEnumerator+GetEnumerator()
++++{
++++++++return+f.Select(s+=>+s+%2B+"3").GetEnumerator();
++++}
}|2360565|但是，实现IEnumerable<>是明智的。然后，您的类型可以与Linq+(IEnumerable<>上的扩展方法)一起使用，并且可以用作其他只需要IEnumerable<>的方法的参数。|2360566|此外，明智的做法是让返回非泛型IEnumerator的方法(或显式接口实现)直接调用返回IEnumerator<>的方法(或显式接口实现)。有两个不同的返回序列确实令人困惑(但是对于询问和回答事情是如何工作的问题来说，这是很好的)。|2360567|entityMap^0|0|2|7|M|D|0|H|6|0|0|0|0|0|5|D|13|D|23|D|0|F|B|18|D|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@$D|17|E|18|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|19|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1A|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1C|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1D|8|@$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1K|8|@$D|1L|E|1M|F|G]|$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|Z|$]]

The other answers sort of miss the point.

Interfaces do not matter at all if the (compile-time) type of what is beeing <code>foreach</code>ed has a <code>public</code> non-generic non-static method called <code>GetEnumerator</code> which takes zero arguments. (The return type of this method can be anything, generic or non-generic: interfaces will not matter.)

So the reason why the first of your methods is called, is that this is the <code>public</code> method.

You can change that:

<pre><code>public class myWords : IEnumerable&lt;string&gt;
{
 string[] f = "I love you".Split(new string[]{"lo"},StringSplitOptions.RemoveEmptyEntries);

 IEnumerator&lt;string&gt; IEnumerable&lt;string&gt;.GetEnumerator()
 {
 return f.Select(s =&gt; s + "2").GetEnumerator();
 }

 public IEnumerator GetEnumerator()
 {
 return f.Select(s =&gt; s + "3").GetEnumerator();
 }
}
</code></pre>

To prove that interfaces are not needed, try this:

<pre><code>public class myWords // no interfaces!
{
 string[] f = "I love you".Split(new string[]{"lo"},StringSplitOptions.RemoveEmptyEntries);

 public IEnumerator GetEnumerator()
 {
 return f.Select(s =&gt; s + "3").GetEnumerator();
 }
}
</code></pre>

However, it is wise to implement <code>IEnumerable&lt;&gt;</code>. Then your type can be used with Linq (extension methods on <code>IEnumerable&lt;&gt;</code>), and can be used as argument to other methods that simply require an <code>IEnumerable&lt;&gt;</code>.

Also, it is wise to have the method (or explicit interface implementation) that returns the non-generic <code>IEnumerator</code> just call through to the method (or explicit interface implementation) that returns <code>IEnumerator&lt;&gt;</code>. Having the two return distinct sequences is really confusing (but nice for asking and answering questions on how things work).

Looking at this code : 

<pre><code>public class myWords : IEnumerable&lt;string&gt;
{
 string[] f = "I love you".Split(new string[]{"lo"},StringSplitOptions.RemoveEmptyEntries);

 public IEnumerator&lt;string&gt; GetEnumerator()
 {
 return f.Select(s =&gt; s + "2").GetEnumerator();
 }

 IEnumerator IEnumerable.GetEnumerator()
 {
 return f.Select(s =&gt; s + "3").GetEnumerator();
 }
}
</code></pre>

Running : 

<pre><code> myWords m = new myWords();
 foreach (var s in m)
 {
 Console.WriteLine(s);
 }
</code></pre>

Yields

<pre><code>I 2
ve you2 // notice "2", so the generic Ienumerator has executed.
</code></pre>

I understand that the non-generic <code>IEnumerator</code> version is for compatibility.

Question:

<ol>
<li>In what scenario will the non-generic be invoked? </li>
<li>How can I force my code to be run with the non-generic <code>IEnumerator</code>?</li>
</ol>

When does IEnumerable.GetEnumerator get called instead of IEnumerable<T>.GetEnumerator?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

看看这段代码：public class myWords : IEnumerable<string>{ string[] f = "I love you".Split(new string[]{"lo"},StringSplitOptions.RemoveEmptyEntries); public IEnum...

问什么时候调用IEnumerable.GetEnumerator而不是IEnumerable<T>.GetEnumerator？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候调用IEnumerable.GetEnumerator而不是IEnumerable<T>.GetEnumerator？EN