如何修复开关操作器中的错误

Question

I have a class named config with two string fields named key paramValue and parameterPath.

When I apply the ChooseType method of the class, the method has to return one variable paramValue in different types (Int or bool or String).

I implemented it as follow:

class ConfigValue
{
    public string parameterPath;
    private string paramValue;

    public ConfigValue(string ParameterPath="empty",string ParamValue="empty")
    {
        this.parameterPath = ParameterPath;
        this.paramValue = ParameterPath;
    }

    public enum RetType { RetInt=1, RetBool, RetString };



    public  T ChooseType<T>(RetType how)
    {

        {

            switch(how)
             {
                case RetType.RetInt:

                     return int.Parse(string this.paramValue);
                        break;

                case RetType.RetBool:

                    return  Boolean.Parse(string this.paramValue);
                        break;

                case RetType.RetString:

                       return this.paramValue;
                      break;
             }

         }
    }

}

But,I get error in switch operator in the next rows:

 return int.Parse(string this.paramValue);

Error:

Only assignment, call, increment, decrement, and new object expressions can be used as a statement.

 return  Boolean.Parse(string this.paramValue);

Error:

Invalid expression term 'string'.

 return this.paramValue;

Error:

Cannot implicitly convert type 'string' to 'T'.

Any idea why do I get these errors and how can I fix the code?

Answer 1

Any idea why do I get these errors?

The compiler has no idea what T will be, and it doesn't know how to implicitly convert from string , bool or int to T .

and how can I fix the code?

You can go through an explicit conversion to object and then another to T :

return (T) (object) int.Parse(string this.paramValue);

The requirement to go "via" object is a little odd - Eric Lippert has a blog post going through this in more detail .

Answer 2

public T ChooseType<T>(RetType how)
{
    switch (how)
    {
        case RetType.RetInt:
            return (dynamic)int.Parse(paramValue);
        case RetType.RetBool:
            return (dynamic)Boolean.Parse(paramValue);
        case RetType.RetString:
            return (dynamic)paramValue;
        default:
            throw new ArgumentException("RetType not supported", "how");
    }
}

You should not specify parameter type when you are calling some method. Parameter types required only for method declaration. Thus just pass parameter:

int.Parse(this.paramValue) // you can use class members without this keyword
int.Parse(paramValue)

Also you should add default branch for your switch block (you must return something if incorrect parameter value was passed to your method).

Also you don't need to break switch branches if you already used return .

And for converting some type to generic value you should use dynamic , or double conversion via object:

return (dynamic)int.Parse(paramValue);
return (T)(object)int.Parse(paramValue);

Answer 3

The problem is that you are stating that the return type of your function will be T. As T can be of ANY type, you can't explicitely return an int, string or any speciffic type. You may want to try using one return instruction, something like

public  T ChooseType<T>() 
{
    return (T)this.paramValue;
}

and then, when calling the function, specify T, like this:

int a = ChooseType<int>();

or

string a = ChooseType<string>();

Keep in mind that if paramValue cannot be casted as T, then an error will be thrown.