I'm guessing you're looking for... Wrapper<T> will have one Counter *per* T, whereas Wrapper will have one Counter across all T.

(as an aside, I'm guessing that treacherous ++Counter means neither implementation is thread-safe...)

Count in Wrapper will be per appdomain, in the Wrapper<T> it will be per type.

[)amien

If calling Get() on the generic class with a T different than the one used to create the object, the Counter will be 0.

Static variables are per type:
Wrapper<int>.Counter is a different variable than Wrapper<float>.Counter

in code:

class Wrapper {
public static int Counter{ get; private set;}
static Wrapper() { Counter = 0; }
public static T Get<T>() { ++Counter; return default(T); }
}//making Get static so that it can be called
class Wrapper<T> {
public static int Counter { get; private set; }
static Wrapper() { Counter = 0; }
public static T Get() {
++Counter; return default(T);

}

}
void Tests() {
Assert.AreEqual(0, Wrapper.Counter);
Wrapper.Get<int>();
Assert.AreEqual(1, Wrapper.Counter);
Wrapper.Get<float>();
Assert.AreEqual(2, Wrapper.Counter);

Assert.AreEqual(0, Wrapper<int>.Counter);
Wrapper<int>.Get();
Assert.AreEqual(1, Wrapper<int>.Counter);
Assert.AreEqual(0, Wrapper<float>.Counter);
Wrapper<float>.Get();
Assert.AreEqual(1, Wrapper<float>.Counter);
}

I guess the next obvious answer is that the Wrapper class needs only be instantiated once to handle multiple types on the Get method when it is implemented as a generic method.

When implemented as a generic class you would need to 'new up' a class per type.

That means that the counter becomes a 'total gets per type' counter with the generic class but is a global 'total gets' counter with the generic method.

Not sure if that is the answer you were fishing for!

On top of my head I would say that the generic class will get a separate counter for each closed use.
Whereas with a generic method you will have one shared counter across all types.

This wasn't a difficult one huh?

Well I did forget about it for a little while, and did a stupid thing. Expect a post on that tomorrow.

In the second implementation (generic class) you will have a seperate counter for each generic type that you pass to the wrapper. Whereas in the first case you have a global wrapper and you count all types (regardless if different) going through the get method.