LayoutKind Enumeração
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Controla o layout de um objeto quando exportado para código não gerido.
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- Herança
- Atributos
Campos
| Name | Valor | Description |
|---|---|---|
| Sequential | 0 | Os elementos do objeto estão dispostos sequencialmente, pela ordem em que aparecem quando exportados para memória não gerida. Os elementos estão dispostos de acordo com o empacotamento especificado em Pack, e podem ser não contíguos. |
| Explicit | 2 | A posição precisa de cada membro de um objeto na memória não gerida é explicitamente controlada, sujeita à configuração do Pack campo. Cada membro deve usar o FieldOffsetAttribute para indicar a posição desse campo dentro do tipo. |
| Auto | 3 | O runtime escolhe automaticamente um layout apropriado para os membros de um objeto na memória não gerida. Objetos definidos com este membro de enumeração não podem ser expostos fora do código gerido. Tentar fazê-lo gera uma exceção. |
Exemplos
O exemplo seguinte mostra a declaração gerida da PtInRect função, que verifica se um ponto se encontra dentro de um retângulo, e define uma Point estrutura com disposição sequencial e uma Rect estrutura com disposição explícita.
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
Observações
Esta enumeração é usada com StructLayoutAttribute. O runtime da linguagem comum usa o Auto valor do layout por defeito. Para reduzir problemas relacionados com o layout associados ao valor Auto, os compiladores C#, Visual Basic e C++ especificam o layout Sequential para os tipos de valor.
Importante
O StructLayoutAttribute.Pack campo controla o alinhamento dos campos de dados e, por isso, afeta a disposição independentemente do LayoutKind valor que especifique. Por defeito, o valor de Pack é 0, o que indica o tamanho de empacotamento por defeito para a plataforma atual. Por exemplo, quando usas o Explicit valor de layout e especificas alinhamentos de campos nos limites dos bytes, tens de definir Pack para 1 para obter o resultado desejado.