MarshalAsAttribute.SizeParamIndex-Feld

Gibt an, welcher Parameter die Anzahl der Arrayelemente enthält, ähnlich wie size_is in COM, und ist nullbasiert.

Namespace: System.Runtime.InteropServices
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public SizeParamIndex As Short
'Usage
Dim instance As MarshalAsAttribute
Dim value As Short

value = instance.SizeParamIndex

instance.SizeParamIndex = value

public short SizeParamIndex

public:
short SizeParamIndex

public short SizeParamIndex

public var SizeParamIndex : short

Hinweise

Dieses Feld wird beim Erstellen verwalteter Objekte mit COM-Unterstützung verwendet. SizeParamIndex ist nur für verwaltete Methoden gültig, die von COM-Clients aufgerufen werden, wobei einer der Parameter ein Array ist. Da der Marshaller die Größe eines nicht verwalteten Arrays nicht bestimmen kann, wird diese Information als eigener Parameter übergeben.

Der Parameter mit der Größe muss eine als Wert übergebene Ganzzahl sein. Wenn Sie sowohl SizeParamIndex als auch MarshalAsAttribute.SizeConst mit UnmanagedType.LPArray angeben, stellt die Summe ihrer Werte einen Gesamtwert für die Größe dar. Dieses Feld wirkt sich nicht auf verwalteten Code aus, der COM-Objekte aufruft. Weitere Informationen finden Sie unter Standardmäßiges Marshalling für Arrays.

Beispiel

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

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();
    }
}

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 );
}

package SomeNamespace; 
import System.Runtime.InteropServices.*;
import SomeNamespace.*; 

/** @attribute StructLayout(LayoutKind.Sequential)
 */
public class Vertex
{
    private float x;
    private float y;
    private float z;
} //Vertex

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.
    /** @attribute DllImport("SomeDll.dll")
     */
    public static native void SomeUnsafeMethod(
        /** @attribute MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)
         */
        Vertex data[], long size);

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

class Test
{
    public static void main(String[] args)
    {
        SomeClass aClass = new SomeClass();
        aClass.SomeMethod();
    } //main
} //Test

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0

Siehe auch

Referenz

MarshalAsAttribute-Klasse
MarshalAsAttribute-Member
System.Runtime.InteropServices-Namespace
SizeConst
LPArray