AbsoluteLayout Classe

Définition

Espace de noms:

Xamarin.Forms

Assembly:

Xamarin.Forms.Core.dll

Positionne des éléments enfants sur des positions absolues.

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

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

Héritage

System.Object

BindableObject

Element

NavigableElement

VisualElement

View

Layout

Layout<View>

AbsoluteLayout

Implémente

IElementConfiguration<AbsoluteLayout>

Remarques

Les développeurs d’applications peuvent contrôler le placement des éléments enfants en fournissant des coordonnées proportionnelles, des coordonnées d’appareil ou une combinaison des deux, en fonction des valeurs passées à SetLayoutFlags(BindableObject, AbsoluteLayoutFlags) la AbsoluteLayoutFlags méthode. Lorsque l’une des valeurs d’énumération proportionnelle AbsoluteLayoutFlags est fournie, les arguments X ou Y correspondants qui se situent entre 0,0 et 1,0 entraînent toujours l’affichage complet de l’enfant à l’écran. Autrement dit, vous n’avez pas besoin de soustraire ou d’ajouter la hauteur ou la largeur d’un enfant pour l’afficher avec la gauche, la droite, le haut ou le AbsoluteLayoutbas du . Pour les valeurs width, height, X ou Y qui ne sont pas spécifiées proportionnellement, les développeurs d’applications utilisent des unités dépendantes de l’appareil pour localiser et dimensionner l’élément enfant.

L’exemple suivant montre comment utiliser un AbsoluteLayout avec des arguments de position proportionnelle.

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

L’exemple de code ci-dessous montre comment placer deux étiquettes en spécifiant des unités dépendantes de l’appareil.

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

}

L’image suivante montre la démonstration AbsoluteLayout de l’exemple FormsGallery .

XAML pour Xamarin. Forms prend en charge les propriétés jointes suivantes pour la AbsoluteLayout classe :

Propriété attachée	Valeur
AbsoluteLayout.LayoutBounds	Liste séparée par des virgules (éventuellement avec des espaces) de quatre valeurs qui spécifient la position et les dimensions du rectangle englobant. Les deux premières valeurs de la liste doivent représenter des nombres. Les deux dernières valeurs peuvent être des nombres ou la chaîne « Taille automatique ». La AbsoluteLayout.LayoutFlags propriété jointe détermine comment les valeurs de la liste sont interprétées pour créer le rectangle englobant.
AbsoluteLayout.LayoutFlags	AbsoluteLayoutFlagsnoms des valeurs d’énumération : All, None, HeightProportional, WidthProportionalSizeProportional, XProportional, YProportional, ou PositionProportional. Les développeurs d’applications peuvent combiner l’un de ces indicateurs en fournissant une liste séparée par des virgules.

Les développeurs d’applications peuvent utiliser XAML pour mettre en place des éléments avec la AbsoluteLayout classe . L’exemple ci-dessous place un bleu BoxView à l’intérieur d’un 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 classe peut disposer ses éléments enfants en unités proportionnelles, unités d’appareil ou une combinaison des deux. Les développeurs d’applications doivent se rappeler les points suivants lors de la spécification d’une Rectangle structure qui définira les limites de disposition d’un élément enfant :

• Pour les éléments dont la hauteur et la largeur s’ajustent à l’écran, les dimensions de position proportionnelle dans la plage [0,1] représentent les éléments qui se trouvent entièrement sur l’écran, que la hauteur, la largeur ou les deux soient spécifiées en unités d’appareil ou proportionnelles. :
• Le point ci-dessus signifie que, pour spécifier un élément dans le coin inférieur droit de l’écran et qui est moitié moins large et moitié moins large que l’écran, avec la AbsoluteLayoutFlags valeur , le développeur d’application Allspécifie « 1.0, 1.0, 0.5, 0.5 ». :
• Le développeur d’application peut par inadvertance faire en sorte que les éléments enfants pour lesquels une ou les deux dimensions de taille ont été spécifiées proportionnellement soient affichés partiellement hors de l’écran, ou masqués, en spécifiant des positions d’unité d’appareil qui ne laissent pas suffisamment de place pour la taille calculée de l’enfant. :
• Chaque partie de la structure englobante Rectangle est interprétée en fonction de la valeur qui la AbsoluteLayoutFlags contrôle. Un rectangle donné peut, par exemple, avoir une coordonnée X qui est en unités d’appareil, une coordonnée Y qui est en unités proportionnelles, une hauteur qui est en unités proportionnelles et une largeur qui est en unités d’appareil, ou toute autre combinaison d’unités d’appareil et d’unités proportionnelles. :
• Les rectangles qui, lorsqu’ils sont interprétés à l’aide de l’ensemble actuel AbsoluteLayoutFlags sur l’enfant, représentent des zones englobantes partiellement ou totalement hors écran( par exemple, en ayant une largeur supérieure à la largeur de l’écran) peuvent donner des résultats inattendus.

Constructeurs

AbsoluteLayout()

Initialise une nouvelle instance de la classe AbsoluteLayout.

Champs

LayoutBoundsProperty	Implémente la propriété jointe qui représente les limites de disposition des éléments enfants. Peut être lié au moment de l’exécution avec la chaîne « LayoutBounds ». Consultez la section Notes.
LayoutFlagsProperty	Implémente la propriété jointe qui contient les valeurs AbsoluteLayoutFlags pour des éléments enfants.

Propriétés

AnchorX	Obtient ou définit le composant X du point central d’une transformation par rapport aux limites de l’élément. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
AnchorY	Obtient ou définit le composant Y du point central d’une transformation par rapport aux limites de l’élément. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
AutomationId	Obtient ou définit une valeur qui permet au framework d’automatisation de rechercher cet élément et d’interagir avec celui-ci. (Hérité de Element)
AutoSize	Valeur qui indique que la largeur ou hauteur de l’enfant doit être dimensionnée à la taille native de cet enfant.
Background	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
BackgroundColor	Obtient ou définit la couleur qui remplit l’arrière-plan d’un VisualElement. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
Batched	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
Behaviors	Obtient la liste des valeurs Behavior associées à cet élément. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
BindingContext	Obtient ou définit l’objet qui contient les propriétés qui seront ciblées par les propriétés liées appartenant à ce BindableObject. (Hérité de BindableObject)
Bounds	Obtient les limites de l’élément. (Hérité de VisualElement)
CascadeInputTransparent	Obtient ou définit une valeur qui contrôle si les éléments enfants héritent de la transparence d’entrée de la disposition this quand la transparence est true. (Hérité de Layout)
Children	Obtient la collection des éléments enfants d’AbsoluteLayout.
class	Positionne des éléments enfants sur des positions absolues. (Hérité de NavigableElement)
ClassId	Obtient ou définit une valeur utilisée pour identifier une collection d’éléments sémantiquement similaires. (Hérité de Element)
Clip	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
DisableLayout	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
Dispatcher	Positionne des éléments enfants sur des positions absolues. (Hérité de BindableObject)
EffectControlProvider	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
Effects	Liste des effets appliqués à cet élément. (Hérité de Element)
FlowDirection	Obtient ou définit le sens de déroulement de la disposition. (Hérité de VisualElement)
GestureController	Obtient le contrôleur de mouvement pour la vue. (Hérité de View)
GestureRecognizers	Collection de modules de reconnaissance de mouvement associée à cette vue. (Hérité de View)
Height	Obtient la hauteur rendue actuelle de cet élément. Il s’agit d’une propriété en lecture seule et pouvant être liée. (Hérité de VisualElement)
HeightRequest	Obtient ou définit la substitution de hauteur souhaitée de cet élément. (Hérité de VisualElement)
HorizontalOptions	Obtient ou définit les LayoutOptions qui définissent la façon dont l’élément est disposé dans un cycle de disposition. Il s’agit d’une propriété pouvant être liée. (Hérité de View)
Id	Obtient une valeur qui permet d’identifier de façon unique un élément lors de l’exécution d’une application. (Hérité de Element)
InputTransparent	Obtient ou définit une valeur indiquant si cet élément doit intervenir dans le cycle d’interaction de l’utilisateur. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
IsClippedToBounds	Obtient ou définit une valeur qui détermine si le Layout doit réduire ses enfants à ses limites. (Hérité de Layout)
IsEnabled	Obtient ou définit une valeur indiquant si cet élément est activé dans l’interface utilisateur. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
IsFocused	Obtient une valeur indiquant si cet élément a actuellement le focus. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
IsInNativeLayout	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
IsNativeStateConsistent	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
IsPlatformEnabled	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
IsTabStop	Obtient ou définit l'inclusion ou non de cet élément dans la navigation par onglets. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
IsVisible	Obtient ou définir une valeur qui détermine si cet élément doit, ou non, faire partie de l’arborescence d’éléments visuels. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
LogicalChildren	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
Margin	Obtient ou définit la marge pour la vue. (Hérité de View)
MinimumHeightRequest	Obtient ou définit une valeur qui substitue la hauteur minimale que l’élément demandera pendant la disposition. (Hérité de VisualElement)
MinimumWidthRequest	Obtient ou définit une valeur qui substitue la largeur minimale que l’élément demandera pendant la disposition. (Hérité de VisualElement)
Navigation	Positionne des éléments enfants sur des positions absolues. (Hérité de NavigableElement)
NavigationProxy	Positionne des éléments enfants sur des positions absolues. (Hérité de NavigableElement)
Opacity	Obtient ou définit la valeur d’opacité appliquée à l’élément quand il est rendu. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
Padding	Obtient ou définit le remplissage interne du Layout. (Hérité de Layout)
Parent	Obtient ou définit l’élément parent de l’élément. (Hérité de Element)
ParentView	Obsolète. Obtient l’élément qui est l’ancêtre le plus proche de cet élément VisualElement. (Hérité de Element)
Platform	Obsolète. Positionne des éléments enfants sur des positions absolues. (Hérité de Element)
RealParent	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
Resources	Obtient ou définit le dictionnaire de ressources local. (Hérité de VisualElement)
Rotation	Obtient ou définit la rotation (en degrés) autour de l’axe Z (rotation affine) quand l’élément est rendu. (Hérité de VisualElement)
RotationX	Obtient ou définit la rotation (en degrés) autour de l’axe X (rotation de perspective) quand l’élément est rendu. (Hérité de VisualElement)
RotationY	Obtient ou définit la rotation (en degrés) autour de l’axe Y (rotation de perspective) quand l’élément est rendu. (Hérité de VisualElement)
Scale	Obtient ou définit le facteur d’échelle appliqué à l’élément. (Hérité de VisualElement)
ScaleX	Obtient ou définit une valeur d’échelle à appliquer à l’axe X. (Hérité de VisualElement)
ScaleY	Obtient ou définit une valeur d’échelle à appliquer à l’axe Y. (Hérité de VisualElement)
Style	Positionne des éléments enfants sur des positions absolues. (Hérité de NavigableElement)
StyleClass	Positionne des éléments enfants sur des positions absolues. (Hérité de NavigableElement)
StyleId	Obtient ou définit une valeur définie par l’utilisateur permettant d’identifier de façon unique l’élément. (Hérité de Element)
TabIndex	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
TranslationX	Obtient ou définit le delta de translation X de l’élément. (Hérité de VisualElement)
TranslationY	Obtient ou définit le delta de translation Y de l’élément. (Hérité de VisualElement)
Triggers	Obtient la liste des valeurs Trigger associées à cet élément. Il s’agit d’une propriété pouvant être liée. (Hérité de VisualElement)
VerticalOptions	Obtient ou définit les LayoutOptions qui définissent la façon dont l’élément est disposé dans un cycle de disposition. Il s’agit d’une propriété pouvant être liée. (Hérité de View)
Visual	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
Width	Obtient la largeur rendue actuelle de cet élément. Il s’agit d’une propriété en lecture seule et pouvant être liée. (Hérité de VisualElement)
WidthRequest	Obtient ou définit la substitution de largeur souhaitée de cet élément. (Hérité de VisualElement)
X	Obtient la position X actuelle de cet élément. Il s’agit d’une propriété en lecture seule et pouvant être liée. (Hérité de VisualElement)
Y	Obtient la position Y actuelle de cet élément. Il s’agit d’une propriété en lecture seule et pouvant être liée. (Hérité de VisualElement)

Méthodes

ApplyBindings()	Applique les liaisons à BindingContext. (Hérité de BindableObject)
BatchBegin()	Signale le début d’un lot de modifications aux propriétés des éléments. (Hérité de VisualElement)
BatchCommit()	Signale la fin d’un lot de commandes à l’élément et que ces commandes doivent maintenant être validées. (Hérité de VisualElement)
ChangeVisualState()	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
ClearValue(BindableProperty)	Efface toute valeur définie par SetValue pour property. (Hérité de BindableObject)
ClearValue(BindablePropertyKey)	Efface toute valeur définie par SetValue pour la propriété qui est identifiée par propertyKey. (Hérité de BindableObject)
CoerceValue(BindableProperty)	Positionne des éléments enfants sur des positions absolues. (Hérité de BindableObject)
CoerceValue(BindablePropertyKey)	Positionne des éléments enfants sur des positions absolues. (Hérité de BindableObject)
Descendants()	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
EffectIsAttached(String)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
FindByName(String)	Retourne l'élément ayant le nom spécifié. (Hérité de Element)
Focus()	Tente de définir le focus sur cet élément. (Hérité de VisualElement)
ForceLayout()	Applique un cycle de disposition à l’élément et à tous ses descendants. (Hérité de Layout)
GetChildElements(Point)	Retourne les éléments enfants qui se trouvent visuellement sous le point spécifié. (Hérité de View)
GetLayoutBounds(BindableObject)	Obtient les limites de disposition de bindable.
GetLayoutFlags(BindableObject)	Obtient les indicateurs de disposition qui ont été spécifiés quand bindable a été ajouté à un AbsoluteLayout.
GetSizeRequest(Double, Double)	Obsolète. Retourne le SizeRequest du Layout. L’appel de cette méthode lance la passe de mesure d’un cycle de disposition. (Hérité de Layout)
GetValue(BindableProperty)	Retourne la valeur qui est contenue dans BindableProperty. (Hérité de BindableObject)
GetValues(BindableProperty, BindableProperty, BindableProperty)	Obsolète. Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de BindableObject)
GetValues(BindableProperty, BindableProperty)	Obsolète. Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de BindableObject)
InvalidateLayout()	Invalide la disposition actuelle. (Hérité de Layout)
InvalidateMeasure()	Méthode qui est appelée pour invalider la disposition de ce VisualElement. Déclenche l’événement MeasureInvalidated. (Hérité de VisualElement)
InvalidateMeasureNonVirtual(InvalidationTrigger)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
IsSet(BindableProperty)	Retourne true si la propriété cible existe et qu’elle a été configurée. (Hérité de BindableObject)
Layout(Rectangle)	Met à jour les limites de l’élément pendant le cycle de disposition. (Hérité de VisualElement)
LayoutChildren(Double, Double, Double, Double)	Positionne et dimensionne les enfants d’un AbsoluteLayout.
LowerChild(View)	Envoie un enfant à l’arrière de la pile d’objets visuels. (Hérité de Layout)
Measure(Double, Double, MeasureFlags)	Retourne la taille minimale dont un élément visuel a besoin pour s’afficher sur l’appareil. (Hérité de VisualElement)
NativeSizeChanged()	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
On<T>()	Retourne l’objet de configuration que le développeur peut utiliser pour appeler des méthodes propres à la plateforme pour la disposition.
OnAdded(T)	Appelée quand un enfant est ajouté à la disposition. Implémentez cette méthode pour ajouter la gestion de classes pour cet événement. (Hérité de Layout<T>)
OnBindingContextChanged()	Appelée chaque fois que le contexte de liaison de l’objet View change. Substitue cette méthode pour permettre la gestion de classes pour cet événement. (Hérité de View)
OnChildAdded(Element)	Appelée quand un enfant est ajouté à l’AbsoluteLayout.
OnChildMeasureInvalidated()	Appelée chaque fois qu’un enfant de la disposition a émis MeasureInvalidated. Implémentez cette méthode pour ajouter la gestion de classes pour cet événement. (Hérité de Layout)
OnChildMeasureInvalidated(Object, EventArgs)	Appelée chaque fois qu’un enfant de la disposition a émis MeasureInvalidated. Implémentez cette méthode pour ajouter la gestion de classes pour cet événement. (Hérité de Layout)
OnChildRemoved(Element, Int32)	Positionne des éléments enfants sur des positions absolues.
OnChildRemoved(Element)	Obsolète. Appelée quand un enfant est supprimé de l’AbsoluteLayout.
OnChildrenReordered()	Appelée chaque fois que l’événement ChildrenReordered est sur le point d’être émis. Implémentez cette méthode pour ajouter la gestion de classes pour cet événement. (Hérité de VisualElement)
OnMeasure(Double, Double)	Méthode qui est appelée quand une mesure de disposition se produit. (Hérité de VisualElement)
OnParentSet()	Positionne des éléments enfants sur des positions absolues. (Hérité de NavigableElement)
OnPropertyChanged(String)	Méthode appelée en cas de changement d’une propriété liée. (Hérité de Element)
OnPropertyChanging(String)	Appelez cette méthode à partir d’une classe enfant pour avertir qu’un changement va se produire au niveau d’une propriété. (Hérité de BindableObject)
OnRemoved(T)	Appelée quand un enfant est supprimé de la disposition. Implémentez cette méthode pour ajouter la gestion de classes pour cet événement. (Hérité de Layout<T>)
OnSizeAllocated(Double, Double)	Cette méthode est appelée quand la taille de l’élément est définie pendant un cycle de disposition. Cette méthode est appelée directement avant que l’événement SizeChanged ne soit émis. Implémentez cette méthode pour ajouter la gestion de classes pour cet événement. (Hérité de Layout)
OnSizeRequest(Double, Double)	Obsolète. Appelée pendant la passe de mesure d’un cycle de disposition pour obtenir la taille souhaitée de l’AbsoluteLayout.
OnTabIndexPropertyChanged(Int32, Int32)	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
OnTabStopPropertyChanged(Boolean, Boolean)	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
RaiseChild(View)	Envoie un enfant à l’avant de la pile d’objets visuels. (Hérité de Layout)
RemoveBinding(BindableProperty)	Supprime une liaison précédemment définie. (Hérité de BindableObject)
RemoveDynamicResource(BindableProperty)	Supprime une ressource dynamique précédemment définie (Hérité de Element)
ResolveLayoutChanges()	Positionne des éléments enfants sur des positions absolues. (Hérité de Layout)
SetBinding(BindableProperty, BindingBase)	Affecte une liaison à une propriété. (Hérité de BindableObject)
SetDynamicResource(BindableProperty, String)	Définit la propriété BindableProperty de cet élément à mettre à jour par le biais du DynamicResource avec la clé fournie. (Hérité de Element)
SetLayoutBounds(BindableObject, Rectangle)	Définit les limites de disposition d’une vue qui permettent de redimensionner ce dernier au moment où il est disposé.
SetLayoutFlags(BindableObject, AbsoluteLayoutFlags)	Définit les indicateurs de disposition d’une vue qui permettent d’interpréter les limites de disposition définies sur celui-ci quand il est ajouté à la disposition.
SetValue(BindableProperty, Object)	Définit la valeur de la propriété spécifiée. (Hérité de BindableObject)
SetValue(BindablePropertyKey, Object)	Définit la valeur de propertyKey. (Hérité de BindableObject)
SetValueCore(BindableProperty, Object, SetValueFlags)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de BindableObject)
SetValueFromRenderer(BindableProperty, Object)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
SetValueFromRenderer(BindablePropertyKey, Object)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
ShouldInvalidateOnChildAdded(View)	En cas d’implémentation, doit retourner true si child doit appeler InvalidateMeasure(), ou false sinon. (Hérité de Layout)
ShouldInvalidateOnChildRemoved(View)	En cas d’implémentation, doit retourner true si child doit appeler InvalidateMeasure() quand il est supprimé, ou false sinon. (Hérité de Layout)
SizeAllocated(Double, Double)	SizeAllocated est appelée pendant un cycle de disposition pour signaler le début d’une disposition de sous-arborescence. (Hérité de VisualElement)
TabIndexDefaultValueCreator()	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
TabStopDefaultValueCreator()	Positionne des éléments enfants sur des positions absolues. (Hérité de VisualElement)
UnapplyBindings()	Supprime toutes les liaisons précédemment définies. (Hérité de BindableObject)
Unfocus()	Annule la définition du focus sur cet élément. (Hérité de VisualElement)
UpdateChildrenLayout()	Indique à la disposition de réorganiser tous ses enfants. (Hérité de Layout)

Événements

BatchCommitted	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
BindingContextChanged	Déclenché chaque fois que la propriété BindingContext est modifiée. (Hérité de BindableObject)
ChildAdded	Se produit chaque fois qu’un élément enfant est ajouté à l’élément. (Hérité de Element)
ChildRemoved	Se produit chaque fois qu’un élément enfant est supprimé de l’élément. (Hérité de Element)
ChildrenReordered	Se produit quand les enfants d’un VisualElement ont été réorganisés. (Hérité de VisualElement)
DescendantAdded	Se produit chaque fois qu’un élément enfant est ajouté à la sous-arborescence d’éléments. (Hérité de Element)
DescendantRemoved	Se produit chaque fois qu’un élément enfant est supprimé de la sous-arborescence d’éléments. (Hérité de Element)
FocusChangeRequested	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de VisualElement)
Focused	Se produit quand l’élément reçoit le focus. (Hérité de VisualElement)
LayoutChanged	Se produit à la fin d’un cycle de disposition si un des Bounds de l’élément enfant a changé. (Hérité de Layout)
MeasureInvalidated	Événement qui est déclenché quand la disposition d’un élément visuel est invalidée. (Hérité de VisualElement)
PlatformSet	Obsolète. Positionne des éléments enfants sur des positions absolues. (Hérité de Element)
PropertyChanged	Déclenché lorsqu’une propriété a été modifiée. (Hérité de BindableObject)
PropertyChanging	Déclenché lorsqu’une propriété est sur le point d’être modifiée. (Hérité de BindableObject)
SizeChanged	Se produit quand la valeur de la propriété Width ou Height change sur cet élément. (Hérité de VisualElement)
Unfocused	Se produit quand l’élément perd le focus. (Hérité de VisualElement)

Implémentations d’interfaces explicites

IDynamicResourceHandler.SetDynamicResource(BindableProperty, String)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de BindableObject)
IElementController.SetValueFromRenderer(BindableProperty, Object)	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de Element)
IGestureController.CompositeGestureRecognizers	Pour un usage interne par la plateforme Xamarin.Forms. (Hérité de View)
INameScope.RegisterName(String, Object)	Uniquement réservé à un usage interne. (Hérité de Element)
IVisualElementController.EffectiveFlowDirection	Obtient le sens du flux visuel effectif pour l’élément sur la plateforme, en prenant en compte les paramètres régionaux et les paramètres de flux logique. (Hérité de VisualElement)
IVisualElementController.InvalidateMeasure(InvalidationTrigger)	Cette méthode est destinée à un usage interne. (Hérité de VisualElement)

Méthodes d’extension

AbortAnimation(IAnimatable, String)	Arrête l’animation.
Animate(IAnimatable, String, Action<Double>, Double, Double, UInt32, UInt32, Easing, Action<Double,Boolean>, Func<Boolean>)	Définit les paramètres spécifiés et démarre l’animation.
Animate(IAnimatable, String, Action<Double>, UInt32, UInt32, Easing, Action<Double,Boolean>, Func<Boolean>)	Définit les paramètres spécifiés et démarre l’animation.
Animate(IAnimatable, String, Animation, UInt32, UInt32, Easing, Action<Double,Boolean>, Func<Boolean>)	Définit les paramètres spécifiés et démarre l’animation.
Animate<T>(IAnimatable, String, Func<Double,T>, Action<T>, UInt32, UInt32, Easing, Action<T,Boolean>, Func<Boolean>)	Définit les paramètres spécifiés et démarre l’animation.
AnimateKinetic(IAnimatable, String, Func<Double,Double,Boolean>, Double, Double, Action)	Définit les paramètres spécifiés et démarre l’animation cinétique.
AnimationIsRunning(IAnimatable, String)	Retourne une valeur booléenne qui indique si l’animation qui est spécifiée par handle est en cours d’exécution.
Batch(IAnimatable)	Positionne des éléments enfants sur des positions absolues.
GetPropertyIfSet<T>(BindableObject, BindableProperty, T)	Positionne des éléments enfants sur des positions absolues.
SetAppThemeColor(BindableObject, BindableProperty, Color, Color)	Positionne des éléments enfants sur des positions absolues.
SetBinding(BindableObject, BindableProperty, String, BindingMode, IValueConverter, String)	Crée et applique une liaison à une propriété.
SetBinding<TSource>(BindableObject, BindableProperty, Expression<Func<TSource,Object>>, BindingMode, IValueConverter, String)	Obsolète. Crée et applique une liaison à partir d’une expression.
SetOnAppTheme<T>(BindableObject, BindableProperty, T, T)	Positionne des éléments enfants sur des positions absolues.
FindByName<T>(Element, String)	Retourne l’instance de type T qui porte le nom name dans l’étendue qui inclut element.
FindNextElement(ITabStopElement, Boolean, IDictionary<Int32,List<ITabStopElement>>, Int32)	Positionne des éléments enfants sur des positions absolues.
GetSortedTabIndexesOnParentPage(VisualElement)	Positionne des éléments enfants sur des positions absolues.
GetTabIndexesOnParentPage(ITabStopElement, Int32)	Positionne des éléments enfants sur des positions absolues.
FadeTo(VisualElement, Double, UInt32, Easing)	Retourne une tâche qui exécute le fondu décrit par les paramètres opacity, length et easing.
LayoutTo(VisualElement, Rectangle, UInt32, Easing)	Retourne une tâche qui accélère les limites du VisualElement spécifié par view dans le rectangle spécifié par le paramètre bounds.
RelRotateTo(VisualElement, Double, UInt32, Easing)	Fait pivoter le VisualElement spécifié par view à partir de sa rotation actuelle par drotation.
RelScaleTo(VisualElement, Double, UInt32, Easing)	Retourne une tâche qui met à l’échelle le VisualElement spécifié par view à partir de son échelle actuelle vers dscale.
RotateTo(VisualElement, Double, UInt32, Easing)	Retourne une tâche qui exécute la rotation décrite par les paramètres rotation, length et easing.
RotateXTo(VisualElement, Double, UInt32, Easing)	Retourne une tâche qui incline l’axe y par opacity, en prenant le temps length et en utilisant easing.
RotateYTo(VisualElement, Double, UInt32, Easing)	Retourne une tâche qui incline l’axe x par opacity, en prenant le temps length et en utilisant easing.
ScaleTo(VisualElement, Double, UInt32, Easing)	Retourne une tâche qui met à l’échelle le VisualElement spécifié par view vers le facteur d’échelle absolu scale.
ScaleXTo(VisualElement, Double, UInt32, Easing)	Positionne des éléments enfants sur des positions absolues.
ScaleYTo(VisualElement, Double, UInt32, Easing)	Positionne des éléments enfants sur des positions absolues.
TranslateTo(VisualElement, Double, Double, UInt32, Easing)	Anime les propriétés TranslationX et TranslationY d’un élément à partir de leurs valeurs actuelles vers leurs nouvelles valeurs. Cela garantit que la disposition d’entrée se trouve à la même position que la disposition visuelle.
HasVisualStateGroups(VisualElement)	Retourne true si element a un ou plusieurs groupes d’états visuels associés. Sinon, retourne false.