Function to generate all subsets of size n
Readability is a big factor in programming when it comes to maintaining the code by yourself or some other developer.
Readability can be improved by using standards which other developers expecting to see. Therefor some guidelines had been created like the .NET Naming Guidelines to name things like classes, properties, variables and parameters. Based on these guidlines variables should be named using camelCase casing instead of snake_case casing.

Omitting braces {} can lead to hidden and therfor hard to find bugs. i would like to encourage you to always use them.  

That beeing said I will first focus on one part of your code...no, on two parts of your code but both are related.  


while (indices[0] &lt;= Set.Length - 1 - ((Set.Length - 1) - (Set.Length - 1 - indices.Length + 0)) + 1)  



and


if (indices[i] &gt; Set.Length - 1 - ((Set.Length - 1) - (Set.Length - 1 - indices.Length + i)) + 1)



but lets focus on the right part of the first line  

Set.Length - 1 - ((Set.Length - 1) - (Set.Length - 1 - indices.Length + 0)) + 1  


using simple math we can shorten this by removing the first () like so  

Set.Length - 1 - (Set.Length - 1 - Set.Length + 1 + indices.Length - 0) + 1   


and by removing the remaining () like so  

Set.Length - 1 - Set.Length + 1 + Set.Length - 1 - indices.Length + 0 + 1    


we get  

Set.Length - indices.Length + 0  


which is just 

Set.Length - nElement + 0  


which makes the while much more readable like so  

int maxValueOfFirstIndex = Set.Length - nElement;

while (indices[0] &lt;= maxValueOfFirstIndex)
{

}


which can be applied to the former if condition like so  

if (indices[i] &gt; maxValueOfFirstIndex  + i)
{

}  


but nElement isn't as expressive as it could so numberOfItems could be a better name.  




The T[] temp_arr isn't used in a useful way. You can safely remove it.  
The check for nElement &lt; 1 whouldn't throw an Exception but an ArgumentOutOfRangeException.  
because variables should be declared as near as possible to their usage you should move the declaration of T[] arr inside the while.  
by using Enumerable.Repeat().Select().ToArray() you can simplify the creation of indeces[] like so  

int[] indices = Enumerable.Repeat(0, nElement).Select((s, d) =&gt; s + d).ToArray();

creating the T[] arr by a method would clean the main method as well  
using the var type instead of concrete types can help if you later need to refactor to use a different type. And its shorter to write hence easier to read, at least if the type can be seen clearly from the right hand side of the assignment.




Applying the mentioned points will lead to  

public List&lt;T[]&gt; GenerateCoupleOf(int numberOfItems)
{
    if (numberOfItems &lt; 1)
    {
        throw new ArgumentOutOfRangeException("numberOfItems", "Value must be greater than 0");
    }

    var tr = new List&lt;T[]&gt;();

    var indices = Enumerable.Repeat(0, numberOfItems).Select((s, d) =&gt; s + d).ToArray();

    var maxValueOfFirstIndex = Set.Length - numberOfItems;

    while (indices[0] &lt;= maxValueOfFirstIndex)
    {

        T[] arr = CreateArrayByIndices(indices, numberOfItems);

        tr.Add(arr);

        indices[indices.Length - 1]++;

        for (var i = indices.Length - 1; i &gt; 0; i--)
        {
            if (indices[i] &gt; maxValueOfFirstIndex + i)
            {
                indices[i - 1]++;
                for (var j = i; j &lt; indices.Length; j++)
                {
                    indices[j] = indices[j - 1] + 1;
                }
            }
        }
    }

    return tr;
}
private T[] CreateArrayByIndices(int[] indices, int numberOfItems)
{

    var arr = new T[numberOfItems];

    for (int i = 0; i &lt; indices.Length; i++)
    {
        arr[i] = Set[indices[i]];
    }
    return arr;
}