Wpf datacontext de liaison à l'aide de MVVM entre viewmodel et vue

Tout d'abord. Définir les dépendances de projets. ViewModel doit avoir accès au Modèle. (Modèle et de la vue projets n'ont pas de référence à d'autres projets.) Si j'étais vous, je voudrais faire un Projet de Démarrage pour transférer le contrôle à ViewModel.
Ce "Démarrage" projet devrait être WPF, tous les autres devraient être la "bibliothèque de classes", mais n'oubliez pas d'ajouter les références nécessaires aux projets (Par exemple le système.xaml pour votre vision de projet pour créer des usercontrols.)

Projets de dépendances:
- Démarrage --> ViewModel;
(- ViewModel --> Affichage; ou d'éviter cela avec DI)
- ViewModel --> Modèle;
(Je devrais faire un autre projet pour les interfaces juste c'est juste mon perversions.)

Projet De Démarrage:
Maintenant, dans votre démarrage (WPF) projet devrait contient (app.xaml.cs):

protected override void OnStartup(StartupEventArgs e)
{
    //delete the startupuri tag from your app.xaml
    base.OnStartup(e);
    //this MainViewModel from your ViewModel project
    MainWindow = new MainWindow(new MainViewModel());
} 

La seule chose (Fenêtre) dans votre démarrage du projet wpf (pour afficher votre UserControls).

MainWindow.contenu xaml:

<Window x:Class="StartUp.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" WindowState="Maximized" WindowStyle="None" AllowsTransparency="True">
        <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center" Content="{Binding Control}"/>
</Window>

(et xaml.cs)

  public partial class MainWindow : Window
    {
        public MainWindow(INotifyPropertyChanged ViewModel)
        {
            InitializeComponent();
            this.DataContext = ViewModel;
            this.Show();
        }
    }

Et c'est tout votre Démarrage du projet WPF.
De cette façon, nous a donné le contrôle de votre Dernier projet.

(Bon d'accord, c'est juste un extra, mais je devrais faire un "ViewService" gérer mon UserControls)

Interface pour retrouver l'ensemble de la Vue et de la correspondance de la Vue avec ViewModel.

public interface IControlView
{
    INotifyPropertyChanged ViewModel { get; set; }
}

J'ai créé un singleton pour stocker et correspond à mes opinions avec mon viewmodel. (Vous pouvez sauter cette partie.) J'ai défini ce dans Modèle projet.

 public class ViewService<T> where T : IControlView
{
private readonly List<WeakReference> cache;
public delegate void ShowDelegate(T ResultView);
public event ShowDelegate Show;
public void ShowControl<Z>(INotifyPropertyChanged ViewModel)
{
if (Show != null)
Show(GetView<Z>(ViewModel));
}
#region Singleton
private static ViewService<T> instance;
public static ViewService<T> GetContainer
{
get
{
if (instance == null)
{
instance = new ViewService<T>();
}
return instance;
}
}
private ViewService()
{
cache = new List<WeakReference>();
var types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(s => s.GetTypes()).Where(r => typeof(T).IsAssignableFrom(r) && !r.IsInterface && !r.IsAbstract && !r.IsEnum);
foreach (Type type in types)
{
cache.Add(new WeakReference((T)Activator.CreateInstance(type)));
}
}
#endregion
private T GetView<Z>(INotifyPropertyChanged ViewModel)
{
T target = default(T);
foreach (var wRef in cache)
{
if (wRef.IsAlive && wRef.Target.GetType().IsEquivalentTo(typeof(Z)))
{
target = (T)wRef.Target;
break;
}
}
if(target==null)
target = (T)Activator.CreateInstance(typeof(Z));
if(ViewModel != null)
target.ViewModel = ViewModel;
return target;
}
}

Et maintenant, vous avez un "service" pour montrer votre UserControls dans la mainwindow à partir de votre
ViewModel:

public class MainViewModel : INotifyPropertyChanged
{
private IControlView _control;
public IControlView Control
{
get
{
return _control;
}
set
{
_control = value;
OnPropertyChanged();
}
}
public MainViewModel()
{   //Subscribe for the ViewService event:   
ViewService<IControlView>.GetContainer.Show += ShowControl;
//in this way, here is how to set a user control to the window.
ViewService<IControlView>.GetContainer.ShowControl<ListViewDatabaseStyle>(new TheViewModel(yourDependencyItems));
//you can call this anywhere in your viewmodel project. For example inside a command too.
}
public void ShowControl(IControlView ControlView)
{
Control = ControlView;
}
//implement INotifyPropertyChanged...
protected void OnPropertyChanged([CallerMemberName] string name = "propertyName")
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(name));
}
}
public event PropertyChangedEventHandler PropertyChanged;
}

Si vous ne souhaitez pas utiliser cette "ViewService". Il suffit de créer un UserControl exemple, correspondre à DataContext de la Vue avec votre ViewModel et donner ce point de vue pour le Contrôle de la propriété.
Ici est votre ViewModel avec la liste (toujours dans ViewMoldel projet.)

public class TheViewModel
{
private readonly ObservableCollection<ISelectable> listOfItems;
public ObservableCollection<ISelectable> ListOfItems 
{
get { return listOfItems; }
}
public ICommand SaveCheckedItemsText{
get{ return new RelayCommand(CollectNamesOfSelectedElements);}
}
public IEnumerable<ISelectable> GetSelectedElements
{
get { return listOfItems.Where(item=>item.CheckStatus); }
}
public TheViewModel(IList<ISelectable> dependencyItems)
{
listOfItems= new ObservableCollection<ISelectable>(dependencyItems);
}
//here is your list...
private List<string> selectedNames
//use this...
private void CollectNamesOfSelectedElements()
{
selectedNames = new List<string>();
foreach(ISelectable item in GetSelectedElements)
{
//you should override the ToString in your model if you want to do this...
selectedNames.Add(item.ToString());
}
}
}

RelayCommand article

Vue: (Garder ici toutes vos usercontrols.)

Dans votre UserControl (xaml):

<UserControl x:Class="View.ListViewDataStyle"
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" namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
mc:Ignorable="d">
<Button Command={Binding SaveCheckedItemsText}/>
<!-- Another content -->
<ListView ItemsSource="{Binding ListOfItems}">
<ListView.ItemTemplate>
<DataTemplate>
<CheckBox Content="{Binding Text}" IsChecked="{Binding CheckedStatus}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</UserControl>

Et avec interface voici le code xaml.cs code (pour les contrôles utilisateur):

public partial class ListViewDatabaseStyle : UserControl, IControlView
{
public ListViewDatabaseStyle ()
{
InitializeComponent();
}
public INotifyPropertyChanged ViewModel
{
get
{
return (INotifyPropertyChanged)DataContext;
}
set
{
DataContext = value;
}
}
}

Et le dernier est le Modèle projet avec vos modèles:

 public interface ISelectable
{
bool CheckStatus { get; set; }
}
public class CheckBoxListModel : INotifyPropertyChanged, ISelectable
{
private string text;
public string Text
{
get { return text; }
set
{
text = value;
RaiseChanged("Text");
}
}
private bool checkStatus;
public bool CheckStatus
{
get { return checkStatus; }
set
{
checkStatus = value;
RaiseChanged("CheckStatus");
}
}
private void RaiseChanged(string propName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propName));
}
}
public event PropertyChangedEventHandler PropertyChanged;
}
}

Excusez-moi pour l'anglais, la grammaire des fautes, j'espère que vous avez compris mon post.

Mise à jour:
Utiliser le DI techn. afin d'éviter la référence à la vue du viewmodel. DI service va injecter de l'objet avec un constructeur d'injection.

OriginalL'auteur Péter Hidvégi