mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 3.6.0

Browse Source 
Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14
This commit is contained in:
Jo Shields
2014-08-13 10:39:27 +01:00
commit a575963da9
50588 changed files with 8155799 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
mcs/class/System.Core/Documentation/en/System/Action.xml Normal file
View File

@@ -0,0 +1,36 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action" FullName="System.Action">
<TypeSignature Language="C#" Value="public delegate void Action();" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>3.5.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters />
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have no parameters and no return value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has no parameters and returns a value, use the generic <see cref="T:System.Func`1" /> delegate instead. </para>
</block>
<para>When you use the <see cref="T:System.Action" /> delegate, you do not have to explicitly define a delegate that encapsulates a parameterless procedure. For example, the following code explicitly declares a delegate named ShowValue and assigns a reference to the Name.DisplayToWindow instance method to its delegate instance.</para>
<para>code reference: System.Action.Delegate#1</para>
<para>The following example simplifies this code by instantiating the <see cref="T:System.Action" /> delegate instead of explicitly defining a new delegate and assigning a named method to it. </para>
<para>code reference: System.Action#2</para>
<para>You can also use the <see cref="T:System.Action" /> delegate with anonymous methods in C#, as the following example illustrates. (For an introduction to anonymous methods, see <format type="text/html"><a href="a62441fa-f0a3-4acb-9aa6-93762a635275">Anonymous Methods (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action#3</para>
<para>You can also assign a lambda expression to an <see cref="T:System.Action" /> delegate instance, as the following example illustrates. (For an introduction to lambda expressions, see <format type="text/html"><a href="57e3ba27-9a82-4067-aca7-5ca446b7bf93">Lambda Expressions (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action#4</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has no parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

113
mcs/class/System.Core/Documentation/en/System/Action`10.xml Normal file
View File

@@ -0,0 +1,113 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`10&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`10" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 10 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 10 parameters and returns a value, use the generic <see cref="T:System.Func`11" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`10" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 10 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

121
mcs/class/System.Core/Documentation/en/System/Action`11.xml Normal file
View File

@@ -0,0 +1,121 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`11&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`11" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 11 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 11 parameters and returns a value, use the generic <see cref="T:System.Func`12" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`11" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 11 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

129
mcs/class/System.Core/Documentation/en/System/Action`12.xml Normal file
View File

@@ -0,0 +1,129 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`12&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`12" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 12 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 12 parameters and returns a value, use the generic <see cref="T:System.Func`13" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`12" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 12 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

137
mcs/class/System.Core/Documentation/en/System/Action`13.xml Normal file
View File

@@ -0,0 +1,137 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`13&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`13" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 13 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 13 parameters and returns a value, use the generic <see cref="T:System.Func`14" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`13" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 13 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

145
mcs/class/System.Core/Documentation/en/System/Action`14.xml Normal file
View File

@@ -0,0 +1,145 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`14&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T14">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
<Parameter Name="arg14" Type="T14" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<typeparam name="T14">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<param name="arg14">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`14" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 14 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 14 parameters and returns a value, use the generic <see cref="T:System.Func`15" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`14" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 14 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

153
mcs/class/System.Core/Documentation/en/System/Action`15.xml Normal file
View File

@@ -0,0 +1,153 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14,in T15&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`15&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T14">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T15">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
<Parameter Name="arg14" Type="T14" />
<Parameter Name="arg15" Type="T15" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<typeparam name="T14">To be added.</typeparam>
<typeparam name="T15">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<param name="arg14">To be added.</param>
<param name="arg15">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`15" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 15 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 15 parameters and returns a value, use the generic <see cref="T:System.Func`16" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`15" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 15 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

161
mcs/class/System.Core/Documentation/en/System/Action`16.xml Normal file
View File

@@ -0,0 +1,161 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14,in T15,in T16&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`16&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T14">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T15">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T16">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
<Parameter Name="arg14" Type="T14" />
<Parameter Name="arg15" Type="T15" />
<Parameter Name="arg16" Type="T16" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<typeparam name="T14">To be added.</typeparam>
<typeparam name="T15">To be added.</typeparam>
<typeparam name="T16">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<param name="arg14">To be added.</param>
<param name="arg15">To be added.</param>
<param name="arg16">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`16" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 16 parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has 16 parameters and returns a value, use the generic <see cref="T:System.Func`17" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`16" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 16 parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

47
mcs/class/System.Core/Documentation/en/System/Action`2.xml Normal file
View File

@@ -0,0 +1,47 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2&gt;" FullName="System.Action&lt;T1,T2&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;T1,T2&gt;(T1 arg1, T2 arg2);" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>3.5.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1" />
<TypeParameter Name="T2" />
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`2" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have two parameters that are both passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has two parameters and returns a value, use the generic <see cref="T:System.Func`3" /> delegate instead.</para>
</block>
<para>When you use the <see cref="T:System.Action`2" /> delegate, you do not have to explicitly define a delegate that encapsulates a method with two parameters. For example, the following code explicitly declares a delegate named ConcatStrings. It then assigns a reference to either of two methods to its delegate instance. One method writes two strings to the console; the second writes two strings to a file. </para>
<para>code reference: System.Action~2#1</para>
<para>The following example simplifies this code by instantiating the <see cref="T:System.Action`2" /> delegate instead of explicitly defining a new delegate and assigning a named method to it.</para>
<para>code reference: System.Action~2#2</para>
<para>You can also use the <see cref="T:System.Action`2" /> delegate with anonymous methods in C#, as the following example illustrates. (For an introduction to anonymous methods, see <format type="text/html"><a href="a62441fa-f0a3-4acb-9aa6-93762a635275">Anonymous Methods (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action~2#3</para>
<para>You can also assign a lambda expression to an <see cref="T:System.Action`2" /> delegate instance, as the following example illustrates. (For an introduction to lambda expressions, see <format type="text/html"><a href="57e3ba27-9a82-4067-aca7-5ca446b7bf93">Lambda Expressions (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action~2#4</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has two parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

51
mcs/class/System.Core/Documentation/en/System/Action`3.xml Normal file
View File

@@ -0,0 +1,51 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3&gt;" FullName="System.Action&lt;T1,T2,T3&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;T1,T2,T3&gt;(T1 arg1, T2 arg2, T3 arg3);" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>3.5.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1" />
<TypeParameter Name="T2" />
<TypeParameter Name="T3" />
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`3" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have three parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has three parameters and returns a value, use the generic <see cref="T:System.Func`4" /> delegate instead.</para>
</block>
<para>When you use the <see cref="T:System.Action`3" /> delegate, you do not have to explicitly define a delegate that encapsulates a method with three parameters. For example, the following code explicitly declares a delegate named StringCopy and assigns a reference to the CopyStrings method to its delegate instance. </para>
<para>code reference: System.Action~3#1</para>
<para>The following example simplifies this code by instantiating the <see cref="T:System.Action`3" /> delegate instead of explicitly defining a new delegate and assigning a named method to it.</para>
<para>code reference: System.Action~3#2</para>
<para>You can also use the <see cref="T:System.Action`3" /> delegate with anonymous methods in C#, as the following example illustrates. (For an introduction to anonymous methods, see <format type="text/html"><a href="a62441fa-f0a3-4acb-9aa6-93762a635275">Anonymous Methods (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action~3#3</para>
<para>You can also assign a lambda expression to an <see cref="T:System.Action`3" /> delegate instance, as the following example illustrates. (For an introduction to lambda expressions, see <format type="text/html"><a href="57e3ba27-9a82-4067-aca7-5ca446b7bf93">Lambda Expressions (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action~3#4</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has three parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

55
mcs/class/System.Core/Documentation/en/System/Action`4.xml Normal file
View File

@@ -0,0 +1,55 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4&gt;" FullName="System.Action&lt;T1,T2,T3,T4&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;T1,T2,T3,T4&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4);" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>3.5.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1" />
<TypeParameter Name="T2" />
<TypeParameter Name="T3" />
<TypeParameter Name="T4" />
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`4" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have four parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has four parameters and returns a value, use the generic <see cref="T:System.Func`5" /> delegate instead.</para>
</block>
<para>When you use the <see cref="T:System.Action`4" /> delegate, you do not have to explicitly define a delegate that encapsulates a method with four parameters. For example, the following code explicitly declares a delegate named StringCopy and assigns a reference to the CopyStrings method to its delegate instance. </para>
<para>code reference: System.Action~4#1</para>
<para>The following example simplifies this code by instantiating the <see cref="T:System.Action`4" /> delegate instead of explicitly defining a new delegate and assigning a named method to it.</para>
<para>code reference: System.Action~4#2</para>
<para>You can also use the <see cref="T:System.Action`4" /> delegate with anonymous methods in C#, as the following example illustrates. (For an introduction to anonymous methods, see <format type="text/html"><a href="a62441fa-f0a3-4acb-9aa6-93762a635275">Anonymous Methods (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action~4#3</para>
<para>You can also assign a lambda expression to an <see cref="T:System.Action`4" /> delegate instance, as the following example illustrates. (For an introduction to lambda expressions, see <format type="text/html"><a href="57e3ba27-9a82-4067-aca7-5ca446b7bf93">Lambda Expressions (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Action~4#4</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has four parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

105
mcs/class/System.Core/Documentation/en/System/Action`9.xml Normal file
View File

@@ -0,0 +1,105 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9&gt;" FullName="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9&gt;">
<TypeSignature Language="C#" Value="public delegate void Action&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Action`9&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use the <see cref="T:System.Action`9" /> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have nine parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.</para>
<block subset="none" type="note">
<para>To reference a method that has nine parameters and returns a value, use the generic <see cref="T:System.Func`10" /> delegate instead.</para>
</block>
<para>You can also use the <see cref="T:System.Action`9" /> delegate with anonymous methods and lambda expressions.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has nine parameters and does not return a value.</para>
</summary>
</Docs>
</Type>

43
mcs/class/System.Core/Documentation/en/System/Func`1.xml Normal file
View File

@@ -0,0 +1,43 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;TResult&gt;" FullName="System.Func&lt;TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;TResult&gt;();" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>3.5.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="TResult" />
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters />
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="TResult">To be added.</typeparam>
<value>To be added.</value>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have no parameters and must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has no parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the <see cref="T:System.Action" /> delegate instead. </para>
</block>
<para>When you use the <see cref="T:System.Func`1" /> delegate, you do not have to explicitly define a delegate that encapsulates a parameterless method. For example, the following code explicitly declares a delegate named WriteMethod and assigns a reference to the OutputTarget.SendToFile instance method to its delegate instance. </para>
<para>code reference: System.Func~1#1</para>
<para>The following example simplifies this code by instantiating the <see cref="T:System.Func`1" /> delegate instead of explicitly defining a new delegate and assigning a named method to it. </para>
<para>code reference: System.Func~1#2</para>
<para>You can use the <see cref="T:System.Func`1" /> delegate with anonymous methods in C#, as the following example illustrates. (For an introduction to anonymous methods, see <format type="text/html"><a href="a62441fa-f0a3-4acb-9aa6-93762a635275">Anonymous Methods (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Func~1#3</para>
<para>You can also assign a lambda expression to a <see cref="T:System.Func`2" /> delegate, as the following example illustrates. (For an introduction to lambda expressions, see <format type="text/html"><a href="137064b0-3928-4bfa-ba71-c3f9cbd951e2">Lambda Expressions</a></format> and <format type="text/html"><a href="57e3ba27-9a82-4067-aca7-5ca446b7bf93">Lambda Expressions (C# Programming Guide)</a></format>.)</para>
<para>code reference: System.Func~1#4</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate. In particular, because many methods of types in the <see cref="N:System.Linq" /> namespace have Func parameters, you can pass these methods a lambda expression without explicitly instantiating a Func delegate.</para>
<para>If you have an expensive computation that you want to execute only if the result is actually needed, you can assign the expensive function to a <see cref="T:System.Func`1" /> delegate. The execution of the function can then be delayed until a property that accesses the value is used in an expression. The example in the next section demonstrates how to do this.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has no parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

113
mcs/class/System.Core/Documentation/en/System/Func`10.xml Normal file
View File

@@ -0,0 +1,113 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`10&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have nine parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has nine parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`9" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`10" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has nine parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

121
mcs/class/System.Core/Documentation/en/System/Func`11.xml Normal file
View File

@@ -0,0 +1,121 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`11&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 10 parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has 10 parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`10" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`11" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 10 parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

129
mcs/class/System.Core/Documentation/en/System/Func`12.xml Normal file
View File

@@ -0,0 +1,129 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`12&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 11 parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has 11 parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`11" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`12" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 11 parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

137
mcs/class/System.Core/Documentation/en/System/Func`13.xml Normal file
View File

@@ -0,0 +1,137 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`13&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 12 parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has 12 parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`12" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`13" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 12 parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

145
mcs/class/System.Core/Documentation/en/System/Func`14.xml Normal file
View File

@@ -0,0 +1,145 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`14&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 13 parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has 13 parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`13" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`14" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 13 parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

153
mcs/class/System.Core/Documentation/en/System/Func`15.xml Normal file
View File

@@ -0,0 +1,153 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`15&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T14">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
<Parameter Name="arg14" Type="T14" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<typeparam name="T14">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<param name="arg14">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 14 parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has 14 parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`14" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`15" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 14 parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

161
mcs/class/System.Core/Documentation/en/System/Func`16.xml Normal file
View File

@@ -0,0 +1,161 @@
<?xml version="1.0" encoding="utf-8"?>
<Type Name="Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult&gt;" FullName="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult&gt;">
<TypeSignature Language="C#" Value="public delegate TResult Func&lt;in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14,in T15,out TResult&gt;(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi sealed Func`16&lt;- T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, + TResult&gt; extends System.MulticastDelegate" />
<AssemblyInfo>
<AssemblyName>System.Core</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<TypeParameters>
<TypeParameter Name="T1">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T2">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T3">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T4">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T5">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T6">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T7">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T8">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T9">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T10">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T11">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T12">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T13">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T14">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="T15">
<Constraints>
<ParameterAttribute>Contravariant</ParameterAttribute>
</Constraints>
</TypeParameter>
<TypeParameter Name="TResult">
<Constraints>
<ParameterAttribute>Covariant</ParameterAttribute>
</Constraints>
</TypeParameter>
</TypeParameters>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="arg1" Type="T1" />
<Parameter Name="arg2" Type="T2" />
<Parameter Name="arg3" Type="T3" />
<Parameter Name="arg4" Type="T4" />
<Parameter Name="arg5" Type="T5" />
<Parameter Name="arg6" Type="T6" />
<Parameter Name="arg7" Type="T7" />
<Parameter Name="arg8" Type="T8" />
<Parameter Name="arg9" Type="T9" />
<Parameter Name="arg10" Type="T10" />
<Parameter Name="arg11" Type="T11" />
<Parameter Name="arg12" Type="T12" />
<Parameter Name="arg13" Type="T13" />
<Parameter Name="arg14" Type="T14" />
<Parameter Name="arg15" Type="T15" />
</Parameters>
<ReturnValue>
<ReturnType>TResult</ReturnType>
</ReturnValue>
<Docs>
<typeparam name="T1">To be added.</typeparam>
<typeparam name="T2">To be added.</typeparam>
<typeparam name="T3">To be added.</typeparam>
<typeparam name="T4">To be added.</typeparam>
<typeparam name="T5">To be added.</typeparam>
<typeparam name="T6">To be added.</typeparam>
<typeparam name="T7">To be added.</typeparam>
<typeparam name="T8">To be added.</typeparam>
<typeparam name="T9">To be added.</typeparam>
<typeparam name="T10">To be added.</typeparam>
<typeparam name="T11">To be added.</typeparam>
<typeparam name="T12">To be added.</typeparam>
<typeparam name="T13">To be added.</typeparam>
<typeparam name="T14">To be added.</typeparam>
<typeparam name="T15">To be added.</typeparam>
<typeparam name="TResult">To be added.</typeparam>
<param name="arg1">To be added.</param>
<param name="arg2">To be added.</param>
<param name="arg3">To be added.</param>
<param name="arg4">To be added.</param>
<param name="arg5">To be added.</param>
<param name="arg6">To be added.</param>
<param name="arg7">To be added.</param>
<param name="arg8">To be added.</param>
<param name="arg9">To be added.</param>
<param name="arg10">To be added.</param>
<param name="arg11">To be added.</param>
<param name="arg12">To be added.</param>
<param name="arg13">To be added.</param>
<param name="arg14">To be added.</param>
<param name="arg15">To be added.</param>
<returns>To be added.</returns>
<remarks>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>You can use this delegate to represent a method that can be passed as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have 15 parameters, each of which is passed to it by value, and that it must return a value.</para>
<block subset="none" type="note">
<para>To reference a method that has 15 parameters and returns void (or in Visual Basic, that is declared as a Sub rather than as a Function), use the generic <see cref="T:System.Action`15" /> delegate instead. </para>
</block>
<para>You can also use the <see cref="T:System.Func`16" /> delegate with anonymous methods and lambda expressions.</para>
<para>The underlying type of a lambda expression is one of the generic Func delegates. This makes it possible to pass a lambda expression as a parameter without explicitly assigning it to a delegate.</para>
</remarks>
<summary>
<attribution license="cc4" from="Microsoft" modified="false" />
<para>Encapsulates a method that has 15 parameters and returns a value of the type specified by the <paramref name="TResult" /> parameter.</para>
</summary>
</Docs>
</Type>

Some files were not shown because too many files have changed in this diff Show More