LayoutKind Enum
Definition
Viktigt
En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.
Styr layouten för ett objekt när det exporteras till ohanterad kod.
public enum class LayoutKindpublic enum LayoutKind[System.Serializable]
public enum LayoutKind[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum LayoutKindtype LayoutKind = [<System.Serializable>]
type LayoutKind = [<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type LayoutKind = Public Enum LayoutKind- Arv
- Attribut
Fält
| Name | Värde | Description |
|---|---|---|
| Sequential | 0 | Medlemmarna i objektet anges sekventiellt i den ordning de visas när de exporteras till ohanterat minne. Medlemmarna anges enligt den förpackning som anges i Pack, och kan vara icke sammanhängande. |
| Extended | 1 | |
| Explicit | 2 | Den exakta positionen för varje medlem i ett objekt i ohanterat minne styrs uttryckligen, med förbehåll för fältets Pack inställning. Varje medlem måste använda för FieldOffsetAttribute att ange positionen för fältet inom typen. |
| Auto | 3 | Körningen väljer automatiskt en lämplig layout för medlemmarna i ett objekt i ohanterat minne. Objekt som definierats med den här uppräkningsmedlemmen kan inte exponeras utanför hanterad kod. Om du försöker göra det genereras ett undantag. |
Exempel
I följande exempel visas den hanterade deklarationen PtInRect av funktionen, som kontrollerar om en punkt ligger inom en rektangel och definierar en Point struktur med sekventiell layout och en Rect struktur med explicit layout.
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 NativeMethods
{
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 = NativeMethods::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
};
[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;
}
internal static class NativeMethods
{
[DllImport("user32.dll", CallingConvention=CallingConvention.StdCall)]
internal 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 = NativeMethods.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.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
Friend Class NativeMethods
<DllImport("user32.dll", CallingConvention := CallingConvention.StdCall)> _
Friend Shared Function PtInRect(ByRef r As Rect, p As Point) As Bool
End Function
End Class
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 = NativeMethods.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
Kommentarer
Den här uppräkningen används med StructLayoutAttribute. Den vanliga språkkörningen Auto använder layoutvärdet som standard. Om du vill minska layoutrelaterade problem som är associerade med Auto-värdet anger C#, Visual Basic och C++ kompilatorer Sequential layout för värdetyper.
Important
Fältet StructLayoutAttribute.Pack styr justeringen av datafält och påverkar därför layouten oavsett vilket LayoutKind värde du anger. Som standard är värdet Pack 0, vilket anger standardstorleken för paketering för den aktuella plattformen. När du till exempel använder Explicit layoutvärdet och anger fältjusteringar för bytegränser måste du ange Pack 1 för att få önskat resultat.
