如何允许方法接受字符串或整数?

发布于 2024-10-16 07:04:14 字数 57 浏览 1 评论 0原文

使用 C# 4.0,有没有办法允许方法(不创建重载)接受字符串或 int,然后允许我检测传入的类型?

Using C# 4.0, is there a way to allow a method (without creating an overload) to accept a string or an int and then allow me to detect what type was passed in?

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

扫码二维码加入Web技术交流群

发布评论

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

评论(4

浪荡不羁 2024-10-23 07:04:14

由于您使用的是 C# 4.0,因此您可以编写通用方法。例如:

void MyMethod<T>(T param)
{
    if (typeof(T) == typeof(int))
    {
        // the object is an int
    }
    else if (typeof(T) == typeof(string))
    {
        // the object is a string
    }
}

但是你应该非常认真地考虑这是否是一个好主意。上面的例子有点代码味道。事实上,泛型的全部意义就是泛型。如果您必须根据传入对象的类型对代码进行特殊处理,则表明您应该使用重载。这样,每个方法重载都会处理其独特的情况。我无法想象这样做有什么缺点。

Since you're using C# 4.0, you can write a generic method. For example:

void MyMethod<T>(T param)
{
    if (typeof(T) == typeof(int))
    {
        // the object is an int
    }
    else if (typeof(T) == typeof(string))
    {
        // the object is a string
    }
}

But you should very seriously consider whether or not this is a good idea. The above example is a bit of a code smell. In fact, the whole point of generics is to be generic. If you have to special-case your code depending on the type of the object passed in, that's a sign you should be using overloading instead. That way, each method overload handles its unique case. I can't imagine any disadvantage to doing so.

分开我的手 2024-10-23 07:04:14

当然可以!一个例子是

    public void MyMethod(object o)
    {
        if (o.GetType() == typeof(string))
        {
            //Do something if string
        }
        else if (o.GetType() == typeof(int))
        {
            // Do something else
        }
    }

Sure you can! An example of this is

    public void MyMethod(object o)
    {
        if (o.GetType() == typeof(string))
        {
            //Do something if string
        }
        else if (o.GetType() == typeof(int))
        {
            // Do something else
        }
    }
清浅ˋ旧时光 2024-10-23 07:04:14

您可以将 stringint 包装在带有标记接口的包装器中,并将它们传递给方法。

像这样的东西

interface IMyWrapper<T> { T Value {get; }}
public class StringWrapper: IMyWrapper<string> { ... }
public class IntWrapper: IMyWrapper<int> { ... }

void MyMethod<T>(IMyWrapper<T> wrapper)
{
}

You can wrap string and int in some wrapper with marker interface and pass them to a method.

Something like this

interface IMyWrapper<T> { T Value {get; }}
public class StringWrapper: IMyWrapper<string> { ... }
public class IntWrapper: IMyWrapper<int> { ... }

void MyMethod<T>(IMyWrapper<T> wrapper)
{
}
乞讨 2024-10-23 07:04:14

如果您想远离反射或检查类型之类的东西,我认为方法重载将是一个简单的解决方案。

public void MethodName(string foo)
{
     int bar = 0;
     if(int.tryparse(foo))
        return MethodName(bar);//calls int overload
}

I would think a method overload would be a straightforward solution, if you want to stay away from stuff like reflection or checking types.

public void MethodName(string foo)
{
     int bar = 0;
     if(int.tryparse(foo))
        return MethodName(bar);//calls int overload
}
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文