Question

Lets say I have a generic class:

class Foo {
//    protected Type t;

//    public void SetT(string strval) {
//        ((Foo<t>)this).Set(strval);
//    }
}

class Foo<T> : Foo {
    private T val;

    public void Set(string strval) {
        if (this is Foo<float>) {
            this.val = float.Parse(strval);
        } else if (this is Foo<int>) {
            this.val = int.Parse(strval);
        }
    }
}

Now I create an object and put it in an ArrayList:

ArrayList a = new ArrayList();
a.Append(new Foo<float>);

And then I forget the type of Foo<>. Now, how do I Set? I tried the obvious candidates:

(Foo)a[0].Set("5.0");
(Foo<a[0].GetType()>)a[0].Set("5.0");

but those failed.

Is there a way I can call that Set method without explicitly knowing the type of Foo<>?

If not, can I somehow save type of Foo into Foo.t, and then uncomment and use Foo.SetT?

Ah, generics. Very nice tool if you know how to use them 🙂

Regards,
dijxtra

Answer 1

There’s absolutely no reason to be using generics here. Generics are intended to be used when the type of operations you will be performing are generic. In other words, they are independent of the type(s) on which they are performed. You are doing the opposite: the operation will be different depending on the types.

Given that, you should remove the generic parameter, make Set() and Foo abstract, and derive appropriate classes to handle the different types:

abstract class Foo
{
    public abstract void Set(string value);
}

class FooDouble : Foo
{
    double val;
    public override void Set(string value)
    {
        this.val = double.Parse(value);
    }
}

// Etc.

Then, you should be storing your Foos in a List<T>:

List<Foo> fooList = new List<Foo>();
fooList.Add(new FooDouble());

Later, you can say this:

fooList[0].Set("5.0");

And it will just work! No need to remember!