/// <summary>
/// 返回 <paramref name="inputType"/> 类型和 <paramref name="outputType"/> 类型之间的标准转换类型。
/// </summary>
/// <param name="inputType">要转换的对象的类型。</param>
/// <param name="outputType">要将输入对象转换到的类型。</param>
/// <returns><paramref name="inputType"/> 类型和 <paramref name="outputType"/> 类型之间的标准转换类型。</returns>
/// <remarks><para>这里标准转换指标准显式转换，包含了所有预定义隐式转换和预定义显式转换的子集，
/// 该子集是预定义隐式转换反向的转换。也就是说，如果存在从 A 类型到 B 类型的预定义隐式转换，
/// 那么 A 类型和 B 类型之间存在标准转换（A 到 B 或 B 到 A）。</para>
/// <para>如果不存在标准类型转换，则总是返回 <see cref="ConversionType.None"/>，即使存在其它的类型转换。</para>
/// </remarks>
internal static ConversionType GetStandardConversion(Type inputType, Type outputType)
{
Contract.Requires(inputType != null && outputType != null);
if (inputType == typeof(void) || outputType == typeof(void))
{
return(ConversionType.None);
}
return(ConversionFactory.GetStandardConversion(inputType, outputType));
}
/// <summary>
/// 返回 <paramref name="types"/> 中能够被其它所有类型包含的类型。
/// </summary>
/// <param name="types">类型集合。</param>
/// <returns><paramref name="types"/> 中能够被其它所有类型包含的类型，如果不存在则为 <c>null</c>。</returns>
/// <exception cref="ArgumentNullException"><paramref name="types"/> 为 <c>null</c>。</exception>
/// <remarks>若 A 类型可以隐式类型转换（指预定义的类型转换）为 B 类型，那么就称 A 被 B 包含，而 B 包含 A。</remarks>
public static Type GetEncompassedType(IEnumerable <Type> types)
{
if (types == null)
{
throw CommonExceptions.ArgumentNull("types");
}
Contract.EndContractBlock();
Type encompassedType = null;
foreach (Type type in types)
{
if (type == null)
{
continue;
}
if (encompassedType == null)
{
encompassedType = type;
}
else if (encompassedType != type)
{
// 这里剔除 void 类型，但若 types 全部是 void，能够使得结果是 void。
if (encompassedType == typeof(void))
{
encompassedType = type;
}
else if (type != typeof(void))
{
ConversionType convType = ConversionFactory.GetStandardConversion(encompassedType, type);
if (convType == ConversionType.None)
{
return(null);
}
if (convType.IsExplicit())
{
encompassedType = type;
}
}
}
}
return(encompassedType);
}