LayoutKind-Enumeration

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

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

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Enumeration LayoutKind
'Usage
Dim instance As LayoutKind

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

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

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public enum LayoutKind

SerializableAttribute 
ComVisibleAttribute(true) 
public enum LayoutKind

Member

	Membername	Beschreibung
	Auto	Für die Member eines Objekts in nicht verwaltetem Speicher wird zur Laufzeit automatisch ein angemessenes Layout ausgewählt. Mit diesem Enumerationsmember definierte Objekte können nicht außerhalb von verwaltetem Code verfügbar gemacht werden. Bei einem entsprechenden Versuch wird eine Ausnahme ausgelöst.
	Explicit	Die exakte Position der einzelnen Member eines Objekts in nicht verwaltetem Speicher wird explizit gesteuert. Jedes Member muss das FieldOffsetAttribute verwenden, um die Position dieses Felds innerhalb des Typs anzugeben.
	Sequential	Das Layout der Member des Objekts erfolgt sequenziell in der Reihenfolge, in der sich diese beim Export in nicht verwalteten Speicher befinden. Das Layout der Member entspricht der in StructLayoutAttribute.Pack angegebenen Komprimierung, und es darf nicht lückenhaft sein.

Hinweise

Diese Enumeration wird mit StructLayoutAttribute verwendet. Die Common Language Runtime verwendet in der Standardeinstellung den Auto-Layoutwert. Um Layoutprobleme wegen des Auto-Werts weitgehend auszuschließen, geben C#-, Visual Basic- und C++-Compiler Sequential-Layout für Werttypen an.

Beispiel

Im folgenden Beispiel wird die verwaltete Deklaration der PtInRect-Funktion veranschaulicht, die überprüft, ob sich ein Punkt innerhalb eines Rechtecks befindet, und es werden eine Point-Struktur mit Sequential-Layout und eine Rect-Struktur mit Explicit-Layout definiert.

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

<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 'Rect


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 lies within the Rect")
         End If
      Catch e As Exception
         Console.WriteLine(("Exception : " + e.Message.ToString()))
      End Try
   End Sub 'Main
End Class 'TestApplication

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 lies within the Rect");
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception : " + e.Message);
      }
   }
}

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

}

enum Bool
{
    False (0),
    True (1);
} //Bool

/** @attribute StructLayout(LayoutKind.Sequential)
 */
public class Point
{
    public static int x;
    public static int y;
} //Point

/** @attribute StructLayout(LayoutKind.Explicit)
 */
public class Rect
{
    /** @attribute FieldOffset(0) */ public int left;

    /** @attribute FieldOffset(4) */ public int top;

    /** @attribute FieldOffset(8) */ public int right;

    /** @attribute FieldOffset(12) */ public int bottom;
} //Rect

class LibWrapper
{
    /** @attribute DllImport("user32.dll", 
        CallingConvention = CallingConvention.StdCall)
     */
    public static native Bool PtInRect(/** @ref */ Rect r, Point p);
} //LibWrapper

class TestApplication
{
    public static void main(String[] args)
    {
        try {
            Bool bPointInRect = (Bool)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.Equals(Bool.True)) {
                Console.WriteLine("Point lies within the Rect");
            }
            else {
                Console.WriteLine("Point does not lie within the Rect");
            }
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception : " + e.get_Message());
        }
    } //main
} //TestApplication

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, 1.0

Siehe auch

Referenz

System.Runtime.InteropServices-Namespace