Multi Threaded Lists of Classes that also contain Lists c#

I have a project that contains a List of subclass Objects which also contain lists.

I am looking for advice on the most efficient way to trigger ListEventUpdates, which will not compromise data/duplicate Lists that are being saved as xml and also memory mapped on list update events.

for ListUpdateEvents I am making the lists available to other applications by memory mapping CreateOrOpen() and also saving the list or parent object list as .xml UpdateListXML(). I will simplify a few classes as an example.

    public Strategies()
    {
        _parentModels = new();
        _brokers = new();
        Management = new();       
    }

New strategies are saved to their own list Strategy

each BidningList<Strategies> object contain a bunch of other lists that I want to stay updated in real time, I am hoping to have each Strategy object run on its own thread

I am using switch statements because I plan on doing more complex things later on ListEventUpdates

I am not sure if below will work for this:

public static void OnListUpdate(dynamic sender, ListChangedEventArgs e)
{
    Thread thr = new Thread(new ThreadStart(ListChanged(sender, e)));
}
private static void ListChanged(dynamic sender, dynamic e)
{

    switch (e.ListChangedType)
    {
        case ListChangedType.ItemDeleted:
            UpdateListXML(sender);
            CreateOrOpen(sender);
            break;
        case ListChangedType.ItemAdded:
            UpdateListXML(sender);
            CreateOrOpen(sender);
            break;
        case ListChangedType.ItemMoved:
            UpdateListXML(sender);
            CreateOrOpen(sender);
            break;
        case ListChangedType.ItemChanged:
            UpdateListXML(sender);
            CreateOrOpen(sender);
            break;
        default: throw new ArgumentException("No case for MLSMCore.ML.Lists.ListChanged()");
    }
}

Then I have my sub classes which are made up of lists I want running inside of the main thread for each Strategy Object

    namespace StrategyLink
{
    [Serializable]
    public class Management 
    {
        public BindingList<Samples> Sample;
        public Platform Platform;
        public Synthetic Synthetic;
        private void InitialiseSample()
        {
            Sample = new BindingList<MLSMCore.Samples>();
            Sample.AllowNew = true;
            Sample.AllowRemove = false;
            Sample.RaiseListChangedEvents = true;
            Sample.AllowEdit = true;
        }

        public Management( )
        {
            Sample = new();
            Platform = new();
            Synthetic = new();
        }       

        private static void ListChanged(dynamic sender, ListChangedEventArgs e)
        {
            switch (e.ListChangedType)
            {
                case ListChangedType.ItemDeleted:
                    UpdateListXML(sender);
                    CreateOrOpen(sender);
                    break;
                case ListChangedType.ItemAdded:
                    UpdateListXML(sender);
                    CreateOrOpen(sender);
                    break;
                case ListChangedType.ItemMoved:
                    UpdateListXML(sender);
                    CreateOrOpen(sender);
                    break;
                case ListChangedType.ItemChanged:
                    UpdateListXML(sender);
                    CreateOrOpen(sender);
                    break;
                default: throw new ArgumentException("No case for MLSMCore.ML.Lists.ListChanged()");
            }
        }
        
    }
}

As you can see the Management Class is also made up of lists, most of the lists in my solution don't update frequently so I really only want 1 or 2 threads per strategy object, I would like to have this.Strategy.Management.Synthetic List and this.Strategy.Management.Platform List, running on their own threads, but I am open to all ideas.

I have just rearranged all my classes while experimenting with inheritance so I am not 100% set in my ways, I can rearrange my whole solution again if need be.