Question

关于c#中的泛型接口

写了一个泛型类如下：

public class Farm<T>:IEnumerable<T> whereT:Animal//自定义泛型类，继承接口并且约束了类型
{
privateList<T> animals=new List<T>();

publicFarm<Cow>GetCows()
{
Farm<Cow> cowFarm=newFarm<Cow>();
foreach(Tanimal in animals)
{
if(animal is Cow)
{
cowFarm.animals.Add(animal as Cow );
}
}
returncowFarm;
}

publicList<T>Animals
{
get
{
return animals;
}
}

publicIEnumerator<T> GetEnumerator()
{
returnanimals.GetEnumerator();//循环访问usingSystem.Collections.Generic.List<T>中的枚举数.
}

IEnumeratorIEnumerable.GetEnumerator()
{
returnanimals.GetEnumerator();
}

publicvoid MakeNoises()
{
foreach(Tanimal in animals)
{
animal.MakeANoise();
}
}

publicvoid FeedTheAnimals()
{
foreach(Tanimal in animals)
{
animal.Feed();
}
}
}
}
我想问一下"public IEnumerator<T> GetEnumerator()"这个方法
他怎么返回一个泛型接口？
具体返回的到底是什么？能表示一下吗 这块不太懂

Answer 1

　　泛型：通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用。在.NET类库中处处都可以看到泛型的身影，尤其是数组和集合中，泛型的存在也大大提高了程序员的开发效率。更重要的是，C#的泛型比C++的模板使用更加安全，并且通过避免装箱和拆箱操作来达到性能提升的目的。因此，我们很有必要掌握并善用这个强大的语言特性。
　　C#泛型特点：
　　1、如果实例化泛型类型的参数相同，那么JIT编辑器会重复使用该类型，因此C#的动态泛型能力避免了C++静态模板可能导致的代码膨胀的问题。
　　2、C#泛型类型携带有丰富的元数据，因此C#的泛型类型可以应用于强大的反射技术。
　　3、C#的泛型采用“基类、接口、构造器，值类型/引用类型”的约束方式来实现对类型参数的“显示约束”，提高了类型安全的同时，也丧失了C++模板基于“签名”的隐式约束所具有的高灵活性
　　C#泛型继承：
　　C#除了可以单独声明泛型类型（包括类与结构）外，也可以在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型要么以实例化，要么来源于子类（同样是泛型类型）声明的类型参数，看如下类型
　　class C<U,V>
　　class D:C<string,int>
　　class E<U,V>:C<U,V>
　　class F<U,V>:C<string,int>
　　class G:C<U,V> //非法
　　E类型为C类型提供了U、V，也就是上面说的来源于子类
　　F类型继承于C<string,int>，个人认为可以看成F继承一个非泛型的类
　　G类型为非法的，因为G类型不是泛型，C是泛型，G无法给C提供泛型的实例化
　　泛型类型的成员：
　　泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在该类型上使用从System.Object继承的公有成员。如下图：

　　泛型接口：
　　泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数
　　泛型委托：
　　泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束
　　delegate bool MyDelegate<T>(T value);
　　class MyClass
　　{
　　static bool F(int i){...}
　　static bool G(string s){...}
　　static void Main()
　　{
　　MyDelegate<string> p2 = G;
　　MyDelegate<int> p1 = new MyDelegate<int>(F);
　　}
　　}
　　泛型方法：
　　1、C#泛型机制只支持“在方法声明上包含类型参数”——即泛型方法。
　　2、C#泛型机制不支持在除方法外的其他成员（包括属性、事件、索引器、构造器、析构器）的声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数。
　　3、泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中。
　　泛型方法声明：如下
　　public static int FunctionName<T>(T value){...}
　　泛型方法的重载：
　　public void Function1<T>(T a);
　　public void Function1<U>(U a);
　　这样是不能构成泛型方法的重载。因为编译器无法确定泛型类型T和U是否不同，也就无法确定这两个方法是否不同
　　public void Function1<T>(int x);
　　public void Function1(int x);
　　这样可以构成重载
　　public void Function1<T>(T t) where T:A;
　　public void Function1<T>(T t) where T:B;
　　这样不能构成泛型方法的重载。因为编译器无法确定约束条件中的A和B是否不同，也就无法确定这两个方法是否不同
　　泛型方法重写：
　　在重写的过程中，抽象类中的抽象方法的约束是被默认继承的。如下：
　　abstract class Base
　　{
　　public abstract T F<T,U>(T t,U u) where U:T;
　　public abstract T G<T>(T t) where T:IComparable;
　　}
　　class MyClass:Base
　　{
　　public override X F<X,Y>(X x,Y y){...}
　　public override T G<T>(T t) where T:IComparable{}
　　}
　　对于MyClass中两个重写的方法来说
　　F方法是合法的，约束被默认继承
　　G方法是非法的，指定任何约束都是多余的
　　泛型约束：
　　1、C#泛型要求对“所有泛型类型或泛型方法的类型参数”的任何假定，都要基于“显式的约束”，以维护C#所要求的类型安全。
　　2、“显式约束”由where子句表达，可以指定“基类约束”，“接口约束”，“构造器约束”，“值类型/引用类型约束”共四种约束。
　　3、“显式约束”并非必须，如果没有指定“显式约束”，范型类型参数将只能访问System.Object类型中的公有方法。例如：在开始的例子中，定义的那个obj成员变量。比如我们在开始的那个例子中加入一个Test1类，在它当中定义两个公共方法Func1、Func2，如下图：

　　泛型的概念，用通俗的语言来讲，泛型其实就是类的一个参数，但是要求参数必须是一个类，而不能是一个对象。很多人可能对泛型中T的作用不太理解，其中T在泛型中扮演的角色就相当于一个占位符，确切的说，是类型占位符。凡是出现T的地方都会替换成你所传递的类型。

Answer 2

public IEnumerator<T> GetEnumerator()
{
    return animals.GetEnumerator();//循环访问usingSystem.Collections.Generic.List<T>枚举数.
}

//这里返回的IEnumerator<T>，是真正进行枚举操作的类。
//这个类有2个方法，1个属性

//获取集合中的当前元素
object Current{get;set;}
  
//枚举数推进到集合的下一个元素，当存在下一个对象时返回true，不存在时返回false
bool MoveNext();
  
//枚举数设置为其初始位置，该位置位于集合中第一个元素之前
void Reset();

//IEnumerable<T>这个接口，只表明实现该接口的类，可以被枚举（类中有可以被枚举的元素，比如你实例中的private List<T> animals = new List<T>()，List<T>一定是实现了IEnumerator接口的，因为它才是真正的枚举的实现）