C# 从泛型函数内部调用正确的重载

我有以下代码，其中我试图从泛型函数内部访问右重载函数：

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: int
b: string
a: string
b : int int
a: int int
b: string string
a: string string

如果参数不匹配，则应调用（params object[]args）

对于实际使用，

A

是，而

A

是

WriteEvent

。

B

是一个具有许多（~1000）

B

s个复杂参数顺序的代码库。 我可以更改

b1

和

b2

<代码>bn（n~10）以便使工作更容易

a

的参数仅为本机类型，如

int、string、long

或

Guid

我能做些什么来实现它？

---

基本上，泛型方法调用的重载解析仍然发生在编译时，因此，除非存在泛型类型约束，否则泛型类型对于函数中的大多数内容都被视为

对象

如果需要不同的行为，则需要运行时重载解决方案。归档的一种方法是对应该使用一些重载的方法调用使用
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); }

publicvidb1（T）{a.a（（动态）T）；}
公共空间b2（T1，t2t2）{a.a（（动态）T1，（动态）T2）；}

但是，这将基本上忽略泛型类型：

假设你写信

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

publicsvoidb（inti）{Console.WriteLine（“b:int”）；b1（i）}

然后动态将忽略您明确指定的
对象
类型，仍然调用
a.a的
int
重载

另一种方法是反射，检查泛型类型并尝试调用匹配的方法重载。
在我的代码库中<代码>B继承A
。。但是这会让生活更简单吗？
a.a（t）
只能解析为
a（params object[]args）
，因为它是唯一与
t
调用匹配的签名。重载解析不是对泛型方法的每次可能调用都“重做”——泛型不是模板。有没有其他方法可以（轻松地）做到这一点采用
int a
变量还是
a
变量？若它总是接受
A
的对象，那个么您必须总是调用default方法。如果将
int a
重命名为
int i
，会发生什么情况？@AshishNegi：根据该名称提取接口和程序，和/或使用
dynamic
、代理（Castle DynamicProxy等）、代码重写（PostSharp等）、T4模板生成，或者只需滚动您自己的代码，通过反射您想要拦截/包装的方法来一次性生成代码。这一切都不是那么容易，但肯定会战胜体力劳动。
public void b(int i) { Console.WriteLine("b: int "); b1<object>(i); }