Comment créer un contrôle D'utilisateur WPF avec du contenu nommé

la réponse est de ne pas utiliser un UserControl pour le faire.

créer une classe qui étend ContentControl

public class MyFunkyControl : ContentControl
{
    public static readonly DependencyProperty HeadingProperty =
        DependencyProperty.Register("Heading", typeof(string),
        typeof(HeadingContainer), new PropertyMetadata(HeadingChanged));

    private static void HeadingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        ((HeadingContainer) d).Heading = e.NewValue as string;
    }

    public string Heading { get; set; }
}

, puis utiliser un style pour spécifier le contenu

<Style TargetType="control:MyFunkyControl">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="control:MyFunkyContainer">
                <Grid>
                    <ContentControl Content="{TemplateBinding Content}"/>
                </Grid>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

et enfin-l'utiliser

<control:MyFunkyControl Heading="Some heading!">            
    <Label Name="WithAName">Some cool content</Label>
</control:MyFunkyControl>

une autre alternative que j'ai utilisée est de simplement définir la propriété Name dans l'événement Loaded .

dans mon cas, j'avais un contrôle assez complexe que je ne voulais pas créer dans le code-derrière, et il cherchait un contrôle optionnel avec un nom spécifique pour certains comportements, et puisque j'ai remarqué que je pouvais définir le nom dans un DataTemplate j'ai pensé que je pouvais le faire dans l'événement Loaded aussi.

private void Button_Loaded(object sender, RoutedEventArgs e)
{
    Button b = sender as Button;
    b.Name = "buttonName";
}

parfois, vous pourriez juste avoir besoin de faire référence à l'élément de C#. Selon le cas d'utilisation, vous pouvez alors définir un x:Uid au lieu d'un x:Name et accéder aux éléments en appelant une méthode Uid finder comme Get object par son Uid dans WPF .

vous pouvez utiliser ce helper pour définir le nom à l'intérieur du contrôle de l'utilisateur:

using System;
using System.Reflection;
using System.Windows;
using System.Windows.Media;
namespace UI.Helpers
{
    public class UserControlNameHelper
    {
        public static string GetName(DependencyObject d)
        {
            return (string)d.GetValue(UserControlNameHelper.NameProperty);
        }

        public static void SetName(DependencyObject d, string val)
        {
            d.SetValue(UserControlNameHelper.NameProperty, val);
        }

        public static readonly DependencyProperty NameProperty =
            DependencyProperty.RegisterAttached("Name",
                typeof(string),
                typeof(UserControlNameHelper),
                new FrameworkPropertyMetadata("",
                    FrameworkPropertyMetadataOptions.None,
                    (d, e) =>
                    {
                        if (!string.IsNullOrEmpty((string)e.NewValue))
                        {
                            string[] names = e.NewValue.ToString().Split(new char[] { ',' });

                            if (d is FrameworkElement)
                            {
                                ((FrameworkElement)d).Name = names[0];
                                Type t = Type.GetType(names[1]);
                                if (t == null)
                                    return;
                                var parent = FindVisualParent(d, t);
                                if (parent == null)
                                    return;
                                var p = parent.GetType().GetProperty(names[0], BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty);
                                p.SetValue(parent, d, null);
                            }
                        }
                    }));

        public static DependencyObject FindVisualParent(DependencyObject child, Type t)
        {
            // get parent item
            DependencyObject parentObject = VisualTreeHelper.GetParent(child);

            // we’ve reached the end of the tree
            if (parentObject == null)
            {
                var p = ((FrameworkElement)child).Parent;
                if (p == null)
                    return null;
                parentObject = p;
            }

            // check if the parent matches the type we’re looking for
            DependencyObject parent = parentObject.GetType() == t ? parentObject : null;
            if (parent != null)
            {
                return parent;
            }
            else
            {
                // use recursion to proceed with next level
                return FindVisualParent(parentObject, t);
            }
        }
    }
}

et votre fenêtre ou le Code de contrôle derrière définir vous contrôle par la propriété:

 public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

    }

    public Button BtnOK { get; set; }
}

votre fenêtre xaml:

    <Window x:Class="user_Control_Name.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:test="clr-namespace:user_Control_Name"
            xmlns:helper="clr-namespace:UI.Helpers" x:Name="mainWindow"
            Title="MainWindow" Height="350" Width="525">
        <Grid>
            <test:TestUserControl>
                <Button helper:UserControlNameHelper.Name="BtnOK,user_Control_Name.MainWindow"/>
            </test:TestUserControl>
            <TextBlock Text="{Binding ElementName=mainWindow,Path=BtnOK.Name}"/>
        </Grid>
    </Window>

UserControlNameHelper obtenez votre nom de contrôle et votre nom de classe pour le contrôle de jeu à la propriété.

j'ai choisi de créer une propriété supplémentaire pour chaque élément que je dois obtenir:

    public FrameworkElement First
    {
        get
        {
            if (Controls.Count > 0)
            {
                return Controls[0];
            }
            return null;
        }
    }

cela me permet d'accéder aux éléments enfants dans XAML:

<TextBlock Text="{Binding First.SelectedItem, ElementName=Taxcode}"/>

<Popup>
    <TextBox Loaded="BlahTextBox_Loaded" />
</Popup>

Code derrière:

public TextBox BlahTextBox { get; set; }
private void BlahTextBox_Loaded(object sender, RoutedEventArgs e)
{
    BlahTextBox = sender as TextBox;
}

La vraie solution serait de Microsoft pour résoudre ce problème, ainsi que tous les autres, cassé visual arbres. Hypothétiquement parlant.

encore une autre solution: référez l'élément comme RelativeSource .

j'ai eu le même problème en utilisant un TabControl pour placer un tas de contrôles nommés.

ma solution était d'utiliser un modèle de contrôle qui contient tous mes contrôles à afficher dans une page d'onglet. À l'intérieur du modèle, vous pouvez utiliser la propriété Nom et aussi lier des données aux propriétés du contrôle nommé à partir d'autres contrôles au moins à l'intérieur du même modèle.

comme contenu de la commande TabItem, utilisez une commande simple et réglez le ControlTemplate en conséquence:

<Control Template="{StaticResource MyControlTemplate}"/>

accéder à ceux nommés contrôle à l'intérieur du modèle à partir du code derrière vous devrait utiliser l'arbre visuel.