c# - 从通用函数内部调用正确的重载

Question

我有以下代码，我试图从通用函数内部访问正确的重载函数:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    class A 
    {
        public void a(int a) { Console.WriteLine("a: int"); }
        public void a(string a) { Console.WriteLine("a: string"); }
        public void a(int a, int b) { Console.WriteLine("a: int int"); }
        public void a(string a, string b) { Console.WriteLine("a: string string"); }
        public void a(params object[] args) { Console.WriteLine("a: object"); }
    }

    class B
    {
        A a;
        public B(A _a) { this.a = _a; }
        public void b1<T>(T t) { a.a(t); } 
        public void b2<T1, T2>(T1 t1, T2 t2) { a.a(t1, t2); }
        public void b(int i) { Console.WriteLine("b: int "); b1(i); }
        public void b(string i) { Console.WriteLine("b: string"); b1(i); }
        public void b(int i, int b) { Console.WriteLine("b : int int"); b2(i,b);}
        public void b(string i, string b) { Console.WriteLine("b: string string"); b2(i,b); }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            Console.WriteLine("Hello, world!");
            B b = new B(new A());
            b.b(1);
            b.b("1");
            b.b(1,2);
            b.b("1", "2");
        }
    }
}

输出:

Hello, world!
b: int 
a: object
b: string
a: object
b : int int
a: object
b: string string
a: object

预期输出:

Hello, world!
b: int 
a: int
b: string
a: string
b : int int
a: int int
b: string string
a: string string

如果参数不匹配，则应调用 public void a(params object[] args)。

对于现实世界的使用，A 是 EventSource a 是 WriteEvent。 B 是一个代码库，包含许多 (~1000) 个具有复杂参数顺序的 b。 我可以更改 b1 和 b2 .. bn (n ~ 10) 以简化工作。

a 的参数仅为原生类型，如 int、string、long 或 Guid。

我该怎么做才能实现它？ 我愿意接受任何其他实现解决方案的好方法。

Answer 1

基本上，泛型方法调用的重载决议仍然发生在编译时，因此除非存在泛型类型约束，否则泛型类型被认为是object 函数内部的大部分内容。

如果您想要不同的行为，则需要运行时重载解决方案。实现它的一种方法是对应该使用一些重载的方法调用使用 dynamic 类型:

public void b1<T>(T t) { a.a((dynamic)t); }
public void b2<T1, T2>(T1 t1, T2 t2) { a.a((dynamic)t1, (dynamic)t2); }

但是，这基本上会忽略泛型类型:

假设你写

public void b(int i) { Console.WriteLine("b: int "); b1<object>(i); }

然后动态将忽略您明确指定的 object 类型并仍然调用 a.a

的 int 重载

另一种方法是反射，检查泛型类型并尝试调用匹配的方法重载。