任何人都可以举一个很好的例子来说明如何使用泛型类？

Question

We recently learned about generic classes in C#, but our teacher failed to mention what they can be used for. I can't really find any good examples and would be extremly happy if somebody help me out :)

Have you made your own generic class, and what did you use it for?

Some code examples would make me, and my classmates, really happy! Pardon the bad english, I am from sweden :)

happy programming!

Sorry- I think I could have written the question a bit better. I am familar with generic collections. I just wondered what your own generic classes can be used for.

and thank you for the MSDN links, I did read them before posting the question, but maybe I missed something? I will have a second look!

Answer 1

Generic Collections

Generics for collections are very useful because they allow compile time type safety. This is useful for a few reasons:

• No casting is required when retreiving values. This is not only a performance benefit but also eliminates the risk of there being a casting exception at runtime

• When value types are added to a non generic list such as an ArrayList, the value's have to be boxed. This means that they are stored as reference types. It also means that not only does the value get stored in memory, but so does a reference to it, so more memory than necessery is used. This problem is eliminated when using generic lists.

Generic Classes

Generic classes can be useful for reusing common code for different types. Take for example a simple non generic factory class:

public class CatFactory
{
  public Cat CreateCat()
  {
    return new Cat();
  }
}

I can use a generic class to provide a factory for (almost) any type:

public class Factory<T> where T : new()
{
  public T Create()
  {
    return new T();
  }
}

In this example I have placed a generic type constraint of new() on the type paramter T. This requires the generic type to contain a parameterless contructor which enables me to create an instance without knowing the type.

Answer 2

Just because you said you are Swedish, I thought I'd give an example integrating IKEA furniture. Your kit couches are an infestation in north america, so I thought I'd give something back :) Imagine a class which represents a particular kit for building chairs and tables. To remain authentic, I'll even use nonsense swedish linguistic homonyms:

// interface for included tools to build your furniture
public interface IToolKit {
    string[] GetTools();
}

// interface for included parts for your furniture    
public interface IParts {
    string[] GetParts();
}

// represents a generic base class for IKEA furniture kit
public abstract class IkeaKit<TContents> where TContents : IToolKit, IParts, new() {
    public abstract string Title {
        get;
    }

    public abstract string Colour {
        get;
    }

    public void GetInventory() {
        // generic constraint new() lets me do this
        var contents = new TContents();
        foreach (string tool in contents.GetTools()) {
            Console.WriteLine("Tool: {0}", tool);
        }
        foreach (string part in contents.GetParts()) {
            Console.WriteLine("Part: {0}", part);
        }
    }
}

// describes a chair
public class Chair : IToolKit, IParts {
    public string[] GetTools() {
        return new string[] { "Screwdriver", "Allen Key" };
    }

    public string[] GetParts() {
        return new string[] {
            "leg", "leg", "leg", "seat", "back", "bag of screws" };
    }
}

// describes a chair kit call "Fnood" which is cyan in colour.
public class Fnood : IkeaKit<Chair> {
    public override string Title {
        get { return "Fnood"; }
    }

    public override string Colour {
        get { return "Cyan"; }
    }
}

public class Snoolma : IkeaKit<Chair> {
    public override string Title {
        get { return "Snoolma "; }
    }

    public override string Colour {
        get { return "Orange"; }
    }
}

Ok, so now we've got all the bits we need to figure out how to build some cheap furniture:

var fnood = new Fnood();
fnood.GetInventory(); // print out tools and components for a fnood chair!

(Yes, the lack of instructions and the three legs in the chair kit is deliberate.)

Hope this helps in a cheeky way.

Answer 3

If one has a List object (non-generic), one can store into it anything that can be cast into Object, but there's no way of knowing at compile time what type of things one will get out of it. By contrast, if one has a generic List<Animal>, the only things one can store into it are Animal or derivatives thereof, and the compiler can know that the only things that will be pulled out of it will be Animal. The compiler can thus allow things to be pulled out of the List and stored directly into fields of type Animal without any need for run-time type checking.

Additionally, if the generic type parameter of a generic class happens to be a value type, use of generic types can eliminate the need for casting to and from Object, a process called "Boxing" which converts value-type entities into reference-type objects; boxing is somewhat slow, and can sometimes alter the semantics of value-type objects, and is thus best avoided when possible.

Note that even though an object of type SomeDerivedClass may be substitutable for TheBaseClass, in general, a GenericSomething<SomeDerivedClass> is not substitutable for a GenericSomething<TheBaseClass>. The problem is that if one could substitute eg a List<Giraffe> for a List<Zebra>, one could pass a List<Zebra> to a routine that was expecting to take a List<Giraffe> and store an Elephant in it. There are a couple of cases where substitutability is permitted, though:

1. Arrays of a derived type may be passed to routines expecting arrays of base type, provided that those routines don't try to store into those arrays any items that are not of the proper derived type.
2. Interfaces may be declared to have "out" type parameters, if the only thing those interfaces will do is return ("output") values of that type. A Giraffe-supplier may be substituted for an Animal-supplier, because all it's going to do is supply Giraffes, which are in turn substitutable for animals. Such interfaces are "covariant" with respect to those parameters.

In addition, it's possible to declare interfaces to declare "in" type parameters, if the only thing the interfaces do is accept parameters of that type by value. An Animal-eater may be substituted a Giraffe-eater, because--being capable of eating all Animals, it is consequently capable of eating all Giraffes. Such interfaces are "contravariant" with respect to those parameters.

Answer 4

The most common example is for collections such as List, Dictionary, etc. All those standard classes are implemented using generics.

Another use is to write more general utility classes or methods for operations such as sorting and comparisons.

Answer 5

real world example for generics.

Think u have a cage where there are many different birds(parrot,pegion,sparrow,crow,duck) in it(non generic).

Now you are assigned a work to move the bird to seperate cages(specifically built for single bird) from the cage specified above.

(problem with the non generic list) It is a tedious task to catch the specific bird from the old cage and to shift it to the cage made for it.(Which Type of bird to which cage --Type casting in c#)

generic list

Now think you have a seperate cage for seperate bird and you want to shift to other cages made for it. This will be a easy task and it wont take time for you to do it(No type casting required-- I mean mapping the birds with cages).

Answer 6

Well, you have a lot of samples inside the framework. Imagine that you need to implement a list of intergers, and later a list of strings... and later a list of you customer class... etc. It would be very painfull.

But, if you implements a generic list the problem is solved in less time, in less code and you only have to test one class.

Maybe one day you will need to implement your own queue, with rules about the priority of every element. Then, it would be a good idea to make this queue generic if it is possible.

This is a very easy sample, but as you improve your coding skills, you will see how usefull can be to have (for example) a generic repository (It's a design patters).

Not everyday programmers make generic classes, but trust me, you will be happy to count with such tool when you need it.

Answer 7

Here is a Microsoft article that can be of help: http://msdn.microsoft.com/en-us/library/b5bx6xee%28v=vs.80%29.aspx

The largest benefit that I've seen is the compile-time safety of generics, as @Charlie mentioned. I've also used a generic class to implement a DataReader for bulk inserts into a database.

Answer 8

My friend is not a programmer and I would like to explain what is generics? I would explain him generics as below. Thus this is a real-world scenario of using generics.

"There is this manufacturer in the next street. He can manufacture any automobile. But at one instance he can manufacture only one type of automobile. Last week, he manufactured a CAR for me, This week he manufactured a TRUCK for my uncle. Like I said this manufacturing unit is so generic that it can manufacture what the customer specifies. But note that when you go to approach this manufacturer, you must go with a type of automobile you need. Otherwise approaching him is simply not possible."

Answer 9

Have a look at this article by Microsoft. You have a nice and clear explanation of what to use them for and when to use them. http://msdn.microsoft.com/en-us/library/ms172192.aspx

Answer 10

The various generic collections are the best example of generics usage but if you want an example you might generate yourself you could take a look at my anwer to this old question:

uses of delegates in c or other languages

Not sure if it's a particularly great example of generics usage but it's something I find myself doing on occasion.

Answer 11

Are you talking about a base class (or perhaps an abstract class)? As a class that you would build other classes (subclasses) off of?

If that's the case, then you'd create a base class to include methods and properties that will be common to the classes that inherit it. For example, a car class would include wheels, engine, doors, etc. Then maybe you'd maybe create a sportsCar subclass that inherits the car class and adds properties such as spoiler, turboCharger, etc.

http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming ) enter link description here

It's hard to understand what you mean by "generic class" without some context.