Listing skills for role-playing characters After I completed writing this code, I started to wonder if the switches should be replaced with a more OOP approach. I originally picked the switch approach because there will never be anymore skill groups, only the 5 listed. It also made it a bit easier on the GUI side of things to associate a selection index to one of the enum values. 

I figure the KISS rule applies since the structure of the data is going to be concrete, but I'm always open to broadening my view.

public class SkillsComponent
{
    private List&lt;AttackSkillData&gt; strikeSkills = new List&lt;AttackSkillData&gt;();
    private List&lt;AttackSkillData&gt; magicSkills = new List&lt;AttackSkillData&gt;();
    private List&lt;AttackSkillData&gt; techSkills = new List&lt;AttackSkillData&gt;();
    private List&lt;AttackSkillData&gt; dualTechSkills = new List&lt;AttackSkillData&gt;();
    private List&lt;AttackSkillData&gt; triTechSkills = new List&lt;AttackSkillData&gt;();

    public SkillsComponent(List&lt;AttackSkillData&gt; strikeSkills, List&lt;AttackSkillData&gt; magicSkills, List&lt;AttackSkillData&gt; techSkills, List&lt;AttackSkillData&gt; dualTechSkills, List&lt;AttackSkillData&gt; triTechSkills)
    {
        this.strikeSkills = strikeSkills;
        this.magicSkills = magicSkills;
        this.techSkills = techSkills;
        this.dualTechSkills = dualTechSkills;
        this.triTechSkills = triTechSkills;
    }

    public void AddNewSkill(SkillAttackType skillAttackType, AttackSkillData data)
    {
        switch (skillAttackType)
        {
            case SkillAttackType.Strike: { strikeSkills.Add(data); } break;
            case SkillAttackType.Magic: { magicSkills.Add(data); } break;
            case SkillAttackType.Tech: { techSkills.Add(data); } break;
            case SkillAttackType.DualTech: { dualTechSkills.Add(data); } break;
            case SkillAttackType.TriTech: { triTechSkills.Add(data); } break;
        }
    }

    public List&lt;AttackSkillData&gt; GetListOfLearnedSkills(SkillAttackType skillAttackType)
    {
        List&lt;AttackSkillData&gt; listToUse = null;
        switch(skillAttackType)
        {
            case SkillAttackType.Strike: { listToUse = strikeSkills; } break;
            case SkillAttackType.Magic: { listToUse = magicSkills; } break;
            case SkillAttackType.Tech: { listToUse = techSkills; } break;
            case SkillAttackType.DualTech: { listToUse = dualTechSkills; } break;
            case SkillAttackType.TriTech: { listToUse = triTechSkills; } break;
        }
        return listToUse;
    }
}
It might be a bit cleaner if you introduce a new class (or struct) containing both AttackSkillData and SkillAttackType.

Consider something like this;

public class AttackSkill
{
    public AttackSkillData data;
    public SkillAttackType type;
}


And consider adding a List&lt;AttackSkill&gt;() instead of five different lists.

Your code should then look like this;

public class SkillsComponent
{
    private List&lt;AttackSkill&gt; skills = new List&lt;AttackSkill&gt;();

    public SkillsComponent(List&lt;AttackSkill&gt; listOfAllSkills)
    {
        this.skills = listOfAllSkills;
    }

    public void AddNewSkill(SkillAttackType skillAttackType, AttackSkillData data)
    {           
        skills.Add(new AttackSkill{ type = skillAttackType, data = data});     
    }

    public List&lt;AttackSkill&gt; GetListOfLearnedSkills(SkillAttackType skillAttackType)
    {
        return skills.Where(s =&gt; s.type == skillAttackType).ToList();
    }
}


You can then acces any type of skill using a Where() where needed. For example, to get all skills having SkillAttackType.Strike;

List&lt;AttackSkill&gt; strikeSkills = skills.Where(s =&gt; s.type == SkillAttackType.Strike).ToList();


It will make your code less noisy and you will be rid of the switch. Double score!