Comment appliquer MVVM Pattern dans ce modèle?

Question

Le problème commence à ce poste: Using binding to a List<UserControl> how can I do for not showing the controls

Je concevais quelque chose comme ceci:

List<Container> 
(Below container properties) 
    - Objective: string 
    - Problems: List<ProblemUserControl> 

ProblemUserControls est un UserControl où contais une propriété supplémentaire appelé problème. Mais le post ci-dessus une personne me suggère d'utiliser MVVM Pattern. J'étudie, mais je suis encore confus ou j'ai besoin d'un peu d'aide pour comprendre le modèle dans WPF.

Answer 1

Voici un exemple à illustrer en utilisant MVVM. Notez qu'il n'est pas nécessaire d'avoir une liste de contrôles usuels et en effet cela serait considéré comme incorrect d'un point de vue MVVM.

Ceci est basé sur le modèle d'application WPF par défaut dans Visual Studio.

Voici les classes concernées.

public abstract class ViewModelBase : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 

    protected virtual void OnPropertyChanged(string propertyName) 
    { 
     PropertyChangedEventHandler changed = PropertyChanged; 
     if (changed != null) 
     { 
      changed(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 
} 

public class Container : ViewModelBase 
{ 
    private string m_Objective; 
    private ProblemCollection m_Problems; 

    public Container() 
    { 
     m_Problems = new ProblemCollection(); 
    } 

    public string Objective 
    { 
     get { return m_Objective; } 
     set 
     { 
      m_Objective = value; 
      OnPropertyChanged("Objective"); 
     } 
    } 

    public ProblemCollection Problems 
    { 
     get { return m_Problems; } 
     set 
     { 
      m_Problems = value; 
      OnPropertyChanged("Problems"); 
     } 
    } 
} 

public class Problem : ViewModelBase 
{ 
    private string m_Name; 

    public string Name 
    { 
     get { return m_Name; } 
     set 
     { 
      m_Name = value; 
      OnPropertyChanged("Name"); 
     } 
    } 
} 

public class ProblemCollection : ObservableCollection<Problem> 
{ 
} 

Et la fenêtre principale. Notez que j'ai commenté votre rectangle pour afficher les liaisons

<Window x:Class="StackOverflowDemo.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525"> 
    <Grid> 
    <TextBlock TextWrapping="Wrap" Text="{Binding Objective}" Grid.Column="0" VerticalAlignment="Center" 
     FontWeight="Bold" /> 
    <ItemsControl ItemsSource="{Binding Problems}"> 
     <ItemsControl.ItemTemplate> 
     <DataTemplate> 
      <!--<Rectangle Stroke="Black" Height="20" Width="20" Margin="1,0" />--> 
      <TextBlock Text="{Binding Path=Name}" /> 
     </DataTemplate> 
     </ItemsControl.ItemTemplate> 
    </ItemsControl> 
    </Grid> 
</Window> 

MainWindow.cs

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

     // Create dummy test data. 
     // Normally this will be passed to the window or set externally 
     var container = new Container(); 
     container.Problems.Add(new Problem {Name = "Foo"}); 
     container.Problems.Add(new Problem {Name = "Bar"}); 
     container.Problems.Add(new Problem {Name = "hello"}); 
     container.Problems.Add(new Problem {Name = "world"}); 

     DataContext = container; 
    } 
} 

Answer 2

Le motif consiste à maintenir une séparation et des dépendances appropriées entre les couches logiques de votre logiciel. Vous confondez la logique d'affichage avec la logique métier dans votre exemple car vous mélangez votre code de modèle (le conteneur d'objectifs) avec votre code d'affichage (une liste de contrôles Userc).

Au lieu de cela, gardez vos objectifs et maintenez un List<Problem> au lieu d'un List<ProblemUserControl>. Ensuite, utilisez WPF et liaison pour associer votre ProblemUserControl à un Problem. Votre contrôle utilisateur comprend ce qu'est un Problem, vous pouvez donc vous lier aux propriétés sur le Problem. De cette façon, vous séparez vos couches et faites en sorte qu'il soit plus facile de raisonner sur votre logiciel en général.