2

如果我们在传递给下面的重载方法之前将其转换为“Object”，则 Int32 类型的变量不会被威胁为 Int32：

public static void MethodName(int a)
{
    Console.WriteLine("int");
}

public static void MethodName(object a)
{
    Console.ReadLine();
}

将其作为 Int32 处理，即使它被转换为“Object”也可以通过反射来实现：

public static void MethodName(object a)
{
    if(a.GetType() == typeof(int))
    {
        Console.WriteLine("int");
    }
    else
    {
        Console.ReadLine();
    }
}

还有另一种方法吗？也许使用泛型？

4

8 回答 8

10

运行时重载解析直到 C# 4.0 才可用，它具有dynamic：

public class Bar
{
    public void Foo(int x)
    {
        Console.WriteLine("int");
    }

    public void Foo(string x)
    {
        Console.WriteLine("string");
    }

    public void Foo(object x)
    {
        Console.WriteLine("dunno");
    }

    public void DynamicFoo(object x)
    {
        ((dynamic)this).Foo(x);
    }
}

object a = 5;
object b = "hi";
object c = 2.1;

Bar bar = new Bar();
bar.DynamicFoo(a);
bar.DynamicFoo(b);
bar.DynamicFoo(c);

转换this为dynamic启用动态重载支持，因此包装器方法能够根据参数的运行时类型DynamicFoo调用最合适的重载。Foo

于 2009-02-04T20:38:48.940 回答
8 
public static void MethodName(object a)
{
        if(a is int)
        {
                Console.WriteLine("int");
        }
        else
        {
                Console.WriteLine("object");
        }
}
于 2009-02-04T19:49:53.797 回答
3

不，调用的方法的特定重载是在编译时确定的，而不是在运行时确定的，除非您使用反射，因此如果您将 int 转换为对象，则将调用对象重载。我不相信有任何其他方法可以做到这一点，而且泛型也不会为你做到这一点。

于 2009-02-04T19:51:52.653 回答
3

这行不通吗？

void MethodName<T>(object a){
    T item = a as T;
    // treat in the manner you require
}

MethodName<object>(1);
MethodName<Int32>(1);
于 2009-02-04T20:00:57.957 回答
2

也许：

public static void MethodName(Type t)
{
     Console.WriteLine(t.Name);
}

然后调用它：

int a = 0;
string b = "";
object c = new object();
MethodName(a.GetType());
MethodName(b.GetType());
MethodName(c.GetType());

或者：

public static void MethodName<T>(T a)
{
    Console.WriteLine(a.GetType().Name);
}

最后：

public static void MethodName<T>()
{
    Console.WriteLine(typeof(T).Name);
}

更新：
归根结底，语言必须能够以某种方式确定您将在编译时处理的类型。

于 2009-02-04T19:54:58.217 回答
1

如果你想打开类型，你几乎会被 if/else 结构所困扰。由于多态性，switch 语句本身将不起作用。如果您使用的是非原始对象，则通常可以使用多态性或接口来完成这种行为，例如：

public static void MethodName(MyBaseObject obj)
{
     Console.WriteLine(obj.MyVirtualFunctionCall());
}
于 2009-02-04T19:51:17.897 回答
1

在 .NET 3.5 之前，动态重载是一个问题，但在 .NET 4 中，它非常可行，只需几行代码。

   public void publish(dynamic queue)
     {
         publish(queue);
         Console.WriteLine("dynamic queue publishing");
     }

     public void publish(ValidationQueue queue)
     {
         Console.WriteLine("Validation queue publishing");
     }

怎么打电话

     foreach (var queue in  _vodaQueueDAO.FetchAllReadyQueuesWithHighestPriority())
        {
            PublishingService.publish(queue);
        }
于 2011-11-11T05:45:13.050 回答
0

我为 .NET 3.5 编写了一个实现，您可以在其中执行以下操作：

object a = 5;

OverloadResolver.Invoke(MethodName, a);

它会使用 int 重载。

适用于编译和缓存的 Lambda 表达式，因此性能应该没问题。

如果有人需要，请给我发邮件，herzmeisterderwelten，他住在 gmail.com

于 2009-04-14T16:29:15.447 回答