Improve my Task Loops

Question

How can I improve up this code?
Is it ok to write code using Invoke and Action so liberally or is this bad?

Performance is not an issue as I'm not using Invoke 50,000x in a a row (a lot of other things will be done in-between, making the performance hit null).

The primary goal is to run my list of tasks either by Item first or task first. The secondary goal is to NOT write a massively long method where each method is written out in each way they can be completed. Doing so makes adding new tasks later much easier.

Code: (Updated with pseudo extras)

public class TaskObject
{
    public bool RunPerItem = true; //PLACEHOLDER, normally derived externally from view model
    public bool RunPerTask = false; //PLACEHOLDER, normally derived externally from view model

    public Dictionary<string, Item>() TaskItems = new Dictionary<string, Item>()
    {
        { "ItemA", new Item() {} }, 
        { "ItemB", new Item() {} }, 
        { "ItemC", new Item() {} }, 
    }   

    private List<Action<TaskObject, Item>> Tasks = new List<Action<TaskObject, Item>>()
    {
        (TO, I) => { TO.TaskA(I); },
        (TO, I) => { TO.TaskB(I); },
        (TO, I) => { TO.TaskC(I); }
    };

    public void RunTasks()
    {
        //RunPerItem & RunPerTask are type `bool`
        if (this.RunPerItem) 
        {
            foreach (var I in this.TaskItems)
            {
                foreach (var T in this.Tasks)
                {
                    T.Invoke(this, I.Value); 
                }
            }
        }
        else if (this.RunPerTask)
        {
            foreach (var T in this.Tasks)
            {
                foreach (var I in this.TaskItems)
                {
                    T.Invoke(this, I.Value); 
                }
            }
        }
    }  

    public void TaskA(Item I) { /*...*/ }
    public void TaskB(Item I) { /*...*/ }
    public void TaskC(Item I) { /*...*/ }
}

public class Item 
{
    public string ItemName { get; set; }
} 

Thanks for any advice/help!!!

Edit/Clarification/Extra Details:

The above code describes 2 different loops with different orders of task completion.

Example Orders:
this.RunPerItem
ItemA
-TaskA
-TaskB
-TaskC

ItemB
-TaskA
-TaskB
-TaskC

this.RunPerTask
ItemA
-TaskA

ItemB
-TaskA

Answer 1

I don't know if you can, depending on your real world needs... but if you can convert the TaskItems Dictionary to a List of KeyValuePairs like this...

public List<KeyValuePair<string, Item>> TaskItems = new List<KeyValuePair<string, Item>>
{
    new KeyValuePair<string, Item>( "ItemA", new Item() {} ),
    new KeyValuePair<string, Item>( "ItemB", new Item() {} ), 
    new KeyValuePair<string, Item>( "ItemC", new Item() {} ), 
};

Then you can use the ForEach() exstension method to reduce the loop code to...

if (this.RunPerItem) 
{
    TaskItems.ForEach(I => Tasks.ForEach(T => T(this, I.Value)));            
}
else if (this.RunPerTask)
{
    Tasks.ForEach(T => TaskItems.ForEach(I => T(this, I.Value)));
}

If you couple that with @Steven Jueris' idea of splitting them into their own methods, your code will be very clean.

Answer 2

Instead of calling your delegates by using Invoke you can call them using the following easier formatting:

Action someAction = () => {};
someAction();

Delegate invocations aren't that much slower than ordinary method calls. No need to worry about performance.

Answer 3

Simple thing I see is for readability i'd place the inside of each top ifs into a seperate method with an explicit name. And I always like returning immediately (often times the method itself) then you don't need the else (your second if).

public void RunTasks()
{
    if (this.RunPerItem) 
    {
        return RunTasksForEachItem();
    }

    return RunEachTask();
}