Most important things about C# generics… lesson learned [closed]

Answer 1

Generic delegate types are always type invariant.

I ran into an issue similar to what is outlined at the link below the other day, and it caused some confusion because I didn't understand why I had to cast my collection.

http://www.theserverside.net/blogs/thread.tss?thread_id=47323

Answer 2

Each specialization of a generic type is treated as a unique type when it comes to things like static members. For example, with this type:

class GenericType<T>
{
    public static int SomeValue;
}

The assert succeeds if we do this:

GenericType<int>.SomeValue = 3;
Debug.Assert(GenericType<double>.SomeValue == 0);

This is because:

typeof(GenericType<int>) != typeof(GenericType<double>)

Even though

typeof(GenericType<int>.GetGenericTypeDefinition() == typeof(GenericType<double>).GetGenericTypeDefinition()

Answer 3

Two interesting lessons. First; with lists; try to think in terms of T; for full details see here, but in short you need to use:

public void Foo<T>(IList<T> data) where T : SomeBaseClassOrInterface {}

and not:

public void Foo(IList<SomeBaseClassOrInterface> data) {}

---

Second: watch for the edge cases ;-p

Can you see the trap here?

static void Foo<T>() where T : new()
{
    T t = new T();
    Console.WriteLine(t.ToString()); // works fine
    Console.WriteLine(t.GetHashCode()); // works fine
    Console.WriteLine(t.Equals(t)); // works fine

    // so it looks like an object and smells like an object...

    // but this throws a NullReferenceException...
    Console.WriteLine(t.GetType()); // BOOM!!!
}

Answer 4

Understand the capabilities and limitations of generic type inference in C#. A deep understanding of what the compiler can, and can't, infer based on (e.g.) the types of parameters in your method can be leveraged to make the common use-cases of your API significantly more readable.

Answer 5

MyGeneric<T> where T : IComparable

doesn't make

MyGeneric<IComparable> 

a base class of it.

Answer 6

The most important lesson about generics I've learned is: the more you use them the better.