. Terminología de genéricos .NET - abierta/cerrada, sin consolidar/construida

Question

. La terminología de genéricos .NET es un poco ambigua. Peor aún, parece que se usa de manera ambigua y diferente en diferentes fuentes. Lo que básicamente no está claro es relaciones entre estos 4 términos (en relación con el "Tipo"):

1. abiertas
2. cerrado
3. no unido
4. construida

entiendo que List<T> es abrir y List<int> está cerrado. Pero, ¿qué es realmente "construido" y "sin consolidar" en relación con los tipos abiertos/cerrados?

Answer 1

Desde el language specification:

4,4 tipos construidos

una declaración de tipo genérico, por sí mismo, denota un no unido tipo genérico que se usa como un “plano” para formar muchos diferentes tipos, mediante la aplicación de escriba argumentos. Los argumentos de tipo son escritos entre paréntesis angulares (< y>) inmediatamente después del nombre del tipo genérico. Un tipo que incluye al menos un argumento de tipo se llama tipo construido. Un tipo construido se puede utilizar en la mayoría de los lugares en el idioma en el que aparece un nombre de tipo . Un tipo genérico no vinculado puede usarse solo dentro de un tipo de expresión (§7.6.11). [...]

4.4.2 abiertos y cerrados tipos

Todos los modelos se pueden clasificar como tipos abiertos o tipos cerrados. Un tipo abierto es un tipo que implica los parámetros del tipo . Más específicamente:

• Un parámetro de tipo define un tipo abierto.

• Un tipo de matriz es un tipo abierto if y solo si su tipo de elemento es un tipo abierto .

• Un tipo construido es un tipo abierto si y solo si uno o más de sus argumentos de tipo es un tipo abierto. Un tipo anidado construido es un tipo abierto si y solo si uno o más de sus argumentos de tipo o los argumentos de tipo de su tipo (s) contiene un tipo abierto .

Un tipo cerrado es un tipo que es no es un tipo abierto. [...]

4.4.3 tipos unido y no unido

El término tipo no unido se refiere a un no genérico tipo o un tipo genérico no unido. El término tipo vinculado se refiere a un tipo no genérico o un tipo construido. Un tipo sin consolidar se refiere a la entidad declarada por una declaración de tipo. Un tipo genérico no vinculado no es en sí mismo un tipo, y no se puede utilizar como el tipo de una variable, argumento o valor de retorno , o como un tipo base. El único constructo en el que se puede hacer referencia a un tipo genérico no vinculado es el tipo de expresión (§7.6.11).

---

He aquí un ejemplo pensé:

// Foo<T> is an unbound generic type. 
class Foo<T> { .. } 

// Bar<K> is an unbound generic type. 
// Its base-class Foo<K> is a constructed, open generic type. 
class Bar<K> : Foo<K> { .. } 

// IntFoo is not a generic type. 
// Its base-class Foo<int> is a constructed, closed generic type. 
class IntFoo : Foo<int> { .. } 

---

Y aquí es un intento de atar que con la API de reflexión, utilizando las propiedades relevantes: IsGenericType, IsGenericTypeDefinition y ContainsGenericParameters

(Estas pruebas no son 100% predictivas de cada "tipo" según la especificación del idioma)

+----------+---------------------+-----------+--------------+-------------------+ 
| Name |  Kind   | IsGenType | IsGenTypeDef | ContainsGenParams | 
+----------+---------------------+-----------+--------------+-------------------+ 
| Foo<> | Unbound    | TRUE  | TRUE   | TRUE    | 
| Foo<>* | Constructed, open | TRUE  | FALSE  | TRUE    | 
| Foo<int> | Constructed, closed | TRUE  | FALSE  | FALSE    | 
| IntFoo | Not generic   | FALSE  | FALSE  | FALSE    | 
+----------+---------------------+-----------+--------------+-------------------+ 
* = Bar<>'s base type.