ItemsSource vs DataContext im Bindungsfall

Question

Meine Hauptfrage ist über Binding Fall in der Szene, die wir mehrere Quellen für ein Steuerelement (eine Combobox in einem Datagrid) haben (oder DataContext und Itemsource). Wie können wir dann herausfinden, welche Quelle die Bindung verwenden wird? (irgendeine Syntax, um das zu verdeutlichen)

Angenommen, ein Datagrid hat eine itemssource = "Liste der Spieler" datacontext = "Manager" , und hat eine Combobox als eine Art Spalte. Wir gehen auch davon aus, dass jeder Spieler eine Inventareigenschaft hat, die ein Sammlertyp ist.

dann in der datagrid.columns:

1. Die Stromquelle jeder Spalte (für die Bindung) ist ein Player (dies ist, wie ich es verstehe so weit). Wir können nur an das Eigentum des Spielers binden, nicht an das Eigentum des DataContext "Managers". Es gibt keine Möglichkeit, an die Eigenschaft des "Managers" zu binden. Hab ich recht?
2. Wenn wir jedoch zu den Combobox-Spalten wechseln, gehe ich davon aus, dass ich itemssource = 'player's inventory' von combobox lasse, dann wird die aktuelle Quelle für comboboxItem jedes Element im Inventar sein. Und wenn ich die Bindung verwende, kann sie nur an die Eigenschaft dieser Elemente binden. Manchmal sehe ich jedoch den Code, den wir auch an die Eigenschaft des Players in der Eigenschaft der Combobox binden können, besonders Selected Value und SelectedItem. Ich bin ein wenig verwirrt hier können Sie mir helfen?

danke

Answer 1

Der Schlüssel Kontrolle darüber nachdenken, ein ItemsControl (ComboBox erbt von ItemsControl und die DataGrid verhält sich sehr ähnlich) ist.

Ein ItemsControl hat ItemsSource Eigenschaft vom Typ IEnumerable. Es hat auch die ItemTemplate Eigenschaft. Was es tun wird, ist Erstellen Sie eine Kopie davon ist ItemTemplate für jeden Artikel in ItemsSource. Die DataContext der ItemTemplate wird jedes Element in der ItemsSource sein.

In Ihrem Fall der ComboBox, die DataContext der DataGrid ‚s Spalte wird Ihr Player Objekt sein. Wenn Sie die ComboBox 's ItemSource an ein Player Inventar binden, dann erhalten Sie jedes Element in Ihrer ComboBox Liste.
Zu beachten ist, dass die DataContext der ComboBox selbst unverändert ist. Es ist immer noch das Objekt Player. Wenn Sie eine ItemTemplate für Ihre ComboBox angeben, wird diese DataContext zu den Artikeln in einem Player Inventar haben.

Answer 2

Es ist wirklich einfach.

DataContext verweist auf die gleiche Eigenschaft der Elemente. Es wird nicht erweitert und es ist nicht dynamisch. DataContext wird auf Eigenschaften von Kindern angewendet, die sich derzeit im übergeordneten Objekt befinden.

Aber ItemsSource ist dynamisch. Es wird mit der Quelle erweitert. Hier ist ein Beispiel von gud.

Dies ist ein Beispiel XAML.

<UserControl x:Class="SilverlightApplication" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
mc:Ignorable="d" 
d:DesignHeight="300" d:DesignWidth="400"> 

<Grid x:Name="LayoutRoot" Background="White"> 
    <Grid.Resources>   
     <DataTemplate x:Key="template2"> 
      <StackPanel Orientation="Horizontal"> 
       <Image x:Name="img1" Source="{Binding Image}"></Image> 
       <TextBlock x:Name="data2" Text="{Binding Data}"></TextBlock> 
      </StackPanel> 
     </DataTemplate> 
    </Grid.Resources> 
    <StackPanel> 
     <StackPanel x:Name="DataContextStack" Orientation="Vertical"> 
      <TextBlock x:Name="data1" Text="{Binding Text1}"></TextBlock> 
      <TextBlock x:Name="data2" Text="{Binding Text2}"></TextBlock> 
     </StackPanel> 
     <ListBox x:Name="lst2" ItemTemplate="{StaticResource template2}"></ListBox> 
    </StackPanel> 
</Grid> 

Hier ist der hinter Code.

namespace SilverlightApplication 
{ 
    public partial class MainPage : UserControl 
{ 
    public MainPage() 
    { 
     InitializeComponent(); 
     loadLists(); 
    } 

    private void loadLists() 
    { 
     ObservableCollection<Temp2> tColl = new ObservableCollection<Temp2>();    

     Temp1 t1 = new Temp1(); 
     t1.Text1 = "DataContext1"; 
     t1.Text2 = "DataContext2";    

     tColl.Add(new Temp2() { Image = "", Data = "Item1" }); 
     tColl.Add(new Temp2() { Image = "", Data = "Item2" }); 


     DataContextStack.DataContext = t1; 
     lst2.ItemsSource = tColl;    
    } 
} 

public class Temp1 
{ 
    public string Text1 { get; set; } 
    public string Text2 { get; set; } 



} 

public class Temp2 
{ 
    public string Image { get; set; } 
    public string Data { get; set; } 
} 
} 

Wie Sie sehen können, gilt die Datacontext auf die Textblöcke, die in dem Stackpanel existieren und auf eine einzige Eigenschaft beziehen, die Text ist.

Während ItemsSource auf Quelle der Bild- und Texteigenschaft des Textblocks verweist und die Elemente in der Liste zusammen mit der ObservableCollection erweitert werden können.

Oder um es Ihnen noch einfacher zu machen.

DataContext - Der Wert wird basierend auf dem Design festgelegt. ItemsSource - Der Wert wird basierend auf der Logik festgelegt.

Hoffe, das hilft.

Markieren Sie dies als Antwort, wenn dies Ihre Frage beantwortet hat.