I have this function
public static T2 MyFunc<T1, T2>( T1 a, T1 b, T2 c)
{
return c;
}
class Person
{ }
Person p = new Person();
Person p2 = new Person();
我正在使用以下内容调用该函数：
MyClass.MyFunc(p, p2, 5);
我的问题是：
到底是谁决定了T1类型？（p？p2？）
因为如果左边是苹果，那么他会检查第二个是否也是苹果。
如果第二个是橙子，则他应该检查第一个是否也是橙子。
这似乎有些奇怪，因为在编译时，如果不相同，它们将失败。
但是，到底是谁决定了类型呢？
其次，如果我将其更改为动态类型-在运行时-谁会决定T1类型应该是什么？
在较高层次上，方法类型推断的工作方式如下。
首先，我们列出所有的参数 -- 您提供的表达式 -- 以及它们对应的形式参数类型。
让我们看一个比你提供的更有趣的例子。 假设我们有：
class Person {}
class Employee : Person {}
...
Person p = whatever;
Employee p2 = whatever;
并且进行相同的调用。因此我们建立对应关系：
p --> T1
p2 --> T1
5 --> T2
然后我们列出每个类型参数的“边界”以及它们是否“固定”。我们有两个类型参数，并且一开始没有上限、下限或确切的边界。
T1: (unfixed) upper { } lower { } exact { }
T2: (unfixed) upper { } lower { } exact { }
然后我们看每个参数及其相应的类型。(如果参数是lambda表达式，则我们可能需要确定查看参数的顺序，但是你没有任何lambda表达式，因此让我们忽略该细节) 对于每个参数，我们对形式参数类型进行推导，并将我们推导出的关于该推导的事实添加到界限集合中。因此，在查看第一个参数之后，我们推导出以下界限：
T1: (unfixed) upper { } lower { Person } exact { }
T2: (unfixed) upper { } lower { } exact { }
T1: (unfixed) upper { } lower { Person, Employee } exact { }
T2: (unfixed) upper { } lower { } exact { }
在第三个参数之后，我们推断出边界：
T1: (unfixed) upper { } lower { Person, Employee } exact { }
T2: (unfixed) upper { } lower { int } exact { }
Person和Employee。是否有一个类型能够满足边界集中的所有边界条件呢？是的。Employee不能满足Person的边界条件，因为Employee是比Person更小的类型；Person是一个下边界——它表示没有比Person更小的类型是合法的。 Person可以满足所有的边界条件：Person与Person相同，并且比Employee大，因此它同时满足这两个边界条件。对于T1，满足所有边界条件的最佳类型是Person，而对于T2，显然是int，因为在边界集中只有一种类型。因此，我们接下来修复类型参数。T1: (fixed) Person
T2: (fixed) int
我们问： "对于每个类型参数，我们是否有一个固定的边界？"
如果我将第一个参数的类型更改为
dynamic，那么T1是如何被推断出来的？
如果任何一个参数是动态的，那么T1和T2的推断会被推迟到运行时，此时语义分析器会将值的最具体可访问运行时类型视为动态参数提供的下限所需的类型。
如果您对此主题感兴趣并希望了解更多信息，可以在这里找到我解释C# 3版本算法的视频:
http://blogs.msdn.com/b/ericlippert/archive/2006/11/17/a-face-made-for-email-part-three.aspx
(C# 3没有上限，只有下限和精确边界；除此之外，算法基本相同。)
我写的有关类型推断问题的文章在这里：
http://blogs.msdn.com/b/ericlippert/archive/tags/type+inference/
MyClass.MyFunc(p1, p2, 5);
这是一种语法糖（除非您使用匿名类型），它编译后与原文完全相同。
MyClass.MyFunc<Person, int>(p1, p2, 5);
p1 == p2。它检查的是 typeof(p1) == typeof(p2)。 - Ilya Koganp1 和 p2 是不同类型，它仍然可以编译。 - svick没有优先级，a和b应该是相同的，这是设计上的考虑，T1在编译时解决。如果你改成dynamic，你只是将类型解析推迟到运行时，如果类型不同，则会在运行时而不是编译时失败。如果你想让它们不同，你需要引入T3。
编辑：
有趣的部分：
Orange a = new Orange();
Apple b = new Apple();
string c = "Doh.";
MyFunc<dynamic, string>(a,b,c);
public static T2 MyFunc<T1, T2>( T1 a, T1 b, T2 c) where T2 : class
{
return (a.ToString() + b.ToString() + c.ToString()) as T2;
}
输出：
I am an orange. I am an apple. Doh.
dynamic a = new Orange();
dynamic b = new Apple();
string c = "Doh.";
MyFunc<Apple, string>(a,b,c);
会抛出以下异常：
RuntimeBinderException: The best overloaded method match for 'UserQuery.MyFunc<UserQuery.Apple,string>(UserQuery.Apple, UserQuery.Apple, string)' has some invalid arguments
然而，似乎我确实需要找一本关于C# 4.0动态类型的好书或资源，以理解这里发生的魔法。
MyFunc(new { p = "p" }, new { p = "p2" }, 5)无法重写以明确指定类型。谁实际上决定了T1类型？（p？p2？）
通常，C#编译器会决定这个。如果方法参数中有一个是动态的，则在运行时（由Microsoft.CSharp库）进行决策。
在这两种情况下，都应用了C#规范中描述的类型推断算法：
将p和p2的类型都添加到T1的下限集合中（也可能是上限，但仅当涉及逆变泛型时）。
p和p2具有相同的类型，所以这个选择是微不足道的。
否则（假设只涉及下限），这意味着编译器选择一种类型，以便所有其他候选类型都可以隐式转换为该类型（svick的答案描述了这一点）。在编译时，如果类型是明确的，则编译器将检查传递的参数类型，并查看它们是否对应并可以匹配到泛型中的类型（无冲突）。
无论如何，真正的检查是在“运行时”进行的。泛型代码将始终作为泛型编译（不像C++模板）。然后，当JIT编译器编译该行时，它将检查并查看是否可以根据您提供的模板和发送的参数创建方法。
MyFunc(p1, "", 5)或者MyFunc("", p2, 5)。 - H H