MarshalAsAttribute.SizeParamIndex-Feld

Artikel
04/20/2017

Veröffentlicht: Oktober 2016

Gibt den nullbasierten Parameter an, die die Anzahl der Arrayelemente, die ähnlich wie enthält size_is in COM.

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

Syntax

public short SizeParamIndex

public:
short SizeParamIndex

val mutable SizeParamIndex : int16

Public SizeParamIndex As Short

Feldwert

Type: System.Int16

Hinweise

Die SizeParamIndex Feld verwalteten zum nicht verwalteten und nicht verwalteten zum verwalteten Aufrufe unterstützt. Es muss nicht auf verwalteten Code, die COM-Objekte aufruft.

Abhängig von den verwalteten Typ und die Attribute angewendet wird kann das Array als sicheres Array oder als Array im C-Format übergeben werden.

Wenn Arrays als Arrays im C-Format übergeben werden, kann nicht der Marshaller die Größe des Arrays bestimmen. Um ein verwaltetes Array an eine nicht verwaltete Funktion oder Methode zu übergeben, müssen Sie daher zwei Argumente bereitstellen:

Das Array, das als Verweis oder Wert definiert.
Die Array-Größe, die als Verweis oder Wert definiert.

Der nullbasierte Index des Array-Größe Parameters wird definiert, mit dem SizeParamIndex Feld.

Wenn Sie beide angeben SizeParamIndex und MarshalAsAttribute.SizeConst mit einem UnmanagedType.LPArray Feld die Summe der Werte für die Felder Größe insgesamt erzeugt.

Weitere Informationen finden Sie unter Default Marshaling for Arrays.

Beispiele

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

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

Versionsinformationen

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Siehe auch

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

Zurück zum Anfang

Freigeben über