Find all possible sumation numbers to a specified sum
Rather than go through a line-by-line critique of your program, let me just say:


It is way too long and too complicated
You are getting hung up on all the adds and removes.  This problem is much easier to solve if you never add or remove anything. Treat sequences as immutable data structures.


You should be able to do this in about four lines of code in your method body, and some little helper methods.  Here's an example:

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    static IEnumerable&lt;T&gt; Singleton&lt;T&gt;(T t)
    {
        yield return t;
    }
    static IEnumerable&lt;IEnumerable&lt;int&gt;&gt; AllSums(int n, int min = 1)
    {
        for (int i = min; i &lt;= n / 2; ++i)
            foreach(var seq in AllSums(n - i, i))
                yield return Singleton(i).Concat(seq);
        yield return Singleton(n);
    }
    public static void Main()
    {
        foreach(var result in AllSums(7))
            Console.WriteLine(string.Join(",", result));
    }
}


The key here is to make a clear specification for the AllSums method.  It takes positive integers n and min and returns a sequence of sequences that all have the following properties:


They sum to n
The smallest number in the sequence is not smaller than min
The sequence is non-decreasing


Once you have a method that has these properties, the recursion becomes much easier to reason about.

Go through this implementation very carefully and annotate each line of code with its meaning and purpose in the algorithm.

For another application of this general principle of generating a sequence of data structures that all have a sum property, see my series of articles which begins here:

https://blogs.msdn.microsoft.com/ericlippert/2010/04/19/every-binary-tree-there-is/