Aider à remanier mon code C# pour qu'il soit plus facile à maintenir et qu'il utilise les meilleures pratiques de codage.

Question

J'ai une structure de classe C# que j'aimerais remanier pour utiliser les meilleures normes de codage (utilisation d'interfaces/de classes abstraites) afin qu'elle soit plus facile à maintenir et à réutiliser. Le code tel qu'il est actuellement n'est pas terrible, mais il n'est pas idéal.

J'ai une série de classes TableItemGroup : AccountTableItemGroup, PendingVoteTableItemGroup et RequestingVoteTableItemGroup. Chaque TableItemGroup contient une chaîne SectionName et une liste pour son TableItem correspondant ... comme suit :

public class AccountTableItemGroup {
    public string SectionName { get; set; }

    public List<AccountTableItem> Items
    {
        get { return this._items; }
        set { this._items = value; }
    }        
    public List<AccountTableItem> _items = new List<AccountTableItem>();

    public AccountTableItemGroup()
    {
    }
}

À l'avenir, il y aura beaucoup plus de TableItemGroups et s'ils sont tous identiques à l'exception de la partie Liste, je ne veux pas avoir à copier le code et à créer un nouveau groupe à chaque fois pour faire ce petit changement. Je sais qu'il doit y avoir une meilleure solution. J'aimerais continuer à utiliser les génériques List<> afin de ne pas avoir à mouler quoi que ce soit par la suite.

L'autre partie est constituée des TableItems. J'ai un AccountTableItem, un PendingVoteTableItem et un RequestingVoteTableItem. Les TableItems sont différents les uns des autres, mais ils partagent tous trois chaînes de caractères communes : TitleLabel, DetailLabel et ImageName. Mais ensuite, chaque TableItem peut avoir ou non des propriétés ou des méthodes supplémentaires, comme par exemple :

public class AccountTableItem
{
    public string TitleLabel { get; set; }

    public string DetailLabel { get; set; }

    public string ImageName { get; set; }

    public bool SwitchSetting { get; set; }

    public AccountTableItem()
    {
    }
}

Ma question à vous tous est donc la suivante : comment redéfinir la structure de mes classes afin de permettre une réutilisation maximale du code et d'utiliser les meilleures normes de codage ?

Je pensais avoir une classe abstraite TableItem ou utiliser une interface pour TableItemGroup ? Je sais que l'utilisation d'une interface ou d'une classe abstraite est préférable pour les normes de codage, mais je ne vois pas comment cela pourrait réduire la quantité de code que j'aurai ?

Merci beaucoup pour votre aide.

Answer 1

Abstraire votre élément de tableau en ajoutant les champs nécessaires à l'interface ou à la classe de base :

    interface ITableItem // or just a simple or abstract class
    {
        // common fields go here
    }

Vous pouvez alors rendre votre groupe d'articles générique avec une contrainte sur le paramètre générique.

    public class ItemGroup<T> where T: ITableItem
    {
        public string SectionName { get; set; }

        public List<T> Items { get; private set; }

        public ItemGroup()
        {
            Items = new List<T>();
        }
    }

Answer 2

Envisagez d'utiliser des éléments génériques pour représenter le TableItemGroup et créez une classe de base pour votre TableItem dont vous pouvez hériter pour des types spécifiques d'éléments de tableau. Si vous héritez directement de List<T> vous pouvez alors traiter votre groupe d'éléments comme une collection sans avoir à utiliser l'option Items comme dans votre modèle existant.

Il n'y a pas beaucoup d'intérêt à utiliser des interfaces pour ce genre de types. En l'état, il s'agit de classes de données qui n'ont donc aucun comportement. S'ils avaient un comportement, l'utilisation d'interfaces aurait un sens car vous seriez alors en mesure de modifier les implémentations et donc de faire varier le comportement.

public class TableItemGroup<T> : List<T> where T : TableItem
{
    public TableItemGroup(string sectionName)
    {
        SectionName = sectionName;
    }

    public string SectionName { get; private set; }
}

public class TableItem
{
    public string TitleLabel { get; set; }

    public string DetailLabel { get; set; }

    public string ImageName { get; set; }
}

public class AccountTableItem : TableItem
{
    public bool SwitchSetting { get; set; }
}

Maintenant que nous disposons d'un TableItemGroup vous pouvez le réutiliser pour tous les conteneurs TableItem types. Le fait d'avoir une classe de base pour les TableItem permet à nouveau une certaine réutilisation.

var items = new TableItemGroup<AccountTableItem>("Accounts");

items.Add(new AccountTableItem { SwitchSetting = true });

Answer 3

À moins que vous ne souhaitiez que les utilisateurs puissent ajouter et supprimer de nouvelles listes à leur guise, vous devez protéger l'élément de configuration de la liste des éléments. Les utilisateurs pourront toujours ajouter et supprimer des éléments, mais pas créer une référence à une nouvelle liste.