Passing a generic List

I know exactly what to do. I'm going to give you two solutions: one is more basic, one more advanced. You may want to keep it more simple, which will allow you to avoid downloading my code, etc.

Actually your example is the perfect one to demonstrate right technique (my 5!).

Now, your 5 skills are combined, as your have check boxes, not radio boxes, right? It means the skill set is represented by just 5 bits. Let's follow simple logic. Best way to implement bit set data is this:

[System.Flags]
enum SkillSet : byte {
    None = 0,
    A = 1 << 1,
    B = 1 << 2, 
    C = 1 << 3,
    D = 1 << 4, 
    E = 1 << 5,
} //enum SkillSet

In other words, A = 1, B = 2, C = 4,.. etc.
To check up a skill in a skill set, use:

static bool HasSkill(SkillSet skillSet, SkillSet skill) {
     return (skillSet & skill) == skill;
}

And this is how to combine skills:

SkillSet mySkills = SkillSet.A | SkillSet.C | SkillSet.E;

This is how to populate your controls with some value of SkillSet Value:

chkA.Checked = HasSkill(Value, SkillSet.A);
chkB.Checked = HasSkill(Valie, SkillSet.B);
//...

This is how to extract SkillSet Value from controls when editing is done by the UI user:

Value = SkillSet.None;
if (chkA.Checked == true)
    SkillSet |= SkillSet.A;
if (chlA.Checked == true)
    SkillSet |= SkillSet.B;
//..., etc.

That's it.

You don't need any list. Complete skill set of one person is expressed with a single bit set of the size of byte.
Also, note you don't have to use any hard-coded string values. The only place use any constants is the definition of the enumeration type itself -- perfectly supportable way.

Even the name of the controls can be generated out of this enumeration type. Pay attention for the attribute System.Flags.
This attribute only effect string representation of the value of the enumeration type.
Consider SkillSet value = (SkillSet)5, same as SkillSet value = SkillSet.A + SkillSet.C. With the attribute, value.ToString() will return "5"; using Flags attribute will return "A, C" -- try it.

A little note on the check up of the boolean value chkA.Checked == true. Frankly, just chkA.checked would do the same, but only if the property has the type bool.
The property of the WPF check box uses different type: bool?. This type is nullable, that is, instead of usual boolean value set of {False, True} it uses 3-value set: {null, False, True}. So, the check would not return bool, it would return bool?.

Learn .NET, Ladies and Gentlemen! It's a bit deeper then you might thought.

As a next step, I will advice somewhat more advanced technique, base of my relatively recent work, this one.

Thank you very much for attention!

I promised to add more advanced recipe then that of Answer 1.

To use my method, you need to see my article Enumeration Types do not Enumerate! Working around .NET and Language Limitations (Generic classes for enumeration-based iteration and array indexing) and download the code.

We need to use this:

using SA.Universal.Enumerations;

My library offers generic classes for iteration through enumeration values and array indexed by enumeration members. Your application requires them both. For base enumeration type we can use the one shown in Answer 3, with one modification:

[System.Flags]
enum SkillSet {
    [NonEnumerable] None = 0,
    A = 1 << 1,
    B = 1 << 2,
    C = 1 << 3,
    D = 1 << 4,
    E = 1 << 5,
} //enum SkillSet

We shall need two variables in you form, one for iteration, another to store an array of check boxes:

Enumeration<SkillSet> SkillSetEnumeration
    = new Enumeration<SkillSet>();
EnumerationIndexedArray<SkillSet, CheckBox> SkillSetControl
    = new EnumerationIndexedArray<SkillSet, CheckBox>();

Check boxes can be created during run-time and automatically set up according to the enumeration type.

We need to have definition of for some check boxes layout somewhere:

const int CheckBoxTop = 8;
const int CheckBoxInterval = 2;
const int CheckBoxLeft = 4;

A good place to call the following set up method is at the end of form constructor (or any time later, but before showing the form).

void Populate() {
    Control parent = this.panelTests;
    int current = CheckBoxTop;
    foreach (var item in SkillSetEnumeration) {
        CheckBox cb = new CheckBox();
        parent.Controls.Add(cb);
        cb.Top = current;
        cb.Left = CheckBoxLeft;
        current += cb.Height + CheckBoxInterval;
        cb.Text = item.Name;
        SkillSetControl[item.EnumValue] = cb;
   } //loop
} //void Populate

And, finally, now we can have a UI property which gets SkillSet value from a set of check box control or translates (sets) this value to the Checked state of those controls:

SkillSet SkillSetControlValue {
     get { //controls to value
         SkillSet value = SkillSet.None;
         foreach (var item in SkillSetEnumeration) {
             if (SkillSetControl[item.EnumValue].Checked)
                 value |= item.EnumValue;
         } //loop
         return value;
     } //SkillSetControlValue get
     set { //values to control
         foreach (var item in SkillSetEnumeration)
             SkillSetControl[item.EnumValue].Checked =
                 (item.EnumValue & value) > 0;
         } //SkillSetControlValue set
} //SkillSetControlValue

That's all!

The ListBox is using the ToString() method of the Generic List which returns a description of it (which is what you see) NOT it's contents.

To get that you will have to write your own class which inherits from List<> and in that class write your own ToString() method which returns a string in the format you like.

Just had a thought. It might be better to use a BitArray[^], which is ideal for storing an 'array' of true/false values. Of course you would still need a ToString() method for that.

Try this (no guarantees):

listbox.Items.AddRange(myGenericList.ToArray());

If this is marked as the answer, why is it voted a 1?