MarshalAsAttribute.SizeParamIndex MarshalAsAttribute.SizeParamIndex MarshalAsAttribute.SizeParamIndex MarshalAsAttribute.SizeParamIndex Field

Definition

Gibt den nullbasierten Parameter an, der die Anzahl von Arrayelementen enthält, vergleichbar mit size_is in COM.Indicates the zero-based parameter that contains the count of array elements, similar to size_is in COM.

public: short SizeParamIndex;
public short SizeParamIndex;
val mutable SizeParamIndex : int16
Public SizeParamIndex As Short 

Feldwert

Beispiele

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

Hinweise

Die SizeParamIndex Feld unterstützt verwalteten zum nicht verwalteten und nicht verwalteten zu verwalteten aufrufen.The SizeParamIndex field supports managed-to-unmanaged and unmanaged-to-managed calls. Er verfügt nicht über keine Auswirkungen auf die verwalteten Code, der COM-Objekte aufruft.It does not have any effect on managed code that calls COM objects.

Abhängig von den verwalteten Typ und die Attribute, die angewendet wird kann das Array als ein sicheres Array oder ein Array im C-Format übergeben werden.Depending on the managed type and the attributes applied to it, the array can be passed as a safe array or C-style array.

Wenn Arrays als Arrays im C-Stil übergeben werden, kann nicht der Marshaller die Größe des Arrays ermitteln.When arrays are passed as C-style arrays, the marshaler cannot determine the size of the array. Um ein verwaltetes Array an eine nicht verwaltete Funktion oder Methode zu übergeben, müssen Sie daher zwei Argumente angeben:Therefore, to pass an managed array to an unmanaged function or method, you must provide two arguments:

  • Das Array, das von Verweis- oder Werttyp definiert.The array, defined by reference or value.

  • Die Arraygröße von Verweis- oder Werttyp definiert.The array size, defined by reference or value.

Der nullbasierte Index des Arrays Size-Parameter wird definiert, mit der SizeParamIndex Feld.The zero-based index of the array size parameter is defined by using the SizeParamIndex field.

Wenn Sie beide angeben SizeParamIndex und MarshalAsAttribute.SizeConst mit einem UnmanagedType.LPArray Feld ist, wird die Summe der Werte für die Felder erzeugt Größe insgesamt.If you specify both SizeParamIndex and MarshalAsAttribute.SizeConst with a UnmanagedType.LPArray field, the sum of the fields' values produces a size total.

Weitere Informationen finden Sie unter Standardmäßiges Marshalling für Arrays.For more information, see Default Marshaling for Arrays.

Gilt für:

Siehe auch