MarshalAsAttribute.SizeParamIndex Campo

Definición

Espacio de nombres:

System.Runtime.InteropServices

Ensamblado:

System.Runtime.InteropServices.dll

Source:

MarshalAsAttribute.cs

Indica el parámetro de base cero que contiene el recuento de elementos de matriz, similar a size_is en COM.

public: short SizeParamIndex;

public short SizeParamIndex;

val mutable SizeParamIndex : int16

Public SizeParamIndex As Short 

Valor de campo

Int16

Ejemplos

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

Comentarios

El SizeParamIndex campo admite llamadas administradas a no administradas y no administradas a administradas. No tiene ningún efecto en el código administrado que llama a objetos COM.

Según el tipo administrado y los atributos aplicados, la matriz se puede pasar como una matriz segura o una matriz de estilo C.

Cuando las matrices se pasan como matrices de estilo C, el serializador no puede determinar el tamaño de la matriz. Por lo tanto, para pasar una matriz administrada a una función o método no administrados, debe proporcionar dos argumentos:

• Matriz, definida por referencia o valor.

• Tamaño de la matriz, definido por referencia o valor.

El índice de base cero del parámetro de tamaño de matriz se define mediante el SizeParamIndex campo .

Si especifica y SizeParamIndexMarshalAsAttribute.SizeConst con un UnmanagedType.LPArray campo, la suma de los valores de los campos genera un tamaño total.

Para obtener más información, vea Serialización predeterminada para matrices.

Consulte también

• SizeConst
• LPArray