WPF Binding innere Kontrolle mit übergeordneten Daten-Kontext

Machte ich ein user control

<UserControl x:Class="MyApp.MyControl"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
         mc:Ignorable="d"  x:Name="uc">
<Grid Width="Auto" Height="Auto">
    <TextBlock Text="{Binding Path=DataContext.TextContent, ElementName=uc}"/>
    <TextBlock Text="{Binding Path=DataContext.TextContent2, ElementName=uc}"/>
</Grid>

Ich möchte die sub-controls im angegebenen control(uc) binden, um die Eigenschaften von uc.DataContext. Ich verwendet, die definiert Steuern wie folgt:

<Window x:Class="Tms.TMSClient.Views.MainWindow" Name="window"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:control="clr-namespace:MyApp"
    xmlns:ribbon="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary">      

    <control:MyControl DataContext="{Binding Path=MyControlVM}"/>

DataContext zugewiesen ist, um die Fenster hat diese Struktur: WindowVM.MyControlVM.TextContent.

Den angegebenen code funktioniert nicht, weil die textbox den DataContext gebunden ist WindowVM statt. Ich denke, das problem kann sein, weil die innere textbox gebunden ist, bevor die definierten control (uc) ist, so ist die begrenzt DataContext für uc nicht wirksam werden, noch nicht.

Was ich will, ist: die custom controls (MyControl) wird an seine entsprechende viewmodel (MyControlVM), und die inneren Elemente von MyControl wird gebunden werden, um die Eigenschaften von MyControlVM.

Haben Sie irgendwelche Lösungen für dieses problem?

Das tun Sie, indem Sie eine chance, etwas zu tun DataContext = this im MyApp.MyControl? Auch, wenn Sie sich nicht ändern DataContext Kontrolle {Binding TextContent} sollte genug sein
Sie setzen MyControlVM.DataContext zu MyControlVM, und da es vererbt durch visuelle Struktur, alles drin, standardmäßig und bis Sie Sie ändern müssen, dass DataContext. In Ihrem Fall TextBlock, Grid und UserControl wird haben gleichen DataContext Satz, der von außen an MyControlVM

InformationsquelleAutor Thomas Lee | 2014-10-24

binding c#user-controls wpf

<TextBlock Text="{Binding Path=TextContent}"/>

funktioniert bei mir in meiner test-Anwendung.

MainWindow.xaml

<Window x:Class="DataContextTest.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:my="clr-namespace:DataContextTest"
    Title="MainWindow" Height="350" Width="525">
<Window.DataContext>
    <my:MyOuterDataContext />
</Window.DataContext>
<Grid>
    <my:MyControl DataContext="{Binding Path=MyInnerDataContext}" />
</Grid>

MyControl.xaml

<UserControl x:Class="DataContextTest.MyControl"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
         mc:Ignorable="d" 
         d:DesignHeight="300" d:DesignWidth="300">
<Grid>
    <TextBlock Text="{Binding Path=TextContent}" />
</Grid>

DataContexts:

public class MyOuterDataContext
{
    public MyInnerDataContext MyInnerDataContext { get; set; }

    public MyOuterDataContext()
    {
        MyInnerDataContext = new MyInnerDataContext();
    }
}

public class MyInnerDataContext
{
    public string TextContent { get { return "foo"; } }
}

InformationsquelleAutor mDC

6

Wenn ich Sie richtig verstehe, wollen Sie die Daten zu binden, eine Eigenschaft von Ihr MyControl view-Modell zu einem TextBox.Text Immobilie innerhalb der MyControl UserControl. Wenn das richtig ist, dann können Sie einen RelativeSource Binding, oder die ElementName syntax, die Sie bereits verwenden.

Erstens, stellen Sie sicher, dass Ihr view-Modell als DataContext für die UserControl:
```
public MyControl()
{
    DataContext = new YourControlViewModel();
}
```
Als Kind steuert automatisch die Erben Ihre Eltern DataContext Objekte, können Sie jetzt mit einem Verweis auf diesen view-Modell aus der TextBox durch die MyControl.DataContext Eigenschaft aus der UserControl's XAML:
```
<TextBlock Text="{Binding DataContext.TextContent, 
    RelativeSource={RelativeSource AncestorType={x:Type Window}}}" />
```
Das ist alles, was Sie brauchen.

InformationsquelleAutor Sheridan
4

Standardmäßig jedes Steuerelement erbt seine DataContext vom übergeordneten Steuerung. So gibt es keine Notwendigkeit, explizit zu binden.

In der Tat, wenn Sie möchten binden eines Steuerelements DataContext einer nested-Eigenschaft musst du dann angeben:
```
<control:MyControl DataContext="{Binding Path=TextContent}"/>
```
Die angegebenen Steuern, kann viele innere Elemente, so verbindlich, direkt, als Ihr Vorschlag ist nicht gut. Was ich will, ist: die custom controls (MyControl) wird an seine entsprechende viewmodel (MyControlVM), und die inneren Elemente von MyControl wird gebunden werden, um die Eigenschaften von MyControlVM
Wow @ThomasLee, du bist wirklich nicht hören, wer hier ist, oder? DIE DataContext AUTOMATISCH VERERBT ALLE UNTERGEORDNETEN STEUERELEMENTE STANDARDMÄßIG. Ich sehe kein problem mit Ihrem code, wie es steht, so müssen Sie etwas anderes zu stören.

InformationsquelleAutor Dennis Kassel

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.