Enumeración LayoutKind

 

Publicado: octubre de 2016

Controla el diseño de un objeto cuando se lo exporta a un código no administrado.

Espacio de nombres:   System.Runtime.InteropServices
Ensamblado:  mscorlib (en mscorlib.dll)

Sintaxis

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

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

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

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

Miembros

	Nombre de miembro	Descripción
	Auto	El runtime elige automáticamente un diseño adecuado para los miembros de un objeto en memoria no administrada. Los objetos definidos con este miembro de enumeración no se pueden exponer fuera del código administrado. Intenta hacerlo, genera una excepción.
	Explicit	La posición precisa de cada miembro de un objeto en memoria no administrada se controla explícitamente, sujeto a la configuración de la StructLayoutAttribute.Pack campo. Cada miembro debe utilizar el FieldOffsetAttribute para indicar la posición del campo dentro del tipo.
	Sequential	Los miembros del objeto se disponen secuencialmente, en el orden en que aparecen cuando se exportan a memoria no administrada. Los miembros están dispuestos de acuerdo con el empaquetado especificado en StructLayoutAttribute.Packy pueden no ser contiguos.

Comentarios

Esta enumeración se utiliza con StructLayoutAttribute. Common language runtime usa la Auto valor de diseño de forma predeterminada. Para reducir los problemas relacionados con el diseño asociados con el Auto valor, los compiladores de C#, Visual Basic y C++ especifican Sequential diseño para los tipos de valor.

Importante

El StructLayoutAttribute.Pack campo controla la alineación de campos de datos y, por tanto, afecta al diseño con independencia de la LayoutKind valor especificado. De forma predeterminada, el valor de Pack es 0, lo que indica el tamaño de la plataforma actual de empaquetado predeterminado. Por ejemplo, cuando usa el Explicit diseño y especifique las alineaciones de campo en límites de bytes, debe establecer Pack en 1 para obtener el resultado deseado.

Ejemplos

En el ejemplo siguiente se muestra la declaración administrada de la PtInRect función, que comprueba si un punto se encuentra dentro de un rectángulo y define una Point estructura con Sequential diseño y un Rect estructura con Explicit diseño.

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

}

Información de versión

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Ver también

Espacio de nombres System.Runtime.InteropServices

Volver al principio