在C＃中，当并行运行异步任务时，最后一个将永远运行一次

Question

When reading an xml from the server, I have to run multiple database inserts, so to do it efficiently I'm trying to run the handling functions in parallel.

This works nicely but for some reason the last task runs again and again forever even though it is not called more than once (I checked it thoroughly in the debugger).

The code in question:

    static string sLast = "";
    static string sReadElement = "";
    static Dictionary<string, string> dctEvent;
    ...
    static void Main(string[] args)
    {
        XmlReader xrReader = XmlReader.Create(GetDataStream(), new XmlReaderSettings() { DtdProcessing = DtdProcessing.Parse });

        try
        {
            Dictionary<string, Task> dctEventTasks = new Dictionary<string, Task>();
            while (xrReader.Read())
            {
                switch (xrReader.NodeType)
                {
                    case XmlNodeType.Element:
                        switch (xrReader.Name)
                        {
                            case "event":
                                dctEvent = new Dictionary<string, string>();
                                break;
                            ...
                            default:
                                sReadElement = xrReader.Name;
                                break;
                        }

                        break;

                    case XmlNodeType.Text:
                        ...
                        break;

                    case XmlNodeType.EndElement:
                        switch (xrReader.Name)
                        {
                            ...
                            case "event":
                                if (!dctEvent.ContainsKey(dctEvent["gamenumber"]))
                                {
                                    Func<Task> func = async () =>  await HandleEvent(dctEvent, lstParticipants, lstPeriods);
                                    dctEventTasks.Add(dctEvent["gamenumber"], Task.Run(func));
                                }
                                break;
                        }
                        break;
                }
            }

            Log("Last: " + sLast);
            Task.WhenAll(dctEventTasks.Values);
        }
        catch (Exception ex)
        {
            Log(ex.Message);
        }

        Console.ReadKey();
    }

    private static async Task HandleEvent(Dictionary<string, string> dctEvent, List<Dictionary<string, string>> lstParticipants, List<Dictionary<string, string>> lstPeriods)
    {
        ...
        Log("Finished handling event: " + dctEvent["gamenumber"]);
    }

Answer 1

I solved it. The problem was that dctEvent, lstParticiapnts and lstPeriods were static and shared through every run of the main while loop. So when the collections were edited the result would change for other async methods running parallel. The solution was to clone the collections like so:

                            case "event":
                                if (!dctEventTasks.ContainsKey(dctEvent["gamenumber"]))
                                {
                                    var cdctEvent = dctEvent.ToDictionary(entry => entry.Key,
                                           entry => entry.Value);
                                    var clstParticipants = lstParticipants.ToList();
                                    var clstPeriods = lstPeriods.ToList();
                                    Func<Task> func = async () =>  await HandleEvent(cdctEvent, clstParticipants, clstPeriods);
                                    dctEventTasks.Add(dctEvent["gamenumber"], Task.Run(func));
                                }
                                break;