LayoutKind-Enumeration

Artikel
04/20/2017

Veröffentlicht: Oktober 2016

Steuert das Layout eines Objekts beim Exportieren in nicht verwalteten Code.

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

Syntax

[SerializableAttribute]
[ComVisibleAttribute(true)]
public enum LayoutKind

[SerializableAttribute]
[ComVisibleAttribute(true)]
public enum class LayoutKind

[<SerializableAttribute>]
[<ComVisibleAttribute(true)>]
type LayoutKind

<SerializableAttribute>
<ComVisibleAttribute(True)>
Public Enumeration LayoutKind

Member

	Membername	Beschreibung
	Auto	Automatisch wählt die Laufzeit ein entsprechende Layout für die Member eines Objekts in nicht verwalteten Speicher. Mit diesem Enumerationsmember definierten Objekte können nicht außerhalb von verwaltetem Code verfügbar gemacht werden. Versuch wird eine Ausnahme generiert.
	Explicit	Die genaue Position der einzelnen Member eines Objekts in nicht verwaltetem Speicher explizit gesteuert wird, gemäß der Einstellung der StructLayoutAttribute.Pack Feld. Jedes Member verwenden, muss die FieldOffsetAttribute auf die Position dieses Felds im Typ anzugeben.
	Sequential	Die Member des Objekts werden sequenziell in der Reihenfolge angeordnet, in denen sie angezeigt, beim Exportieren in nicht verwalteten Speicher werden. Die Elemente im angegebenen angelegt StructLayoutAttribute.Pack, nicht zusammenhängende möglich.

Hinweise

Diese Enumeration wird zusammen mit StructLayoutAttribute. Die common Language Runtime verwendet die Auto standardmäßig Layoutwert. Zum Reduzieren der Layout-bezogene Probleme im Zusammenhang mit der Auto -Wert, c#, Visual Basic und C++-Compiler geben Sequential Layout für Werttypen.

Wichtig

Die StructLayoutAttribute.Pack Feld steuert die Ausrichtung der Datenfelder und wirkt sich daher auf das Layout unabhängig von der LayoutKind von Ihnen angegebene Wert. Standardmäßig wird der Wert der Pack ist 0, womit die Standardkomprimierungsgröße für die aktuelle Plattform. Z. B. bei Verwendung der Explicit Layout Wert und geben Sie die Ausrichtungen Feld auf Byte-Grenzen, müssen Sie festlegen Pack auf 1 fest, um das gewünschte Ergebnis zu erhalten.

Beispiele

Das folgende Beispiel zeigt die verwaltete Deklaration der PtInRect -Funktion, die überprüft, ob ein Punkt innerhalb eines Rechtecks befindet, und definiert einen Point Struktur mit Sequential Layout und ein Rect Struktur mit Explicit Layout.

enum Bool
{
   False = 0,
   True
};
[StructLayout(LayoutKind.Sequential)]
public struct Point 
{
   public int x;
   public int y;
}   

[StructLayout(LayoutKind.Explicit)]
public struct Rect 
{
   [FieldOffset(0)] public int left;
   [FieldOffset(4)] public int top;
   [FieldOffset(8)] public int right;
   [FieldOffset(12)] public int bottom;
}   

class LibWrapper
{
   [DllImport("user32.dll", CallingConvention=CallingConvention.StdCall)]
   public static extern Bool PtInRect(ref Rect r, Point p);
};

class TestApplication
{
   public static void Main()
   {
      try
      {
         Bool bPointInRect = 0;
         Rect myRect = new Rect();
         myRect.left = 10;
         myRect.right = 100;
         myRect.top = 10;
         myRect.bottom = 100;
         Point myPoint = new Point();
         myPoint.x = 50;
         myPoint.y = 50;
         bPointInRect = LibWrapper.PtInRect(ref myRect, myPoint);
         if(bPointInRect == Bool.True)
            Console.WriteLine("Point lies within the Rect");
         else
            Console.WriteLine("Point did not lie within the Rect");
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception : " + e.Message);
      }
   }
}

'  The program shows a managed declaration of the PtInRect function and defines Point
'  structure with sequential layout and Rect structure with explicit layout. The PtInRect
'  checks the point lies within the rectangle or not.
Imports System
Imports System.Runtime.InteropServices

   Enum Bool
      [False] = 0
      [True]
   End Enum 
   <StructLayout(LayoutKind.Sequential)>  _
   Public Structure Point
      Public x As Integer
      Public y As Integer
   End Structure 

   <StructLayout(LayoutKind.Explicit)>  _   
   Public Structure Rect
      <FieldOffset(0)> Public left As Integer
      <FieldOffset(4)> Public top As Integer
      <FieldOffset(8)> Public right As Integer
      <FieldOffset(12)> Public bottom As Integer
   End Structure 


   Class LibWrapper

      <DllImport("user32.dll", CallingConvention := CallingConvention.StdCall)>  _
      Public Shared Function PtInRect(ByRef r As Rect, p As Point) As Bool
      End Function  
   End Class 'LibWrapper


   Class TestApplication

      Public Shared Sub Main()
         Try
            Dim bPointInRect As Bool = 0
            Dim myRect As New Rect()
            myRect.left = 10
            myRect.right = 100
            myRect.top = 10
            myRect.bottom = 100
            Dim myPoint As New Point()
            myPoint.x = 50
            myPoint.y = 50
            bPointInRect = LibWrapper.PtInRect(myRect, myPoint)
            If bPointInRect = Bool.True Then
               Console.WriteLine("Point lies within the Rect")
            Else
               Console.WriteLine("Point did not lie within the Rect")
            End If
         Catch e As Exception
            Console.WriteLine(("Exception : " + e.Message.ToString()))
         End Try
      End Sub 
   End Class

enum class Bool
{
   False = 0,
   True
};


[StructLayout(LayoutKind::Sequential)]
value struct Point
{
public:
   int x;
   int y;
};


[StructLayout(LayoutKind::Explicit)]
value struct Rect
{
public:

   [FieldOffset(0)]
   int left;

   [FieldOffset(4)]
   int top;

   [FieldOffset(8)]
   int right;

   [FieldOffset(12)]
   int bottom;
};

ref class LibWrapper
{
public:

   [DllImport("user32.dll",CallingConvention=CallingConvention::StdCall)]
   static Bool PtInRect( Rect * r, Point p );
};

int main()
{
   try
   {
      Bool bPointInRect = (Bool)0;
      Rect myRect = Rect(  );
      myRect.left = 10;
      myRect.right = 100;
      myRect.top = 10;
      myRect.bottom = 100;
      Point myPoint = Point(  );
      myPoint.x = 50;
      myPoint.y = 50;
      bPointInRect = LibWrapper::PtInRect(  &myRect, myPoint );
      if ( bPointInRect == Bool::True )
            Console::WriteLine( "Point lies within the Rect" );
      else
            Console::WriteLine( "Point did not lie within the Rect" );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception : {0}", e->Message );
   }

}

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

System.Runtime.InteropServices-Namespace

Zurück zum Anfang

Freigeben über