泛型方法的返回类型

发布于 2024-10-18 07:07:51 字数 364 浏览 1 评论 0原文

我有一个通用方法，它返回通用类型的对象。一些代码：

public static T Foo<T>(string value)
{
    if (typeof(T) == typeof(String))
        return value;

    if (typeof(T) == typeof(int))
        return Int32.Parse(value);

    // Do more stuff
}

我可以看到编译器可能会抱怨这一点（“无法将类型'String'转换为'T'”），即使代码不应在运行时导致任何逻辑错误。有什么办法可以实现我正在寻找的东西吗？选角并没有什么帮助...

原文

I have a generic method which is to return an object of the generic type. Some code:

public static T Foo<T>(string value)
{
    if (typeof(T) == typeof(String))
        return value;

    if (typeof(T) == typeof(int))
        return Int32.Parse(value);

    // Do more stuff
}

I can see that the compiler might complain about this ("Cannot convert type 'String' to 'T'"), even if the code shouldn't cause any logical errors runtime. Is there any way to achieve what I'm looking for? Casting doesn't help...

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

遇到 2024-10-25 07:07:51

好吧，您可以这样做：

public static T Foo<T>(string value)
{
    if (typeof(T) == typeof(String))
        return (T) (object) value;

    if (typeof(T) == typeof(int))
        return (T) (object) Int32.Parse(value);

    ...
}

这将涉及值类型的装箱，但它会起作用。

您确定这最好作为单一方法来完成，而不是（比如说）可以由不同转换器实现的通用接口？

或者，您可能需要一个像这样的 Dictionary ：

Dictionary<Type, Delegate> converters = new Dictionary<Type, Delegate>
{
    { typeof(string), new Func<string, string>(x => x) }
    { typeof(int), new Func<string, int>(x => int.Parse(x)) },
}

然后您可以像这样使用它：

public static T Foo<T>(string value)
{
    Delegate converter;
    if (converters.TryGetValue(typeof(T), out converter))
    {
        // We know the delegate will really be of the right type
        var strongConverter = (Func<string, T>) converter;
        return strongConverter(value);
    }
    // Oops... no such converter. Throw exception or whatever
}

Well, you can do this:

public static T Foo<T>(string value)
{
    if (typeof(T) == typeof(String))
        return (T) (object) value;

    if (typeof(T) == typeof(int))
        return (T) (object) Int32.Parse(value);

    ...
}

That will involve boxing for value types, but it will work.

Are you sure this is best done as a single method though, rather than (say) a generic interface which can be implemented by different converters?

Alternatively, you might want a Dictionary<Type, Delegate> like this:

Dictionary<Type, Delegate> converters = new Dictionary<Type, Delegate>
{
    { typeof(string), new Func<string, string>(x => x) }
    { typeof(int), new Func<string, int>(x => int.Parse(x)) },
}

then you'd use it like this:

public static T Foo<T>(string value)
{
    Delegate converter;
    if (converters.TryGetValue(typeof(T), out converter))
    {
        // We know the delegate will really be of the right type
        var strongConverter = (Func<string, T>) converter;
        return strongConverter(value);
    }
    // Oops... no such converter. Throw exception or whatever
}

回复收藏 0 原文

~没有更多了~