Výchozí zařazování pro poleDefault Marshaling for Arrays

V aplikaci, která se skládá výhradně ze spravovaného kódu, modul common language runtime předá typy polí jako vstupně-výstupní parametry.In an application consisting entirely of managed code, the common language runtime passes array types as In/Out parameters. Naproti tomu zařazovací modul Interop předá pole jako parametry ve výchozím nastavení.In contrast, the interop marshaler passes an array as In parameters by default.

S optimalizací připnutíse může při interakci s objekty ve stejném objektu Apartment zdát, že se jako parametr v/v funguje přenositelná pole.With pinning optimization, a blittable array can appear to operate as an In/Out parameter when interacting with objects in the same apartment. Nicméně pokud později exportujete kód do knihovny typů, která se používá k vygenerování mezipočítačového proxy serveru, a tato knihovna slouží k zařazování volání napříč objekty Apartment, volání se mohou vrátit na hodnotu true v chování parametrů.However, if you later export the code to a type library used to generate the cross-machine proxy, and that library is used to marshal your calls across apartments, the calls can revert to true In parameter behavior.

Pole jsou složitá podle povahy a rozdíly mezi spravovanými a nespravovanými poli opravňují více informací než jiné nepřenositelné typy.Arrays are complex by nature, and the distinctions between managed and unmanaged arrays warrant more information than other non-blittable types.

Spravovaná poleManaged Arrays

Typy spravovaných polí se mohou lišit. Třída System.Array je však základní třídou všech typů polí.Managed array types can vary; however, the System.Array class is the base class of all array types. Třída System. Array má vlastnosti pro určení pořadí, délky a dolních a horních mezí pole a také metod pro přístup, řazení, hledání, kopírování a vytváření polí.The System.Array class has properties for determining the rank, length, and lower and upper bounds of an array, as well as methods for accessing, sorting, searching, copying, and creating arrays.

Tyto typy polí jsou dynamické a nemají odpovídající statický typ definovaný v knihovně základních tříd.These array types are dynamic and do not have a corresponding static type defined in the base class library. Je vhodné si představit každou kombinaci typu prvku a seřadit jako odlišný typ pole.It is convenient to think of each combination of element type and rank as a distinct type of array. Proto jednorozměrné pole celých čísel je jiného typu než jednorozměrné pole typu Double.Therefore, a one-dimensional array of integers is of a different type than a one-dimensional array of double types. Podobně dvourozměrné pole celých čísel je jiné než jednorozměrné pole celých čísel.Similarly a two-dimensional array of integers is different from a one-dimensional array of integers. Hranice pole se při porovnávání typů neberou v potaz.The bounds of the array are not considered when comparing types.

Jak ukazuje následující tabulka, jakákoli instance spravovaného pole musí být konkrétního typu prvku, pořadí a dolní mez.As the following table shows, any instance of a managed array must be of a specific element type, rank, and lower bound.

Typ spravovaného poleManaged array type Typ elementuElement type PořadíRank Dolní mezLower bound Zápis signaturySignature notation
ELEMENT_TYPE_ARRAYELEMENT_TYPE_ARRAY Zadáno podle typu.Specified by type. Určeno podle pořadí.Specified by rank. Volitelně určené hranicemi.Optionally specified by bounds. typ [ n,m ]type [ n,m ]
ELEMENT_TYPE_CLASSELEMENT_TYPE_CLASS NeznáméUnknown NeznáméUnknown NeznáméUnknown System. ArraySystem.Array
ELEMENT_TYPE_SZARRAYELEMENT_TYPE_SZARRAY Zadáno podle typu.Specified by type. první1 0,80 typ [ n ]type [ n ]

Nespravovaná poleUnmanaged Arrays

Nespravovaná pole jsou buď bezpečná pole ve stylu COM, nebo pole ve stylu jazyka C s pevnou nebo proměnnou délkou.Unmanaged arrays are either COM-style safe arrays or C-style arrays with fixed or variable length. Bezpečná pole jsou samy popisující pole, která přenesou typ, pořadí a meze přidružených dat pole.Safe arrays are self-describing arrays that carry the type, rank, and bounds of the associated array data. Pole stylu C jsou jednorozměrná typová pole s pevně nastavenou dolní mezí 0.C-style arrays are one-dimensional typed arrays with a fixed lower bound of 0. Zařazovací služba má omezené podpory pro oba typy polí.The marshaling service has limited support for both types of arrays.

Předávání parametrů pole do kódu .NETPassing Array Parameters to .NET Code

Pole stylu C a bezpečná pole mohou být předány do kódu .NET z nespravovaného kódu jako bezpečné pole nebo pole ve stylu jazyka C.Both C-style arrays and safe arrays can be passed to .NET code from unmanaged code as either a safe array or a C-style array. Následující tabulka ukazuje nespravovaný typ hodnoty a importovaný typ.The following table shows the unmanaged type value and the imported type.

Nespravovaný typUnmanaged type Importovaný typImported type
SAFEARRAY ( typ )SafeArray( Type ) ELEMENT_TYPE_SZARRAY < ConvertedType >ELEMENT_TYPE_SZARRAY < ConvertedType >

Rank = 1, dolní mez = 0.Rank = 1, lower bound = 0. Velikost je známá pouze v případě, že je k dispozici ve spravovaném podpisu.Size is known only if provided in the managed signature. Bezpečná pole, která nejsou pořadí = 1 nebo dolní mez = 0, nelze zařadit jako SZARRAY.Safe arrays that are not rank = 1 or lower bound = 0 cannot be marshaled as SZARRAY.
Typ []Type [] ELEMENT_TYPE_SZARRAY < ConvertedType >ELEMENT_TYPE_SZARRAY < ConvertedType >

Rank = 1, dolní mez = 0.Rank = 1, lower bound = 0. Velikost je známá pouze v případě, že je k dispozici ve spravovaném podpisu.Size is known only if provided in the managed signature.

Bezpečná poleSafe Arrays

Když je bezpečné pole importováno z knihovny typů do sestavení .NET, pole je převedeno na jednorozměrné pole známého typu (například int).When a safe array is imported from a type library to a .NET assembly, the array is converted to a one-dimensional array of a known type (such as int). Stejná pravidla převodu typů, která platí pro parametry, platí také pro prvky pole.The same type conversion rules that apply to parameters also apply to array elements. Například bezpečné pole typů BSTR se stávají spravovaným polem řetězců a bezpečné pole variant se stávají spravovaným polem objektů.For example, a safe array of BSTR types becomes a managed array of strings and a safe array of variants becomes a managed array of objects. Typ elementu SAFEARRAY je zachycen z knihovny typů a uložen v hodnotě SAFEARRAY výčtu UnmanagedType.The SAFEARRAY element type is captured from the type library and saved in the SAFEARRAY value of the UnmanagedType enumeration.

Vzhledem k tomu, že pořadí a meze bezpečného pole nelze určit z knihovny typů, předpokládá se, že pořadí je rovno 1 a dolní mez je rovna 0.Because the rank and bounds of the safe array cannot be determined from the type library, the rank is assumed to equal 1 and the lower bound is assumed to equal 0. Pořadí a meze musí být definovány ve spravovaném podpisu vytvořeném pomocí nástroje pro Import knihovny typů (Tlbimp. exe).The rank and bounds must be defined in the managed signature produced by the Type Library Importer (Tlbimp.exe). Pokud pořadí předané metodě v době běhu se liší, je vyvolána SafeArrayRankMismatchException.If the rank passed to the method at run time differs, a SafeArrayRankMismatchException is thrown. Pokud se typ pole předaného v době běhu liší, je vyvolána SafeArrayTypeMismatchException.If the type of the array passed at run time differs, a SafeArrayTypeMismatchException is thrown. Následující příklad zobrazuje bezpečná pole ve spravovaném a nespravovaném kódu.The following example shows safe arrays in managed and unmanaged code.

Nespravovaný podpisUnmanaged signature

HRESULT New1([in] SAFEARRAY( int ) ar);  
HRESULT New2([in] SAFEARRAY( DATE ) ar);  
HRESULT New3([in, out] SAFEARRAY( BSTR ) *ar);  

Spravovaný podpisManaged signature

Sub New1(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VT_I4)> _  
   ar() As Integer)  
Sub New2(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VT_DATE)> _   
   ar() As DateTime)  
Sub New3(ByRef <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VT_BSTR)> _   
   ar() As String)  
void New1([MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VT_I4)] int[] ar) ;  
void New2([MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VT_DATE)]   
   DateTime[] ar);  
void New3([MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VT_BSTR)]   
   ref String[] ar);  

Vícerozměrné nebo nenulové bezpečné pole s vazbou lze zařadit do spravovaného kódu, je-li signatura metody vytvořená pomocí nástroje Tlbimp. exe změněna tak, aby označovala typ prvku ELEMENT_TYPE_ARRAY namísto ELEMENT_TYPE_SZARRAY.Multidimensional, or nonzero-bound safe arrays, can be marshaled into managed code if the method signature produced by Tlbimp.exe is modified to indicate an element type of ELEMENT_TYPE_ARRAY instead of ELEMENT_TYPE_SZARRAY. Alternativně můžete použít přepínač /sysarray s nástrojem Tlbimp. exe pro import všech polí jako objektů System.Array.Alternatively, you can use the /sysarray switch with Tlbimp.exe to import all arrays as System.Array objects. V případech, kdy je předávané pole známo multidimenzionální, můžete upravit kód jazyka MSIL (Microsoft Intermediate Language) vytvořený pomocí nástroje Tlbimp. exe a poté jej znovu zkompilovat.In cases where the array being passed is known to be multidimensional, you can edit the Microsoft intermediate language (MSIL) code produced by Tlbimp.exe and then recompile it. Podrobnosti o tom, jak upravit kód jazyka MSIL, najdete v tématu přizpůsobení obálek za běhu, které lze volat.For details about how to modify MSIL code, see Customizing Runtime Callable Wrappers.

Pole stylu CC-Style Arrays

Když je pole ve stylu jazyka C importováno z knihovny typů do sestavení .NET, pole je převedeno na ELEMENT_TYPE_SZARRAY.When a C-style array is imported from a type library to a .NET assembly, the array is converted to ELEMENT_TYPE_SZARRAY.

Typ prvku pole je určen z knihovny typů a zůstane během importu.The array element type is determined from the type library and preserved during the import. Stejná pravidla převodu, která platí pro parametry, platí také pro prvky pole.The same conversion rules that apply to parameters also apply to array elements. Například pole typů typem LPStr se stávají polem typů řetězců .For example, an array of LPStr types becomes an array of String types. Nástroj Tlbimp. exe zachytí typ prvku pole a použije atribut MarshalAsAttribute pro parametr.Tlbimp.exe captures the array element type and applies the MarshalAsAttribute attribute to the parameter.

Předpokládá se, že se rozměr pole rovná 1.The array rank is assumed to equal 1. Pokud je pořadí větší než 1, pole je zařazeno jako jednorozměrné pole v pořadí podle sloupců.If the rank is greater than 1, the array is marshaled as a one-dimensional array in column-major order. Dolní mez se vždycky rovná 0.The lower bound always equals 0.

Knihovny typů mohou obsahovat pole s pevnou nebo proměnlivou délkou.Type libraries can contain arrays of fixed or variable length. Nástroj Tlbimp. exe může importovat pouze pole s pevnou délkou z knihoven typů, protože knihovny typů nemají informace potřebné pro zařazování polí s proměnnou délkou.Tlbimp.exe can import only fixed-length arrays from type libraries because type libraries lack the information needed to marshal variable-length arrays. S poli s pevnou délkou je velikost importována z knihovny typů a zachycena v MarshalAsAttribute , která je použita pro parametr.With fixed-length arrays, the size is imported from the type library and captured in the MarshalAsAttribute that is applied to the parameter.

Je nutné ručně definovat knihovny typů obsahující pole s proměnnou délkou, jak je znázorněno v následujícím příkladu.You must manually define type libraries containing variable-length arrays, as shown in the following example.

Nespravovaný podpisUnmanaged signature

HRESULT New1(int ar[10]);  
HRESULT New2(double ar[10][20]);  
HRESULT New3(LPWStr ar[10]);  

Spravovaný podpisManaged signature

Sub New1(<MarshalAs(UnmanagedType.LPArray, SizeConst=10)> _  
   ar() As Integer)  
Sub New2(<MarshalAs(UnmanagedType.LPArray, SizeConst=200)> _  
   ar() As Double)  
Sub New2(<MarshalAs(UnmanagedType.LPArray, _  
   ArraySubType=UnmanagedType.LPWStr, SizeConst=10)> _  
   ar() As String)  
void New1([MarshalAs(UnmanagedType.LPArray, SizeConst=10)] int[] ar);  
void New2([MarshalAs(UnmanagedType.LPArray, SizeConst=200)] double[] ar);  
void New2([MarshalAs(UnmanagedType.LPArray,   
   ArraySubType=UnmanagedType.LPWStr, SizeConst=10)] String[] ar);  

I když můžete použít atributy size_is nebo length_is na pole ve zdroji rozhraní IDL (Interface Definition Language) pro předávání velikosti klientovi, kompilátor rozhraní Microsoft Interface Definition Language (MIDL) nešíří tuto velikost informace do knihovny typů.Although you can apply the size_is or length_is attributes to an array in Interface Definition Language (IDL) source to convey the size to a client, the Microsoft Interface Definition Language (MIDL) compiler does not propagate that information to the type library. Bez znalosti velikosti nemůže služba interop marshaling zařadit prvky pole.Without knowing the size, the interop marshaling service cannot marshal the array elements. V důsledku toho se pole s proměnlivou délkou importují jako argumenty reference.Consequently, variable-length arrays are imported as reference arguments. Příklad:For example:

Nespravovaný podpisUnmanaged signature

HRESULT New1(int ar[]);  
HRESULT New2(int ArSize, [size_is(ArSize)] double ar[]);  
HRESULT New3(int ElemCnt, [length_is(ElemCnt)] LPStr ar[]);  

Spravovaný podpisManaged signature

Sub New1(ByRef ar As Integer)  
Sub New2(ByRef ar As Double)  
Sub New3(ByRef ar As String)  
void New1(ref int ar);    
void New2(ref double ar);    
void New3(ref String ar);   

Zařazovacímu programu můžete poskytnout velikost pole úpravou kódu jazyka MSIL (Microsoft Intermediate Language) vytvořeného pomocí nástroje Tlbimp. exe a jeho opětovnou kompilací.You can provide the marshaler with the array size by editing the Microsoft intermediate language (MSIL) code produced by Tlbimp.exe and then recompiling it. Podrobnosti o tom, jak upravit kód jazyka MSIL, najdete v tématu přizpůsobení obálek za běhu, které lze volat.For details about how to modify MSIL code, see Customizing Runtime Callable Wrappers. Chcete-li určit počet prvků v poli, použijte MarshalAsAttribute typ pro parametr pole definice spravované metody jedním z následujících způsobů:To indicate the number of elements in the array, apply the MarshalAsAttribute type to the array parameter of the managed method definition in one of the following ways:

  • Identifikujte další parametr, který obsahuje počet prvků v poli.Identify another parameter that contains the number of elements in the array. Parametry jsou identifikovány podle pozice počínaje prvním parametrem jako číslo 0.The parameters are identified by position, starting with the first parameter as number 0.

    Sub [New](ElemCnt As Integer, _  
       \<MarshalAs(UnmanagedType.LPArray, SizeParamIndex:=1)> _  
       ar() As Integer)  
    
    void New(  
       int ElemCnt,   
       [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0)] int[] ar );  
    
  • Definujte velikost pole jako konstantu.Define the size of the array as a constant. Příklad:For example:

    Sub [New](\<MarshalAs(UnmanagedType.LPArray, SizeConst:=128)> _  
       ar() As Integer)  
    
    void New(  
       [MarshalAs(UnmanagedType.LPArray, SizeConst=128)] int[] ar );  
    

Při zařazování polí z nespravovaného kódu do spravovaného kódu zařazovací modul zkontroluje MarshalAsAttribute přidružený k parametru a určí velikost pole.When marshaling arrays from unmanaged code to managed code, the marshaler checks the MarshalAsAttribute associated with the parameter to determine the array size. Pokud není určena velikost pole, je zařazen pouze jeden prvek.If the array size is not specified, only one element is marshaled.

Poznámka

MarshalAsAttribute nemá žádný vliv na zařazování spravovaných polí do nespravovaného kódu.The MarshalAsAttribute has no effect on marshaling managed arrays to unmanaged code. V tomto směru je velikost pole určena kontrolou.In that direction, the array size is determined by examination. Neexistuje žádný způsob, jak zařadit podmnožinu spravovaného pole.There is no way to marshal a subset of a managed array.

Zařazovací modul Interop používá metody CoTaskMemAlloc a CoTaskMemFree k přidělení a načtení paměti.The interop marshaler uses the CoTaskMemAlloc and CoTaskMemFree methods to allocate and retrieve memory. Tyto metody musí používat i přidělení paměti prováděné nespravovaným kódem.Memory allocation performed by unmanaged code must also use these methods.

Předávání polí do modelu COMPassing Arrays to COM

Všechny typy spravovaných polí lze předat nespravovanému kódu ze spravovaného kódu.All managed array types can be passed to unmanaged code from managed code. V závislosti na spravovaném typu a použitých atributech může být pole dostupné jako bezpečné pole nebo ve stylu jazyka C, jak je znázorněno v následující tabulce.Depending on the managed type and the attributes applied to it, the array can be accessed as a safe array or a C-style array, as shown in the following table.

Typ spravovaného poleManaged array type Exportováno jakoExported as
Typ < ELEMENT_TYPE_SZARRAY >ELEMENT_TYPE_SZARRAY < type > UnmanagedType . SafeArray ( typ )UnmanagedType .SafeArray( type )

UnmanagedType. typy LPArrayUnmanagedType.LPArray

V signatuře je uveden typ.Type is provided in the signature. Pořadí je vždy 1, dolní hranice je vždy 0.Rank is always 1, lower bound is always 0. Velikost je vždy známá v době běhu.Size is always known at run time.
ELEMENT_TYPE_ARRAY < typ > < pořadí > [ < hranice > ]ELEMENT_TYPE_ARRAY < type > < rank >[< bounds >] UnmanagedType. SAFEARRAY ( typ )UnmanagedType.SafeArray( type )

UnmanagedType. typy LPArrayUnmanagedType.LPArray

Typ, rozsah, meze jsou k dispozici v signatuře.Type, rank, bounds are provided in the signature. Velikost je vždy známá v době běhu.Size is always known at run time.
ELEMENT_TYPE_CLASS < System.Array >ELEMENT_TYPE_CLASS <System.Array> UT_InterfaceUT_Interface

UnmanagedType. SAFEARRAY ( typ )UnmanagedType.SafeArray( type )

Typ, pořadí, meze a velikost jsou vždy známy v době běhu.Type, rank, bounds, and size are always known at run time.

V automatizaci OLE existuje omezení související s poli struktur, která obsahují typem LPStr nebo LPWSTR.There is a limitation in OLE Automation relating to arrays of structures that contain LPSTR or LPWSTR. Proto musí být pole řetězců zařazena jako UnmanagedType. BSTR.Therefore, String fields have to be marshaled as UnmanagedType.BSTR. V opačném případě bude vyvolána výjimka.Otherwise, an exception will be thrown.

ELEMENT_TYPE_SZARRAYELEMENT_TYPE_SZARRAY

Pokud je metoda obsahující parametr ELEMENT_TYPE_SZARRAY (jednorozměrné pole) exportována ze sestavení .NET do knihovny typů, je parametr pole převeden na hodnotu SAFEARRAY daného typu.When a method containing an ELEMENT_TYPE_SZARRAY parameter (one-dimensional array) is exported from a .NET assembly to a type library, the array parameter is converted to a SAFEARRAY of a given type. Stejná pravidla převodu se vztahují na typy prvků pole.The same conversion rules apply to the array element types. Obsah spravovaného pole se automaticky zkopíruje ze spravované paměti do pole SAFEARRAY.The contents of the managed array are automatically copied from managed memory into the SAFEARRAY. Příklad:For example:

Spravovaný podpisManaged signature

Sub [New](ar() As Long)  
Sub [New](ar() As String)  
void New(long[] ar );  
void New(String[] ar );  

Nespravovaný podpisUnmanaged signature

HRESULT New([in] SAFEARRAY( long ) ar);
HRESULT New([in] SAFEARRAY( BSTR ) ar);  

Rozsah bezpečných polí je vždycky 1 a dolní hranice je vždycky 0.The rank of the safe arrays is always 1 and the lower bound is always 0. Velikost je určena v době běhu podle velikosti předávaného spravovaného pole.The size is determined at run time by the size of the managed array being passed.

Pole lze také zařadit jako pole ve stylu jazyka C pomocí atributu MarshalAsAttribute.The array can also be marshaled as a C-style array by using the MarshalAsAttribute attribute. Příklad:For example:

Spravovaný podpisManaged signature

Sub [New](<MarshalAs(UnmanagedType.LPArray, SizeParamIndex:=1)> _  
   ar() As Long, size as Integer)  
Sub [New](<MarshalAs(UnmanagedType.LPArray, SizeParamIndex:=1)> _  
   ar() As String, size as Integer)  
Sub [New](<MarshalAs(UnmanagedType.LPArray, _  
   ArraySubType= UnmanagedType.LPStr, SizeParamIndex:=1)> _  
   ar() As String, size as Integer)  
void New([MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)]   
   long [] ar, int size );  
void New([MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)]   
   String [] ar, int size );  
void New([MarshalAs(UnmanagedType.LPArray, ArraySubType=   
   UnmanagedType.LPStr, SizeParamIndex=1)]   
   String [] ar, int size );  

Nespravovaný podpisUnmanaged signature

HRESULT New(long ar[]);
HRESULT New(BSTR ar[]);
HRESULT New(LPStr ar[]);  

I když zařazovací jednotka má informace o délce potřebné k zařazení pole, délka pole je obvykle předána jako samostatný argument pro vyjádření délky volaného.Although the marshaler has the length information needed to marshal the array, the array length is usually passed as a separate argument to convey the length to the callee.

ELEMENT_TYPE_ARRAYELEMENT_TYPE_ARRAY

Je-li metoda, která obsahuje parametr ELEMENT_TYPE_ARRAY , exportována ze sestavení .NET do knihovny typů, je parametr pole převeden na hodnotu SAFEARRAY daného typu.When a method containing an ELEMENT_TYPE_ARRAY parameter is exported from a .NET assembly to a type library, the array parameter is converted to a SAFEARRAY of a given type. Obsah spravovaného pole se automaticky zkopíruje ze spravované paměti do pole SAFEARRAY.The contents of the managed array are automatically copied from managed memory into the SAFEARRAY. Příklad:For example:

Spravovaný podpisManaged signature

Sub [New](ar(,) As Long)  
Sub [New](ar(,) As String)  
void New( long [,] ar );  
void New( String [,] ar );  

Nespravovaný podpisUnmanaged signature

HRESULT New([in] SAFEARRAY( long ) ar);
HRESULT New([in] SAFEARRAY( BSTR ) ar);  

Pořadí, velikost a hranice bezpečných polí jsou určeny za běhu podle vlastností spravovaného pole.The rank, size, and bounds of the safe arrays are determined at run time by the characteristics of the managed array.

Pole lze také zařadit jako pole ve stylu jazyka C použitím atributu MarshalAsAttribute.The array can also be marshaled as a C-style array by applying the MarshalAsAttribute attribute. Příklad:For example:

Spravovaný podpisManaged signature

Sub [New](<MarshalAs(UnmanagedType.LPARRAY, SizeParamIndex:=1)> _  
   ar(,) As Long, size As Integer)  
Sub [New](<MarshalAs(UnmanagedType.LPARRAY, _  
   ArraySubType:=UnmanagedType.LPStr, SizeParamIndex:=1)> _  
   ar(,) As String, size As Integer)  
void New([MarshalAs(UnmanagedType.LPARRAY, SizeParamIndex=1)]   
   long [,] ar, int size );  
void New([MarshalAs(UnmanagedType.LPARRAY,   
   ArraySubType= UnmanagedType.LPStr, SizeParamIndex=1)]   
   String [,] ar, int size );  

Nespravovaný podpisUnmanaged signature

HRESULT New(long ar[]);
HRESULT New(LPStr ar[]);  

Vnořená pole nelze zařadit.Nested arrays cannot be marshaled. Například následující signatura generuje chybu při exportu pomocí typu Exportér knihovny typů (Tlbexp. exe).For example, the following signature generates an error when exported with the Type Library Exporter (Tlbexp.exe).

Spravovaný podpisManaged signature

Sub [New](ar()()() As Long)  
void New(long [][][] ar );  

ELEMENT_TYPE_CLASS <System. Array >ELEMENT_TYPE_CLASS <System.Array>

Je-li metoda, která obsahuje parametr System.Array, exportována ze sestavení .NET do knihovny typů, je parametr pole převeden na rozhraní _array .When a method containing a System.Array parameter is exported from a .NET assembly to a type library, the array parameter is converted to an _Array interface. Obsah spravovaného pole je přístupný pouze prostřednictvím metod a vlastností rozhraní _array .The contents of the managed array are accessible only through the methods and properties of the _Array interface. System. Array se dá také zařadit jako SAFEARRAY pomocí atributu MarshalAsAttribute.System.Array can also be marshaled as a SAFEARRAY by using the MarshalAsAttribute attribute. Při zařazování jako bezpečné pole jsou prvky pole zařazeny jako varianty.When marshaled as a safe array, the array elements are marshaled as variants. Příklad:For example:

Spravovaný podpisManaged signature

Sub New1( ar As System.Array )  
Sub New2( <MarshalAs(UnmanagedType.Safe array)> ar As System.Array )  
void New1( System.Array ar );  
void New2( [MarshalAs(UnmanagedType.Safe array)] System.Array ar );  

Nespravovaný podpisUnmanaged signature

HRESULT New([in] _Array *ar);
HRESULT New([in] SAFEARRAY(VARIANT) ar);  

Pole ve strukturáchArrays within Structures

Nespravované struktury mohou obsahovat vložená pole.Unmanaged structures can contain embedded arrays. Ve výchozím nastavení jsou tato vložená pole pole zařazena jako SAFEARRAY.By default, these embedded array fields are marshaled as a SAFEARRAY. V následujícím příkladu je s1 vložené pole, které je přiděleno přímo v rámci struktury samotné.In the following example, s1 is an embedded array that is allocated directly within the structure itself.

Nespravované reprezentaceUnmanaged representation

struct MyStruct {  
    short s1[128];  
}  

Pole lze zařadit jako UnmanagedType, což vyžaduje, abyste nastavili pole MarshalAsAttribute.Arrays can be marshaled as UnmanagedType, which requires you to set the MarshalAsAttribute field. Velikost lze nastavit pouze jako konstantu.The size can be set only as a constant. Následující kód ukazuje odpovídající spravovanou definici MyStruct.The following code shows the corresponding managed definition of MyStruct.

Public Structure <StructLayout(LayoutKind.Sequential)> MyStruct  
   Public <MarshalAs(UnmanagedType.ByValArray, SizeConst := 128)> _  
     s1() As Short  
End Structure  
[StructLayout(LayoutKind.Sequential)]  
public struct MyStruct {  
   [MarshalAs(UnmanagedType.ByValArray, SizeConst=128)] public short[] s1;  
}  

Viz také:See also