blocks|key|320717|text|C#语言将开放类型定义为类型参数或使用未知类型参数定义的泛型类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|320718|320719|所有类型都可以分为开放类型和封闭类型。开放类型是一种涉及类型参数的类型。更确切地说：|blockquote|320720|320721|320722|320723|类型参数定义开放类型。|unordered-list-item|320724|当且仅当数组类型的元素类型是开放类型时，数组类型才是开放类型。|320725|构造的类型当且仅当其一个或多个类型参数是开放类型时，才是开放类型。当且仅当构造的嵌套类型的一个或多个类型参数或其包含类型的类型参数是开放类型时，该构造的嵌套类型才是开放类型。|320726|320727|闭合类型是指不是开放类型的类型。|320728|因此，T、List<T>、Dictionary<string,T>和Dictionary<T,U>都是开放类型(T和U是类型参数)，而List<int>和Dictionary<string,int>是封闭类型。|offset|length|style|CODE|320729|有一个相关的概念:未绑定的泛型类型是具有未指定类型参数的泛型类型。非绑定类型不能用在typeof()以外的表达式中，也不能实例化它或调用它的方法。例如，List<>和Dictionary<,>是未绑定的类型。|320730|要澄清开放类型和未绑定类型之间的细微区别：|320731|class+Program+{
+++static+void+Main()+{+Test<int>();+}
+++static+void+Test<T>()+{
++++++Console.WriteLine(typeof(List<T>));+//+Print+out+the+type+name
+++}
}|code-block|syntax|javascript|320732|如果您运行此代码段，它将打印出来|320733|System.Collections.Generic.List`1[System.Int32]|320734|这是List<int>的CLR名称。很明显，在运行时，类型参数是System.Int32。这使得List<T>成为绑定的开放类型。|320735|在运行时，可以使用反射将类型参数绑定到具有Type.MakeGenericType+method的未绑定泛型类型的未指定类型参数|320736|Type+unboundGenericList+=+typeof(List<>);
Type+listOfInt+=+unboundGenericList.MakeGenericType(typeof(int));
if+(listOfInt+==+typeof(List<int>))
+++++Console.WriteLine("Constructed+a+List<int>+type.");|320737|可以检查类型是否是未绑定的泛型类型(泛型类型定义)，通过该类型可以使用Type.IsGenericTypeDefinition+property构造绑定类型|320738|Console.WriteLine(typeof(Dictionary<,>).IsGenericTypeDefinition);+//+True
Console.WriteLine(typeof(Dictionary<int,int>).IsGenericTypeDefinition);+//+False|320739|要在运行时从构造的类型中获取未绑定的类型，可以使用Type.GetGenericTypeDefinition+method。|320740|Type+listOfInt+=+typeof(List<int>);
Type+list+=+listOfInt.GetGenericTypeDefinition();+//+==+typeof(List<>)|320741|请注意，对于泛型类型，可以有一个完全未绑定的类型定义，也可以有一个完全绑定的定义。您不能绑定某些类型参数，而不绑定其他类型参数。例如，您不能使用Dictionary<int,>或Dictionary<,string>。|320742|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.type.makegenerictype.aspx|1|http://msdn.microsoft.com/en-us/library/system.type.isgenerictypedefinition.aspx|2|http://msdn.microsoft.com/en-us/library/system.type.getgenerictypedefinition.aspx^0|0|0|0|0|0|0|0|0|0|0|0|3|1|5|7|D|K|Y|F|1K|1|1M|1|1V|9|25|M|0|16|8|24|6|2B|D|0|0|0|0|0|2|9|W|C|1C|7|0|L|K|L|R|0|0|0|Z|S|Z|11|1|0|0|P|T|P|10|2|0|0|20|G|2H|J|0^^$0|@$1|2|3|4|5|6|7|23|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|25|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|26|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|28|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|29|8|@]|9|@]|A|$]]|$1|L|3|M|5|K|7|2A|8|@]|9|@]|A|$]]|$1|N|3|O|5|K|7|2B|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2D|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|2E|8|@$U|2F|V|2G|W|X]|$U|2H|V|2I|W|X]|$U|2J|V|2K|W|X]|$U|2L|V|2M|W|X]|$U|2N|V|2O|W|X]|$U|2P|V|2Q|W|X]|$U|2R|V|2S|W|X]|$U|2T|V|2U|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2V|8|@$U|2W|V|2X|W|X]|$U|2Y|V|2Z|W|X]|$U|30|V|31|W|X]]|9|@]|A|$]]|$1|10|3|11|5|6|7|32|8|@]|9|@]|A|$]]|$1|12|3|13|5|14|7|33|8|@]|9|@]|A|$15|16]]|$1|17|3|18|5|6|7|34|8|@]|9|@]|A|$]]|$1|19|3|1A|5|14|7|35|8|@]|9|@]|A|$15|16]]|$1|1B|3|1C|5|6|7|36|8|@$U|37|V|38|W|X]|$U|39|V|3A|W|X]|$U|3B|V|3C|W|X]]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|3D|8|@$U|3E|V|3F|W|X]]|9|@$U|3G|V|3H|1|3I]]|A|$]]|$1|1F|3|1G|5|14|7|3J|8|@]|9|@]|A|$15|16]]|$1|1H|3|1I|5|6|7|3K|8|@$U|3L|V|3M|W|X]]|9|@$U|3N|V|3O|1|3P]]|A|$]]|$1|1J|3|1K|5|14|7|3Q|8|@]|9|@]|A|$15|16]]|$1|1L|3|1M|5|6|7|3R|8|@$U|3S|V|3T|W|X]]|9|@$U|3U|V|3V|1|3W]]|A|$]]|$1|1N|3|1O|5|14|7|3X|8|@]|9|@]|A|$15|16]]|$1|1P|3|1Q|5|6|7|3Y|8|@$U|3Z|V|40|W|X]|$U|41|V|42|W|X]]|9|@]|A|$]]|$1|1R|3|-4|5|6|7|43|8|@]|9|@]|A|$]]]|1S|$1T|$5|1U|1V|1W|A|$1X|1Y]]|1Z|$5|1U|1V|1W|A|$1X|20]]|21|$5|1U|1V|1W|A|$1X|22]]]]

The C# language defines an open type to be a type that's either a type argument or a generic type defined with unknown type arguments:
<blockquote>
All types can be classified as either open types or closed types. An open type is a type that involves type parameters. More specifically:
<ul>
<li>A type parameter defines an open type.</li>
<li>An array type is an open type if and only if its element type is an open type.</li>
<li>A constructed type is an open type if and only if one or more of its type arguments is an open type. A constructed nested type is an open type if and only if one or more of its type arguments or the type arguments of its containing type(s) is an open type.</li>
</ul>
A closed type is a type that is not an open type.
</blockquote>
Therefore <code>T</code>, <code>List&lt;T&gt;</code>, and <code>Dictionary&lt;string,T&gt;</code>, and <code>Dictionary&lt;T,U&gt;</code> are all open types (<code>T</code> and <code>U</code> are type arguments) whereas <code>List&lt;int&gt;</code> and <code>Dictionary&lt;string,int&gt;</code> are closed types.
There's a related concept: An unbound generic type is a generic type with unspecified type arguments. An unbound type can't be used in expressions other than <code>typeof()</code> and you can't instantiate it or call its methods. For instance, <code>List&lt;&gt;</code> and <code>Dictionary&lt;,&gt;</code> are unbound types.
To clarify the subtle distinction between an open type and an unbound type:
<pre><code>class Program {
 static void Main() { Test&lt;int&gt;(); }
 static void Test&lt;T&gt;() {
 Console.WriteLine(typeof(List&lt;T&gt;)); // Print out the type name
 }
}
</code></pre>
If you run this snippet, it'll print out
<pre><code>System.Collections.Generic.List`1[System.Int32]
</code></pre>
which is the CLR name for <code>List&lt;int&gt;</code>. It's clear at runtime that the type argument is <code>System.Int32</code>. This makes <code>List&lt;T&gt;</code> a bound open type.
At runtime, you can use reflection to bind type arguments to unspecified type parameters of unbound generic types with the <a href="http://msdn.microsoft.com/en-us/library/system.type.makegenerictype.aspx" rel="noreferrer"><code>Type.MakeGenericType</code> method</a>:
<pre><code>Type unboundGenericList = typeof(List&lt;&gt;);
Type listOfInt = unboundGenericList.MakeGenericType(typeof(int));
if (listOfInt == typeof(List&lt;int&gt;))
 Console.WriteLine(&quot;Constructed a List&lt;int&gt; type.&quot;);
</code></pre>
You can check whether a type is an unbound generic type (generic type definition) from which you can construct bound types with the <a href="http://msdn.microsoft.com/en-us/library/system.type.isgenerictypedefinition.aspx" rel="noreferrer"><code>Type.IsGenericTypeDefinition</code> property</a>:
<pre><code>Console.WriteLine(typeof(Dictionary&lt;,&gt;).IsGenericTypeDefinition); // True
Console.WriteLine(typeof(Dictionary&lt;int,int&gt;).IsGenericTypeDefinition); // False
</code></pre>
To get the unbound type from a constructed type at runtime, you can use the <a href="http://msdn.microsoft.com/en-us/library/system.type.getgenerictypedefinition.aspx" rel="noreferrer"><code>Type.GetGenericTypeDefinition</code> method</a>.
<pre><code>Type listOfInt = typeof(List&lt;int&gt;);
Type list = listOfInt.GetGenericTypeDefinition(); // == typeof(List&lt;&gt;)
</code></pre>
Note that for a generic type, you can either have a completely unbound type definition, or a completely bound definition. You can't bind some type parameters and leave others unbound. For instance, you can't have <code>Dictionary&lt;int,&gt;</code> or <code>Dictionary&lt;,string&gt;</code>.

blocks|key|317879|text|“开放泛型类型”只是还没有指定其类型的泛型类型(例如，CargoCrate<T>)。一旦指定了具体的类型(例如CargoCrate<Widget>)，它就会变成“关闭的”。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|317880|例如，假设你有这样的东西：|317881|public+class+Basket<T>+{
++T[]+basketItems;
}

public+class+PicnicBlanket<T>+{
++Basket<T>+picnicBasket;+++//+Open+type+here.+We+don't+know+what+T+is.
}

+++++++++++++++++++++++++++++++++//+Closed+type+here:+T+is+Food.
public+class+ParkPicnicBlanket+:+PicnicBlanket<Food>+{
}|code-block|syntax|javascript|317882|这里，picnicBasket的类型是开放的:还没有任何东西被赋值给T，当你用特定的类型创建一个具体的PicnicBlanket时--例如，通过编写PicnicBlanket<Food>+p+=+new+PicnicBlanket<Food>()+--我们现在称它为closed。|317883|entityMap^0|R|D|1J|I|0|0|0|3|C|Y|1|22|1D|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

An "open generic type" is just a generic type that doesn't yet have its type specified (e.g., <code>CargoCrate&lt;T&gt;</code>). It becomes "closed" once a concrete type has been assigned (e.g. <code>CargoCrate&lt;Widget&gt;</code>).

For example, say you have something like this:

<pre><code>public class Basket&lt;T&gt; {
 T[] basketItems;
}

public class PicnicBlanket&lt;T&gt; {
 Basket&lt;T&gt; picnicBasket; // Open type here. We don't know what T is.
}

 // Closed type here: T is Food.
public class ParkPicnicBlanket : PicnicBlanket&lt;Food&gt; {
}
</code></pre>

Here, <code>picnicBasket</code>'s type is open: nothing's yet been assigned to <code>T</code>. When you make a concrete PicnicBlanket with a specific type -- for example, by writing <code>PicnicBlanket&lt;Food&gt; p = new PicnicBlanket&lt;Food&gt;()</code> -- we now call it closed.

blocks|key|320764|text|只是补充一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|320765|Dictionary<string,+T>+(或者更准确地说，Dictionary<string,>)仍然是一种开放类型。|offset|length|style|CODE|320766|示例：|320767|void+Foo<T>(Dictionary<string,T>+dic)+{+...+}|code-block|syntax|javascript|320768|entityMap^0|0|0|L|V|J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Just to add:

<code>Dictionary&lt;string, T&gt;</code> (or more precisely <code>Dictionary&lt;string,&gt;</code>) is still an open type.

Example:

<pre><code>void Foo&lt;T&gt;(Dictionary&lt;string,T&gt; dic) { ... }
</code></pre>

blocks|key|3277985|text|有三种泛型类型。简而言之，在这个(简化的)声明中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3277986|public+class+Dictionary<TKey,+TValue>+:+IEnumerable<KeyValuePair<TKey,+TValue>>|code-block|syntax|javascript|3277987|3277988|Dictionary<TKey,+TValue>是一个无界泛型type.|unordered-list-item|offset|length|style|CODE|BOLD|3277989|KeyValuePair<TKey,+TValue>，在本例中是一个开放构造的泛型类型。它有一些类型参数，但它们已经在其他地方定义(在字典中，在这个case).|3277990|Dictionary<string,+int>中是一个闭合构造的泛型type.|3277991|3277992|entityMap^0|0|0|0|0|O|R|8|0|0|Q|Y|9|0|0|N|R|B|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Z|8|@$K|10|L|11|M|N]|$K|12|L|13|M|O]]|9|@]|A|$]]|$1|P|3|Q|5|J|7|14|8|@$K|15|L|16|M|N]|$K|17|L|18|M|O]]|9|@]|A|$]]|$1|R|3|S|5|J|7|19|8|@$K|1A|L|1B|M|N]|$K|1C|L|1D|M|O]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|V|$]]

There are three kinds of generic types. To make it short, in this (simplified) declaration:

<pre><code>public class Dictionary&lt;TKey, TValue&gt; : IEnumerable&lt;KeyValuePair&lt;TKey, TValue&gt;&gt;
</code></pre>

<ul>
<li><code>Dictionary&lt;TKey, TValue&gt;</code> is an unbounded generic type.</li>
<li><code>KeyValuePair&lt;TKey, TValue&gt;</code> is, in this case, an open constructed generic type. It has some type parameters, but they are already defined elsewhere (in Dictionary, in this case).</li>
<li><code>Dictionary&lt;string, int&gt;</code> would be a closed constructed generic type.</li>
</ul>

I was going through <a href="http://www.asp.net/learn/mvc/tutorial-34-cs.aspx" rel="noreferrer">Asp.Net MVC lesson</a> and learned that, for a method to qualify as an action for a controller, 

<ul>
<li>It must not have an "open generic type"</li>
</ul>

I understand generics somewhat and use them to some extent, but:

<ul>
<li>What is an open generic type in .Net.</li>
<li>Is there such a thing as a closed generic type?</li>
<li>Open generic type is a term not used very often. What is used / confused with it ?</li>
</ul>

What exactly is an "open generic type" in .NET?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我通过了解到，对于一个符合控制器操作条件的方法，open generic type"“It不能有”我对泛型有一定的了解，并在一定程度上使用它们，但是：什么是开放泛型类型 in .Net。 is a typeOpen generic type是一个很少用到的术语。它使用/混淆了什么?

问.NET中的“开放泛型类型”到底是什么？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的“开放泛型类型”到底是什么？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的“开放泛型类型”到底是什么？
EN