471,350 Members | 1,839 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,350 software developers and data experts.

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<Twhere 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<Tinstead 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<Tinherit from IEnumerable.

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

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

namespace ConsoleApplication9
{
class Program
{
static void Main(string[] args)
{
Farm<Animalfarm = 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<CowdairyFarm = 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<Twhere T : Animal
{
private List<Tanimals = new List<T>();

public List<TAnimal
{
get { return animals; }
}

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

public IEnumerator<TGetEnumerator()
{
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<CowGetCows()
{
Farm<CowcowFarm = new Farm<Cow>();
foreach (T animal in animals)
if (animal is Cow)
cowFarm.animals.Add(animal as Cow);
return cowFarm;
}
}
}

//Tony
Jun 27 '08 #1
2 2338
Tony Johansson <jo*****************@telia.comwrote:
Below I have a working program.
I have one generic class called Farm<T>
with this header definition public class Farm<T: IEnumerable<Twhere 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.
In this particular program, yes.
So what advantage do I get if I implement the generic interface
IEnumerable<Tinstead of the
generell IEnumerable ?
You end up with a more strongly typed API. This enables things like
LINQ to Objects to work much more smoothly, and fewer casts which need
to be checked at execution time. (In fact your foreach loops ended up
needing execution time casts anyway, but that's often not the case.)

In general, when you *can* implement a generic interface instead of a
nongeneric one, it's a good idea to do so.

--
Jon Skeet - <sk***@pobox.com>
Web site: http://www.pobox.com/~skeet
Blog: http://www.msmvps.com/jon.skeet
C# in Depth: http://csharpindepth.com
Jun 27 '08 #2
On Jun 19, 12:05*am, Jon Skeet [C# MVP] <sk...@pobox.comwrote:
Tony Johansson <johansson.anders...@telia.comwrote:
Below I have a working program.
I have one generic class called Farm<T>
with this header definition public class Farm<T: IEnumerable<TwhereT :
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.

In this particular program, yes.
So what advantage do I get if I implement the generic interface
IEnumerable<Tinstead of the
generell IEnumerable ?

You end up with a more strongly typed API. This enables things like
LINQ to Objects to work much more smoothly, and fewer casts which need
to be checked at execution time. (In fact your foreach loops ended up
needing execution time casts anyway, but that's often not the case.)

In general, when you *can* implement a generic interface instead of a
nongeneric one, it's a good idea to do so.
In addition to all this, there is one more practical reason to
implement IEnumerable<T>: if you do that, then any method that takes
IEnumerable<Twill be able to work with your object (and also any
method that takes a plain IEnumerable, since, as you've noticed,
IEnumerable<Textends IEnumerable). For example, the vast majority of
LINQ methods require IEnumerable<T>. You can use
Enumerable.Cast<TResult>() method to create wrappers as needed, of
course, but, same as with plain casts, it gets tedious to write it
again and again, and there is an associated performance hit as well.
Jun 27 '08 #3

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

15 posts views Thread by Gustaf | last post: by
7 posts views Thread by Andrew Robinson | last post: by
2 posts views Thread by Morgan Cheng | last post: by
3 posts views Thread by ajay2552 | last post: by
2 posts views Thread by Berryl Hesh | last post: by
reply views Thread by XIAOLAOHU | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.