PropertyOrder, classe

Utilisé pour définir l'ordre dans lequel les propriétés apparaissent dans une catégorie ou dans une liste de sous-propriétés.

Hiérarchie d'héritage

System.Object
  Microsoft.Windows.Design.OrderToken
    Microsoft.Windows.Design.PropertyEditing.PropertyOrder

Espace de noms :  Microsoft.Windows.Design.PropertyEditing
Assembly :  Microsoft.Windows.Design.Interaction (dans Microsoft.Windows.Design.Interaction.dll)

Syntaxe

'Déclaration
Public NotInheritable Class PropertyOrder _
    Inherits OrderToken

public sealed class PropertyOrder : OrderToken

public ref class PropertyOrder sealed : public OrderToken

[<Sealed>]
type PropertyOrder =  
    class
        inherit OrderToken
    end

public final class PropertyOrder extends OrderToken

Le type PropertyOrder expose les membres suivants.

Propriétés

	Nom	Description
	Default	Obtient la position par défaut définie par le système.
	Early	Obtient la position initiale définie par le système.
	Late	Obtient la dernière position définie par le système.

Début

Méthodes

	Nom	Description
	CompareTo	Compare ce jeton d'ordre avec le jeton d'ordre spécifié. (Hérité de OrderToken.)
	CreateAfter	Crée un objet PropertyOrder qui est ajouté après le jeton spécifié.
	CreateBefore	Crée un objet PropertyOrder qui est ajouté avant le jeton spécifié.
	Equals	Détermine si l'Object spécifié est égal à l'Object en cours. (Hérité de OrderToken.)
	Finalize	Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
	GetHashCode	Sert de fonction de hachage pour un type particulier. (Hérité de OrderToken.)
	GetType	Obtient le Type de l'instance actuelle. (Hérité de Object.)
	MemberwiseClone	Crée une copie superficielle de l'objet Object actif. (Hérité de Object.)
	ResolveConflict	Appelé par l'implémentation CompareTo par défaut lorsque deux objets OrderToken semblent être équivalents. (Hérité de OrderToken.)
	ToString	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object.)

Début

Notes

Créez des instances privées de PropertyOrder pour regrouper un jeu de propriétés particulier dans la fenêtre Propriétés.

La classe PropertyOrder contrôle l'ordre des propriétés, qui inclut des propriétés racine et des sous-propriétés. Les propriétés racine apparaissent en premier par catégories, puis par alphabétique et enfin par PropertyOrder. Les sous-propriétés sont classées par PropertyOrder, puis par ordre alphabétique.

Les jetons d'ordre standard sont fournis par la classe PropertyOrder. Ces jetons d'ordre définis par le système comprennent les propriétés Early, Default et Late. Le jeton d'ordre Early désigne une position supérieure dans la fenêtre Propriétés.

L'ordre Default est affecté aux propriétés qui ne sont associées à aucun ordre particulier. Vous pouvez dériver de cette classe et créer vos propres jetons d'ordre personnalisés, garantissant ainsi l'ordre et le regroupement des propriétés.

Exemples

L'exemple de code suivant indique comment dériver de PropertyOrder pour implémenter une classe

LayoutSizePriority à utiliser pour les propriétés Width et Height. Cette classe est créée d'après l'ordre Early. Par conséquent, elle apparaît dans la liste après les propriétés Early. LayoutAlignmentPriority est appliqué aux propriétés HorizontalAlignment et VerticalAlignment et est créé après LayoutSizePriority.

Les instances de PropertyOrder sont liées aux propriétés à l'aide de PropertyOrderAttribute. Les méthodes CreateBefore et CreateAfter placent Width avant Height et HorizontalAlignment avant VerticalAlignment..

Imports System
Imports System.Windows
Imports System.Windows.Controls
Imports Microsoft.Windows.Design.PropertyEditing
Imports Microsoft.Windows.Design.Metadata

Public Class PropertyOrderTokens
    Private Shared layoutSizePriorityValue As PropertyOrder
    Private Shared layoutAlignmentPriorityValue As PropertyOrder


    Public Shared ReadOnly Property LayoutSizePriority() As PropertyOrder
        Get
            If layoutSizePriorityValue Is Nothing Then
                LayoutSizePriority = PropertyOrder.CreateAfter(PropertyOrder.Early)
            End If

            Return layoutSizePriorityValue
        End Get
    End Property


    Public Shared ReadOnly Property LayoutAlignmentPriority() As PropertyOrder
        Get
            If layoutAlignmentPriorityValue Is Nothing Then
                layoutAlignmentPriorityValue = PropertyOrder.CreateAfter(PropertyOrderTokens.LayoutSizePriority)
            End If

            Return layoutAlignmentPriorityValue
        End Get
    End Property
End Class

' Container for any general design-time metadata to initialize.
' Designers look for a type in the design-time assembly that 
' implements IProvideAttributeTable. If found, designers instantiate
' this class and access its AttributeTable property automatically.
Friend Class Metadata
    Implements IProvideAttributeTable

    ' Accessed by the designer to register any design-time metadata.
    Public ReadOnly Property AttributeTable() As AttributeTable _
        Implements IProvideAttributeTable.AttributeTable
        Get
            Dim builder As New AttributeTableBuilder()

            builder.AddCustomAttributes( _
                GetType(Button), _
                "HeightProperty", _
                New PropertyOrderAttribute( _
                    PropertyOrder.CreateAfter( _
                        PropertyOrderTokens.LayoutSizePriority)))

            builder.AddCustomAttributes( _
                GetType(Button), _
                "Width", _
                New PropertyOrderAttribute( _
                    PropertyOrder.CreateBefore( _
                        PropertyOrderTokens.LayoutSizePriority)))

            builder.AddCustomAttributes( _
                GetType(Button), _
                "VerticalAlignment", _
                New PropertyOrderAttribute( _
                    PropertyOrder.CreateAfter( _
                        PropertyOrderTokens.LayoutAlignmentPriority)))

            builder.AddCustomAttributes( _
                GetType(Button), _
                "HorizontalAlignment", _
                New PropertyOrderAttribute( _
                    PropertyOrder.CreateBefore( _
                        PropertyOrderTokens.LayoutAlignmentPriority)))

            Return builder.CreateTable()
        End Get
    End Property
End Class

using System;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Windows.Design.PropertyEditing;
using Microsoft.Windows.Design.Metadata;

public static class PropertyOrderTokens
{
    private static PropertyOrder layoutSizePriority;
    private static PropertyOrder layoutAlignmentPriority;

    public static PropertyOrder LayoutSizePriority
    {
        get
        {
            if (layoutSizePriority == null)
            {
                layoutSizePriority = PropertyOrder.CreateAfter(
                    PropertyOrder.Early);
            }

            return layoutSizePriority;
        }
    }

    public static PropertyOrder LayoutAlignmentPriority
    {
        get
        {
            if (layoutAlignmentPriority == null)
            {
                layoutAlignmentPriority = PropertyOrder.CreateAfter(
                    PropertyOrderTokens.LayoutSizePriority);
            }

            return layoutAlignmentPriority;
        }
    }
}

// Container for any general design-time metadata to initialize.
// Designers look for a type in the design-time assembly that 
// implements IProvideAttributeTable. If found, designers instantiate 
// this class and access its AttributeTable property automatically.
internal class Metadata : IProvideAttributeTable
{
    // Accessed by the designer to register any design-time metadata.
    public AttributeTable AttributeTable
    {
        get
        {
            AttributeTableBuilder builder = new AttributeTableBuilder();

            builder.AddCustomAttributes(
                typeof(Button),
                "Height",
                new PropertyOrderAttribute(
                    PropertyOrder.CreateAfter(
                    PropertyOrderTokens.LayoutSizePriority)));

            builder.AddCustomAttributes(
                typeof(Button),
                "Width",
                new PropertyOrderAttribute(
                    PropertyOrder.CreateBefore(
                    PropertyOrderTokens.LayoutSizePriority)));

            builder.AddCustomAttributes(
                typeof(Button),
                "VerticalAlignment",
                new PropertyOrderAttribute(
                    PropertyOrder.CreateAfter(
                    PropertyOrderTokens.LayoutAlignmentPriority)));

            builder.AddCustomAttributes(
                typeof(Button),
                "HorizontalAlignment",
                new PropertyOrderAttribute(
                    PropertyOrder.CreateBefore(
                    PropertyOrderTokens.LayoutAlignmentPriority)));

            return builder.CreateTable();
        }
    }
}

Sécurité des threads

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Voir aussi

Référence

Microsoft.Windows.Design.PropertyEditing, espace de noms

Autres ressources

Architecture d'édition de propriété

Extensibilité du Concepteur WPF