AbsoluteLayout Clase

Referencia

Definición

Espacio de nombres:: Xamarin.Forms

Ensamblado:: Xamarin.Forms.Core.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Coloca los elementos secundarios en posiciones absolutas.

public class AbsoluteLayout : Xamarin.Forms.Layout<Xamarin.Forms.View>, Xamarin.Forms.IElementConfiguration<Xamarin.Forms.AbsoluteLayout>

type AbsoluteLayout = class
    inherit Layout<View>
    interface IElementConfiguration<AbsoluteLayout>

Herencia: Object

BindableObject

Element

NavigableElement

VisualElement

View

Layout

Layout<View>
AbsoluteLayout

Implementaciones: IElementConfiguration<AbsoluteLayout>

Comentarios

Los desarrolladores de aplicaciones pueden controlar la colocación de elementos secundarios proporcionando coordenadas proporcionales, coordenadas del dispositivo o una combinación de ambos, en función de los AbsoluteLayoutFlags valores que se pasan al SetLayoutFlags(BindableObject, AbsoluteLayoutFlags) método . Cuando se proporciona uno de los valores de enumeración proporcionales AbsoluteLayoutFlags , los argumentos X o Y correspondientes que oscilan entre 0,0 y 1,0 siempre harán que el elemento secundario se muestre completamente en pantalla. Es decir, no es necesario restar ni agregar el alto o ancho de un elemento secundario para mostrarlo vaciado con la parte izquierda, derecha, superior o inferior de AbsoluteLayout. Para los valores de ancho, alto, X o Y que no se especifican proporcionalmente, los desarrolladores de aplicaciones usan unidades dependientes del dispositivo para buscar y ajustar el tamaño del elemento secundario.

En el ejemplo siguiente se muestra cómo usar un objeto AbsoluteLayout con argumentos de posición proporcionales.


Label header = new Label
{
    Text = "AbsoluteLayout Demo",
    FontSize = Device.GetNamedSize(NamedSize.Large, typeof(Label)),
    HorizontalOptions = LayoutOptions.Center
};

AbsoluteLayout simpleLayout = new AbsoluteLayout
{
    BackgroundColor = Color.Blue.WithLuminosity(0.9),
    VerticalOptions = LayoutOptions.FillAndExpand
};

topLeftLabel = new Label
{
    Text = "Top Left",
    TextColor = Color.Black
};

centerLabel = new Label
{
    Text = "Centered",
    TextColor = Color.Black
};

bottomRightLabel = new Label
{
    Text = "Bottom Right",
    TextColor = Color.Black
};

// PositionProportional flag maps the range (0.0, 1.0) to
// the range "flush [left|top]" to "flush [right|bottom]"
AbsoluteLayout.SetLayoutFlags(bottomRightLabel,
    AbsoluteLayoutFlags.PositionProportional);

AbsoluteLayout.SetLayoutBounds(topLeftLabel,
    new Rectangle(0f,
        0f, AbsoluteLayout.AutoSize, AbsoluteLayout.AutoSize));

AbsoluteLayout.SetLayoutFlags(centerLabel,
    AbsoluteLayoutFlags.PositionProportional);

AbsoluteLayout.SetLayoutBounds(centerLabel,
    new Rectangle(0.5,
        0.5, AbsoluteLayout.AutoSize, AbsoluteLayout.AutoSize));

AbsoluteLayout.SetLayoutFlags(bottomRightLabel,
    AbsoluteLayoutFlags.PositionProportional);

AbsoluteLayout.SetLayoutBounds(bottomRightLabel,
    new Rectangle(1f,
        1f, AbsoluteLayout.AutoSize, AbsoluteLayout.AutoSize));

simpleLayout.Children.Add(topLeftLabel);
simpleLayout.Children.Add(centerLabel);
simpleLayout.Children.Add(bottomRightLabel);

En el ejemplo de código siguiente se muestra cómo colocar dos etiquetas especificando unidades dependientes del dispositivo.


AbsoluteLayout simpleLayout = new AbsoluteLayout
{

    BackgroundColor = Color.Blue.WithLuminosity(0.9),
    VerticalOptions = LayoutOptions.FillAndExpand
};

Label header = new Label
{
    Text = "Device Units Demo",
    TextColor = Color.Black,
    FontSize = Device.GetNamedSize(NamedSize.Large, typeof(Label))
};

topLeftText = new Label
{
    Text = "Left",
    TextColor = Color.Black
};

AbsoluteLayout.SetLayoutFlags(topLeftText,
    AbsoluteLayoutFlags.None);

AbsoluteLayout.SetLayoutBounds(topLeftText,
    new Rectangle(0f, 0f, 100f, 50f));

middleText = new Label
{
    Text = "Device-dependent location",
    TextColor = Color.Black
};

AbsoluteLayout.SetLayoutFlags(middleText,
    AbsoluteLayoutFlags.None);

AbsoluteLayout.SetLayoutBounds(middleText,
    new Rectangle(100f, 200f, 200f, 50f));

simpleLayout.Children.Add(topLeftText);
simpleLayout.Children.Add(middleText);

}

En la imagen siguiente se muestra la demostración AbsoluteLayout del ejemplo FormsGallery .

XAML para Xamarin.Forms admite las siguientes propiedades adjuntas para la AbsoluteLayout clase :

Propiedad adjunta Value

AbsoluteLayout.LayoutBounds

Propiedad adjunta	Value
AbsoluteLayout.LayoutBounds	Una lista separada por comas (posiblemente con espacios) de cuatro valores que especifican la posición y las dimensiones del rectángulo delimitador. Los dos primeros valores de la lista deben representar números. Los dos últimos valores pueden ser números o la cadena "AutoSize". La `AbsoluteLayout.LayoutFlags` propiedad adjunta determina cómo se interpretan los valores de la lista para crear el rectángulo delimitador.
AbsoluteLayout.LayoutFlags	AbsoluteLayoutFlagsnombres de valor de enumeración: `All`, `None`, , `XProportionalHeightProportionalSizeProportionalWidthProportional`, , , `YProportional`o .`PositionProportional` Los desarrolladores de aplicaciones pueden combinar cualquiera de estas marcas proporcionando una lista separada por comas.

Una lista separada por comas (posiblemente con espacios) de cuatro valores que especifican la posición y las dimensiones del rectángulo delimitador. Los dos primeros valores de la lista deben representar números. Los dos últimos valores pueden ser números o la cadena "AutoSize". La AbsoluteLayout.LayoutFlags propiedad adjunta determina cómo se interpretan los valores de la lista para crear el rectángulo delimitador.

AbsoluteLayout.LayoutFlags

AbsoluteLayoutFlagsnombres de valor de enumeración: All, None, , XProportionalHeightProportionalSizeProportionalWidthProportional, , , YProportionalo .PositionProportional Los desarrolladores de aplicaciones pueden combinar cualquiera de estas marcas proporcionando una lista separada por comas.

Los desarrolladores de aplicaciones pueden usar XAML para diseñar elementos con la AbsoluteLayout clase . En el ejemplo siguiente se coloca un color azul BoxView dentro de :AbsoluteLayout

<AbsoluteLayout VerticalOptions="FillAndExpand"
                    HorizontalOptions="FillAndExpand">
<BoxView    AbsoluteLayout.LayoutBounds="0.25, 0.25, 0.5, 0.5"
                    Color="Blue"
                    AbsoluteLayout.LayoutFlags="All" />
</AbsoluteLayout>

La AbsoluteLayout clase puede colocar sus elementos secundarios en unidades proporcionales, unidades de dispositivo o una combinación de ambos. Los desarrolladores de aplicaciones deben recordar los siguientes puntos al especificar una Rectangle estructura que definirá los límites de diseño de un elemento secundario:

En el caso de los elementos cuyo alto y ancho caben en la pantalla, las dimensiones de posición proporcionales del intervalo [0,1] representan elementos que están completamente en la pantalla, independientemente de si el alto, el ancho o ambos se especifican en unidades de dispositivo o proporcionales.
El punto anterior significa que, para especificar un elemento en la esquina inferior derecha de la pantalla y que es la mitad tan ancha y media como la pantalla, con un AbsoluteLayoutFlags valor de , el desarrollador de Allaplicaciones especificaría "1.0, 1.0, 0.5, 0,5".
El desarrollador de la aplicación puede provocar accidentalmente elementos secundarios para los que se especificaron una o ambas dimensiones de tamaño proporcionalmente para mostrarse parcialmente fuera de la pantalla, o ocultar por completo, especificando posiciones de unidad de dispositivo que no dejan espacio suficiente para el tamaño calculado del elemento secundario.
Cada parte de la estructura delimitador Rectangle se interpreta según el AbsoluteLayoutFlags valor que lo controla. Un rectángulo determinado podría, por ejemplo, tener una coordenada X que se encuentra en unidades de dispositivo, una coordenada Y que se encuentra en unidades proporcionales, un alto que está en unidades proporcionales y un ancho que se encuentra en unidades de dispositivo o cualquier otra combinación de unidades proporcionales y de dispositivo.
Rectángulos que, cuando se interpretan mediante el conjunto actual AbsoluteLayoutFlags en el elemento secundario, representan cuadros de límite que están parcialmente o totalmente fuera de pantalla (por ejemplo, si tiene un ancho mayor que el ancho de pantalla) puede dar resultados inesperados.

Constructores

AbsoluteLayout()

Inicializa una nueva instancia de la clase AbsoluteLayout.

Campos

LayoutBoundsProperty	Implementa la propiedad adjunta que representa los límites de diseño de los elementos secundarios. Enlazable en tiempo de ejecución con la cadena "LayoutBounds". Vea la sección Comentarios.
LayoutFlagsProperty	Implementa la propiedad adjunta que contiene los valores de AbsoluteLayoutFlags de los elementos secundarios.

Propiedades

AnchorX	Obtiene o establece el componente X del punto central de cualquier transformación relativa a los límites del elemento. Es una propiedad enlazable. (Heredado de VisualElement)
AnchorY	Obtiene o establece el componente Y del punto central de cualquier transformación relativa a los límites del elemento. Es una propiedad enlazable. (Heredado de VisualElement)
AutomationId	Obtiene o establece un valor que permite que el marco de automatización busque este elemento e interactúe con él. (Heredado de Element)
AutoSize	Valor que indica que el ancho o el alto del elemento secundario se debe ajustar al tamaño nativo de ese elemento secundario.
Background	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
BackgroundColor	Obtiene o establece el color que rellenará el fondo de un VisualElement. Es una propiedad enlazable. (Heredado de VisualElement)
Batched	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
Behaviors	Obtiene la lista de comportamientos asociados a este elemento. Es una propiedad enlazable. (Heredado de VisualElement)
BindingContext	Obtiene o establece el objeto que contiene las propiedades que van a dirigir las propiedades enlazadas que pertenecen a este BindableObject. (Heredado de BindableObject)
Bounds	Obtiene los límites del elemento. (Heredado de VisualElement)
CascadeInputTransparent	Obtiene o establece un valor que controla si los elementos secundarios heredan la transparencia de entrada de `this` diseño cuando la transparencia se establece en `true`. (Heredado de Layout)
Children	Obtiene la colección de elementos secundarios de AbsoluteLayout.
class	Coloca los elementos secundarios en posiciones absolutas. (Heredado de NavigableElement)
ClassId	Obtiene o establece un valor que se usa para identificar una colección de elementos similares semánticamente. (Heredado de Element)
Clip	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
DisableLayout	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
Dispatcher	Coloca los elementos secundarios en posiciones absolutas. (Heredado de BindableObject)
EffectControlProvider	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
Effects	Lista de los efectos aplicados a este elemento. (Heredado de Element)
FlowDirection	Obtiene o establece la dirección de flujo del diseño. (Heredado de VisualElement)
GestureController	Obtiene el controlador de gestos de la vista. (Heredado de View)
GestureRecognizers	Colección de reconocedores de gestos asociados a esta vista. (Heredado de View)
Height	Obtiene el alto representado actualmente de este elemento. Esta propiedad enlazable es de solo lectura. (Heredado de VisualElement)
HeightRequest	Obtiene o establece la invalidación de alto deseado de este elemento. (Heredado de VisualElement)
HorizontalOptions	Obtiene o establece el objeto LayoutOptions que define cómo se dispone el elemento dentro de un ciclo de diseño. Es una propiedad enlazable. (Heredado de View)
Id	Obtiene un valor que se puede utilizar para identificar de forma única un elemento durante la ejecución de una aplicación. (Heredado de Element)
InputTransparent	Obtiene o establece un valor que indica si este elemento deber involucrarse en el ciclo de interacción del usuario. Es una propiedad enlazable. (Heredado de VisualElement)
IsClippedToBounds	Obtiene o establece un valor que determina si el diseño debe recortar sus elementos secundarios por sus límites. (Heredado de Layout)
IsEnabled	Obtiene o establece un valor que indica si este elemento está habilitado en la interfaz de usuario. Es una propiedad enlazable. (Heredado de VisualElement)
IsFocused	Obtiene un valor que indica si este elemento está visible en estos momentos. Es una propiedad enlazable. (Heredado de VisualElement)
IsInNativeLayout	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
IsNativeStateConsistent	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
IsPlatformEnabled	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
IsTabStop	Obtiene o establece un valor que indica si este elemento está incluido en la navegación por tabulación. Es una propiedad enlazable. (Heredado de VisualElement)
IsVisible	Obtiene o establece un valor que determina si estos elementos deben formar parte del árbol visual o no. Es una propiedad enlazable. (Heredado de VisualElement)
LogicalChildren	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
Margin	Obtiene o establece el margen de la vista. (Heredado de View)
MinimumHeightRequest	Obtiene o establece un valor que reemplaza la altura mínima que solicitará el elemento durante el diseño. (Heredado de VisualElement)
MinimumWidthRequest	Obtiene o establece un valor que reemplaza el ancho mínimo que solicitará el elemento durante el diseño. (Heredado de VisualElement)
Navigation	Coloca los elementos secundarios en posiciones absolutas. (Heredado de NavigableElement)
NavigationProxy	Coloca los elementos secundarios en posiciones absolutas. (Heredado de NavigableElement)
Opacity	Obtiene o establece el valor de opacidad aplicado al elemento cuando se representa. Es una propiedad enlazable. (Heredado de VisualElement)
Padding	Obtiene o establece el espaciado interno del diseño. (Heredado de Layout)
Parent	Obtiene o establece el elemento principal del elemento. (Heredado de Element)
ParentView	Obsoleto. Obtiene el elemento que es el antecesor más cercano de este elemento, que es un VisualElement. (Heredado de Element)
Platform	Obsoleto. Coloca los elementos secundarios en posiciones absolutas. (Heredado de Element)
RealParent	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
Resources	Obtiene o establece el diccionario de recursos locales. (Heredado de VisualElement)
Rotation	Obtiene o establece la rotación en grados sobre el eje Z (rotación afín) cuando se representa el elemento. (Heredado de VisualElement)
RotationX	Obtiene o establece la rotación en grados sobre el eje X (rotación de perspectiva) cuando se representa el elemento. (Heredado de VisualElement)
RotationY	Obtiene o establece la rotación en grados sobre el eje Y (rotación de perspectiva) cuando se representa el elemento. (Heredado de VisualElement)
Scale	Obtiene o establece el factor de escala aplicado al elemento. (Heredado de VisualElement)
ScaleX	Obtiene o establece un valor de escala que se aplicará a la dirección del eje X. (Heredado de VisualElement)
ScaleY	Obtiene o establece un valor de escala que se aplicará a la dirección del eje Y. (Heredado de VisualElement)
Style	Coloca los elementos secundarios en posiciones absolutas. (Heredado de NavigableElement)
StyleClass	Coloca los elementos secundarios en posiciones absolutas. (Heredado de NavigableElement)
StyleId	Obtiene o establece un valor definido por el usuario que identifica de forma única el elemento. (Heredado de Element)
TabIndex	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
TranslationX	Obtiene o establece el delta de traslación X del elemento. (Heredado de VisualElement)
TranslationY	Obtiene o establece el delta de traslación Y del elemento. (Heredado de VisualElement)
Triggers	Obtiene la lista de desencadenadores asociados a este elemento. Es una propiedad enlazable. (Heredado de VisualElement)
VerticalOptions	Obtiene o establece el objeto LayoutOptions que define cómo se dispone el elemento dentro de un ciclo de diseño. Es una propiedad enlazable. (Heredado de View)
Visual	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
Width	Obtiene el ancho representado actualmente de este elemento. Esta propiedad enlazable es de solo lectura. (Heredado de VisualElement)
WidthRequest	Obtiene o establece la invalidación de ancho deseado de este elemento. (Heredado de VisualElement)
X	Obtiene la posición X actual de este elemento. Esta propiedad enlazable es de solo lectura. (Heredado de VisualElement)
Y	Obtiene la posición Y actual de este elemento. Esta propiedad enlazable es de solo lectura. (Heredado de VisualElement)

Métodos

ApplyBindings()	Aplica los enlaces a BindingContext. (Heredado de BindableObject)
BatchBegin()	Señala el inicio de un lote de cambios en las propiedades de elementos. (Heredado de VisualElement)
BatchCommit()	Señala el final de un lote de comandos para el elemento y que esos comandos ahora deberían estar confirmados. (Heredado de VisualElement)
ChangeVisualState()	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
ClearValue(BindableProperty)	Borra cualquier valor establecido por SetValue para `property`. (Heredado de BindableObject)
ClearValue(BindablePropertyKey)	Borra cualquier valor establecido por SetValue para la propiedad que `propertyKey` identifica. (Heredado de BindableObject)
CoerceValue(BindableProperty)	Coloca los elementos secundarios en posiciones absolutas. (Heredado de BindableObject)
CoerceValue(BindablePropertyKey)	Coloca los elementos secundarios en posiciones absolutas. (Heredado de BindableObject)
Descendants()	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
EffectIsAttached(String)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
FindByName(String)	Recupera el elemento que tiene el nombre especificado. (Heredado de Element)
Focus()	Intenta establecer el foco en este elemento. (Heredado de VisualElement)
ForceLayout()	Fuerza un ciclo de diseño ciclo en el elemento y todos sus descendientes. (Heredado de Layout)
GetChildElements(Point)	Devuelve los elementos secundarios que están visualmente bajo el `point` especificado. (Heredado de View)
GetLayoutBounds(BindableObject)	Obtiene los límites de diseño de `bindable`.
GetLayoutFlags(BindableObject)	Obtiene las marcas de diseño que se especificaron cuando `bindable` se agregó a un objeto AbsoluteLayout.
GetSizeRequest(Double, Double)	Obsoleto. Devuelve SizeRequest del diseño. Al llamar a este método empieza el paso de medida de un ciclo de diseño. (Heredado de Layout)
GetValue(BindableProperty)	Devuelve el valor contenido en la propiedad BindableProperty. (Heredado de BindableObject)
GetValues(BindableProperty, BindableProperty)	Obsoleto. Para uso interno de la plataforma de Xamarin.Forms. (Heredado de BindableObject)
GetValues(BindableProperty, BindableProperty, BindableProperty)	Obsoleto. Para uso interno de la plataforma de Xamarin.Forms. (Heredado de BindableObject)
InvalidateLayout()	Invalida el diseño actual. (Heredado de Layout)
InvalidateMeasure()	Método que se llama para invalidar el diseño de este VisualElement. Genera el evento MeasureInvalidated. (Heredado de VisualElement)
InvalidateMeasureNonVirtual(InvalidationTrigger)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
IsSet(BindableProperty)	Devuelve `true` si existe y se ha establecido la propiedad de destino. (Heredado de BindableObject)
Layout(Rectangle)	Actualiza los límites del elemento durante el ciclo de diseño. (Heredado de VisualElement)
LayoutChildren(Double, Double, Double, Double)	Coloca y cambia el tamaño de los elementos secundarios de un AbsoluteLayout.
LowerChild(View)	Envía un elemento secundario al final de la pila visual. (Heredado de Layout)
Measure(Double, Double, MeasureFlags)	Devuelve el tamaño mínimo que un elemento visual necesita para mostrarse en el dispositivo. (Heredado de VisualElement)
NativeSizeChanged()	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
On<T>()	Devuelve el objeto de configuración que puede usar el desarrollador para llamar a métodos específicos de la plataforma para el diseño.
OnAdded(T)	Se invoca cuando se agrega un elemento secundario al diseño. Implemente este método a fin de agregar el control de clases para este evento. (Heredado de Layout<T>)
OnBindingContextChanged()	Se invoca siempre que cambia el contexto de enlace de View. Invalide este método a fin de agregar el control de clases para este evento. (Heredado de View)
OnChildAdded(Element)	Se llama cuando se agrega un elemento secundario a AbsoluteLayout.
OnChildMeasureInvalidated()	Se invoca cuando un elemento secundario del diseño ha emitido MeasureInvalidated. Implemente este método a fin de agregar el control de clases para este evento. (Heredado de Layout)
OnChildMeasureInvalidated(Object, EventArgs)	Se invoca cuando un elemento secundario del diseño ha emitido MeasureInvalidated. Implemente este método a fin de agregar el control de clases para este evento. (Heredado de Layout)
OnChildRemoved(Element)	Obsoleto. Se llama cuando se quita un elemento secundario de AbsoluteLayout.
OnChildRemoved(Element, Int32)	Coloca los elementos secundarios en posiciones absolutas.
OnChildrenReordered()	Se invoca siempre que el evento ChildrenReordered está a punto de ser emitido. Implemente este método a fin de agregar el control de clases para este evento. (Heredado de VisualElement)
OnMeasure(Double, Double)	Método que se llama cuando se produce una medición del diseño. (Heredado de VisualElement)
OnParentSet()	Coloca los elementos secundarios en posiciones absolutas. (Heredado de NavigableElement)
OnPropertyChanged(String)	Método al que se llama cuando una propiedad enlazada cambia. (Heredado de Element)
OnPropertyChanging(String)	Llama a este método desde una clase secundaria para notificar que se va a producir un cambio en una propiedad. (Heredado de BindableObject)
OnRemoved(T)	Se invoca cuando se quita un elemento secundario del diseño. Implemente este método a fin de agregar el control de clases para este evento. (Heredado de Layout<T>)
OnSizeAllocated(Double, Double)	Este método se llama cuando se establece el tamaño del elemento durante un ciclo de diseño. Este método se llama justo antes de que se produzca el evento SizeChanged. Implemente este método a fin de agregar el control de clases para este evento. (Heredado de Layout)
OnSizeRequest(Double, Double)	Obsoleto. Se llama durante el paso de medida de un ciclo de diseño para obtener el tamaño deseado de AbsoluteLayout.
OnTabIndexPropertyChanged(Int32, Int32)	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
OnTabStopPropertyChanged(Boolean, Boolean)	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
RaiseChild(View)	Envía un elemento secundario al principio de la pila visual. (Heredado de Layout)
RemoveBinding(BindableProperty)	Quita un enlace definida previamente. (Heredado de BindableObject)
RemoveDynamicResource(BindableProperty)	Quita un recurso dinámico definido previamente. (Heredado de Element)
ResolveLayoutChanges()	Coloca los elementos secundarios en posiciones absolutas. (Heredado de Layout)
SetBinding(BindableProperty, BindingBase)	Asigna un enlace a una propiedad. (Heredado de BindableObject)
SetDynamicResource(BindableProperty, String)	Establece que la propiedad BindableProperty de este elemento se actualice a través del DynamicResource con la clave proporcionada. (Heredado de Element)
SetLayoutBounds(BindableObject, Rectangle)	Establece los límites de diseño de una vista que se usarán para cambiarla de tamaño cuando vaya a disponerse.
SetLayoutFlags(BindableObject, AbsoluteLayoutFlags)	Establece las marcas de diseño de una vista que se usarán para interpretar los límites de diseño establecidos en dicha vista cuando se agregue al diseño.
SetValue(BindableProperty, Object)	Establece el valor de la propiedad especificada. (Heredado de BindableObject)
SetValue(BindablePropertyKey, Object)	Establece el valor de la propiedad propertyKey. (Heredado de BindableObject)
SetValueCore(BindableProperty, Object, SetValueFlags)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de BindableObject)
SetValueFromRenderer(BindableProperty, Object)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
SetValueFromRenderer(BindablePropertyKey, Object)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
ShouldInvalidateOnChildAdded(View)	Una vez implementado, debería devolver `true` si `child` llama a InvalidateMeasure() y devolver `false` en caso contrario. (Heredado de Layout)
ShouldInvalidateOnChildRemoved(View)	Una vez implementado, debería devolver `true` si `child` llama a InvalidateMeasure() al quitarse y devolver `false` en caso contrario. (Heredado de Layout)
SizeAllocated(Double, Double)	Se llama a SizeAllocated durante un ciclo de diseño para indicar el inicio de un diseño de árbol secundario. (Heredado de VisualElement)
TabIndexDefaultValueCreator()	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
TabStopDefaultValueCreator()	Coloca los elementos secundarios en posiciones absolutas. (Heredado de VisualElement)
UnapplyBindings()	Deshace todos los enlaces establecidos previamente. (Heredado de BindableObject)
Unfocus()	Anula el foco en este elemento. (Heredado de VisualElement)
UpdateChildrenLayout()	Indica al diseño que rediseñe todos sus elementos secundarios. (Heredado de Layout)

Eventos

BatchCommitted	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
BindingContextChanged	Se produce siempre que cambia la propiedad BindingContext. (Heredado de BindableObject)
ChildAdded	Se produce cada vez que se agrega un elemento secundario al elemento. (Heredado de Element)
ChildRemoved	Se produce cada vez que se quita un elemento secundario del elemento. (Heredado de Element)
ChildrenReordered	Se produce cuando se han vuelto a ordenar los elementos secundarios de un VisualElement. (Heredado de VisualElement)
DescendantAdded	Se produce cada vez que se agrega un elemento secundario al subárbol de elementos. (Heredado de Element)
DescendantRemoved	Se produce cada vez que se quita un elemento secundario del subárbol de elementos. (Heredado de Element)
FocusChangeRequested	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de VisualElement)
Focused	Se produce cuando el elemento recibe el foco. (Heredado de VisualElement)
LayoutChanged	Se produce al final de un ciclo de diseño si alguna Bounds del elemento secundario ha cambiado. (Heredado de Layout)
MeasureInvalidated	Evento que se provoca cuando se invalida el diseño de un elemento visual. (Heredado de VisualElement)
PlatformSet	Obsoleto. Coloca los elementos secundarios en posiciones absolutas. (Heredado de Element)
PropertyChanged	Se produce cuando ha cambiado una propiedad. (Heredado de BindableObject)
PropertyChanging	Se produce cuando una propiedad está a punto de cambiar. (Heredado de BindableObject)
SizeChanged	Se produce cuando las propiedades Width o Height cambian el valor en este elemento. (Heredado de VisualElement)
Unfocused	Se produce cuando el elemento pierde el foco. (Heredado de VisualElement)

Implementaciones de interfaz explícitas

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de BindableObject)
IElementController.SetValueFromRenderer(BindableProperty, Object)	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de Element)
IGestureController.CompositeGestureRecognizers	Para uso interno de la plataforma de Xamarin.Forms. (Heredado de View)
INameScope.RegisterName(String, Object)	Sólo para uso interno. (Heredado de Element)
IVisualElementController.EffectiveFlowDirection	Obtiene la dirección de flujo visual efectiva para el elemento en la plataforma, teniendo en cuenta la configuración regional y del flujo lógico. (Heredado de VisualElement)
IVisualElementController.InvalidateMeasure(InvalidationTrigger)	Este método es para uso interno. (Heredado de VisualElement)

Métodos de extensión

AbortAnimation(IAnimatable, String)	Detiene la animación.
Animate(IAnimatable, String, Action<Double>, Double, Double, UInt32, UInt32, Easing, Action<Double,Boolean>, Func<Boolean>)	Establece los parámetros especificados e inicia la animación.
Animate(IAnimatable, String, Action<Double>, UInt32, UInt32, Easing, Action<Double,Boolean>, Func<Boolean>)	Establece los parámetros especificados e inicia la animación.
Animate(IAnimatable, String, Animation, UInt32, UInt32, Easing, Action<Double,Boolean>, Func<Boolean>)	Establece los parámetros especificados e inicia la animación.
Animate<T>(IAnimatable, String, Func<Double,T>, Action<T>, UInt32, UInt32, Easing, Action<T,Boolean>, Func<Boolean>)	Establece los parámetros especificados e inicia la animación.
AnimateKinetic(IAnimatable, String, Func<Double,Double,Boolean>, Double, Double, Action)	Establece los parámetros especificados e inicia la animación cinética.
AnimationIsRunning(IAnimatable, String)	Devuelve un valor booleano que indica si la animación que ha especificado `handle` se está ejecutando o no.
Batch(IAnimatable)	Coloca los elementos secundarios en posiciones absolutas.
GetPropertyIfSet<T>(BindableObject, BindableProperty, T)	Coloca los elementos secundarios en posiciones absolutas.
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)	Coloca los elementos secundarios en posiciones absolutas.
SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)	Crea y aplica un enlace a una propiedad.
SetBinding<TSource>(BindableObject, BindableProperty, Expression<Func<TSource,Object>>, BindingMode, IValueConverter, String)	Obsoleto. Crea y aplica un enlace desde una expresión.
SetOnAppTheme<T>(BindableObject, BindableProperty, T, T)	Coloca los elementos secundarios en posiciones absolutas.
FindByName<T>(Element, String)	Devuelve la instancia del tipo `T` que tiene el nombre `name` en el ámbito que incluye `element`.
FindNextElement(ITabStopElement, Boolean, IDictionary<Int32,List<ITabStopElement>>, Int32)	Coloca los elementos secundarios en posiciones absolutas.
GetSortedTabIndexesOnParentPage(VisualElement)	Coloca los elementos secundarios en posiciones absolutas.
GetTabIndexesOnParentPage(ITabStopElement, Int32)	Coloca los elementos secundarios en posiciones absolutas.
FadeTo(VisualElement, Double, UInt32, Easing)	Devuelve una tarea que realiza la atenuación que describen los parámetros `opacity`, `length` y `easing`.
LayoutTo(VisualElement, Rectangle, UInt32, Easing)	Devuelve una tarea que disminuye los límites del VisualElement especificado por la `view` al rectángulo especificado por el parámetro `bounds`.
RelRotateTo(VisualElement, Double, UInt32, Easing)	Gira el VisualElement especificado por `view` de su giro actual por `drotation`.
RelScaleTo(VisualElement, Double, UInt32, Easing)	Devuelve una tarea que escala el VisualElement especificado por `view` de su escala actual a `dscale`.
RotateTo(VisualElement, Double, UInt32, Easing)	Devuelve una tarea que realiza la rotación que describen los parámetros `rotation`, `length` y `easing`.
RotateXTo(VisualElement, Double, UInt32, Easing)	Devuelve una tarea que sesga el eje Y por `opacity`, al tomar la `length` del período y al usar `easing`.
RotateYTo(VisualElement, Double, UInt32, Easing)	Devuelve una tarea que sesga el eje X por `opacity`, al tomar la `length` del período y al usar `easing`.
ScaleTo(VisualElement, Double, UInt32, Easing)	Devuelve una tarea que escala el VisualElement especificado por `view` al factor `scale` de escala absoluta.
ScaleXTo(VisualElement, Double, UInt32, Easing)	Coloca los elementos secundarios en posiciones absolutas.
ScaleYTo(VisualElement, Double, UInt32, Easing)	Coloca los elementos secundarios en posiciones absolutas.
TranslateTo(VisualElement, Double, Double, UInt32, Easing)	Anima las propiedades TranslationX y TranslationY de un elemento de sus valores actuales a los nuevos. Esto garantiza que el diseño de entrada está en la misma posición que el diseño visual.
HasVisualStateGroups(VisualElement)	Devuelve `true` si `element` tiene uno o varios grupos de estado visual asociados a él. De lo contrario, devuelve `false`.

Se aplica a