实现泛型的特定案例，而不是从中派生

Question

I am trying to write out a specific case of a generic class with additional functionality, but I am not sure why the following happens.

Suppose I have a generic class:

class Generic<T>
{
   protected T value;
}

If I write out a specific implementation, I can't actually use the specific type I've narrowed it down to:

EDIT: I goofed up, this doesn't work.

class Generic<float>
{
    // This doesn't work
    public void Add()
    {
        value + 1.0f;
    }
}

But if I inherit from the specific version, it does work:

class Specific : Generic<float>
{
    // This does work
    public void Add()
    {
        value + 1.0f;
    }
}

Answer 1

In case someone is still reading this, I wanted to point out that this seems to be possible with extension methods:

class Generic<T>
{
    public T value;
}

static class Extension
{
    public static void Add (this Generic<float> generic)
    {
        generic.value += 1.0f;
    }
}

The downside seems to be that 'value' has to be public or internal.

Answer 2

I also looked for similar solution, I think you also got this thinking from ADA or such programming language. But, as others wrote, making type specific class definition is not generic programming, it's specialization, so the simpliest (and only in C#) way is to create a specified class, based on generic structure:

class Generic<T>
{
    protected T value;
    public Generic(T val)
    {
        value = val;
    }
}

class Generic_float : Generic<float>
{
    public Generic_float(float val)
        : base(val)
    {
    }
    public void Add()
    {
        value = value + 1.0f;
    }
}

As you can see, we created a class for the specified case, having the extra ability of extending the structure with fields and methods. This advantage is very good to refine behavior of our objects, and gives ability of implicit cast of the typed generic class to our customized one (with the notice that casting back is not possible):

public void Test()
{
    Generic<float> var1 = new Generic<float>(1.5f);
    Generic_float var2 = new Generic_float(2.5f);
    var1 = var2; // Works, var links to var2's memory field casted as Generic<float>
    var2 = var1; // cannot implicitly convert error, if want to use then have to make explicit conversion
}

Don't know if the way you expected should work in languages like C# or other managed ones, but maybe this workaround gives you what you really wanted to get.

Answer 3

Your first attempt simply isn't a valid declaration - the part that specifies a class can't specify any type arguments.

If you think about it, how would the CLR know whether or not there was a specialized type available? What would it do if there were two different specializations of the same generic type in two loaded assemblies? It would have to check all the referenced assemblies any time a particular type argument combination was used for the first time. (This couldn't be done at compile-time, as other classes may just be referring to Generic<T> .)

In many cases you can use values of the type in ways which are meaningful to the type using constraints. For example, if you constrain T with where T : IComparable<T> then you can compare any two T values using Compare . Unfortunately there's no way of representing arithmetic operators in this way, although you may want to look at Marc Gravell's generic operator work in MiscUtil .

While I feel your pain, there's simply nothing like this in .NET generics - you'll want to think of alternative designs for whatever problem you're really trying to solve.

Answer 4

in this case :

class Generic<float>
{
    // This doesn't work
    public void Add()
    {
        value + 1.0f;
    }
}

It doesn't mean that you are working with a Generic class using float as its generic type but it means that the name of the generic type is "float" in the source (instead of using T you are using "float" as its name ) Thus there's no conversion to float.In other words you are using a generic notation as a template that can be substituted with real types later (but not in the template itself and that's why in C++ they are called templates)

In this code :

    class Specific : Generic<float>
{
    // This does work
    public void Add()
    {
        value + 1.0f;
    }
}

you are telling the compiler that you want the specific class be a child of a generic class while it's template type will be replaced by type float.

Answer 5

Generic types are used for arithmetic reusability. That is, you must write something common between all possible Ts in your code.

class Generic<T>
{
   protected T value;   //it's valid to declare a member whose type is T
   public void Add()
   {
      value + 1.0f;   //invalid, because not all T are allowed to add 
                      //with 0.1f by default
                      //consider T is the type Person
   }

   public void Print()
   {
      Type t = typeof(T);   //valid, for all T we can get its type
   }
}

And when you specified some T (eg float in your question), the compiler knows the T is float, so it's valid to add 0.1f to it.