我知道Java通过擦除实现了参数多态性(泛型)。我明白什么是擦除。
我知道 C# 通过具体化实现了参数多态性。我知道这可以让你写作
public void dosomething(List<String> input) {}
public void dosomething(List<Int> input) {}
或者您可以在运行时知道某些参数化类型的类型参数是什么,但我不明白它是什么。
- 什么是物化类型?
- 什么是物化价值?
- 当类型/值被具体化时会发生什么?
我知道Java通过擦除实现了参数多态性(泛型)。我明白什么是擦除。
我知道 C# 通过具体化实现了参数多态性。我知道这可以让你写作
public void dosomething(List<String> input) {}
public void dosomething(List<Int> input) {}
或者您可以在运行时知道某些参数化类型的类型参数是什么,但我不明白它是什么。
物化是一个抽象的东西,创造一个具体的东西的过程。
C# 泛型中的术语具体化是指将泛型类型定义和一个或多个泛型类型参数(抽象事物)组合以创建新泛型类型(具体事物)的过程。
换一种说法,它是定义List<T>
并int
产生具体List<int>
类型的过程。
要进一步理解它,请比较以下方法:
在 Java 泛型中,泛型类型定义本质上被转换为一种在所有允许的类型参数组合中共享的具体泛型类型。因此,多个(源代码级别)类型被映射到一个(二进制级别)类型 - 但结果,有关实例类型参数的信息在该实例中被丢弃(类型擦除)。
在 C# 泛型中,泛型类型定义在运行时保存在内存中。每当需要一个新的具体类型时,运行时环境就会结合泛型类型定义和类型参数并创建新类型(具体化)。因此,我们在运行时为类型参数的每个组合获得了一个新类型。
System.Type
类自行执行具体化(即使您实例化的特定泛型类型参数组合没有' t 直接出现在您的源代码中)。在 C++ 模板中,模板定义在编译时保存在内存中。每当源代码中需要模板类型的新实例时,编译器就会结合模板定义和模板参数并创建新类型。所以我们在编译时为模板参数的每个组合获得了一个唯一的类型。
物化通常意味着(在计算机科学之外)“使某物成为现实”。
在编程中,如果我们能够在语言本身中访问有关它的信息,那么某些东西就会被具体化。
对于 C# 所做和未具体化的两个完全与泛型无关的示例,让我们来看看方法和内存访问。
OO 语言通常具有方法,(并且许多没有类似但未绑定到类的函数)。因此,您可以用这种语言定义一个方法,调用它,或者覆盖它,等等。并非所有此类语言都允许您将方法本身作为程序的数据实际处理。C#(实际上是 .NET 而不是 C#)确实允许您使用MethodInfo
表示方法的对象,因此在 C# 中方法被具体化。C# 中的方法是“第一类对象”。
所有实用语言都有一些访问计算机内存的方法。在像 C 这样的低级语言中,我们可以直接处理计算机使用的数字地址之间的映射,所以类似这样int* ptr = (int*) 0xA000000; *ptr = 42;
是合理的(只要我们有充分的理由怀疑0xA000000
以这种方式访问内存地址不会) t炸掉一些东西)。在 C# 中这是不合理的(我们可以在 .NET 中强制使用它,但是随着 .NET 内存管理的移动,它不太可能有用)。C# 没有具体化的内存地址。
因此,由于refied意味着“变得真实”,“具体类型”是我们可以用相关语言“谈论”的类型。
在泛型中,这意味着两件事。
一个是那List<string>
是一种string
类型int
。我们可以比较那个类型,得到它的名字,然后查询它:
Console.WriteLine(typeof(List<string>).FullName); // System.Collections.Generic.List`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
Console.WriteLine(typeof(List<string>) == (42).GetType()); // False
Console.WriteLine(typeof(List<string>) == Enumerable.Range(0, 1).Select(i => i.ToString()).ToList().GetType()); // True
Console.WriteLine(typeof(List<string>).GenericTypeArguments[0] == typeof(string)); // True
这样做的结果是我们可以在方法本身内“谈论”泛型方法(或泛型类的方法)参数的类型:
public static void DescribeType<T>(T element)
{
Console.WriteLine(typeof(T).FullName);
}
public static void Main()
{
DescribeType(42); // System.Int32
DescribeType(42L); // System.Int64
DescribeType(DateTime.UtcNow); // System.DateTime
}
通常,这样做太多是“臭”的,但它有很多有用的案例。例如,看:
public static TSource Min<TSource>(this IEnumerable<TSource> source)
{
if (source == null) throw Error.ArgumentNull("source");
Comparer<TSource> comparer = Comparer<TSource>.Default;
TSource value = default(TSource);
if (value == null)
{
using (IEnumerator<TSource> e = source.GetEnumerator())
{
do
{
if (!e.MoveNext()) return value;
value = e.Current;
} while (value == null);
while (e.MoveNext())
{
TSource x = e.Current;
if (x != null && comparer.Compare(x, value) < 0) value = x;
}
}
}
else
{
using (IEnumerator<TSource> e = source.GetEnumerator())
{
if (!e.MoveNext()) throw Error.NoElements();
value = e.Current;
while (e.MoveNext())
{
TSource x = e.Current;
if (comparer.Compare(x, value) < 0) value = x;
}
}
}
return value;
}
这不会TSource
对不同行为的类型和各种类型进行大量比较(通常表明您根本不应该使用泛型),但它确实在可能的类型的代码路径之间拆分null
(null
如果未找到元素,并且如果比较的元素之一是 ,则不得进行比较以找到最小值null
)和无法找到的类型的代码路径null
(如果未找到元素,则应抛出,并且不必担心null
元素的可能性)。
因为TSource
在方法中是“真实的”,所以这种比较可以在运行时或 jitting 时间进行(通常是 jitting 时间,当然上述情况会在 jitting 时间这样做,并且不会为未采用的路径生成机器代码),我们有一个每种情况下单独的“真实”版本的方法。(虽然作为一种优化,机器码是为不同的引用类型参数的不同方法共享的,因为它可以不影响这一点,因此我们可以减少机器码的数量)。
(在 C# 中谈论泛型类型的具体化并不常见,除非您还处理 Java,因为在 C# 中我们只是认为这种具体化是理所当然的;所有类型都被具体化。在 Java 中,非泛型类型被称为具体化,因为是它们和泛型类型之间的区别)。
正如duffymo 已经指出的那样,“具体化”并不是关键区别。
在 Java 中,泛型基本上是用来改进编译时支持的——它允许您在代码中使用强类型的例如集合,并为您处理类型安全。然而,这只存在于编译时——编译后的字节码不再有任何泛型的概念;所有泛型类型都转换为“具体”类型(object
如果泛型类型是无界的,则使用),根据需要添加类型转换和类型检查。
在 .NET 中,泛型是 CLR 的一个组成部分。编译泛型类型时,它在生成的 IL 中保持泛型。它不只是像在 Java 中那样转换为非通用代码。
这对泛型在实践中的工作方式有几个影响。例如:
SomeType<?>
允许您传递给定泛型类型的任何具体实现。C# 无法做到这一点 - 每个特定的(具体化的)泛型类型都是它自己的类型。object
. 在此类泛型中使用值类型时,这可能会对性能产生影响。在 C# 中,当您在泛型类型中使用值类型时,它仍然是值类型。举个例子,假设您有一个List
带有一个泛型参数的泛型类型。在 Java 中,List<String>
最终List<Int>
将在运行时成为完全相同的类型 - 泛型类型仅在编译时代码中真正存在。所有对 eg 的调用都GetValue
将分别转换为(String)GetValue
和(Int)GetValue
。
在 C# 中,List<string>
和List<int>
是两种不同的类型。它们不可互换,并且它们的类型安全性也在运行时强制执行。无论您做什么,new List<int>().Add("SomeString")
都将永远无法工作-底层存储实际上是List<int>
一些整数数组,而在Java中,它必然是一个数组。在 C# 中,不涉及强制转换,没有装箱等。object
这也应该清楚为什么 C# 不能用SomeType<?>
. 在 Java 中,所有“派生自”的泛型类型SomeType<?>
最终都是完全相同的类型。在 C# 中,所有各种特定SomeType<T>
的 s 都是它们自己独立的类型。删除编译时检查,可以通过SomeType<Int>
而不是SomeType<String>
(实际上,这SomeType<?>
意味着“忽略给定泛型类型的编译时检查”)。在 C# 中,这是不可能的,甚至对于派生类型也不行(也就是说,List<object> list = (List<object>)new List<string>();
即使string
派生自也不能这样做object
)。
两种实现都有其优点和缺点。有几次我很想SomeType<?>
在 C# 中只允许作为参数 - 但 C# 泛型的工作方式根本没有意义。
Reification 是一个面向对象的建模概念。
Reify 是一个动词,意思是“使抽象的东西成为现实”。
当您进行面向对象编程时,通常将现实世界的对象建模为软件组件(例如窗口、按钮、人、银行、车辆等)。
将抽象概念具体化为组件也很常见(例如 WindowListener、Broker 等)