Zone de texte, Bouton et ListBox dans une ListBox

La solution la plus simple serait susceptible d'être pour avoir un objet de représenter chaque élément que l'extérieur de la zone de liste. Elle possède alors des propriétés qui pourraient représenter chaque contrôle dans l'élément de texte dans la zone de texte, et les éléments dans la zone de liste (une liste de Tâches, je pense, en fonction de votre gestionnaire de Clic).

Dans votre gestionnaire de Clic, vous pouvez obtenir le Bouton du DataContext (ce qui devrait être un élément dans la collection de la liste externe), et ajouter une nouvelle Tâche à l'objet de la liste de tâches. Depuis l'intérieure de la zone de liste est liée à cette liste, il doit être mis à jour avec le nouvel élément (en supposant qu'il envoie des événements lorsque des éléments sont ajoutés, comme avec ObservableCollection).

Mise à jour: en Fonction de vos commentaires, la suite devrait fonctionner.

Votre Project classe devrait avoir deux propriétés:

class Project
{
    public string Name { get; set; }

    private ObservableCollection<Task> tasks =
        new ObservableCollection<Task>();
    public IList<Task> Tasks
    {
        get { return this.tasks; }
    }
}

La Task classe n'a qu'un seul bien - le nom de la tâche.

La ProjectView classe est un wrapper autour de la Project classe (j'ai eu cette idée de @timothymcgrath de réponse). Il garde la trace du nom d'une nouvelle tâche, et le courant Project:

class ProjectView : INotifyPropertyChanged
{
    public Project Project { get; set; }

    private string newTaskName = string.Empty;
    public string NewTaskName
    {
        get { return this.newTaskName; }
        set
        {
            this.newTaskName = value;
            this.OnPropertyChanged("NewTaskName");
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    private void OnPropertyChanged(string propName)
    {
        PropertyChangedEventHandler eh = this.PropertyChanged;
        if(null != eh)
        {
            eh(this, new PropertyChangedEventArgs(propName));
        }
    }
}

Vous aurez besoin d'une nouvelle classe qui sera utilisée comme DataContext. Quelque chose comme ceci:

class Model
{
    private ObservableCollection<ProjectView> projects =
        new ObservableCollection<ProjectView>();
    public IList<ProjectView> Projects
    {
        get { return this.projects; }
    }
}

Dans le code-behind, définir la DataContext de l'objet à une instance de la classe ci-dessus:

public class Window1
{
    public Window1()
    {
        this.InitializeComponent();

        this.DataContext = this.model;
    }

    private Model model = new Model();
}

Dans le code XAML, les liaisons doivent être modifiés afin de lier les propriétés ci-dessus:

<ListBox x:Name="projectList" IsSynchronizedWithCurrentItem="True"
    ItemsSource="{Binding Path=Projects}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel>
                <TextBlock Text="{Binding Project.Name}" />
                <ListBox x:Name="taskList"
                    ItemsSource="{Binding Project.Tasks}"
                    DisplayMemberPath="Name" />
                <TextBox x:Name="textBoxTask"
                    Text="{Binding Path=NewTaskName, UpdateSourceTrigger=PropertyChanged}"/>
                <Button x:Name="ButtonAddNewTask" Content="Test"
                    Click="ButtonAddNewTask_Click" />
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

Enfin, dans le gestionnaire de clic pour le bouton, créez la tâche. Le DataContext de la Button sera le ProjectView pour cet article.

private void ButtonAddNewTask_Click(object sender, RoutedEventArgs e)
{
    Button btn = (Button)sender;
    ProjectView curProject = btn.DataContext as Project;
    if(null != curProject)
    {
        curProject.Project.Tasks.Add(new Task()
        {
            Name = curProject.NewTaskName
        });
    }
}

Puisque toutes les commandes d'obtenir leurs valeurs via la liaison, vous n'avez pas besoin d'accès le contrôle d'elle-même pour obtenir les données - il suffit d'utiliser les structures de données qui fournissent des contrôles déjà.

Il serait probablement préférable de déplacer le code qui crée la Tâche dans une autre classe (éventuellement Project), mais j'ai juste laissé dans le gestionnaire d'événement pour la facilité de frappe de ma part.

Mise à jour 2: Modifié le code ci-dessus pour déplacer le NewTaskName propriété dans une autre classe qui encapsule une instance de Project pour une utilisation avec l'INTERFACE utilisateur. Cela fonctionne mieux pour vous?

Cette solution a fonctionné pour la tâche à portée de main afin de parler.

    private void ButtonAddNewTask_Click(object sender, RoutedEventArgs e)
    {
        Button button = (Button)sender;
        DependencyObject obj = LogicalTreeHelper.GetParent(button);
        StackPanel item = obj as StackPanel;
        TextBox textBox = item.FindName("textBoxTask") as TextBox;
        ListBox listBox = item.FindName("taskList") as ListBox;

        Project proj = button.DataContext as Project;
        if(proj.Tasks == null)
            proj.Tasks = new List<Task>();

        listBox.ItemsSource = proj.Tasks;
        listBox.Items.Refresh();
    }