What is the disadvantage if I don't implement IEnumerable<T>

Hello!

Below I have a working program.
I have one generic class called Farm<T>
with this header definition public class Farm<T> : IEnumerable<T> where T :
Animal

Now to my question I changed the inheritance of the IEnumerable from the
generic IEnumerable<T>
to the generel IEnumerable and the program function just the same so no
difference occured.

So what advantage do I get if I implement the generic interface
IEnumerable<T> instead of the
generell IEnumerable ?
Can you also give me some example that show on advantage to implement the
generic interface IEnumerable<T>?

I know that this IEnumerable<T> inherit from IEnumerable.

So as a summary I can't see what purpose or advantage I get when I
implement IEnumerable<T> instead of
IEnumerable.?

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;

namespace ConsoleApplication9
{
class Program
{
static void Main(string[] args)
{
Farm<Animal> farm = new Farm<Animal>();
farm.Animal.Add(new Cow("Jack"));
farm.Animal.Add(new Chicken("Vera"));
farm.Animal.Add(new Chicken("Sally"));
farm.Animal.Add(new SuperCow("Kevin"));

farm.MakeNoises();
Farm<Cow> dairyFarm = farm.GetCows();
dairyFarm.FeedTheAnimals();

foreach (Cow cow in dairyFarm)
{
if (cow is SuperCow)
((SuperCow)cow).Fly();
}
Console.ReadKey();

}
}




public abstract class Animal
{
string name;
public Animal(string name)
{
this.name = name;
}

public string Name
{
get { return name; }
}

public abstract void MakeANoise();
public abstract void Feed();
}

public class Chicken : Animal
{
public Chicken(string name) : base(name) {}

public override void MakeANoise()
{
Console.WriteLine("{0} says 'cluck!'", Name);
}

public override void Feed()
{
Console.WriteLine(Name + " has been feed(Chicken)");
}
}

public class Cow : Animal
{
public Cow(string name) : base(name) {}

public override void MakeANoise()
{
Console.WriteLine("{0} says 'moo!'", Name);
}

public override void Feed()
{
Console.WriteLine(Name + " has been fed(Cow)");
}
}

public class SuperCow : Cow
{
public SuperCow(string name) : base(name)
{ }

public void Fly()
{
Console.WriteLine("{0} is flying!", Name);
}

public override void MakeANoise()
{
Console.WriteLine("{0} says 'here I come to save the day!'",
Name);
}

public override void Feed()
{
Console.WriteLine(Name + " has been feed(SuperCow)");
}
}

public class Farm<T> : IEnumerable<T> where T : Animal
{
private List<T> animals = new List<T>();

public List<T> Animal
{
get { return animals; }
}

IEnumerator IEnumerable.GetEnumerator()
{
return animals.GetEnumerator();
}

public IEnumerator<T> GetEnumerator()
{
return animals.GetEnumerator();
}


public void MakeNoises()
{
foreach (T animal in animals)
animal.MakeANoise();
}

public void FeedTheAnimals()
{
foreach (T animal in animals)
animal.Feed();
}

public Farm<Cow> GetCows()
{
Farm<Cow> cowFarm = new Farm<Cow>();
foreach (T animal in animals)
if (animal is Cow)
cowFarm.animals.Add(animal as Cow);
return cowFarm;
}
}
}

//Tony


.

Relevant Pages

  • Re: about using compare with generics
    ... foreach (Cow cow in dairyFarm) ... public override void MakeANoise() ... foreach (T animal in animals) ...
    (microsoft.public.dotnet.languages.csharp)
  • about using compare with generics
    ... for example compare a Chicken with a Cow in some way or a Cow with another ... foreach ... public override void MakeANoise() ... foreach (T animal in animals) ...
    (microsoft.public.dotnet.languages.csharp)
  • Some cast problem and something about generic
    ... But If I change the foreach clause to foreach (Animal animal in animals) ... but not here because I'm forced to use the animal as Cow ... public override void MakeANoise() ...
    (microsoft.public.dotnet.languages.csharp)
  • compile error problems
    ... public class Chicken: Animal ... public override void MakeANoise() ... public class SuperCow: Cow ... foreach (T animal in animals) ...
    (microsoft.public.dotnet.languages.csharp)