ViewModels in ViewModelLocator MVVM Light

tout d'abord, regardons ce que ViewModelLocator fait et pourquoi nous l'utilisons:

ViewModelLocator est déclaré comme un objet sur notre Application.XAML page et est une application singleton. Nous allons en avoir un, et un seul d'entre eux disponibles pour l'application quand il fonctionne.

ViewModelLocator est la source de tous nos Viewmodel dans MVVM Light. Pour chaque ViewModel, nous aurons une propriété sur le ViewModelLocator qui nous permet d'obtenir un ViewModel pour une vue. Ce code ressemble ceci:

public class ViewModelLocator
{
    public MainPageViewModel MainPage
    {
        get { return new MainPageViewModel(); }
    }
}

Ceci est une partie de mon application.xaml:

<Application.Resources>
    <vm:ViewModelLocator
        x:Key="ViewModelLocator" />
</Application.Resources>

C'est un morceau de Vue.xaml

DataContext="{Binding MainPage, Source={StaticResource ViewModelLocator}}"

So far So good. Pour répondre à votre première question, devez-vous utiliser Ioc in MVVM Light? Aucun. Il n'y a aucun besoin car votre viewmodel sera donné à votre vue entièrement construite et instanciée par le ViewModelLocator.

maintenant, sur votre deuxième question: Quel est le but du CIO?

le COI est conçu pour vous permettre de faire suivantes:

Avec Mvvm Light vous faites le au-dessus comme ceci:

public class ViewModelLocator
{
    public ViewModelLocator()
    {
        ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);

        if (ViewModelBase.IsInDesignModeStatic)
        {
            SimpleIoc.Default.Register<IDataService, Design.DesignDataService>();
        }
        else
        {
            SimpleIoc.Default.Register<IDataService, DataService>();         
        }

        SimpleIoc.Default.Register<MainViewModel>();
    }

    public MainViewModel Main
    {
        get { return SimpleIoc.Default.GetInstance<MainViewModel>(); }
    }
}

public class MainViewModel
{
    public ObservableCollection<Foo> Foos { get; set; }

    public MainViewModel(IDataService dataService)
    {
        _dataService=dataService;
        Foos=_dataService.GetFoos();
    }
}

Quand je résoudre mon MainViewModel quand je l'appelle

SimpleIoc.Default.GetInstance<MainViewModel>()

ce qui se passe en interne, c'est que le SimpleIoc vérifie si le Modèleview main a des dépendances (paramètres dans son constructeur). Il essaie ensuite de résoudre ces paramètres en regardant les interfaces qui ont été enregistrées avec lui. Il le fait de façon récursive, donc si DataService avait une dépendance, il serait instancié et passé au constructeur DataService lors de son instanciation.

pourquoi ferais-je tout ce travail?

1. rendez vos classes facilement testables à l'unité
2. activez l'interface de votre code. Cela signifie que vous faites référence à des interfaces plutôt qu'à des classes concrètes
3. faites un couplage lâche de votre code. Cela signifie que quelqu'un peut changer la mise en œuvre d'une interface et les classes qui consomment cette interface ne se soucient pas et n'avez pas à être re-codé.
4. résolvez vos dépendances de classes de manière automatisée.
5. à la lumière MVVM, vous verrez qu'elle peut dire quand elle tourne en mode design (ViewModelBase.IsInDesignModeStatic), cela signifie que vous pouvez créer des services de design-time pour fournir vos données de modèles de vue afin que votre vue dans Visual Studio contienne des données réelles.