MarshalAsAttribute.SizeParamIndex Champ

Définition

Espace de noms:

System.Runtime.InteropServices

Assembly:

System.Runtime.InteropServices.dll

Source:

MarshalAsAttribute.cs

Indique le paramètre de base zéro qui contient le nombre d'éléments de tableau, semblable à size_is dans COM.

public: short SizeParamIndex;

public short SizeParamIndex;

val mutable SizeParamIndex : int16

Public SizeParamIndex As Short 

Valeur de champ

Int16

Exemples

using namespace System;
using namespace System::Runtime::InteropServices;

// Force the layout of your fields to the C-style struct layout.
// Without this, the .NET Framework will reorder your fields.

[StructLayoutAttribute(LayoutKind::Sequential)]
value struct Vertex
{
public:
   float x;
   float y;
   float z;
};


// Add [In] or [In, Out] attributes as appropriate.
// Marshal as a C-style array of Vertex, where the second (SizeParamIndex is zero-based)
// parameter (size) contains the count of array elements.

[DllImport("SomeDLL.dll")]
extern void SomeUnsafeMethod( [MarshalAs(UnmanagedType::LPArray,SizeParamIndex=1)]array<Vertex>^data, long size );
int main()
{
   array<Vertex>^verts = gcnew array<Vertex>(3);
   SomeUnsafeMethod( verts, verts->Length );
}

using System.Runtime.InteropServices;
using SomeNamespace;

namespace SomeNamespace
{
    // Force the layout of your fields to the C style struct layout.
    // Without this, the .NET Framework will reorder your fields.
    [StructLayout(LayoutKind.Sequential)]
    public struct Vertex
    {
        float	x;
    float	y;
        float	z;
    }

    class SomeClass
    {
        // Add [In] or [In, Out] attributes as approppriate.
        // Marshal as a C style array of Vertex, where the second (SizeParamIndex is zero-based)
        //  parameter (size) contains the count of array elements.
        [DllImport ("SomeDll.dll")]
        public static extern void SomeUnsafeMethod(
                                      [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] Vertex[] data,
                                      long size );

        public void SomeMethod()
        {
            Vertex[] verts = new Vertex[3];
            SomeUnsafeMethod( verts, verts.Length );
        }
    }
}

class Test
{
    public static void Main()
    {
        SomeClass AClass = new SomeClass();

        AClass.SomeMethod();
    }
}

Option Strict Off

Imports System.Runtime.InteropServices
Imports SomeNamespace

Namespace SomeNamespace
    ' Force the layout of your fields to the C style struct layout.
    ' Without this, the .NET Framework will reorder your fields.
    
    <StructLayout(LayoutKind.Sequential)> _
    Structure Vertex
        Dim x As Decimal
        Dim y As Decimal
        Dim z As Decimal
    End Structure

    Class SomeClass
        ' Add [In] or [In, Out] attributes as approppriate.
        ' Marshal as a C style array of Vertex, where the second (SizeParamIndex is zero-based)
        '  parameter (size) contains the count of array elements.

        Declare Auto Sub SomeUnsafeMethod Lib "somelib.dll" ( _
                                      <MarshalAs(UnmanagedType.LPArray, SizeParamIndex:=1)> data() As Vertex, _
                                      size As Long ) 

        Public Sub SomeMethod()
            Dim verts(3) As Vertex
            SomeUnsafeMethod( verts, verts.Length )
        End Sub

    End Class

End Namespace

Module Test
    Sub Main
        Dim AClass As New SomeClass

        AClass.SomeMethod
        End Sub
End Module

Remarques

Le SizeParamIndex champ prend en charge les appels managés vers non managés et non managés à gérés. Elle n’a aucun effet sur le code managé qui appelle des objets COM.

Selon le type managé et les attributs qui lui sont appliqués, le tableau peut être passé en tant que tableau sécurisé ou tableau de style C.

Lorsque des tableaux sont passés en tant que tableaux de style C, le marshaleur ne peut pas déterminer la taille du tableau. Par conséquent, pour passer un tableau managé à une fonction ou une méthode non managée, vous devez fournir deux arguments :

• Tableau, défini par référence ou valeur.

• Taille du tableau, définie par référence ou valeur.

L’index de base zéro du paramètre de taille de tableau est défini à l’aide du SizeParamIndex champ .

Si vous spécifiez à la fois SizeParamIndex et MarshalAsAttribute.SizeConst avec un UnmanagedType.LPArray champ, la somme des valeurs des champs produit un total de taille.

Pour plus d’informations, consultez Marshaling par défaut pour les tableaux.

Voir aussi

• SizeConst
• LPArray