泛型参数转换的问题

泛型不一样参数类型生成的对象是相互独立的。

//如
Tuple<string> ts;
Tuple<object> to;
//ts to 是两个类型的对象。

不少时候，咱们但愿实现 to = ts 这种操做，为何？由于看上去它应该如此。

为了达到这个目的，就要解决“泛型参数转换的问题”，这个问题的知识点是in out 泛型变体。老实说，这个问题自己不困难，只是很是不直观，很容易让人忘记。

首先一点，为了实现to = ts，其实是有前提的，那就是该参数只能用在“返回类型”上。

//如
delegate object FuncObj();

FuncObj func = ()=>"string";

func之因此成功，就是由于string 能够转换成 object。当“用户”调用func,但愿获得的是object对象，而string也是object对象，因此没有任何问题。

这里的关键是学会采用"用户"的视角分析问题。

//A
delegate void FuncObj2(object obj);
FuncObj2 func2 = (string str)=>{};
//B
delegate void FuncStr(string str);
FuncStr func3 = (object obj)=>{};

分析这两组代码，哪个更加合理？

在用户角度，它使用的是func2 和 func3

用户使用func2,传递的对象必然是object，但实际处理的函数是(string)=>{},object是没法转换成string的，因此很不合理。

用户使用func3，传递的对象只能是string,而实际处理的函数是(object)=>{},string 是能够转换成object的，因此是合理的。

固然这两组代码都是不成立的，由于函数参数类型不匹配。

可是泛型提供了一个方法，让类型不匹配的对象之间可以隐式转换！它实现的逻辑就是上面分析的。

//out 修饰返回类型
delegate ResultType FuncOut<out ResultType>();
//in 修饰参数类型
delegate void FuncIn<in ParamType>(ParamType param);

//这是一开始咱们想作到的目标
FuncOut<object> fun4 = () => "string";
//这个效果刚好相反
FuncIn<object> funcobj = (object obj) => { };
FuncIn<string> fun5 = funcobj;

//注意，泛型变体通常只能和泛型变体之间隐式转换
//lambda表达式会自动转换成参数相同的泛型变体，但没法接着作变体之间的隐式转换，因此须要funcobj来过渡

out修饰返回类型，in修饰参数类型，仍是挺形象的，可是要注意泛型in参数，和out参数正好相反。

开始咱们想实现 to = ts，只是看到问题的一半，实际上泛型是存在 ts = to的可能性的，但愿读者能理解这一点。

总结：

out : to = ts;

in : ts = to;

没有修饰：to，ts彻底独立。

---------------------------（备注）-------------------------------
out 参数：只能用在返回类型。

in 参数：只能用在参数。

没有修饰：任意位置。

---------------------------（备注2）------------------------------

in、out泛型参数只能用在委托和接口上面。

//综合运用
delegate ResultType FuncInOut<in ParamType, out ResultType>(ParamType param);

FuncInOut<object, string> funcobj2 = (object obj) => "string";
            
FuncInOut<string, object> func6 = funcobj2;