Comment puis-je émuler un héritage multiple et utiliser la réflexion pour optimiser ce code?

Question

J'ai une application WPF où les objets de page sont des objets de modèle.

Mon ViewModel principal a une ObservableCollection of PageItemViewModels , chacun se construisant à partir de son objet modèle PageItem correspondant.

Chaque PageItemViewModel hérite de la classe abstraite BaseViewModel afin d'obtenir la fonctionnalité INotifyPropertyChanged.

Chaque PageItemViewModel implémente également le IPageItemViewModel afin de s’assurer qu’il dispose des propriétés requises.

J'aurai finalement environ 50 pages, donc je veux éliminer tout code inutile :

• RESOLU (voir ci-dessous) : y a-t-il un moyen d'obtenir que les classes PageItemViewModel héritent de l'IdCode et du Titre , de sorte que je n'ai pas à les implémenter dans chaque classe? Je ne peux pas les mettre dans BaseViewModel, car d'autres ViewModels en héritent et n'ont pas besoin de ces propriétés. Je ne peux pas les mettre dans IPageItemViewModel car il ne s'agit que d'une interface. Je comprends que j’ai besoin d’un héritage multiple pour lequel C # ne prend pas en charge
• RÉSOLU (voir ci-dessous) : puis-je me débarrasser de la déclaration switch , par exemple. en quelque sorte, utilisez réflexion à la place?

Ci-dessous, une application console autonome qui illustre le code que j'ai dans mon application WPF :

using System.Collections.Generic;

namespace TestInstantiate838
{
    public class Program
    {
        static void Main(string[] args)
        {
            List<PageItem> pageItems = PageItems.GetAll();
            List<ViewModelBase> pageItemViewModels = new List<ViewModelBase>();

            foreach (PageItem pageItem in pageItems)
            {
                switch (pageItem.IdCode)
                {
                    case "manageCustomers":
                        pageItemViewModels.Add(new PageItemManageCustomersViewModel(pageItem));
                        break;
                    case "manageEmployees":
                        pageItemViewModels.Add(new PageItemManageEmployeesViewModel(pageItem));
                        break;
                    default:
                        break;
                }
            }
        }
    }

    public class PageItemManageCustomersViewModel : ViewModelBase, IPageItemViewModel
    {
        public string IdCode { get; set; }
        public string Title { get; set; }

        public PageItemManageCustomersViewModel(PageItem pageItem)
        {

        }
    }

    public class PageItemManageEmployeesViewModel : ViewModelBase, IPageItemViewModel
    {
        public string IdCode { get; set; }
        public string Title { get; set; }

        public PageItemManageEmployeesViewModel(PageItem pageItem)
        {

        }
    }

    public interface IPageItemViewModel
    {
        //these are the properties which every PageItemViewModel needs
        string IdCode { get; set; }
        string Title { get; set; }
    }

    public abstract class ViewModelBase
    {
        protected void OnPropertyChanged(string propertyName)
        {
            //this is the INotifyPropertyChanged method which all ViewModels need
        }
    }

    public class PageItem
    {
        public string IdCode { get; set; }
        public string Title { get; set; }
    }

    public class PageItems
    {
        public static List<PageItem> GetAll()
        {
            List<PageItem> pageItems = new List<PageItem>();
            pageItems.Add(new PageItem { IdCode = "manageCustomers", Title = "ManageCustomers"});
            pageItems.Add(new PageItem { IdCode = "manageEmployees", Title = "ManageEmployees"});
            return pageItems;
        }
    }

}

Refactorisé: interface modifiée en classe abstraite

using System;
using System.Collections.Generic;

namespace TestInstantiate838
{
    public class Program
    {
        static void Main(string[] args)
        {
            List<PageItem> pageItems = PageItems.GetAll();
            List<ViewModelPageItemBase> pageItemViewModels = new List<ViewModelPageItemBase>();

            foreach (PageItem pageItem in pageItems)
            {
                switch (pageItem.IdCode)
                {
                    case "manageCustomers":
                        pageItemViewModels.Add(new PageItemManageCustomersViewModel(pageItem));
                        break;
                    case "manageEmployees":
                        pageItemViewModels.Add(new PageItemManageEmployeesViewModel(pageItem));
                        break;
                    default:
                        break;
                }
            }

            foreach (ViewModelPageItemBase pageItemViewModel in pageItemViewModels)
            {
                System.Console.WriteLine("{0}:{1}", pageItemViewModel.IdCode, pageItemViewModel.Title);
            }
            Console.ReadLine();
        }
    }

    public class PageItemManageCustomersViewModel : ViewModelPageItemBase
    {
        public PageItemManageCustomersViewModel(PageItem pageItem)
        {
            IdCode = pageItem.IdCode;
            Title = pageItem.Title;
        }
    }

    public class PageItemManageEmployeesViewModel : ViewModelPageItemBase
    {
        public PageItemManageEmployeesViewModel(PageItem pageItem)
        {
            IdCode = pageItem.IdCode;
            Title = pageItem.Title;
        }
    }

    public abstract class ViewModelPageItemBase : ViewModelBase
    {
        //these are the properties which every PageItemViewModel needs
        public string IdCode { get; set; }
        public string Title { get; set; }
    }

    public abstract class ViewModelBase
    {
        protected void OnPropertyChanged(string propertyName)
        {
            //this is the INotifyPropertyChanged method which all ViewModels need
        }
    }

    public class PageItem
    {
        public string IdCode { get; set; }
        public string Title { get; set; }
    }

    public class PageItems
    {
        public static List<PageItem> GetAll()
        {
            List<PageItem> pageItems = new List<PageItem>();
            pageItems.Add(new PageItem { IdCode = "manageCustomers", Title = "ManageCustomers"});
            pageItems.Add(new PageItem { IdCode = "manageEmployees", Title = "ManageEmployees"});
            return pageItems;
        }
    }

}

Réponse à l'élimination de l'instruction Switch:

Merci Jab:

string assemblyName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
string viewModelName = assemblyName + ".ViewModels.PageItem" + StringHelpers.ForcePascalNotation(pageItem.IdCode) + "ViewModel";
var type = Type.GetType(viewModelName);
var viewModel = Activator.CreateInstance(type, pageItem) as ViewModelBase;
AllPageViewModels.Add(viewModel);

Answer 1

Une solution qui n’est pas très jolie, mais qui fonctionne, consisterait à utiliser la convention pour se débarrasser de l’instruction switch. Cela suppose que vous puissiez modifier les IdCodes ou au moins modifier la casse afin qu'elle corresponde à ViewModel.

    var type = Type.GetType("PageItem" + pageItem.IdCode + "ViewModel");
    var viewModel = Activator.CreateInstance(type) as ViewModelBase;
    pageItemViewModels.Add(viewModel);

Notez que vous devez ajouter ici une vérification d’erreur, il ya quelques points de défaillance ici. Cela vaut toutefois mieux que de devoir conserver une déclaration de commutateur en croissance constante.

Answer 2

Pouvez-vous créer une classe héritant de BaseViewModel qui implémentera ces deux propriétés - vos classes PageItemViewModel qui en ont besoin pourraient ensuite en hériter.

Answer 3

Comme suggéré par Paddy, je viens de créer une classe abstraite supplémentaire, PageViewModelBase, avec les prop-auto définis:

using System.Collections.Generic;

namespace TestInstantiate838
{
    public class Program
    {
        static void Main(string[] args)
        {
            List<PageItem> pageItems = PageItems.GetAll();
            List<ViewModelBase> pageItemViewModels = new List<ViewModelBase>();

            foreach (PageItem pageItem in pageItems)
            {
                switch (pageItem.IdCode)
                {
                    case "manageCustomers":
                        pageItemViewModels.Add(new PageItemManageCustomersViewModel(pageItem));
                        break;
                    case "manageEmployees":
                        pageItemViewModels.Add(new PageItemManageEmployeesViewModel(pageItem));
                        break;
                    default:
                        break;
                }
            }
        }
    }

    public class PageItemManageCustomersViewModel : PageViewModelBase
    {
        public PageItemManageCustomersViewModel(PageItem pageItem)
        {

        }
    }

    public class PageItemManageEmployeesViewModel : PageViewModelBase
    {
        public PageItemManageEmployeesViewModel(PageItem pageItem)
        {


        }
    }

    public abstract class ViewModelBase
    {
        protected void OnPropertyChanged(string propertyName)
        {
            //this is the INotifyPropertyChanged method which all ViewModels need
        }
    }

    public abstract class PageViewModelBase : ViewModelBase
    {
        //these are the properties which every PageItemViewModel needs
        public string IdCode { get; set; }
        public string Title { get; set; }
    }

    public class PageItem
    {
        public string IdCode { get; set; }
        public string Title { get; set; }
    }

    public class PageItems
    {
        public static List<PageItem> GetAll()
        {
            List<PageItem> pageItems = new List<PageItem>();
            pageItems.Add(new PageItem { IdCode = "manageCustomers", Title = "ManageCustomers"});
            pageItems.Add(new PageItem { IdCode = "manageEmployees", Title = "ManageEmployees"});
            return pageItems;
        }
    }

}

Answer 4

Pourquoi ne pouvez-vous pas insérer une GetViewModel() méthode virtuelle dans votre classe PageItem de base qui renvoie le modèle de vue approprié?

   foreach (PageItem pageItem in pageItems)
   {
       pageItemViewModels.Add(pageItem.GetViewModel());
   }

La chose qui ressemble immédiatement à une odeur de code est l'utilisation de & "id &"; propriétés - cela peut généralement être remplacé par un polymorphisme. Vous devez donc remplacer la switch déclaration par le code ci-dessus.

Modifier:

Si votre classe PageItem ne sait rien de votre modèle de vue, il ne peut pas être implémenté de cette façon. En gros, vous avez besoin d’une usine que vous avez déjà (d’une certaine manière).

J'ai généralement une liste de relations (PageItem to ViewModel), qui serait dans votre cas un Dictionary<String, Type>. Ensuite, vous pouvez remplir cette liste lors de l’initialisation et faire instancier le modèle de vue approprié ultérieurement.

Pour utiliser la réflexion pour construire cette liste, vous devez au moins savoir par programme quel élément de page est pris en charge par un modèle de vue. Pour cela, vous pouvez utiliser un attribut personnalisé pour décorer votre classe, par exemple:

.

public class SupportsPageItemAttribute : Attribute
{
    private readonly string _id;
    public string ID
    {
        get { return _id;}
    }

    public SupportsPageItemAttribute(string id)
    {
        _id = id;
    }
}

Et utilisez ensuite cet attribut pour définir le PageItem que votre modèle peut accepter:

[SupportsPageItemAttribute("manageCustomers")
public class PageItemManageCustomersViewModel
{
   // ...
}

Ensuite, vous utilisez la réflexion pour obtenir toutes les classes implémentant IPageItemViewModel et vérifiez leurs attributs pour obtenir la chaîne d'identifiant PageItem.

Par exemple (sans trop de vérification d'erreur):

Dictionary<String, Type> modelsById = new Dictionary<String, Type>();
String viewModelInterface = typeof(IPageItemViewModel).FullName;

// get the assembly
Assembly assembly = Assembly.GetAssembly(typeof(IPageItemViewModel));

// iterate through all types
foreach (Type viewModel in assembly.GetTypes())
{
    // get classes which implement IPageItemViewModel
    if (viewModel.GetInterface(viewModelInterface) != null)
    {
        // get the attribute we're interested in
        foreach (Attribute att in Attribute.GetCustomAttributes(viewModel))
        {
            if (att is SupportsPageItemAttribute)
            {
                // get the page item id
                String id = (att as SupportsPageItemAttribute).ID;

                // add to dictionary
                modelsById.Add(id, viewModel);
            }
        }
    }
}

D'autre part, vous pouvez envisager divers cadres d'inversion de contrôle au lieu de faire le travail de réflexion désagréable vous-même.

Answer 5

Une solution possible consiste à inverser la relation entre PageItem et PageItemViewModel dans votre code. Pour le moment, vous générez un switch basé sur un <=>, mais que se passe-t-il si vous avez créé le <=> en premier, puis dans le constructeur de chaque <=>, vous avez créé le <=> approprié? Ceci élimine le besoin de <=> et rend les choses plus propres, car maintenant votre modèle de vue est responsable du modèle, au lieu du modèle qui est responsable du modèle de vue.

Un exemple basé sur votre code actuel:

using System;
using System.Collections.Generic;

namespace TestInstantiate838
{
    public class Program
    {
        static void Main(string[] args)
        {
            List<ViewModelPageItemBase> pageItemViewModels = PageItemViewModels.GetAll();

            // No switch needed anymore. Each PageItem's view-model contains its PageItem
            // which is exposed as property of the view-model.
            foreach (ViewModelPageItemBase pageItemViewModel in pageItemViewModels)
            {
                System.Console.WriteLine("{0}:{1}", pageItemViewModel.PageItem.IdCode, pageItemViewModel.PageItem.Title);
            }
            Console.ReadLine();
        }
    }

    public class PageItemManageCustomersViewModel : ViewModelPageItemBase
    {
        public PageItemManageCustomersViewModel()
        {
            PageItem = new PageItem { IdCode = "manageCustomers", Title = "ManageCustomers" };
        }
    }

    public class PageItemManageEmployeesViewModel : ViewModelPageItemBase
    {
        public PageItemManageEmployeesViewModel()
        {
            PageItem = new PageItem { IdCode = "manageEmployees", Title = "ManageEmployees" };
        }
    }

    public abstract class ViewModelPageItemBase : ViewModelBase
    {
        //The PageItem associated with this view-model
        public PageItem PageItem { get; protected set; }
    }

    public abstract class ViewModelBase
    {
        protected void OnPropertyChanged(string propertyName)
        {
            //this is the INotifyPropertyChanged method which all ViewModels need
        }
    }

    public class PageItem
    {
        public string IdCode { get; set; }
        public string Title { get; set; }
    }

    // Replaces PageItems class
    public class PageItemViewModels
    {
        // Return a list of PageItemViewModel's instead of PageItem's.
        // Each PageItemViewModel knows how to build it's corresponding PageItem object.
        public static List<PageItemViewModelBase> GetAll()
        {
            List<PageItemViewModelBase> pageItemViewModels = new List<PageItemViewModelBase>();
            pageItemViewModels.Add(new PageItemManageCustomersViewModel());
            pageItemViewModels.Add(new PageItemManageEmployeesViewModel());
            return pageItemViewModels;
        }
    }
}