MVVM Héritage Avec les Modèles de Vue

Je me demande comment aborder l'héritage avec les Modèles de Vue dans le pattern MVVM. Dans mon application j'ai un Modèle de Données qui ressemble à la suivante:

class CustomObject
{
    public string Title { get; set; }
}

class CustomItem : CustomObject
{
    public string Description { get; set; }
}

class CustomProduct : CustomItem
{
    public double Price { get; set; }
}

Dans mon application j'ai une classe ViewModelBase puis allait avoir le point de Vue suivant les Modèles:

CustomObjectViewModel
CustomItemViewModel
CustomProductViewModel

Un accidenté de la mise en œuvre de la CustomObjectViewModel devrait ressembler à ceci:

class CustomObjectViewModel : ViewModelBase
{
    private readonly CustomObject _customObject;

    public CustomObjectViewModel( CustomObject customObject )
    {
        _customObject = customObject;
    }

    public string Title
    {
        //implementation excluded for brevity
    }
}

Il semble logique pour moi que mon point de Vue, les Modèles se prolonger dans la même manière que mon Modèle n' (CustomItemViewModel s'étend CustomObjectViewModel et ainsi de suite). Cependant, j'ai remarqué qu'à mesure que je descends de l'arbre d'héritage je vais être en ajoutant des références supplémentaires pour le même objet. Cela me semble excessif pour moi et je me demandais comment aborder ce problème et si il était possible de faire beaucoup plus propre.

OriginalL'auteur Richard McGuire | 2009-06-10

c#design-patterns mvvm wpf

17

En général, je voudrais vous recommandons de de ne pas avoir d'héritage entre les différentes classes ViewModel, mais au lieu d'avoir à hériter directement à partir d'une même classe de base abstraite.
C'est pour éviter d'introduire une complexité inutile par de polluer le ViewModel classes d'interfaces avec les membres qui viennent de plus haut dans la hiérarchie, mais ne sont pas entièrement cohérente à la classe de l'objet principal.
Le couplage qui vient avec l'héritage sera également plus il est difficile de modifier une classe ViewModel sans affecter l'un de ses classes dérivées.

Si vos classes ViewModel toujours référence à un Modèle unique de l'objet, vous pouvez utiliser des génériques pour encapsuler cette règle dans la classe de base:
```
public abstract class ViewModelBase<TModel>
{
    private readonly TModel _dataObject;

    public CustomObjectViewModel(TModel dataObject)
    {
        _dataObject = dataObject;
    }

    protected TModel DataObject { get; }
}

public class CustomObjectViewModel : ViewModelBase<CustomObject>
{
    public string Title
    {
        //implementation excluded for brevity
    }
}

public class CustomItemViewModel : ViewModelBase<CustomItem>
{
    public string Title
    {
        //implementation excluded for brevity
    }

    public string Description
    {
        //implementation excluded for brevity
    }
}
```
J'ai utilisé les génériques modèle comme illustré ici, et je dois dire que je n'ai pas vraiment eu de problèmes avec le fait d'avoir une hiérarchie d'héritage pour les ViewModels.
Il va sûrement travailler sans problèmes dans de nombreux cas. Cependant, à mon avis, je vois ViewModel classes comme étant étroitement couplé avec des Vues. L'héritage entre classes ViewModel aurait du sens si leurs Vues associées en commun certaines de l'INTERFACE utilisateur.
Je suis face au même scénario de Richard connu, sauf que ma question est à propos de la vue. J'ai une classe abstraite avec 10 champs, et de ses divers sous-classes ajouter beaucoup plus de champs (chacun ajoute ses propres), comment dois-je créer les différents points de vue? Je ne veux pas redeclare la base de champs dans chacun d'eux (je suis toujours pas sûre de ce Dernier lui-même, serais reconnaissant de toute aide).
Si vous avez un morceau de l'INTERFACE utilisateur que vous souhaitez réutiliser, à travers de multiples points de vue, vous pourriez créer un UserControl et exposer ses données et les commandes par l'intermédiaire des propriétés de dépendance. De cette façon, vous pouvez avoir le ViewModel associé à la Vue de l'hébergement de l'objet UserControl lier pour que les propriétés de contrôler son comportement.
Cela fait plusieurs années, mais j'ai trouver ce code un peu déroutant. Pourquoi le constructeur de l'une des classes héritées de la classe de base abstraite? Comment cela fonctionne?

OriginalL'auteur Enrico Campidoglio
5

Liées au commentaire ci-dessus de Enrico. Viewmodel ne doit pas être étroitement couplé avec des points de vue, il devrait être dans l'autre sens. Les points de vue devraient être faiblement couplés à Viewmodel. Un ViewModel ne devraient pas connaître une vue, cela permet à l'unité de test d'un ViewModel facilement.Toutes les interactions entre les points de Vue avec le ViewModel devraient être mises en œuvre via les propriétés dans le ViewModel(ICommand propriétés pour les actions et les autres propriétés de liaison de données).

La seule chose qui est vrai, c'est que le ViewModel est étroitement couplé avec le Modèle, de sorte que l'utilisation de médicaments génériques ci-dessus permet beaucoup de possibilité d'extension. C'est le modèle que je vous recommanderais.

En fournissant une classe ViewModel que, fondamentalement, tout simplement expose les Propriétés qu'il doit vous permettre de vous plop que dans tout type de cadre de présentation et de tirer parti de tout le code que vous avez utilisé précédemment. En d'autres termes, si elles sont appliquées correctement, vous pourriez tomber votre Viewmodel assemblée dans une ASP.NET MVC application et une cravate de la vue pour les propriétés et n'ont pas de changement de code.

Un bon article sur MVVM notions de base est : celui-ci.
Je pense vraiment que MVVM est la meilleure chose pour le développement de l'INTERFACE utilisateur. Nous ne pouvons évidemment pas tous les utiliser car il nécessite la création d'une application à partir du sol à l'aide de la MVVM approche, mais quand vous êtes la construction d'une nouvelle application qui n'est pas un problème.

Le seul reproche que j'ai avec ICommand, c'est qu'il est dans le PresentationCore Assemblée qui est fondamentalement pour WPF. Si Microsoft voulait couplage lâche, il devrait être dans une autre assemblée tout à fait.

Permettez-moi de clarifier mon point: "couplé" je ne veux pas dire que le ViewModel classe devrait avoir aucune dépendance sur la Vue. Cependant, il doit exposer des données/comportement qui est pertinente pour ce qui est affiché par le point de Vue particulier s'il est utilisé avec
Sur votre reproche: ce qui a changé dans .NET4.5: il fait désormais partie de System.dll msdn.microsoft.com/en-us/library/...

OriginalL'auteur Jose

Je serais curieux de voir si il y a une meilleure réponse à cette question, mais quand j'ai eu le même problème j'ai toujours joint un cast explicite de l'objet en tant que propriété privée comme suit:

class CustomObjectViewModel : ViewModelBase
{
    protected readonly CustomObject CustomObject;

    public CustomObjectViewModel( CustomObject customObject )
    {
        CustomObject = customObject;
    }

    public string Title
    {
        //implementation excluded for brevity
    }
}

class CustomItemViewModel : CustomObjectViewModel 
{
    protected CustomItem CustomItem  { get { return (CustomItem)CustomObject; } }

    public CustomItemViewModel( CustomItem customItem )
        :base(customItem)
    {
    }
}

Il fonctionne, et c'est le meilleur que j'ai trouvé, mais n'a jamais senti très propre pour moi.

Je pense que c'est effectivement une bonne idée... de cette façon, vous n'avez pas reproduire le modèle objet dans hérité Viewmodel

OriginalL'auteur Martin Harris

4

Je pense que le problème ici est qu'il doit y avoir un ViewModel pour chaque Vue, et non pas un ViewModel pour chaque modèle.

La raison pour cela est assez évident que vous ne pouvez définir qu'un seul objet à la DataContext, cet objet doit être le Dernier de ce point de Vue.

OriginalL'auteur Cameron MacFarland

Vous devez vous connecter pour publier un commentaire.