使用泛型类作为非泛型类C＃的属性

Question

Say I have the following two classes, which ideally do what I want:

Foo.cs:

public class Foo
{
    private int Type { get; set; } = 0;

    public FooHelper FooHelper
    {
        get
        {
            switch (Type)
            {
                case 1:
                    return new FooHelper<Guid>("Foo", "Bar", "foobar", "", Guid.NewGuid());
                case 2:
                default:
                    return new FooHelper<int>("Bar", "Foo", "", "", 11);
            }
        }
    }

    public Foo(int type)
    {
        Type = type;
    }
}

FooHelper.cs:

public class FooHelper<T> where T : struct
{
    public string Controller { get; set; }    = string.Empty;
    public string Action { get; set; }        = string.Empty;
    public string Area { get; set; }          = string.Empty;
    public string NameParameter { get; set; } = string.Empty;
    public T IdParameter { get; set; }        = default(T);

    public FooHelper() { }
    public FooHelper(string controller, string action, string area, string name, T id)
    {
        Controller    = controller;
        Action        = action;
        Area          = area;
        NameParameter = name;
        IdParameter   = id;
    }
}

Depending on the integer value passed in as parameter for the constructor of non-generic class Foo , the property FooHelper returns a new instance of the generic class FooHelper based on either a Guid or an int.

However, I cannot seem to make this work without making Foo also generic, which I don't want. The error I'm getting is on the property line of FooHelper, stating:

Using the generic type 'FooHelper<T>' requires 1 type arguments

which makes sense, but which I don't know at that point. I want to determine the type of FooHelper inside the constructor of Foo .

Am I missing something or is it just not possible to do what I want in this case?

Answer 1

The problem is that public FooHelper FooHelper won´t even compile because there is no type called FooHelper . However there are FooHelper<int> and FooHelper<Guid> which however don´t have anything in common. Thus this porblem is (again) caused by the fact that you supply an information (the type-switch) at runtime and expect the compiler to infer the right generic type at compile-time, which isn´t possible.

What you can do instead is create a non-generic interface from that all your helpers derive and which your method returns:

public interface IFooHelper { ... }
public class FooHelper<T> : IFooHelper where T : struct { ... }

Now within your Foo -class:

public IFooHelper FooHelper
{
    get
    {
        switch (Type)
        {
            case 1:
                return new FooHelper<Guid>("Foo", "Bar", "foobar", "", Guid.NewGuid());
            case 2:
            default:
                return new FooHelper<int>("Bar", "Foo", "", "", 11);
        }
    }
}

However as mentioned above during compile-time there is no way to know what the actual generic type-parameter actually is, because that type doesn´t even exist.