Improve my Task Loops 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&lt;string, Item&gt;() TaskItems = new Dictionary&lt;string, Item&gt;()
    {
        { "ItemA", new Item() {} }, 
        { "ItemB", new Item() {} }, 
        { "ItemC", new Item() {} }, 
    }   

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

    public void RunTasks()
    {
        //RunPerItem &amp; 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
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&lt;KeyValuePair&lt;string, Item&gt;&gt; TaskItems = new List&lt;KeyValuePair&lt;string, Item&gt;&gt;
{
    new KeyValuePair&lt;string, Item&gt;( "ItemA", new Item() {} ),
    new KeyValuePair&lt;string, Item&gt;( "ItemB", new Item() {} ), 
    new KeyValuePair&lt;string, Item&gt;( "ItemC", new Item() {} ), 
};


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

if (this.RunPerItem) 
{
    TaskItems.ForEach(I =&gt; Tasks.ForEach(T =&gt; T(this, I.Value)));            
}
else if (this.RunPerTask)
{
    Tasks.ForEach(T =&gt; TaskItems.ForEach(I =&gt; 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.