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<AttackSkillData> strikeSkills = new List<AttackSkillData>();    private List<AttackSkillData> magicSkills = new List<AttackSkillData>();    private List<AttackSkillData> techSkills = new List<AttackSkillData>();    private List<AttackSkillData> dualTechSkills = new List<AttackSkillData>();    private List<AttackSkillData> triTechSkills = new List<AttackSkillData>();    public SkillsComponent(List<AttackSkillData> strikeSkills, List<AttackSkillData> magicSkills, List<AttackSkillData> techSkills, List<AttackSkillData> dualTechSkills, List<AttackSkillData> 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<AttackSkillData> GetListOfLearnedSkills(SkillAttackType skillAttackType)    {        List<AttackSkillData> 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;    }}
Listing skills for role-playing characters
c#;object oriented;role playing game
At this stage I would probably leave the code as is in that I wouldn't consider a more OOP solution.  The fact that you have thought about it is good because it meansat least you know this possibility exists and it's in the back of your mind in future development.  Now, if you find yourself doing another switch statement on  SkillAttackType you might want to consider refactoring the code to a more OOP approach.  But until then, I like your KISS approach.In saying that I do have a couple of comments up for discussion.I always try and keep my variable naming in convention, in both the format of the variable i.e. camelCase, underscore or no, as well as the ordering of the naming.I noticed you have both AttackSkillData and SkillAttackType.  IMO it would be better to pick a consistent naming and either run with (SkillAttackType , SkillAttackData)or (AttackSkillType, AttackSkillData).Even though you are not using OOP you can still minimize the two switches into just one but refactoring it out into a method.public void AddNewSkill(SkillAttackType skillAttackType, AttackSkillData data){  var skillDataList = GetSkillData(skillAttackType);  skillDataList.Add(data);}public List<AttackSkillData> GetListOfLearnedSkills(SkillAttackType skillAttackType){    return GetSkillData(skillAttackType);}private void GetSkillData(SkillAttackType skillAttackType){   // One method used for both public operations  switch (skillAttackType)  {    case SkillAttackType.Strike: return strikeSkills;    case SkillAttackType.Magic: return magicSkills;    case SkillAttackType.Tech: return techSkills;    case SkillAttackType.DualTech: return dualTechSkills;    case SkillAttackType.TriTech: retirm triTechSkills;    default:        throw new NotSupportedException(The following skill  + skillAttackType +  is not supported);  }}Alternatively you could get rid of the multiple private fields and just use a dictionary to maintain your skill data sets.  Hence a refactored solution using that method mightbe.public class SkillsComponent{  private readonly Dictionary<AttackSkillType, List<AttackSkillData>> _skillData;  public SkillsComponent(    List<AttackSkillData> strikeSkills,     List<AttackSkillData> magicSkills,     List<AttackSkillData> techSkills,     List<AttackSkillData> dualTechSkills,     List<AttackSkillData> triTechSkills)  {      _skillData = new Dictionary<AttackSkillType, List<AttackSkillData>>      {         { SkillAttackType.Strike, List<AttackSkillData> strikeSkills },         { SkillAttackType.Magic, List<AttackSkillData> magicSkills },         { SkillAttackType.Tech, List<AttackSkillData> techSkills },         { SkillAttackType.DualTech, List<AttackSkillData> dualTechSkills },         { SkillAttackType.TriTech, List<AttackSkillData> triTechSkills },      };   }    public void AddNewSkill(AttackSkillType skillAttackType, AttackSkillData data)    {       var skillDataList = GetSkillData(skillAttackType);       skillDataList.Add(data);    }    public List<AttackSkillData> GetListOfLearnedSkills(AttackSkillType skillAttackType)    {        return GetSkillData(attackSkillType);    }    private void GetSkillData(AttackSkillType attackSkillType)    {       if(!_skillData.ContainsKey(attackSkillType)        {        throw new NotSupportedException(The following skill  + attackSkillType +  is not supported);        }        return _skillData[attackSkillType);     }   }