C#

Attachment data = new Attachment(fs, fileToAdd, "text/plain");

Attachment data = new Attachment(fs, Path.GetFileName(fileToAdd), "text/plain");

public interface IChild<TParent>
{
    void SetParent(TParent parent);
}

public class ChildCollection<TChild, TParent> : System.Collections.ObjectModel.Collection<TChild> where TChild : IChild<TParent>
{
    public ChildCollection(TParent parent)
    {
        Parent = parent;
    }

    public TParent Parent { get; }

    protected override void InsertItem(int index, TChild item)
    {
        item.SetParent(Parent);
        base.InsertItem(index, item);
    }

    protected override void SetItem(int index, TChild item)
    {
        Items[index].SetParent(default(TParent));
        item.SetParent(Parent);
        base.SetItem(index, item);
    }

    protected override void RemoveItem(int index)
    {
        Items[index].SetParent(default(TParent));
        base.RemoveItem(index);
    }

    protected override void ClearItems()
    {
        foreach (TChild child in Items)
        {
            child.SetParent(default(TParent));
        }

        base.ClearItems();
    }
}

public class OuterClass
{
    public OuterClass()
    {
        AllInners = new ChildCollection<InnerClass, OuterClass>(this);
    }
    
    public IList<InnerClass> AllInners { get; }
}

public class InnerClass : IChild<OuterClass>, IChild<InnerClass>
{
    public InnerClass()
    {
        ChildInners = new ChildCollection<InnerClass, InnerClass>(this);
    }
    
    public OuterClass MyOuter { get; private set; }
    public InnerClass Parent { get; private set; }

    public IList<InnerClass> ChildInners { get; }

    public string Text { get; set; }
    public int Level { get; set; }
    
    protected virtual void SetParent(OuterClass parent, bool fromCollection)
    {
        if (ReferenceEquals(MyOuter, parent)) return;
        
        var oldOuter = MyOuter;
        if (oldOuter != null)
        {
            MyOuter = null;
            oldOuter.AllInners.Remove(this);
        }
        
        MyOuter = parent;
        
        if (parent != null && !fromCollection)
        {
            parent.AllInners.Add(this);
        }
        
        foreach (var child in ChildInners)
        {
            child.SetParent(parent, false);
        }
    }

    void IChild<OuterClass>.SetParent(OuterClass parent)
    {
        SetParent(parent, true);
    }
    
    protected virtual void SetParent(InnerClass parent)
    {
        if (ReferenceEquals(Parent, parent)) return;
        
        var oldParent = Parent;
        if (oldParent != null)
        {
            Parent = null;
            oldParent.ChildInners.Remove(this);
        }
        
        Parent = parent;
        
        var newOuter = parent != null ? parent.MyOuter : null;
        SetParent(newOuter, false);
    }
    
    void IChild<InnerClass>.SetParent(InnerClass parent)
    {
        SetParent(parent);
    }
}

var outer = new OuterClass();
var root = new InnerClass { Text = "A", Level = 0 };
var child = new InnerClass { Text = "A.1", Level = 1 };
var grandchild = new InnerClass { Text = "A.1.i", Level = 2 };

child.ChildInners.Add(grandchild);
root.ChildInners.Add(child);
outer.AllInners.Add(root);

/*
outer.AllInners == [root, child, grandchild]
root.MyOuter == child.MyOuter == grandchild.MyOuter == outer
root.Parent == null, root.ChildInners == [child]
child.Parent == root, child.ChildInners == [grandchild]
grandchild.Parent == child, grandchild.ChildInners == []
*/

// Changing the structure should also work:
root.ChildInners.Add(grandchild);

/*
outer.AllInners == [root, child, grandchild]
root.MyOuter == child.MyOuter == grandchild.MyOuter == outer
root.Parent == null, root.ChildInners == [child, grandchild]
child.Parent == root, child.ChildInners == []
grandchild.Parent == root, grandchild.ChildInners == []
*/

Do I just need to add something below this: 
Color.FromName(colours[res[0] - '0']);
Color.FromName(colours[res[1] - '0']);
Color.FromName(colours[third != 0 ? third : res.Count() - 2]);